Kompozitsiya yoki vorislik?

Nimalarni örganasiz
- has-a ("unda bor", kompozitsiya) va is-a ("X - bu Y", vorislik) orasidagi farq
- Obyektlarni boşqa obyektlardan qanday quriş va çaqirişlarni ularga topşiriş (delegation)
- Nega "vorislikdan köra kompozitsiyani afzal köring" keng tarqalgan maslahat
- Klassni moslaşuvçan va test qiliş oson qiliş uçun unga qismlarni qanday uzatiş (boğliqlikni kiritiş, dependency injection)
Nega bu muhim
Maşina dvigatel emas, lekin unda dvigatel bor. Haqiqiy dasturlardagi köp obyektlar, xuddi haqiqiy narsalar qismlardan yasalgani kabi, boşqa obyektlardan quriladi. Vorislik - klasslar orasidagi eng qattiq boğlaniş: bola ota klassning har bir metodini abadiy oladi. Kompozitsiya (composition) erkinroq va moslaşuvçanroq, ular orasida tanlaş esa asosiy loyihalaş könikmasi.
has-a va is-a
"Menejer - xodim" vorislikni talab qiladi: class Manager(Employee):. "Maşinada dvigatel bor" esa kompozitsiyani talab qiladi: maşina dvigatelni atributda saqlaydi, self.engine = engine, va işini bajariş uçun undan foydalanadi.
Batafsil misol: almaştiriladigan dvigatelli maşina
class Engine:
def __init__(self, horsepower, fuel="benzin"):
self.horsepower = horsepower
self.fuel = fuel
def describe(self):
return f"{self.horsepower} ot kuçi, {self.fuel}"
class ElectricMotor:
def __init__(self, kw):
self.kw = kw
def describe(self):
return f"{self.kw} kVt, elektr"
class Car:
def __init__(self, model, engine):
self.model = model
self.engine = engine # maşinada dvigatel BOR
def spec(self):
return f"{self.model}: {self.engine.describe()}"
cars = [Car("Cobalt", Engine(106, "metan")), Car("Spark EV", ElectricMotor(105))]
for car in cars:
print(car.spec())Cobalt: 106 ot kuçi, metan
Spark EV: 105 kVt, elektrHar bir klassning bitta vazifasi bor. Vorislik bilan PetrolCar, MethaneCar, ElectricCar... kerak bölardi. Kompozitsiya bilan esa bitta Car describe() i bor istalgan qism bilan işlaydi: kompozitsiya içidagi duck typing.
Batafsil misol: qatorlardan iborat buyurtma
Buyurtma qatorlardan iborat, har bir qator esa mahsulot va miqdordan:
class Product:
def __init__(self, name, price):
self.name = name
self.price = price
class LineItem:
def __init__(self, product, quantity):
self.product = product
self.quantity = quantity
@property
def subtotal(self):
return self.product.price * self.quantity
class Order:
def __init__(self, customer):
self.customer = customer
self.items = []
def add(self, product, quantity=1):
self.items.append(LineItem(product, quantity))
@property
def total(self):
return sum(item.subtotal for item in self.items)
order = Order("Bekzod")
order.add(Product("Somsa", 8_000), 6)
order.add(Product("Lağmon", 38_000), 2)
print(f"{order.customer} uçun jami: {order.total:,} söm")Bekzod uçun jami: 124,000 sömOrder.total narxlarni özi köpaytiriş örniga har bir qatordan uning subtotal ini söraydi, bu har bir klassni sodda saqlaydi. Kitoblar va aʼzolari bor kutubxona ham xuddi şunday işlaydi; uni Loyiha: Kutubxona boşqaruv tizimi darsida quriysiz.
Oldin va keyin: list dan meros olgan stek
Stek ustma-ust qöyilgan likopçalarga öxşaydi: siz tepaga qöşasiz (push) va tepadan olasiz (pop). Mana jozibali qisqa yöl:
class Stack(list): # "stek — bu röyxat"mi?
def push(self, item):
self.append(item)
plates = Stack()
plates.push("1-likopça")
plates.push("2-likopça")
plates.insert(0, "ayyor likopça") # barça röyxat metodlari ham birga keldi
print(plates)['ayyor likopça', '1-likopça', '2-likopça']Klass 40 dan ortiq röyxat metodini meros qilib oldi va ularning istalgani stek qoidasini buza oladi: röyxat bilan qila oladigan hamma narsa ham stek uçun maʼnoli emas. Qayta tuzişdan keyin stek işni yaşirin röyxatga topşiradi va faqat özi xohlagan amallarni uzatadi:
class Stack:
def __init__(self):
self._items = [] # qism
def push(self, item):
self._items.append(item) # röyxatga topşiramiz
def pop(self):
return self._items.pop()
def __len__(self):
return len(self._items) # topşiramiz
plates = Stack()
for n in range(1, 4):
plates.push(f"{n}-likopça")
print(plates.pop(), len(plates), hasattr(plates, "insert"))3-likopça 2 FalseEndi interfeysni siz boşqarasiz va keyinroq röyxatni heç bir çaqiruvçini özgartirmasdan almaştira olasiz. _items dagi pastki çiziq içki tafsilotni belgilaydi.
Boğliqlikni kiritiş: qismlarni uzatiş
Car öz dvigatelini taşqaridan oldi. Bu boğliqlikni kiritiş (dependency injection): klass qismlarini özi yaratiş örniga ularni oladi:
class SmsNotifier:
def notify(self, customer, text):
print(f"[{customer} ga SMS] {text}")
class FakeNotifier:
"""Testlaş uçun: xabarlarni yuboriş örniga eslab qoladi."""
def __init__(self):
self.sent = []
def notify(self, customer, text):
self.sent.append((customer, text))
class Shop:
def __init__(self, notifier=None):
self.notifier = notifier if notifier is not None else SmsNotifier()
self.orders = []
def place_order(self, customer, total):
self.orders.append((customer, total))
self.notifier.notify(customer, f"{len(self.orders)}-buyurtma qabul qilindi: {total:,} söm")
Shop().place_order("Aziza", 145_000)
fake = FakeNotifier()
test_shop = Shop(fake)
test_shop.place_order("Dilnoza", 10_000)
test_shop.place_order("Dilnoza", 20_000)
assert fake.sent[1] == ("Dilnoza", "2-buyurtma qabul qilindi: 20,000 söm")
print("Test ötdi:", len(fake.sent), "ta xabar yozib olindi, birortasi ham yuborilmadi")[Aziza ga SMS] 1-buyurtma qabul qilindi: 145,000 söm
Test ötdi: 2 ta xabar yozib olindi, birortasi ham yuborilmadiÖşa bitta Shop SMS yoki email yuborişi, testlarda esa umuman heç narsa yubormasligi mumkin (11-modul). Standart qiymat oddiy qöllanişni sodda saqlaydi. Uni notifier or SmsNotifier() bilan emas, is not None bilan yozing: or tasodifan falsy bölib qolgan, masalan __len__ i 0 qaytaradigan, kiritilgan soxta obyektni jimgina almaştirib yuboradi.
Nega "vorislikdan köra kompozitsiyani afzal köring"
Vorislik - qattiq boğlaniş: bola ota klassning har bir metodini oladi va ota klassdagi özgariş uni buzişi mumkin. Kompozitsiya - erkin boğlaniş: nimani oçiq qilişni özingiz tanlaysiz, qismlarni esa almaştiriş yoki birlaştiriş mumkin, hatto dastur işlayotganda ham. "Afzal köring" "heç qaçon meros olmang" degani emas. Faqat "har bir X - bu Y" töğri eşitilsa, Y ning har bir metodi X uçun maʼnoli bölsa va xatti-harakatlarni almaştiriş kerak bölmasa, meros oling. Aks holda kompozitsiyadan foydalaning.

Özingiz sinab köring
Robot klassiga boşqa Battery bering yoki say() metodli Speaker qismini qöşing va robot gapiriş işini unga topşirsin.
Köp uçraydigan xatolar
1. Imkoniyat oliş uçun meros oliş
class Logger:
def clear_log_file(self):
print("log fayli öçirildi")
class Order(Logger): # Yomon: buyurtma logger emas
pass
order = Order()
print(isinstance(order, Logger))
order.clear_log_file()True
log fayli öçirildiEndi buyurtma "logger hisoblanadi" va log faylini öçira oladi. Tuzatiş: unga qism bering: self.logger = Logger().
2. Qismlarning çuqur içiga kiriş
class LineItem:
def __init__(self, product, quantity):
self.product_name = product.name # oldin self.product edi
self.unit_price = product.price
self.quantity = quantity
# Yomon: çaqiruvçi eski içki tuzilişga tayangan
print(order.items[0].product.price * order.items[0].quantity)AttributeError: 'LineItem' object has no attribute 'product'Içkariga kirgan har bir çaqiruvçi buziladi. Tuzatiş: obyektning özidan sörang: order.items[0].subtotal.
3. Qism hali mavjud emasligini unutiş
class Car:
def __init__(self, model, engine=None):
self.model = model
self.engine = engine
def start(self):
return self.engine.start()
Car("Nexia").start()AttributeError: 'NoneType' object has no attribute 'start'Tuzatiş: qismni __init__ da majburiy qiling yoki topşirişdan oldin None ni tekşiring.
Maşqlar
1. Kompyuter qismlari
Cpu (cores) va Memory (gb) klasslarini hamda ularning har biridan bittasi bor Computer klassini yarating. Computer ga "Ofis kompyuteri: 4 yadro, 8 GB RAM" kabi satr qaytaradigan spec() metodini qöşing.
Yeçim
class Cpu:
def __init__(self, cores):
self.cores = cores
class Memory:
def __init__(self, gb):
self.gb = gb
class Computer:
def __init__(self, name, cpu, memory):
self.name = name
self.cpu = cpu
self.memory = memory
def spec(self):
return f"{self.name}: {self.cpu.cores} yadro, {self.memory.gb} GB RAM"
print(Computer("Ofis kompyuteri", Cpu(4), Memory(8)).spec())Ofis kompyuteri: 4 yadro, 8 GB RAM2. Savatçada topşiriş
Mahsulotlarni yaşirin _items luğatida (nom -> miqdor) saqlaydigan Cart klassini yozing. Luğatga topşiradigan add(name, qty=1), __len__ (turli mahsulotlar soni) va __contains__ ni yarating. Somsa (3), çoy va yana somsa qöşing, keyin uzunlikni hamda somsa va palov savatçada bor-yöqligini çop eting.
Yeçim
class Cart:
def __init__(self):
self._items = {}
def add(self, name, qty=1):
self._items[name] = self._items.get(name, 0) + qty
def __len__(self):
return len(self._items)
def __contains__(self, name):
return name in self._items
cart = Cart()
cart.add("somsa", 3)
cart.add("çoy")
cart.add("somsa")
print(len(cart), "somsa" in cart, "palov" in cart)2 True False3. Navbatni qayta tuziş
Bankdagi navbat class Queue(list) sifatida yozilgan. Uni faqat join(person), next() va __len__ mavjud böladigan qilib, collections.deque qismi yordamida kompozitsiya bilan qayta yozing. next() odamlarga ular qöşilgan tartibda xizmat körsatadi va navbat böş bölganda IndexError("heç kim kutmayapti") çaqiradi. Aziza, Bekzod va Dilnoza bilan sinab köring.
Yeçim
from collections import deque
class Queue:
def __init__(self):
self._people = deque()
def join(self, person):
self._people.append(person)
def next(self):
if not self._people:
raise IndexError("heç kim kutmayapti")
return self._people.popleft()
def __len__(self):
return len(self._people)
q = Queue()
for name in ["Aziza", "Bekzod", "Dilnoza"]:
q.join(name)
print(q.next(), q.next(), len(q))
q.next()
try:
q.next()
except IndexError as error:
print("Xato:", error)Aziza Bekzod 1
Xato: heç kim kutmayapti4. Tavsifdan loyihalaş: meteostansiya
Samarqanddagi meteostansiyada termometr (read() bilan) va displey (show(text) bilan) bor. Uning report() metodi "Samarqand: 31.5 C" kabi matnni körsatadi. Stansiyani boğliqlikni kiritiş bilan loyihalang, keyin uni qatʼiy qiymatlar (31.5, keyin 29.0) qaytaradigan FakeThermometer va qatorlarni röyxatda saqlaydigan RecordingDisplay bilan sinab köring. Ikki hisobotni assert bilan tekşiring va Testlar ötdi ni çop eting.
Yeçim
class FakeThermometer:
def __init__(self, values):
self.values = list(values)
def read(self):
return self.values.pop(0)
class RecordingDisplay:
def __init__(self):
self.lines = []
def show(self, text):
self.lines.append(text)
class WeatherStation:
def __init__(self, city, thermometer, display):
self.city = city
self.thermometer = thermometer
self.display = display
def report(self):
self.display.show(f"{self.city}: {self.thermometer.read()} C")
display = RecordingDisplay()
station = WeatherStation("Samarqand", FakeThermometer([31.5, 29.0]), display)
station.report()
station.report()
assert display.lines == ["Samarqand: 31.5 C", "Samarqand: 29.0 C"]
print("Testlar ötdi")Testlar ötdiStansiya öz qismlarini heç qaçon özi yaratmaydi, şuning uçun soxta qismlar örniga haqiqiy qurilmalarni qöyiş mumkin.
5. Qöşimçali pitsa
Pitsaning ölçami ("S", "M", "L": 45,000 / 60,000 / 75,000 söm) va nomi hamda narxi bor istalgan miqdordagi qöşimçalari bor. CheeseMushroomPizza kabi bola klasslar soni haddan taşqari köpayib ketgan bölardi, şuning uçun kompozitsiyadan foydalaning: Pizza da ölçam va Topping obyektlari röyxati, self qaytaradigan add_topping(), price xossasi va __str__ bor. Notöğri ölçam ValueError çaqiradi. Pişloqli (12,000) va qöziqorinli (9,000) katta pitsani, oddiy örta pitsani va "XL" uçun xatoni çop eting.
Yeçim
class Topping:
def __init__(self, name, price):
self.name = name
self.price = price
class Pizza:
BASE_PRICES = {"S": 45_000, "M": 60_000, "L": 75_000}
def __init__(self, size):
if size not in self.BASE_PRICES:
raise ValueError(f"Nomaʼlum ölçam {size!r}, S, M yoki L ni tanlang")
self.size = size
self.toppings = []
def add_topping(self, topping):
self.toppings.append(topping)
return self
@property
def price(self):
return self.BASE_PRICES[self.size] + sum(t.price for t in self.toppings)
def __str__(self):
names = ", ".join(t.name for t in self.toppings) or "oddiy"
return f"{self.size} pitsa ({names}): {self.price:,} söm"
print(Pizza("L").add_topping(Topping("pişloq", 12_000)).add_topping(Topping("qöziqorin", 9_000)))
print(Pizza("M"))
try:
Pizza("XL")
except ValueError as error:
print("Xato:", error)L pitsa (pişloq, qöziqorin): 96,000 söm
M pitsa (oddiy): 60,000 söm
Xato: Nomaʼlum ölçam 'XL', S, M yoki L ni tanlangXulosa
- Kompozitsiya: obyekt boşqa obyektlarni atribut sifatida saqlaydi. Maşinada dvigatel bor.
- Faqat ota klassning har bir metodi bola uçun maʼnoli bölgan haqiqiy is-a munosabatlarida meros oling.
- Topşiriş: işni qismga uzating va faqat özingiz tanlagan narsani oçiq qiling.
listni öring, undan meros olmang. - Boğliqlikni kiritiş: qismlarni
__init__ga uzating, şunda ularni almaştiriş va testlarda soxta obyektlardan foydalaniş mumkin. - Obyektlarning tuzilişiga kiriş örniga ulardan javob söring (
item.subtotal).