31.11-dars: Texnik intervyu — Python savollari

31-QISM — KARYERA VA KATTA LOYIHALAR · 11-dars

1. Kirish va motivatsiya

Algoritmik intervyu 31.10-bob umumiy edi. Endi Python'ga xos intervyu savollari — bu til tanlaganingizni chuqur bilishingizni tekshiradi. Intervyuer so'raydi: "GIL nima?", "generator va ro'yxat farqi?", "dekorator qanday ishlaydi?", "is va == farqi?". Bu savollar sizni haqiqiy Python dasturchidan (tilni chuqur biladigan) sirtqidan (faqat sintaksis) ajratadi. Yaxshi xabar: bu savollar aniq — ma'lum mavzular bor (GIL, generator, dekorator, kontekst menejer, xotira, muomala turlari). Bu dars eng ko'p so'raladigan Python savollarini va ularga aniq, chuqur javob berishni o'rgatadi. Kursning ko'p qismini (16-21 qismlar) esga oladi.

Python intervyu savollari — tilni chuqur bilishni tekshiruvchi savollar: GIL (Global Interpreter Lock — bir ip, 17/30.5-qism), generator vs ro'yxat (lazy — xotira, 11-qism), dekorator (funksiyani o'rash — 14-qism), is vs == (ayniyat vs tenglik), o'zgaruvchan standart argument (def f(x=[]) tuzoq), kontekst menejer (with — 13-qism), *args/**kwargs (o'zgaruvchan argument). Foydalanish: Python intervyu, chuqur bilim. Bu 11-21 qismlar (Python xususiyatlari) ni intervyuga tatbiq. Bu 31.10 (algoritmlar), 15-21 qismlar bilan bog'liq. Python savollari — GIL, generator, dekorator, is/==. Chuqur bilim.

Real vaziyat. Ikki nomzod bir savol oldi: "is va == farqi?". Birinchi: "ikkalasi ham tenglik tekshiradi" (noto'g'ri — sirtqi). Ikkinchi: "== qiymat tengligi (__eq__), is ayniyat — bir obyektmi (xotira manzili); masalan a = [1,2]; b = [1,2] → a == b True (qiymat teng), a is b False (turli obyekt); Noneni is None bilan tekshiriladi" (to'g'ri, chuqur, misol bilan). Intervyuer ikkinchini tanladi — chuqur bildi (til mexanizmi, misol). Python savollari — chuqur, aniq, misolli javob.

Bu darsda Python intervyu savollarini o'rganamiz.

Bu darsda:

• GIL (Global Interpreter Lock)
• Generator vs ro'yxat
• Dekorator va kontekst menejer
• is vs == va xotira
• Umumiy tuzoq savollar
• Savollarga yondashuv
• Python savollari amaliyoti
• Amaliy: Python savollari modeli

ℹ Savollar chuqur bilim talab qiladi; misollar Python tushunchalarini (deterministik) modellashtiradi.

2. Nazariya — chuqur tushuntirish

2.1. GIL (Global Interpreter Lock)

Eng ko'p so'raladigan savol:

SAVOL: "GIL nima va nega muhim?"

JAVOB:
   GIL — bir vaqtda faqat BIR ip Python bytecode bajaradi
   sabab: xotira boshqaruvi (havola hisobi) xavfsizligi
   ta'sir: CPU-og'ir ishda thread parallel EMAS
   yechim: multiprocessing (jarayonlar), yoki C/async (I/O)

GIL (Global Interpreter Lock) — eng ko'p so'raladigan Python savoli: javob — GIL bir vaqtda faqat bir ip Python bytecode bajaradi (17/30.5-qism); sabab — xotira boshqaruvi (havola hisobi — reference counting) xavfsizligi (ip-xavfsiz emas); ta'sir — CPU-og'ir ishda thread parallel emas (bir ip); yechim — multiprocessing (jarayonlar — GIL'dan qochadi), C kengaytma (30.6 — GIL bo'shatadi), yoki async (I/O — GIL muammo emas). Sabab: GIL Python'ning muhim xususiyati (parallellikka ta'sir — intervyuer biladingizni tekshiradi); chuqur javob (nima, nega, ta'sir, yechim) — chuqur bilim. GIL — bir ip, havola xavfsizligi. CPU parallel emas. multiprocessing.

2.2. Generator vs ro'yxat

Xotira va lazy:

SAVOL: "generator va ro'yxat farqi?"

JAVOB:
   ro'yxat — barcha element XOTIRADA (bir vaqtda)
   generator — LAZY (bir vaqtda bitta — yield)

   ro'yxat: [x*2 for x in range(1000000)]  → 1M xotira
   generator: (x*2 for x in range(1000000)) → deyarli 0

   → katta ma'lumot: generator (xotira tejaydi)

Generator vs ro'yxat — xotira va lazy: javob — ro'yxat barcha element xotirada (bir vaqtda — [...]), generator lazy (bir vaqtda bitta — yield, (...), 11-qism); ro'yxat [x*2 for x in range(1M)] → 1M xotira, generator (x*2 for ...) → deyarli 0 (kerak paytda hisoblaydi). Sabab: generator xotira tejaydi (katta ma'lumot — 1M element ro'yxat og'ir, generator yengil); lekin generator bir marta (qayta ishlatib bo'lmaydi — o'qilgach tugaydi). Foydalanish: katta ma'lumot (generator — oqim, xotira), kichik (ro'yxat — qayta ishlatish). Bu 11-qism (generatorlar) amaliyoti. Generator vs ro'yxat — lazy vs xotira. Katta → generator. yield.

2.3. Dekorator va kontekst menejer

Ikki muhim mexanizm:

DEKORATOR (14-qism):
   funksiyani o'rash (o'zgartirmasdan xatti-harakat qo'shish)
   @decorator → funksiya = decorator(funksiya)
   misol: @timer, @cache, @login_required

KONTEKST MENEJER (13-qism):
   with — resursni avtomatik boshqarish (och/yop)
   __enter__ / __exit__ (yoki @contextmanager)
   misol: with open(...) — fayl avtomatik yopiladi

Dekorator va kontekst menejer — ikki muhim mexanizm: dekorator (14-qism — funksiyani o'rash, o'zgartirmasdan xatti-harakat qo'shish; @decorator → funksiya = decorator(funksiya); misol @timer, @cache, @login_required — 30.10 PyO3 atribut kabi), kontekst menejer (13-qism — with bilan resursni avtomatik boshqarish; __enter__/__exit__ yoki @contextmanager; misol with open(...) — fayl avtomatik yopiladi). Sabab: dekorator/kontekst menejer Python'ning kuchli xususiyatlari (o'rash, resurs — intervyuer biladingizni tekshiradi); chuqur javob (qanday ishlaydi, misol) — chuqur bilim. Dekorator — o'rash. Kontekst menejer — resurs (with). Chuqur mexanizm.

2.4. is vs == va xotira

Ayniyat vs tenglik:

SAVOL: "is va == farqi?"

JAVOB:
   ==  — QIYMAT tengligi (__eq__ chaqiradi)
   is  — AYNIYAT (bir obyektmi — xotira manzili)

   a = [1,2]; b = [1,2]
   a == b  → True  (qiymat teng)
   a is b  → False (turli obyekt — turli xotira)

   → None, True, False ni 'is' bilan tekshir (yagona obyekt)

is vs == va xotira — ayniyat vs tenglik: javob — == qiymat tengligi (__eq__ chaqiradi — mazmun teng?), is ayniyat (identity — bir obyektmi, xotira manzili teng?); a = [1,2]; b = [1,2] → a == b True (qiymat teng), a is b False (turli obyekt — turli xotira). Sabab: is va == chalkashadi (yangilar — intervyuer tushunishingizni tekshiradi); None/True/False ni is bilan (yagona obyekt — x is None, x == None emas). Kichik int (-5..256) Python kesh qiladi (a = 5; b = 5; a is b True — kesh, lekin bunga tayanma). is — ayniyat (obyekt), == — qiymat. None → is. Xotira.

2.5. Umumiy tuzoq savollar

Xatoga moyil holatlar:

O'ZGARUVCHAN STANDART ARGUMENT:
   def f(x=[]):  # TUZOQ — bir ro'yxat barcha chaqiruvga
       x.append(1); return x
   f() → [1], f() → [1,1]  (kutilmagan!)
   yechim: def f(x=None): if x is None: x = []

SHALLOW vs DEEP COPY:
   copy() — sirtqi (ichki obyektlar bir xil)
   deepcopy() — to'liq (ichki ham nusxa)

MUTABLE vs IMMUTABLE:
   list/dict/set — o'zgaruvchan · tuple/str/int — o'zgarmas

Umumiy tuzoq savollar — xatoga moyil holatlar: o'zgaruvchan standart argument (def f(x=[]) — TUZOQ: standart [] bir marta yaratiladi, barcha chaqiruv bir ro'yxatni ulashadi — f()→[1], f()→[1,1] kutilmagan; yechim def f(x=None): if x is None: x = []), shallow vs deep copy (copy() — sirtqi, ichki obyektlar bir xil; deepcopy() — to'liq nusxa), mutable vs immutable (list/dict/set — o'zgaruvchan, tuple/str/int — o'zgarmas). Sabab: bular klassik tuzoqlar (intervyuer xatoga moyil joylarni tekshiradi — chuqur bilim); tushunish (nega — mexanizm). Bu 5/16-qism (obyektlar) amaliyoti. Tuzoq — standart argument, copy, mutable. Klassik. Mexanizm.

2.6. Savollarga yondashuv

Python savollarga yondashuv: aniq javob (nima — ta'rif); sabab (nega — mexanizm, "chunki"); misol (kod — ko'rsat, 31.8); ta'sir/yechim (amaliy — qachon, qanday); halol (bilmasang — "aniq bilmayman, lekin taxminim..."); chuqurlik (sirtqi emas — mexanizm). Sabab: Python savollari chuqur bilimni tekshiradi (til mexanizmi — sirtqi sintaksis emas); yaxshi javob (nima + nega + misol + ta'sir) — chuqur; yomon ("ikkalasi tenglik" — sirtqi). Tayyorgarlik (mavzular — GIL, generator, dekorator, is/== — ma'lum, o'rgan). Tuzoqlar: sirtqi javob (mexanizm yo'q), misol yo'q (mavhum), yolg'on (bilmasang halol — 31.9), yodlash (tushunmasdan — chuqur savolda tushadi). Yondashuv — aniq, sabab, misol, chuqur. Python savollari — chuqur, misolli.

2.7. Python savollari amaliyoti

Python intervyu savollari amaliyotlari: mavzularni o'rgan (GIL, generator, dekorator, kontekst menejer, is/==, tuzoqlar — ma'lum); mexanizm tushun (nega — sirtqi emas); misol tayyorla (har mavzuga — kod ko'rsat); kurs esla (11-21 qismlar — Python xususiyatlari); amaliyot (savol-javob mashqi, o'zi tushuntir); halol (bilmasang — ayt, taxmin qil); bog'la (mavzular bog'liq — GIL↔multiprocessing, generator↔xotira). Tuzoqlar: sirtqi (mexanizm yo'q — chuqur savolda tushadi), yodlash (tushunmasdan — variatsiyada tushadi), misol yo'q (mavhum — kod kuchliroq), yolg'on (bilgandek — tushadi). Amaliyot — mavzu, mexanizm, misol, kurs esla. Python savollari — chuqur tayyorgarlik.

2.8. Python savollari — tilni chuqur bilishni ko'rsatish

Python savollari asosiy g'oyasi — tilni chuqur bilishni ko'rsatish: intervyuer sizni haqiqiy Python dasturchidan (til mexanizmini biladigan — GIL, generator, dekorator) sirtqidan (faqat sintaksis) ajratadi. Chuqur bilim (nega — mexanizm) real ishda muhim (to'g'ri vosita, tuzoqlardan qochish — o'zgaruvchan argument, GIL). Bu savollar aniq (ma'lum mavzular — GIL, generator, dekorator, is/==, tuzoqlar); tayyorgarlik (o'rgan, misol, mexanizm) yengiladigan qiladi. Bu 11-21 qismlar (Python xususiyatlari) ni intervyuga tatbiq (kurs bilimi — esla). Natijaviy javob (nima + nega + misol — 31.8 "ko'rsat"), chuqurlik (sirtqi emas). Bu 31.10 (algoritmlar) bilan intervyu qismi, 31.12 (tizim dizayn) ga o'tish. Python savollari — chuqur bilim ko'rsat. Til mexanizmi. Aniq mavzular.

3. Tez ma'lumotnoma

GIL: bir ip Python bytecode (havola xavfsizligi)
   CPU parallel emas → multiprocessing / C / async (I/O)

GENERATOR vs RO'YXAT:
   ro'yxat — barcha xotirada · generator — lazy (yield, tejaydi)

DEKORATOR (14): funksiyani o'rash (@decorator)
KONTEKST MENEJER (13): with — resurs (__enter__/__exit__)

is vs ==:
   == qiymat (__eq__) · is ayniyat (obyekt, xotira)
   None/True/False → is

TUZOQLAR:
   def f(x=[]) — bir ro'yxat barchaga (yechim: x=None)
   shallow (copy) vs deep (deepcopy) · mutable vs immutable

YONDASHUV: nima + nega (mexanizm) + misol + ta'sir (chuqur)

QOIDA: mavzu o'rgan · mexanizm · misol · kurs esla · halol

Python savollari xulosasi

Python savollari — tilni chuqur bilish (mexanizm, sirtqi emas)
GIL — bir ip (havola xavfsizligi, CPU parallel emas)
Generator (lazy, xotira) vs ro'yxat (barcha xotirada)
Dekorator (o'rash) · kontekst menejer (with) · is (ayniyat) vs == (qiymat)
Javob — nima + nega + misol (chuqur, misolli)

4. Batafsil misollar

Savollar chuqur bilim talab qiladi; misollar Python tushunchalarini (deterministik) modellashtiradi.

Misol 1 — Generator vs ro'yxat (xotira)

"""Generator vs ro'yxat: xotira modeli."""

import sys


def main() -> None:
    print("=== 1. Ro'yxat (barcha xotirada) ===")
    royxat = [x * 2 for x in range(1000)]
    print(f"  turi: {type(royxat).__name__}, uzunlik: {len(royxat)}")
    print(f"  xotira: ~{sys.getsizeof(royxat)} bayt")

    print("\n=== 2. Generator (lazy) ===")
    gen = (x * 2 for x in range(1000))
    print(f"  turi: {type(gen).__name__}")
    print(f"  xotira: ~{sys.getsizeof(gen)} bayt (deyarli 0)")

    print("\n=== 3. Farq ===")
    print("  ro'yxat — barcha element, generator — bittadan (yield)")

    print("\n=== 4. Qachon ===")
    print("  katta ma'lumot → generator (xotira tejaydi)")
    print("  ⭐ Generator — lazy (xotira) vs ro'yxat (barcha)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Ro'yxat (barcha xotirada) ===
  turi: list, uzunlik: 1000
  xotira: ~8856 bayt

=== 2. Generator (lazy) ===
  turi: generator
  xotira: ~208 bayt (deyarli 0)

=== 3. Farq ===
  ro'yxat — barcha element, generator — bittadan (yield)

=== 4. Qachon ===
  katta ma'lumot → generator (xotira tejaydi)
  ⭐ Generator — lazy (xotira) vs ro'yxat (barcha)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 2 — is vs == (ayniyat vs qiymat)

"""is vs ==: ayniyat vs qiymat (model)."""


def main() -> None:
    a = [1, 2, 3]
    b = [1, 2, 3]
    c = a

    print("=== 1. == (qiymat) ===")
    print(f"  a == b: {a == b} (qiymat teng)")

    print("\n=== 2. is (ayniyat) ===")
    print(f"  a is b: {a is b} (turli obyekt)")
    print(f"  a is c: {a is c} (bir obyekt — c = a)")

    print("\n=== 3. None tekshiruvi ===")
    x = None
    print(f"  x is None: {x is None} (to'g'ri usul)")

    print("\n=== 4. Farq ===")
    print("  == qiymat (__eq__), is ayniyat (obyekt)")
    print("  ⭐ is (ayniyat) vs == (qiymat)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. == (qiymat) ===
  a == b: True (qiymat teng)

=== 2. is (ayniyat) ===
  a is b: False (turli obyekt)
  a is c: True (bir obyekt — c = a)

=== 3. None tekshiruvi ===
  x is None: True (to'g'ri usul)

=== 4. Farq ===
  == qiymat (__eq__), is ayniyat (obyekt)
  ⭐ is (ayniyat) vs == (qiymat)

Nima ko'rsatdi: 2.4-bo'lim.

Misol 3 — O'zgaruvchan standart argument (tuzoq)

"""O'zgaruvchan standart argument: klassik tuzoq (model)."""


def tuzoq(x=[]):        # TUZOQ — bir ro'yxat barchaga
    x.append(1)
    return x


def togri(x=None):      # yechim
    if x is None:
        x = []
    x.append(1)
    return x


def main() -> None:
    print("=== 1. Tuzoq (x=[]) ===")
    print(f"  tuzoq(): {tuzoq()}")
    print(f"  tuzoq(): {tuzoq()} (kutilmagan — bir ro'yxat!)")

    print("\n=== 2. Nega ===")
    print("  standart [] bir marta yaratiladi (ulashadi)")

    print("\n=== 3. To'g'ri (x=None) ===")
    print(f"  togri(): {togri()}")
    print(f"  togri(): {togri()} (har safar yangi)")

    print("\n=== 4. Yechim ===")
    print("  def f(x=None): if x is None: x = []")
    print("  ⭐ O'zgaruvchan standart — tuzoq (x=None)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Tuzoq (x=[]) ===
  tuzoq(): [1]
  tuzoq(): [1, 1] (kutilmagan — bir ro'yxat!)

=== 2. Nega ===
  standart [] bir marta yaratiladi (ulashadi)

=== 3. To'g'ri (x=None) ===
  togri(): [1]
  togri(): [1] (har safar yangi)

=== 4. Yechim ===
  def f(x=None): if x is None: x = []
  ⭐ O'zgaruvchan standart — tuzoq (x=None)

Nima ko'rsatdi: 2.5-bo'lim.

Misol 4 — Dekorator (o'rash)

"""Dekorator: funksiyani o'rash (model)."""

import functools


def hisoblagich(func):
    @functools.wraps(func)
    def orab(*args, **kwargs):
        orab.chaqiruvlar += 1        # xatti-harakat qo'shildi
        return func(*args, **kwargs)
    orab.chaqiruvlar = 0
    return orab


@hisoblagich
def salom(ism):
    return f"Salom, {ism}"


def main() -> None:
    print("=== 1. Dekoratorlangan funksiya ===")
    print(f"  {salom('Ali')}")
    print(f"  {salom('Vali')}")

    print("\n=== 2. Xatti-harakat qo'shildi ===")
    print(f"  chaqiruvlar soni: {salom.chaqiruvlar}")

    print("\n=== 3. Qanday ishlaydi ===")
    print("  @hisoblagich → salom = hisoblagich(salom)")

    print("\n=== 4. O'rash ===")
    print("  funksiyani o'zgartirmasdan (xatti-harakat)")
    print("  ⭐ Dekorator — funksiyani o'rash")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Dekoratorlangan funksiya ===
  Salom, Ali
  Salom, Vali

=== 2. Xatti-harakat qo'shildi ===
  chaqiruvlar soni: 2

=== 3. Qanday ishlaydi ===
  @hisoblagich → salom = hisoblagich(salom)

=== 4. O'rash ===
  funksiyani o'zgartirmasdan (xatti-harakat)
  ⭐ Dekorator — funksiyani o'rash

Nima ko'rsatdi: 2.3-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. is va == chalkashtirish

if x == None:   # ishlaydi, lekin noto'g'ri uslub              # ⚠️
if x is None:   # ayniyat (yagona obyekt)                       # ✅

2. O'zgaruvchan standart argument

def f(x=[]):   # bir ro'yxat barchaga (tuzoq)                  # ⚠️
def f(x=None): x = x or []   # har safar yangi                  # ✅

3. GIL'ni CPU sekinlik deb

# "GIL Python'ni sekin qiladi" (noto'g'ri)                     # ⚠️
# GIL — parallel emas (havola xavfsizligi)                      # ✅

4. Generatorni qayta ishlatish

gen = (x for x in range(3)); list(gen); list(gen)   # bo'sh    # ⚠️
# generator bir marta (qayta kerak → ro'yxat)                   # ✅

5. Shallow copy chuqur deb

b = a.copy(); b[0].append(1)   # a ham o'zgardi (ichki bir)    # ⚠️
b = copy.deepcopy(a)   # to'liq nusxa                           # ✅

6. Sirtqi javob

# "is tenglik" (mexanizm yo'q)                                 # ⚠️
# "is ayniyat — xotira manzili" (chuqur)                        # ✅

7. Bilmasa yolg'on

# bilmagan javobni to'qish (tushadi)                           # ⚠️
# "aniq bilmayman, taxminim..." (halol — 31.9)                  # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 11-21 qismlar (o'tilgan): Python xususiyatlari
• 30.5-dars (o'tilgan): GIL
• 31.10-dars (o'tilgan): Texnik intervyu — algoritmlar
• 31.12-dars: Tizim dizayni suhbati
• 13-14 qismlar (o'tilgan): Kontekst menejer, dekorator

8. Eng yaxshi amaliyotlar

1. Mavzularni o'rgan (GIL, generator, dekorator, is/==).

2. Mexanizm tushun (nega — sirtqi emas).

3. Misol tayyorla (har mavzuga — kod).

4. Kurs esla (11-21 qismlar).

5. Nima + nega + misol (chuqur javob).

6. Halol (bilmasang — ayt, taxmin).

7. Tuzoqlarni bil (standart argument, copy).

8. Amaliyot (savol-javob mashqi).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # GIL nima?
2.  # GIL nega?
3.  # GIL yechimi?
4.  # generator vs ro'yxat?
5.  # generator afzalligi?
6.  # dekorator nima?
7.  # kontekst menejer nima?
8.  # is vs ==?
9.  # None qanday tekshiriladi?
10. # def f(x=[]) tuzoq?
11. # shallow vs deep copy?
12. # javob qanday bo'lsin?

Vazifa 2: Xatolarni tuzating

1.  if x == None

2.  def f(x=[])

3.  # "GIL Python sekin"

4.  gen ni ikki marta list()

5.  # "is tenglik" (sirtqi)

1.  if x is None

2.  def f(x=None): x = x or []

3.  GIL parallel emas (havola xavfsizligi)

4.  generator bir marta (list qil)

5.  "is ayniyat — xotira" (chuqur)

Vazifa 3: GIL

Modellang:

1. Nima
2. Nega
3. Ta'sir
4. Yechim

Vazifa 4: Generator

Modellang:

1. Ro'yxat
2. Generator
3. Xotira
4. Qachon

Vazifa 5: is vs ==

Modellang:

1. ==
2. is
3. None
4. Xotira

Vazifa 6: Tuzoq

Modellang:

1. Standart argument
2. Nega
3. Yechim
4. copy

Vazifa 7: O'ylash

Python savollari "sirtqi" (faqat sintaksis) va "chuqur" (til mexanizmini biladigan) dasturchini ajratadi. Nima uchun "mexanizmni tushunish" (nega shunday ishlaydi) "sintaksisni yodlash"dan (qanday yozish) muhandislikda ancha qadrli, va nega chuqur tushunish yangi/kutilmagan muammolarni yechishda hal qiluvchi?

Nimani mustahkamlaydi: 2.6, 2.8-bo'limlar.

Xulosa

Bu darsda Python intervyu savollarini o'rgandik.

Eng muhim uch fikr:

1. GIL va generator. GIL (Global Interpreter Lock) — eng ko'p savol: bir vaqtda bir ip Python bytecode (17/30.5); sabab — xotira boshqaruvi (havola hisobi) xavfsizligi; ta'sir — CPU-og'ir thread parallel emas; yechim — multiprocessing, C kengaytma, async (I/O). Generator vs ro'yxat: ro'yxat barcha element xotirada ([...]), generator lazy (bir vaqtda bitta — yield, (...)); generator xotira tejaydi (katta ma'lumot), lekin bir marta (qayta ishlatib bo'lmaydi).

2. Dekorator/kontekst menejer, is/==. Dekorator (14-qism) — funksiyani o'rash (@decorator → funksiya = decorator(funksiya), @timer/@cache); kontekst menejer (13-qism) — with bilan resurs avtomatik (__enter__/__exit__, with open(...)). is vs ==: == qiymat tengligi (__eq__), is ayniyat (obyekt — xotira manzili); a=[1,2]; b=[1,2] → a==b True, a is b False; None/True/False → is. Tuzoqlar: o'zgaruvchan standart argument (def f(x=[]) — bir ro'yxat barchaga, yechim x=None), shallow vs deep copy, mutable vs immutable.

3. Yondashuv va chuqur bilim. Savollarga yondashuv: aniq javob (nima) + sabab (nega — mexanizm) + misol (kod) + ta'sir/yechim; halol (bilmasang — ayt), chuqurlik (sirtqi emas). Python savollari — tilni chuqur bilishni ko'rsatish (haqiqiy dasturchi — mexanizm, vs sirtqi — sintaksis); aniq mavzular (GIL, generator, dekorator, is/==, tuzoqlar — o'rgan); 11-21 qismlar (kurs) ni intervyuga tatbiq. "Mexanizmni tushunish" sintaksisni yodlashdan qadrli (umumlashtiriladigan — yangi holatga qo'llaniladi, tuzoqlardan qochish); chuqur tushunish yangi/kutilmagan muammolarda hal qiluvchi (yodlangan holat kam — tamoyil qo'llaniladi, tushunchalar bog'lanadi).

Keyingi (oxirgi) darsda Tizim dizayni suhbati ni o'rganamiz: katta miqyosli tizim dizaynini muhokama qilish — talablarni aniqlash, komponentlar, miqyoslash, ma'lumot saqlash, savdolar (trade-offs) va yuqori daraja fikrlash (butun kurs yakuni).