Assalomu alaykum, yosh dasturchilar! 😊
Bugun biz Python'ning juda kuchli va professional xususiyatlarini o'rganamiz
Mixins - bu kichik, maxsus maqsadli class'lar. Ular to'liq class emas, balki faqat ma'lum funksionallikni ta'minlaydi.
💡 Real hayotdan misol:
Agar sizda "Telefon" class bo'lsa, unda "Qo'ng'iroq qilish", "Xabar yuborish", "Internet", "Kamera" kabi xususiyatlar bor. Lekin ba'zi telefonlarda "Kamera" yo'q, ba'zilarida "Internet" yo'q. Mixins - bu xususiyatlarni alohida class'lar sifatida yaratish va kerakli joyda ishlatish.
class Qo_ng_iroq_mixin:
def qo_ng_iroq_qilish(self, raqam):
print(f"{self.nom} {raqam} raqamiga qo'ng'iroq qilmoqda...")
def qo_ng_iroq_qabul_qilish(self):
print(f"{self.nom} qo'ng'iroqni qabul qilmoqda...")
class Xabar_mixin:
def xabar_yuborish(self, raqam, xabar):
print(f"{self.nom} {raqam} raqamiga xabar yuborayapti: {xabar}")
def xabar_qabul_qilish(self, xabar):
print(f"{self.nom} xabar qabul qildi: {xabar}")
class Internet_mixin:
def internet_ochish(self):
print(f"{self.nom} internetga ulandi...")
def veb_sayt_ochish(self, url):
print(f"{self.nom} {url} saytini ochmoqda...")
class Kamera_mixin:
def rasm_olish(self):
print(f"{self.nom} rasm olayapti...")
def video_olish(self):
print(f"{self.nom} video olayapti...")
class Telefon:
def __init__(self, nom, model):
self.nom = nom
self.model = model
self.batareya = 100
class Smartfon(Telefon, Qo_ng_iroq_mixin, Xabar_mixin, Internet_mixin, Kamera_mixin):
def __init__(self, nom, model):
super().__init__(nom, model)
self.ram = 4
self.xotira = 64
class Oddiy_telefon(Telefon, Qo_ng_iroq_mixin, Xabar_mixin):
def __init__(self, nom, model):
super().__init__(nom, model)
self.sim_karta = True
# Test qilish
smartfon = Smartfon("iPhone", "14")
oddiy_telefon = Oddiy_telefon("Nokia", "3310")
print("=== Smartfon ===")
smartfon.qo_ng_iroq_qilish("+998901234567")
smartfon.xabar_yuborish("+998901234567", "Salom!")
smartfon.internet_ochish()
smartfon.rasm_olish()
print("\n=== Oddiy telefon ===")
oddiy_telefon.qo_ng_iroq_qilish("+998901234567")
oddiy_telefon.xabar_yuborish("+998901234567", "Salom!")
# oddiy_telefon.internet_ochish() # Bu ishlamaydi - Internet_mixin yo'q
"IS-A" munosabati
Mashina IS-A Transport
class Transport:
def __init__(self, nom):
self.nom = nom
self.tezlik = 0
def harakatlanish(self):
print(f"{self.nom} harakatlanmoqda...")
class Mashina(Transport): # Inheritance
def __init__(self, nom, rang):
super().__init__(nom)
self.rang = rang
"HAS-A" munosabati
Mashina HAS-A Dvigatel
class Dvigatel:
def __init__(self, kuch):
self.kuch = kuch
self.yoniq = False
def yoqish(self):
self.yoniq = True
print(f"Dvigatel yoqildi! Kuch: {self.kuch} ot kuchi")
class Mashina_composition:
def __init__(self, nom, rang):
self.nom = nom
self.rang = rang
self.dvigatel = Dvigatel(150) # Composition
class Tormoz:
def __init__(self, tur):
self.tur = tur
self.ishlamoqda = False
def ishlatish(self):
self.ishlamoqda = True
print(f"{self.tur} tormoz ishlatildi!")
class Koleso:
def __init__(self, o_lcham):
self.o_lcham = o_lcham
self.tezlik = 0
def aylanish(self, tezlik):
self.tezlik = tezlik
print(f"Koleso {tezlik} km/h tezlikda aylanmoqda!")
class Mashina_composition:
def __init__(self, nom, rang):
self.nom = nom
self.rang = rang
self.tezlik = 0
# Composition - mashina boshqa object'larni o'z ichiga oladi
self.dvigatel = Dvigatel(150)
self.tormoz = Tormoz("Disk")
self.kolesolar = [Koleso(17) for _ in range(4)]
def yoqish(self):
self.dvigatel.yoqish()
print(f"{self.rang} {self.nom} yoqildi!")
def harakatlanish(self):
if self.dvigatel.yoniq:
self.tezlik = 60
for koleso in self.kolesolar:
koleso.aylanish(self.tezlik)
print(f"{self.nom} harakatlanmoqda! Tezlik: {self.tezlik} km/h")
Design Patterns - bu dasturlashda tez-tez uchraydigan muammolarni yechish uchun ishlatiladigan tayyor yechimlar.
class Transport_factory:
@staticmethod
def transport_yaratish(tur, nom, **kwargs):
if tur == "mashina":
return Mashina(nom, kwargs.get("rang", "Oq"))
elif tur == "samolyot":
return Samolyot(nom, kwargs.get("model", "Boeing"))
elif tur == "kema":
return Kema(nom, kwargs.get("tur", "Passajir"))
else:
raise ValueError(f"Noto'g'ri transport turi: {tur}")
class Observer:
def update(self, xabar):
pass
class Subject:
def __init__(self):
self.observers = []
def observer_qo_shish(self, observer):
self.observers.append(observer)
def observer_olish(self, observer):
self.observers.remove(observer)
def xabar_yuborish(self, xabar):
for observer in self.observers:
observer.update(xabar)
class Telefon(Observer):
def __init__(self, nom):
self.nom = nom
def update(self, xabar):
print(f"{self.nom} xabar qabul qildi: {xabar}")
class Kompyuter(Observer):
def __init__(self, nom):
self.nom = nom
def update(self, xabar):
print(f"{self.nom} xabar qabul qildi: {xabar}")
Singleton Pattern - bu class'ning faqat bitta instance (nusxasi) yaratilishini ta'minlaydi.
class Singleton:
_instance = None
def __new__(cls):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
def __init__(self):
if not hasattr(self, 'initialized'):
self.initialized = True
self.ma_lumot = "Singleton ma'lumoti"
print("Singleton yaratildi!")
# Test qilish
singleton1 = Singleton()
singleton2 = Singleton()
print(f"singleton1: {singleton1}")
print(f"singleton2: {singleton2}")
print(f"singleton1 == singleton2: {singleton1 == singleton2}")
singleton1.ma_lumot = "Yangi ma'lumot"
print(f"singleton2.ma_lumot: {singleton2.ma_lumot}")
# Decorator bilan Singleton
def singleton_decorator(cls):
instances = {}
def get_instance(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return get_instance
@singleton_decorator
class Database:
def __init__(self):
self.ma_lumotlar = {}
print("Database yaratildi!")
def ma_lumot_qo_shish(self, kalit, qiymat):
self.ma_lumotlar[kalit] = qiymat
print(f"Ma'lumot qo'shildi: {kalit} = {qiymat}")
def ma_lumot_olish(self, kalit):
return self.ma_lumotlar.get(kalit, "Topilmadi")
# Test qilish
db1 = Database()
db2 = Database()
print(f"db1: {db1}")
print(f"db2: {db2}")
print(f"db1 == db2: {db1 == db2}")
db1.ma_lumot_qo_shish("ism", "Ali")
print(f"db2.ma_lumot_olish('ism'): {db2.ma_lumot_olish('ism')}")
from abc import ABC, abstractmethod
# Mixins
class Hujum_mixin:
def hujum_qilish(self, dushman):
zarar = self.kuch * 2
print(f"{self.nom} {dushman}ga {zarar} zarar yetkazdi!")
return zarar
class Himoya_mixin:
def himoya_qilish(self):
himoya_kuchi = self.defans * 1.5
print(f"{self.nom} himoya qildi! Himoya kuchi: {himoya_kuchi}")
return himoya_kuchi
class Sehr_mixin:
def sehr_qilish(self, dushman):
if self.mana >= 20:
self.mana -= 20
zarar = self.kuch * 3
print(f"{self.nom} {dushman}ga sehr bilan {zarar} zarar yetkazdi!")
return zarar
else:
print(f"{self.nom} mana yetarli emas!")
return 0
# Abstract class
class O_yinchi(ABC):
def __init__(self, nom, daraja=1):
self.nom = nom
self.daraja = daraja
self.jon = 100
self.kuch = 10
self.defans = 5
self.tajriba = 0
def daraja_oshirish(self):
if self.tajriba >= 100:
self.daraja += 1
self.kuch += 5
self.defans += 3
self.tajriba = 0
print(f"{self.nom} {self.daraja}-darajaga ko'tarildi!")
else:
print(f"Daraja oshirish uchun {100 - self.tajriba} tajriba kerak!")
@abstractmethod
def maxsus_kuch(self):
pass
@abstractmethod
def ma_lumot_ko_rsatish(self):
pass
# Concrete classes
class Jangchi(O_yinchi, Hujum_mixin, Himoya_mixin):
def __init__(self, nom, daraja=1):
super().__init__(nom, daraja)
self.kuch += 10
self.defans += 5
def maxsus_kuch(self):
print(f"{self.nom} qilich bilan maxsus hujum qildi!")
self.tajriba += 20
return self.kuch * 3
def ma_lumot_ko_rsatish(self):
print(f"=== {self.nom} (Jangchi) ===")
print(f"Daraja: {self.daraja}")
print(f"Jon: {self.jon}")
print(f"Kuch: {self.kuch}")
print(f"Defans: {self.defans}")
print(f"Tajriba: {self.tajriba}")
Kichik, maxsus maqsadli class'lar
"HAS-A" munosabati, moslashuvchanlik
Tayyor yechimlar
Bitta instance ta'minlash
Amaliy loyiha
Keyingi dars: OOP Best Practices mavzusini o'rganamiz
Savollaringiz bo'lsa, yozib qoldiring! 😊