27.3-dars: Dizayn naqshlari — yaratuvchi (creational)

27-QISM — ARXITEKTURA · 3-dars

1. Kirish va motivatsiya

Dasturchilar bir xil muammolarga qayta-qayta duch keladi: obyekt qanday yaratiladi, sinflar qanday bog'lanadi, xulq qanday o'zgaradi. Har safar noldan yechish — vaqt isrofi va xato manbai. Dizayn naqshlari — bu takrorlanuvchi muammolarning sinalgan yechimlari: tajribali dasturchilar topgan va nomlagan andozalar. Ular tayyor kod emas, balki g'oya (qolip): "bu vaziyatda shunday qil". Naqshlar — umumiy til: "bu yerda Factory ishlatamiz" desangiz, jamoa darrov tushunadi.

Yaratuvchi naqshlar (creational patterns) — obyekt yaratish bilan bog'liq naqshlar: obyektni qanday, qachon, qayerda yaratishni tartibga soladi. Asosiylari: Factory (fabrika — obyekt yaratishni funksiyaga topshirish), Singleton (yagona nusxa — butun dasturda bitta), Builder (quruvchi — murakkab obyektni qadam-baqadam yig'ish), Prototype (nusxa — mavjud obyektdan klonlash). Bu naqshlar SOLID ni 27.2-bob amalda qo'llaydi: yaratishni ajratadi (SRP), yangi turlarga ochiq (OCP), abstraksiyaga bog'laydi (DIP). Yaratuvchi naqshlar — obyekt tug'ilishini boshqarish.

Real vaziyat. Bir loyihada har joyda if turi == "pdf": PdfHisobot() elif turi == "excel": ExcelHisobot() takrorlanardi — yangi format qo'shilsa, hamma joyni topish kerak. Factory naqshi qo'llanildi: HisobotFabrikasi.yarat(turi) — bitta joyda yaratish mantiqi. Yangi format — faqat fabrikaga qo'shiladi (bir joy). Kod tozalandi, yangi format qo'shish oson bo'ldi. Naqsh — takror muammoning tayyor javobi.

Bu darsda yaratuvchi dizayn naqshlarini o'rganamiz.

Bu darsda:

• Dizayn naqshi nima
• Factory (fabrika)
• Singleton (yagona nusxa)
• Builder (quruvchi)
• Prototype (nusxa)
• Naqsh qachon kerak (va kerak emas)
• Naqshlar va SOLID
• Amaliy: naqsh qo'llash

ℹ Misollar sof Python bilan — deterministik.

2. Nazariya — chuqur tushuntirish

2.1. Dizayn naqshi nima

Takror muammoning sinalgan yechimi:

Muammo (takrorlanuvchi) → Naqsh (sinalgan yechim, nom)
Naqsh: tayyor kod emas — g'oya (qolip)
"Bu yerda Factory" → jamoa tushunadi (umumiy til)

Dizayn naqshi (design pattern) — dasturlashda tez-tez uchraydigan muammoning sinalgan, nomlangan yechimi: tajribali dasturchilar topgan andoza (Gang of Four kitobi — 23 klassik naqsh). Naqsh — tayyor kod emas (nusxa-joylash), balki g'oya (qolip — bu vaziyatda shunday tuzilma). Foyda: sinalgan (ishlaydi), umumiy til (nom bilan muloqot — "Factory", "Observer"), tez (noldan o'ylamaslik). Naqsh — tajriba tildasi. Uch tur: yaratuvchi (obyekt), strukturaviy (bog'lanish — 27.4), xulq-atvor (o'zaro ta'sir — 27.5).

2.2. Factory (fabrika)

Obyekt yaratishni ajratish:

# yomon: yaratish har joyda takror
if turi == "pdf": h = PdfHisobot()
elif turi == "excel": h = ExcelHisobot()

# yaxshi: fabrika (bir joyda yaratish)
class HisobotFabrikasi:
    @staticmethod
    def yarat(turi):
        return {"pdf": PdfHisobot, "excel": ExcelHisobot}[turi]()

Factory (fabrika) — obyekt yaratishni alohida joyga (funksiya/sinf) topshirish: mijoz Fabrika.yarat(turi) chaqiradi, qaysi aniq sinf yaratilishini bilmaydi. Sabab: yaratish mantiqi bir joyda (takror emas — DRY), yangi tur qo'shish oson (faqat fabrikada — OCP), mijoz aniq sinfga bog'lanmaydi (DIP). Foydalanish: turga qarab obyekt (format, to'lov turi, ma'lumot manbai). Factory — obyekt tug'ilishini markazlashtirish. Bir joyda yaratish — o'zgarish oson.

2.3. Singleton (yagona nusxa)

Butun dasturda bitta nusxa:

class Sozlama:
    _nusxa = None
    def __new__(cls):
        if cls._nusxa is None:
            cls._nusxa = super().__new__(cls)
        return cls._nusxa
# har chaqiruv bir xil nusxani qaytaradi

Singleton (yagona nusxa) — sinfning butun dasturda bitta nusxasi bo'lishini ta'minlaydi: har Sozlama() chaqiruvi bir xil obyektni qaytaradi. Foydalanish: sozlama (bir manba), ulanish havzasi (connection pool), log yozuvchi (bitta). Python'da: __new__ (nusxani nazorat), yoki modul darajasidagi obyekt (Python moduli tabiiy singleton). Ehtiyot: Singleton — global holat (test qiyin, yashirin bog'liqlik) — ba'zan "anti-naqsh" deyiladi; ehtiyot bilan ishlatish. Singleton — yagona umumiy nuqta.

2.4. Builder (quruvchi)

Murakkab obyektni qadam-baqadam:

class SorovQuruvchi:
    def __init__(self): self.qismlar = {}
    def jadval(self, n): self.qismlar["jadval"] = n; return self
    def shart(self, s): self.qismlar["shart"] = s; return self
    def qur(self): return f"SELECT * FROM {self.qismlar['jadval']}..."
# zanjir: .jadval("users").shart("id=1").qur()

Builder (quruvchi) — murakkab obyektni qadam-baqadam yig'ish: har qadam bir qism qo'shadi (.jadval().shart().tartib()), oxirida qur(). Sabab: murakkab obyekt (ko'p parametr, ixtiyoriy qismlar) — bitta ulkan konstruktor o'rniga ravshan zanjir. Foydalanish: SQL so'rov, HTTP so'rov, murakkab konfiguratsiya, hujjat. Ko'pincha fluent (zanjir — return self). Builder — murakkablikni qadamlarga bo'lish. Qadam-baqadam qurish — ravshan va moslashuvchan.

2.5. Prototype (nusxa)

Mavjud obyektdan klonlash:

import copy
asl = Shablon(rang="qora", olcham=12)
nusxa = copy.deepcopy(asl)   # klon
nusxa.rang = "qizil"          # o'zgartirish (asl tegilmaydi)

Prototype (nusxa/prototip) — yangi obyektni noldan emas, mavjud obyektni klonlash orqali yaratish: copy.deepcopy(asl) — nusxa, keyin o'zgartirish. Sabab: obyekt yaratish qimmat (ko'p sozlash) yoki murakkab — tayyor namunani nusxalash tezroq; yoki bir xil asosli ko'p obyekt (shablon + kichik farq). Python'da: copy.copy (sayoz), copy.deepcopy (chuqur — ichki obyektlar ham). Foydalanish: shablon, standart konfiguratsiya, o'yin obyektlari. Prototype — klonlash orqali yaratish.

2.6. Naqsh qachon kerak (va kerak emas)

Naqsh — vosita, maqsad emas: muammo bo'lganda qo'llash, "naqsh ishlatish uchun" emas. Belgi: takror muammo (Factory — takror yaratish), murakkablik (Builder — ko'p parametr), cheklov (Singleton — bitta nusxa kerak). Haddan qo'llash (over-engineering) — har oddiy narsaga naqsh — murakkablik (KISS buzildi): oddiy obyektga Factory keraksiz (Sinf() yetadi). "Naqsh hidini" sez (muammo naqshga mos), lekin majburlama. Ko'pincha oddiy Python (funksiya, dataclass, modul) naqshni almashtiradi. Naqsh — muammoga javob, ko'rgazma emas.

2.7. Naqshlar va SOLID

Yaratuvchi naqshlar SOLID ni (27.2) amalda qo'llaydi: Factory — yaratishni ajratadi (SRP), yangi turga ochiq (OCP), aniq sinfga bog'lamaydi (DIP); Builder — qurish mas'uliyatini ajratadi (SRP); Singleton — yagona nuqta (lekin DIP bilan ziddiyat — global). Naqshlar — SOLID ning "retsepti" (tamoyilni qanday amalga oshirish). Ular toza kod 27.1-bob va SOLID ustiga quriladi: naqsh — struktura, toza kod — sifat. Naqshlarni bilish — SOLID ni amaliy qo'llash. Naqsh — tamoyilning kod ko'rinishi.

2.8. Yaratuvchi naqshlar — obyekt hayotining boshi

Yaratuvchi naqshlar obyekt hayotining boshini (yaratilishini) boshqaradi: kim yaratadi (Factory), nechta (Singleton), qanday (Builder), nimadan (Prototype). Bu "yaratish" mantiqini "ishlatish" mantiqidan ajratadi (mijoz obyektni ishlatadi, yaratishni bilmaydi — past bog'liqlik). Katta tizimda obyektlar ko'p va murakkab (bog'liqliklar, konfiguratsiya) — yaratishni tartibga solish muhim (DI konteynerlar buni avtomatlashtiradi — 20-qism FastAPI Depends). Keyingi darslar: strukturaviy (27.4 — obyektlar qanday bog'lanadi), xulq-atvor (27.5 — qanday o'zaro ishlaydi). Yaratuvchi naqshlar — poydevor (obyekt tug'iladi, keyin ishlaydi).

3. Tez ma'lumotnoma

# FACTORY — yaratishni ajrat
class Fabrika:
    @staticmethod
    def yarat(turi: str):
        return {"a": SinfA, "b": SinfB}[turi]()

# SINGLETON — bitta nusxa
class S:
    _n = None
    def __new__(cls):
        if cls._n is None: cls._n = super().__new__(cls)
        return cls._n

# BUILDER — qadam-baqadam (fluent)
class Quruvchi:
    def qism(self, x): self._x = x; return self
    def qur(self): return Natija(self._x)
q = Quruvchi().qism(1).qur()

# PROTOTYPE — klonlash
import copy
nusxa = copy.deepcopy(asl)

# QACHON: takror/murakkab muammo bor
# QACHON EMAS: oddiy (Sinf() yetadi) — KISS

Yaratuvchi naqshlar xulosasi

Factory — yaratishni ajrat (turga qarab, bir joyda)
Singleton — bitta nusxa (sozlama, ehtiyot: global)
Builder — qadam-baqadam (murakkab obyekt, fluent)
Prototype — klonlash (copy.deepcopy)
Naqsh — muammoga javob (majburlama, KISS)
SOLID ni amalda qo'llaydi (SRP, OCP, DIP)

4. Batafsil misollar

Misollar sof Python bilan — deterministik.

Misol 1 — Factory: turga qarab obyekt

"""Factory: yaratishni bir joyga ajratish (yangi tur qo'shish oson)."""
from abc import ABC, abstractmethod


class Hisobot(ABC):
    @abstractmethod
    def chiqar(self, malumot: str) -> str: ...


class PdfHisobot(Hisobot):
    def chiqar(self, malumot: str) -> str:
        return f"[PDF] {malumot}"


class ExcelHisobot(Hisobot):
    def chiqar(self, malumot: str) -> str:
        return f"[EXCEL] {malumot}"


class HtmlHisobot(Hisobot):
    def chiqar(self, malumot: str) -> str:
        return f"[HTML] <p>{malumot}</p>"


class HisobotFabrikasi:
    _turlar = {"pdf": PdfHisobot, "excel": ExcelHisobot, "html": HtmlHisobot}

    @classmethod
    def yarat(cls, turi: str) -> Hisobot:
        if turi not in cls._turlar:
            raise ValueError(f"Noma'lum tur: {turi}")
        return cls._turlar[turi]()


def main() -> None:
    print("=== 1. Fabrikadan obyekt yaratish ===")
    for turi in ["pdf", "excel", "html"]:
        h = HisobotFabrikasi.yarat(turi)
        print(f"  {turi}: {h.chiqar('Sotuv 100')}")

    print("\n=== 2. Mijoz aniq sinfni bilmaydi ===")
    h = HisobotFabrikasi.yarat("pdf")
    print(f"  tur: {type(h).__name__}")

    print("\n=== 3. Noma'lum tur — xato ===")
    try:
        HisobotFabrikasi.yarat("word")
    except ValueError as e:
        print(f"  {e}")

    print("\n=== 4. Yangi tur qo'shish oson ===")
    print("  faqat _turlar lug'atiga qo'shiladi (OCP)")
    print(f"  hozirgi turlar: {list(HisobotFabrikasi._turlar)}")
    print("  ⭐ Factory — yaratish bir joyda (turga qarab)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Fabrikadan obyekt yaratish ===
  pdf: [PDF] Sotuv 100
  excel: [EXCEL] Sotuv 100
  html: [HTML] <p>Sotuv 100</p>

=== 2. Mijoz aniq sinfni bilmaydi ===
  tur: PdfHisobot

=== 3. Noma'lum tur — xato ===
  Noma'lum tur: word

=== 4. Yangi tur qo'shish oson ===
  faqat _turlar lug'atiga qo'shiladi (OCP)
  hozirgi turlar: ['pdf', 'excel', 'html']
  ⭐ Factory — yaratish bir joyda (turga qarab)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 2 — Singleton: yagona nusxa

"""Singleton: butun dasturda bitta nusxa (sozlama)."""


class Sozlama:
    _nusxa = None

    def __new__(cls):
        if cls._nusxa is None:
            cls._nusxa = super().__new__(cls)
            cls._nusxa.qiymatlar = {}
        return cls._nusxa

    def ornat(self, kalit: str, qiymat: str) -> None:
        self.qiymatlar[kalit] = qiymat

    def ol(self, kalit: str) -> str:
        return self.qiymatlar.get(kalit, "")


def main() -> None:
    print("=== 1. Ikki marta yaratish ===")
    s1 = Sozlama()
    s2 = Sozlama()
    print(f"  s1 is s2 (bir xil nusxa): {s1 is s2}")

    print("\n=== 2. Bir joyda o'zgartirish, boshqada ko'rinadi ===")
    s1.ornat("til", "uz")
    print(f"  s2.ol('til'): {s2.ol('til')}")

    print("\n=== 3. Umumiy holat ===")
    s2.ornat("tema", "qora")
    print(f"  s1 qiymatlar: {s1.qiymatlar}")

    print("\n=== 4. Ehtiyot: global holat ===")
    print("  bitta nusxa — qulay (sozlama)")
    print("  lekin global (test qiyin, yashirin bog'liqlik)")
    print("  ⭐ Singleton — bitta nusxa (ehtiyot bilan)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Ikki marta yaratish ===
  s1 is s2 (bir xil nusxa): True

=== 2. Bir joyda o'zgartirish, boshqada ko'rinadi ===
  s2.ol('til'): uz

=== 3. Umumiy holat ===
  s1 qiymatlar: {'til': 'uz', 'tema': 'qora'}

=== 4. Ehtiyot: global holat ===
  bitta nusxa — qulay (sozlama)
  lekin global (test qiyin, yashirin bog'liqlik)
  ⭐ Singleton — bitta nusxa (ehtiyot bilan)

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Builder: qadam-baqadam qurish

"""Builder: murakkab obyektni qadam-baqadam (fluent zanjir)."""


class SorovQuruvchi:
    def __init__(self) -> None:
        self._jadval = ""
        self._shartlar: list = []
        self._tartib = ""

    def jadval(self, nom: str) -> "SorovQuruvchi":
        self._jadval = nom
        return self

    def shart(self, ifoda: str) -> "SorovQuruvchi":
        self._shartlar.append(ifoda)
        return self

    def tartib(self, ustun: str) -> "SorovQuruvchi":
        self._tartib = ustun
        return self

    def qur(self) -> str:
        sorov = f"SELECT * FROM {self._jadval}"
        if self._shartlar:
            sorov += " WHERE " + " AND ".join(self._shartlar)
        if self._tartib:
            sorov += f" ORDER BY {self._tartib}"
        return sorov


def main() -> None:
    print("=== 1. Oddiy so'rov ===")
    s1 = SorovQuruvchi().jadval("users").qur()
    print(f"  {s1}")

    print("\n=== 2. Shartli so'rov ===")
    s2 = SorovQuruvchi().jadval("users").shart("yosh > 18").qur()
    print(f"  {s2}")

    print("\n=== 3. To'liq (zanjir) ===")
    s3 = (
        SorovQuruvchi()
        .jadval("orders")
        .shart("narx > 100")
        .shart("faol = 1")
        .tartib("sana")
        .qur()
    )
    print(f"  {s3}")

    print("\n=== 4. Fluent zanjir ===")
    print("  har qadam .qism() → return self")
    print("  murakkab obyekt — ravshan qadamlar")
    print("  ⭐ Builder — qadam-baqadam (fluent)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Oddiy so'rov ===
  SELECT * FROM users

=== 2. Shartli so'rov ===
  SELECT * FROM users WHERE yosh > 18

=== 3. To'liq (zanjir) ===
  SELECT * FROM orders WHERE narx > 100 AND faol = 1 ORDER BY sana

=== 4. Fluent zanjir ===
  har qadam .qism() → return self
  murakkab obyekt — ravshan qadamlar
  ⭐ Builder — qadam-baqadam (fluent)

Nima ko'rsatdi: 2.4-bo'lim.

Misol 4 — Prototype: klonlash

"""Prototype: mavjud obyektni klonlash (copy.deepcopy) va o'zgartirish."""
import copy


class Shablon:
    def __init__(self, sarlavha: str, uslub: dict) -> None:
        self.sarlavha = sarlavha
        self.uslub = uslub

    def __repr__(self) -> str:
        return f"Shablon({self.sarlavha!r}, {self.uslub})"


def main() -> None:
    asl = Shablon("Hisobot", {"rang": "qora", "olcham": 12})

    print("=== 1. Asl shablon ===")
    print(f"  {asl}")

    print("\n=== 2. Sayoz nusxa (copy) ===")
    sayoz = copy.copy(asl)
    sayoz.sarlavha = "Nusxa"
    print(f"  sayoz sarlavha o'zgardi: {sayoz.sarlavha}")
    print(f"  asl sarlavha (o'zgarmadi): {asl.sarlavha}")

    print("\n=== 3. Chuqur nusxa (deepcopy) ===")
    chuqur = copy.deepcopy(asl)
    chuqur.uslub["rang"] = "qizil"    # ichki lug'at o'zgaradi
    print(f"  chuqur rang: {chuqur.uslub['rang']}")
    print(f"  asl rang (o'zgarmadi): {asl.uslub['rang']}")

    print("\n=== 4. Sayoz vs chuqur farqi ===")
    sayoz2 = copy.copy(asl)
    sayoz2.uslub["olcham"] = 20        # asl ham o'zgaradi (bir lug'at!)
    print(f"  sayoz ichki o'zgardi → asl olcham: {asl.uslub['olcham']}")
    print("  sayoz — ichki obyekt umumiy; chuqur — mustaqil")
    print("  ⭐ Prototype — klonlash (deepcopy mustaqil)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Asl shablon ===
  Shablon('Hisobot', {'rang': 'qora', 'olcham': 12})

=== 2. Sayoz nusxa (copy) ===
  sayoz sarlavha o'zgardi: Nusxa
  asl sarlavha (o'zgarmadi): Hisobot

=== 3. Chuqur nusxa (deepcopy) ===
  chuqur rang: qizil
  asl rang (o'zgarmadi): qora

=== 4. Sayoz vs chuqur farqi ===
  sayoz ichki o'zgardi → asl olcham: 20
  sayoz — ichki obyekt umumiy; chuqur — mustaqil
  ⭐ Prototype — klonlash (deepcopy mustaqil)

Nima ko'rsatdi: 2.5-bo'lim.

5. To'g'ri va noto'g'ri tushunishlar

6. Keng tarqalgan xatolar va yechimlari

1. Naqshni majburlash (over-engineering)

class SonFabrikasi: ...   # oddiy songa      # ⚠️
son = 5                                       # ✅ KISS

2. Factory da if/elif o'sadi

if t=="a": ... elif t=="b": ...   # uzun     # ⚠️
_turlar = {"a": A, "b": B}  # lug'at          # ✅

3. Singleton — global holat suiiste'moli

# hamma joyda Singleton (yashirin bog'liqlik)  # ⚠️
# DI (parametr) yoki modul obyekti             # ✅

4. Builder da return self unutish

def qism(self, x): self._x = x   # None        # ⚠️
def qism(self, x): self._x = x; return self    # ✅

5. Sayoz nusxa (ichki obyekt umumiy)

copy.copy(obj)   # ichki lug'at umumiy         # ⚠️
copy.deepcopy(obj)  # to'liq mustaqil          # ✅

6. Naqsh nomini bilmay ishlatish

# "aqlli" nom (o'zi o'ylagan)                   # ⚠️
# standart nom (Factory, Builder — umumiy til)  # ✅

7. Python'ni unutish (oddiyroq yo'l bor)

class Fabrika: ...   # oddiy holatga            # ⚠️
# dataclass, dict, funksiya (Python idiomi)     # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 27.2-dars (o'tilgan): SOLID — naqshlar amalga oshiradi
• 27.4-dars: Strukturaviy naqshlar — bog'lanish
• 27.5-dars: Xulq-atvor naqshlar — o'zaro ta'sir
• 20-qism (o'tilgan): FastAPI — DI (Factory/Singleton)
• 16-qism (o'tilgan): OOP — sinf, meros

8. Eng yaxshi amaliyotlar

1. Naqsh — muammoga (majburlama).

2. Factory — turga qarab yaratish.

3. Singleton — ehtiyot (global holat).

4. Builder — murakkab obyekt (fluent).

5. deepcopy — mustaqil nusxa.

6. Standart nom (umumiy til).

7. Python idiomi (dataclass, dict) — oddiyroq.

8. KISS — haddan naqsh emas.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # dizayn naqshi nima?
2.  # naqsh tayyor kodmi?
3.  # yaratuvchi naqsh nima?
4.  # Factory nima?
5.  # Factory qanday foyda?
6.  # Singleton nima?
7.  # Singleton xatari?
8.  # Builder nima?
9.  # fluent nima?
10. # Prototype nima?
11. # copy vs deepcopy?
12. # naqsh qachon kerak emas?

Vazifa 2: Xatolarni tuzating

1.  class SonFabrikasi   # oddiy songa      # KISS

2.  if t=="a" elif t=="b"  # uzun           # lug'at

3.  def qism(self,x): self._x=x  # None      # return

4.  copy.copy(obj)  # ichki umumiy           # deepcopy

5.  # o'zi o'ylagan nom                       # standart

1.  son = 5   # oddiy (naqsh keraksiz)

2.  _turlar = {"a": A, "b": B}

3.  def qism(self, x): self._x = x; return self

4.  copy.deepcopy(obj)

5.  Factory, Builder (umumiy til)

Vazifa 3: Factory

Tuzing:

1. Abstraksiya
2. Vorislar
3. Fabrika
4. Yangi tur

Vazifa 4: Singleton

Tuzing:

1. __new__
2. _nusxa
3. Bir xil
4. Ehtiyot

Vazifa 5: Builder

Tuzing:

1. Qadamlar
2. return self
3. Zanjir
4. qur()

Vazifa 6: Prototype

Tuzing:

1. Asl
2. deepcopy
3. O'zgartirish
4. Mustaqil

Vazifa 7: O'ylash

Dizayn naqshlari — kuchli vosita, lekin haddan qo'llash (over-engineering) toza kodning dushmani (har oddiy narsaga Factory, Builder — murakkablik). Nima uchun tajribasiz dasturchilar ko'pincha naqshlarni haddan ishlatadi (yangi o'rgangan bolg'a — hamma narsa mix ko'rinadi), va nega "naqsh kerakmi?" savoli "qaysi naqsh?" savolidan muhimroq?

Nimani mustahkamlaydi: 2.6, 2.7-bo'limlar.

Xulosa

Bu darsda yaratuvchi dizayn naqshlarini o'rgandik.

Eng muhim uch fikr:

1. Dizayn naqshi va Factory. Dizayn naqshi — dasturlashda tez-tez uchraydigan muammoning sinalgan, nomlangan yechimi (tajribali dasturchilar andozasi): tayyor kod emas, g'oya (qolip); foydasi — sinalgan, umumiy til (nom bilan muloqot), tez. Uch tur: yaratuvchi (obyekt), strukturaviy 27.4-bob, xulq-atvor 27.5-bob. Factory (fabrika) — obyekt yaratishni alohida joyga topshirish (Fabrika.yarat(turi)): yaratish bir joyda (DRY), yangi tur oson (OCP), aniq sinfga bog'lanmaydi (DIP) — turga qarab obyekt (format, to'lov).

2. Singleton, Builder, Prototype. Singleton (yagona nusxa) — sinfning butun dasturda bitta nusxasi (__new__ bilan) — sozlama, log; ehtiyot: global holat (test qiyin — ba'zan anti-naqsh). Builder (quruvchi) — murakkab obyektni qadam-baqadam yig'ish (.qism().qism().qur() — fluent zanjir, return self) — SQL/HTTP so'rov, murakkab konfiguratsiya. Prototype (nusxa) — mavjud obyektni klonlash (copy.deepcopy — chuqur, mustaqil; copy.copy — sayoz, ichki obyekt umumiy) — shablon, standart konfiguratsiya.

3. Naqsh — muammoga javob, majburlama emas. Naqsh — vosita, maqsad emas: takror/murakkab muammo bo'lganda qo'llash ("naqsh ishlatish uchun" emas). Haddan qo'llash (over-engineering) — har oddiy narsaga naqsh — murakkablik (KISS buzildi); oddiy Python (funksiya, dataclass, dict, modul) ko'pincha naqshni almashtiradi. "Naqsh kerakmi?" savoli "qaysi naqsh?" dan muhimroq (ko'pincha javob — yo'q); to'g'ri ketma-ketlik: avval oddiy (KISS), muammo ko'ringanda naqsh (refactoring). Yaratuvchi naqshlar SOLID ni 27.2-bob amalda qo'llaydi (Factory — SRP/OCP/DIP) va obyekt hayotining boshini (yaratilishini) boshqaradi (kim, nechta, qanday, nimadan) — "yaratish"ni "ishlatish"dan ajratadi. Yetuklik — naqshni bilish emas, qachon kerak emasligini bilish.

Keyingi darsda strukturaviy dizayn naqshlarini o'rganamiz: obyektlar va sinflar qanday bog'lanishi haqidagi naqshlar (Adapter, Decorator, Facade, Proxy, Composite) — mavjud qismlarni moslashtirish va birlashtirish.