30.8-dars: Cython tezlashtirish

30-QISM — PYTHON VA BOSHQA TILLAR · 8-dars

1. Kirish va motivatsiya

Cython nima ekanini 30.7-bob ko'rdik: statik turlar, .pyx, kompilyatsiya. Endi uni amaliyotda ishlatamiz: haqiqiy sekin funksiyani olib, uni bosqichma-bosqich tezlashtiramiz. Bu jarayon aniq tartibga ega: (1) o'lcha (profil — qayer sekin, 29.1), (2) annotatsiya (cython -a — qaysi qatorlar Python obyekt ishlatadi, sariq rangda), (3) tur qo'sh (cdef — eng sariq/issiq joyga), (4) qayta o'lcha (tezlashdimi). Bu tsikl har qadamda taqqoslash bilan davom etadi. Bundan tashqari amaliy usullar bor: cdef funksiyalar (C chaqiruv), nogil (GIL bo'shatish), numpy massiv turlari (memoryview), chegara tekshiruvini o'chirish (boundscheck). Cython tezlashtirinishni "san'at"dan "muhandislik"ga aylantiradi.

Cython tezlashtirinishi — sekin Python kodni Cython bilan bosqichma-bosqich tezlashtirish amaliyoti: profil (29.1 — qayer sekin), annotatsiya (cython -a — sariq qatorlar Python obyekt), statik tur (cdef — issiq joyga), cdef funksiya (cdef/cpdef — C chaqiruv, tez), direktivalar (boundscheck=False, wraparound=False — tekshiruvni o'chir), nogil (GIL bo'shat — parallel), memoryview (numpy massiv — tez kirish). Foydalanish: sonli hisob, sikllar tezlashtirish. Bu 30.7 (Cython tushuncha) ning amaliyoti. Bu 30.7, 29.1 (profil) bilan bog'liq. Tezlashtirish — o'lcha, annotatsiya, cdef. Bosqichma-bosqich.

Real vaziyat. Bir jamoada rasm filtri (piksel sikli — million amal) 4 soniya edi (29.2 bottleneck). Cython amaliyoti: cython -a — ichki sikl sariq (Python obyekt har piksel). cdef int (piksel indekslari), memoryview (rasm massivi — C kirish), boundscheck=False (chegara tekshiruvi o'chirildi). Har qadamda qayta o'lchandi: 4s → 1.2s → 0.3s → 0.05s (80x). Kod deyarli Python (o'qiladi), lekin C tez. Jamoa taxmin qilmadi — o'lchadi (annotatsiya sariq joyni ko'rsatdi). Tezlashtirish — o'lchab, sariq joyga tur.

Bu darsda Cython tezlashtirinishni o'rganamiz.

Bu darsda:

• Tezlashtirish tsikli (o'lcha-tur-o'lcha)
• Annotatsiya (cython -a — sariq)
• cdef funksiyalar (C chaqiruv)
• Direktivalar (boundscheck)
• nogil va memoryview
• Tezlashtirish amaliyoti
• Umumiy tuzoqlar
• Amaliy: tezlashtirish modeli

ℹ Cython kompilyator talab qiladi; misollar tezlashtirish tsikli mantiqini (deterministik) modellashtiradi.

2. Nazariya — chuqur tushuntirish

2.1. Tezlashtirish tsikli

O'lcha → tur → o'lcha:

1. O'LCHA (profil — 29.1)
   qaysi funksiya/qator sekin (bottleneck)

2. ANNOTATSIYA (cython -a)
   sariq qatorlar — Python obyekt (sekin)

3. TUR QO'SH (cdef — eng sariq joyga)
   statik tur → C amal

4. QAYTA O'LCHA
   tezlashdimi? (yo'q → boshqa joy)

→ tsikl takrorlanadi (eng issiq joygacha)

Tezlashtirish tsikli — Cython amaliyotining tartibi: o'lcha (profil 29.1 — qayer sekin, taxmin emas) → annotatsiya (cython -a — sariq qatorlar, Python obyekt) → tur qo'sh (cdef — eng sariq/issiq joyga) → qayta o'lcha (tezlashdimi — tasdiqla) → takrorla (keyingi issiq joy). Sabab: tezlashtirish ma'lumotga asoslangan bo'lishi kerak (29.1 — taxmin emas); tsikl har qadamda tekshiradi (o'zgarish yaxshiladimi). Cheklov: eng issiq joygacha (Amdahl 29.2 — 3% kod, 97% vaqt), keyin to'xta (yetarli). Bu iterativ (bir marta emas — takroriy). Tsikl — o'lcha, tur, o'lcha. Ma'lumotga asoslangan. Iterativ.

2.2. Annotatsiya (cython -a)

Sariq joyni ko'rish:

cython -a mening.pyx  →  mening.html

HTML'da har qator rangli:
   oq (rangsiz) — sof C (tez)
   och sariq — kam Python o'zaro ta'sir
   to'q sariq — ko'p Python obyekt (sekin — bu yerga tur!)

→ eng sariq (to'q) qatorlarga cdef qo'sh

Annotatsiya (cython -a) — Cython'ning tezlashtirish kaliti: .pyx kodini HTML sifatida ko'rsatadi, har qatorni rangli (Python o'zaro ta'sir darajasi bo'yicha): oq (sof C — tez), sariq (Python obyekt — sekin, to'qroq = ko'proq). Sabab: qayer sekinligini ko'rsatadi (taxmin emas — 29.1); to'q sariq qatorda ko'p Python amal (obyekt, tur tekshirish — 30.7) → shu joyga cdef (tur berib oqartir). Foydalanish: annotatsiyani och → to'q sariq joyni top → tur qo'sh → qayta annotatsiya (oqardi?). Bu vizual profil (qator darajasida). Annotatsiya — sariq = Python (sekin). cython -a. To'q joyga tur.

2.3. cdef funksiyalar (C chaqiruv)

Tez funksiya chaqiruvi:

# def — Python funksiya (chaqiruv sekin — obyekt)
def yordamchi(x):
    return x * 2

# cdef — C funksiya (chaqiruv tez, lekin faqat Cython ichida)
cdef int yordamchi_c(int x):
    return x * 2

# cpdef — ikkalasi (Python'dan ham, C'dan ham)
cpdef int yordamchi_cp(int x):
    return x * 2

cdef funksiyalar — funksiya chaqiruvini tezlashtirish: def (oddiy Python funksiya — chaqiruv sekin, argument/natija obyekt), cdef (C funksiya — chaqiruv tez, C darajasida, lekin faqat Cython ichida ko'rinadi), cpdef (ikkalasi — Python'dan ham, Cython'dan ham). Sabab: sikl ichida funksiya chaqirish sekin (def — har chaqiruvda obyekt); cdef C chaqiruv (tez, obyektsiz). Foydalanish: ichki yordamchi funksiya (cdef — faqat Cython), tashqi interfeys (cpdef — Python ham). Bu sikl ichidagi chaqiruvlarni tezlashtiradi. cdef funksiya — C chaqiruv (tez). def/cdef/cpdef. Ichki — cdef.

2.4. Direktivalar (boundscheck)

Tekshiruvlarni o'chirish:

# Cython direktivalari (tezlik uchun tekshiruvni o'chir)
import cython

@cython.boundscheck(False)   # massiv chegara tekshiruvi o'chik
@cython.wraparound(False)    # manfiy indeks (a[-1]) o'chik
def tez_massiv(double[:] a):
    cdef int i
    cdef double s = 0
    for i in range(a.shape[0]):
        s += a[i]            # tekshiruvsiz kirish (tez)
    return s

Direktivalar — Cython'ning xavfsizlik tekshiruvlarini o'chirish (tezlik uchun): boundscheck=False (massiv chegara tekshiruvi — a[i] chegaradan chiqmaganini tekshirmaydi), wraparound=False (manfiy indeks — a[-1] ishlamaydi), cdivision=True (Python bo'lish tekshiruvi o'chik). Sabab: bu tekshiruvlar xavfsizlik (chegaradan chiqish — crash oldini), lekin sekin (har kirishda tekshiruv); ishonchli siklda (indeks to'g'ri) o'chirsa — tezroq. Xavf: chegaradan chiqsa — crash (tekshiruv yo'q); faqat ishonch hosil qilganda (test qilingan). Foydalanish: issiq sikl (massiv kirish — 30.8). Direktiva — tekshiruv o'chik (tez, lekin xavfli). boundscheck. Ehtiyot.

2.5. nogil va memoryview

GIL bo'shatish va tez massiv:

# nogil — GIL bo'shatish (parallel C — 30.5)
cdef double hisob(double[:] a) nogil:
    cdef double s = 0
    cdef int i
    for i in range(a.shape[0]):
        s += a[i]           # Python obyekt tegmaydi (GIL kerak emas)
    return s

# memoryview — numpy massivga tez kirish (double[:])
def ishla(double[:, :] rasm):   # 2D numpy massiv (C kirish)
    ...

nogil va memoryview — ikki kuchli amaliy usul: nogil (GIL bo'shatish — 30.5, funksiya Python obyektga tegmasa, GIL kerak emas → parallel C, ko'p yadro); memoryview (double[:], int[:, :] — numpy massivga to'g'ridan C kirish, obyektsiz — tez). Sabab: nogil bilan CPU-og'ir C sikl parallel (GIL to'smaydi — 30.5); memoryview bilan massiv elementlari C darajasida (numpy obyekt orqali emas — tez). Cheklov: nogil ichida Python obyekt yo'q (faqat C), memoryview tur aniq (double[:]). Foydalanish: numpy og'ir hisob (memoryview + nogil + boundscheck=False). nogil — parallel C. memoryview — tez massiv. Numpy bilan.

2.6. Tezlashtirish amaliyoti

Cython tezlashtirish amaliyotlari: o'lcha (profil 29.1 — bottleneck top); annotatsiya (cython -a — sariq joy); tsikl (o'lcha-tur-o'lcha, iterativ); issiq joyga cdef (to'q sariq — statik tur); cdef funksiya (sikl ichidagi chaqiruv — C); memoryview (numpy massiv — tez); direktiva ehtiyotkorlik (boundscheck=False faqat ishonchli sikl); nogil (parallel C — ehtiyot, Python obyekt yo'q); qayta o'lcha (har qadam tasdiqla). Tuzoqlar: profilsiz (noto'g'ri joy), hamma joyga tur (ortiqcha), direktiva xavfi (crash), nogil ichida Python obyekt (xato). Amaliyot — o'lcha, sariq, cdef, tasdiqla. Iterativ, ma'lumotga asoslangan.

2.7. Umumiy tuzoqlar

Cython tezlashtirish tuzoqlari: profilsiz optimallashtirish (29.1 — noto'g'ri joy tezlashtirish, foydasiz), hamma joyga tur (kod murakkab, ko'pi keraksiz — faqat issiq joy), direktiva xavfi (boundscheck=False noto'g'ri indeksda crash — faqat test qilingan sikl), nogil ichida Python (obyekt tegish — xato/crash), memoryview tur xatosi (double[:] int massivda — mos emas), qayta o'lchamaslik (tezlashdimi — bilmasdan), erta to'xtash (yoki haddan tashqari — Amdahl 29.2, yetarli joyda to'xta). Sabab: tezlashtirish ma'lumotga asoslangan (o'lcha — 29.1), tanlab (issiq joy — 29.2), ehtiyot (direktiva/nogil — xavfsizlik). Yechim: tsikl (o'lcha-tur-o'lcha), annotatsiya (sariq), test (direktiva oldin). Tuzoq — profilsiz, ortiqcha, xavfli direktiva. O'lcha, tanla, ehtiyot.

2.8. Tezlashtirish — o'lchashga asoslangan muhandislik

Cython tezlashtirish asosiy g'oyasi — o'lchashga asoslangan muhandislik: tezlashtirish taxminga emas, ma'lumotga asoslanadi (profil 29.1 — qayer sekin, annotatsiya — qaysi qator), va tanlab amalga oshadi (issiq joy — 29.2 Amdahl, 3% kod). Tsikl (o'lcha-tur-o'lcha) har qadamni tekshiradi (yaxshilandimi — obyektiv), taxminni emas. Bu 29-qism (unumdorlik — o'lcha, profil, benchmark) ning Cython'ga tatbiqi: sekin funksiya → profil → annotatsiya → cdef (issiq joy) → qayta o'lcha. Amaliy usullar (cdef funksiya, memoryview, nogil, direktiva) issiq joyga qo'llanadi (o'lchab topilgan). Natija: Python qulaylik (97% kod) + C tezlik (3% issiq joy). Bu 30.7 (Cython) ni amaliyotga aylantiradi. Tezlashtirish — o'lcha, sariq, cdef, tasdiqla. Muhandislik, san'at emas.

3. Tez ma'lumotnoma

# CYTHON TEZLASHTIRISH AMALIYOTI

# 1. O'LCHA (profil — 29.1): qayer sekin
# 2. ANNOTATSIYA: cython -a mening.pyx → sariq qatorlar (Python obyekt)
# 3. TUR QO'SH: issiq (to'q sariq) joyga cdef
# 4. QAYTA O'LCHA: tezlashdimi

# STATIK TUR (issiq joyga):
cdef int i, s

# CDEF FUNKSIYA (C chaqiruv):
cdef int yordamchi(int x): return x * 2   # faqat Cython
cpdef int interfeys(int x): return x * 2  # Python ham

# DIREKTIVALAR (tekshiruv o'chir — ehtiyot):
@cython.boundscheck(False)   # chegara tekshiruvi o'chik
@cython.wraparound(False)    # manfiy indeks o'chik

# NOGIL + MEMORYVIEW (numpy parallel):
cdef double hisob(double[:] a) nogil:   # GIL bo'shat + numpy
    cdef double s = 0
    cdef int i
    for i in range(a.shape[0]): s += a[i]
    return s

# QOIDA: o'lcha → sariq → cdef (issiq joy) → qayta o'lcha (iterativ)

Tezlashtirish xulosasi

Tsikl — o'lcha (profil) → annotatsiya (sariq) → cdef → qayta o'lcha
Annotatsiya — cython -a (sariq = Python obyekt, issiq joy)
cdef funksiya — C chaqiruv (cdef ichki, cpdef Python ham)
Direktiva — boundscheck/wraparound False (tez, xavfli — ehtiyot)
nogil (parallel C) + memoryview (numpy tez) · o'lchashga asoslangan

4. Batafsil misollar

Cython kompilyator talab qiladi; misollar tezlashtirish tsikli mantiqini (deterministik) modellashtiradi.

Misol 1 — Tezlashtirish tsikli

"""Tezlashtirish tsikli: o'lcha → tur → o'lcha (bosqichlar modeli)."""


TSIKL = [
    {"qadam": "o'lcha", "natija": "ichki sikl bottleneck (profil)"},
    {"qadam": "annotatsiya", "natija": "sikl qatori to'q sariq"},
    {"qadam": "tur qo'sh", "natija": "cdef int i, s (issiq joyga)"},
    {"qadam": "qayta o'lcha", "natija": "4s → 0.05s (80x)"},
]


def main() -> None:
    print("=== 1. Tsikl qadamlari ===")
    for i, q in enumerate(TSIKL, 1):
        print(f"  {i}. {q['qadam']}: {q['natija']}")

    print("\n=== 2. Ma'lumotga asoslangan ===")
    print("  taxmin emas — o'lcha 29.1-bob")

    print("\n=== 3. Iterativ ===")
    print("  har qadam tekshiriladi (tezlashdimi)")

    print("\n=== 4. To'xtash ===")
    print("  yetarli tezlikda to'xta (Amdahl 29.2)")
    print("  ⭐ Tsikl — o'lcha, tur, o'lcha (iterativ)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Tsikl qadamlari ===
  1. o'lcha: ichki sikl bottleneck (profil)
  2. annotatsiya: sikl qatori to'q sariq
  3. tur qo'sh: cdef int i, s (issiq joyga)
  4. qayta o'lcha: 4s → 0.05s (80x)

=== 2. Ma'lumotga asoslangan ===
  taxmin emas — o'lcha 29.1-bob

=== 3. Iterativ ===
  har qadam tekshiriladi (tezlashdimi)

=== 4. To'xtash ===
  yetarli tezlikda to'xta (Amdahl 29.2)
  ⭐ Tsikl — o'lcha, tur, o'lcha (iterativ)

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — Annotatsiya (rang darajasi)

"""Annotatsiya: qator rangi = Python obyekt darajasi (model)."""


def rang(python_amal: int) -> str:
    if python_amal == 0:
        return "oq (sof C — tez)"
    elif python_amal <= 2:
        return "och sariq (kam Python)"
    else:
        return "to'q sariq (ko'p Python — bu yerga tur!)"


def main() -> None:
    qatorlar = [
        ("cdef int i", 0),
        ("s += a[i]  # memoryview", 0),
        ("x = obyekt.usul()", 3),
        ("for i in range(n)", 1),
    ]

    print("=== 1. Qatorlar rangi ===")
    for kod, amal in qatorlar:
        print(f"  {kod!r}: {rang(amal)}")

    print("\n=== 2. Sariq = Python obyekt ===")
    print("  to'qroq → ko'proq Python amal (sekin)")

    print("\n=== 3. Strategiya ===")
    print("  to'q sariq qatorga cdef (oqartir)")

    print("\n=== 4. Qayta annotatsiya ===")
    print("  tur qo'shgach — oqardimi (tekshir)")
    print("  ⭐ Annotatsiya — sariq = Python (issiq joy)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Qatorlar rangi ===
  'cdef int i': oq (sof C — tez)
  's += a[i]  # memoryview': oq (sof C — tez)
  'x = obyekt.usul()': to'q sariq (ko'p Python — bu yerga tur!)
  'for i in range(n)': och sariq (kam Python)

=== 2. Sariq = Python obyekt ===
  to'qroq → ko'proq Python amal (sekin)

=== 3. Strategiya ===
  to'q sariq qatorga cdef (oqartir)

=== 4. Qayta annotatsiya ===
  tur qo'shgach — oqardimi (tekshir)
  ⭐ Annotatsiya — sariq = Python (issiq joy)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — Funksiya turlari (def/cdef/cpdef)

"""Funksiya turlari: def/cdef/cpdef chaqiruv (model)."""


TURLAR = {
    "def": {"chaqiruv": "Python (sekin)", "korinish": "Python + Cython"},
    "cdef": {"chaqiruv": "C (tez)", "korinish": "faqat Cython"},
    "cpdef": {"chaqiruv": "C (tez)", "korinish": "Python + Cython"},
}


def main() -> None:
    print("=== 1. Funksiya turlari ===")
    for nom, info in TURLAR.items():
        print(f"  {nom}: {info['chaqiruv']}, {info['korinish']}")

    print("\n=== 2. Ichki yordamchi (sikl ichida) ===")
    print("  cdef — C chaqiruv (faqat Cython, eng tez)")

    print("\n=== 3. Tashqi interfeys ===")
    print("  cpdef — Python ham chaqiradi (tez + moslik)")

    print("\n=== 4. Tanlov ===")
    print("  ichki → cdef, interfeys → cpdef")
    print("  ⭐ cdef funksiya — C chaqiruv (sikl ichida)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Funksiya turlari ===
  def: Python (sekin), Python + Cython
  cdef: C (tez), faqat Cython
  cpdef: C (tez), Python + Cython

=== 2. Ichki yordamchi (sikl ichida) ===
  cdef — C chaqiruv (faqat Cython, eng tez)

=== 3. Tashqi interfeys ===
  cpdef — Python ham chaqiradi (tez + moslik)

=== 4. Tanlov ===
  ichki → cdef, interfeys → cpdef
  ⭐ cdef funksiya — C chaqiruv (sikl ichida)

Nima ko'rsatdi: 2.3-bo'lim.

Misol 4 — Direktiva ta'siri (tekshiruv)

"""Direktiva: tekshiruv o'chirish tezlik/xavf (model)."""


def kirish_ish(n: int, boundscheck: bool) -> dict:
    # har kirish: element o'qish (1) + chegara tekshiruvi (1 agar yoq)
    if boundscheck:
        ish = n * 2   # o'qish + tekshiruv
        xavf = "yo'q (xavfsiz)"
    else:
        ish = n       # faqat o'qish (tekshiruvsiz)
        xavf = "bor (noto'g'ri indeks → crash)"
    return {"ish": ish, "xavf": xavf}


def main() -> None:
    n = 1000

    print("=== 1. boundscheck=True (standart) ===")
    b = kirish_ish(n, boundscheck=True)
    print(f"  ish: {b['ish']}, xavf: {b['xavf']}")

    print("\n=== 2. boundscheck=False (tez) ===")
    f = kirish_ish(n, boundscheck=False)
    print(f"  ish: {f['ish']}, xavf: {f['xavf']}")

    print("\n=== 3. Tezlik ===")
    print(f"  tekshiruvsiz {b['ish'] // f['ish']}x kam ish (kirishda)")

    print("\n=== 4. Ehtiyot ===")
    print("  faqat ishonchli (test qilingan) siklda o'chir")
    print("  ⭐ Direktiva — tez, lekin xavfli (ehtiyot)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. boundscheck=True (standart) ===
  ish: 2000, xavf: yo'q (xavfsiz)

=== 2. boundscheck=False (tez) ===
  ish: 1000, xavf: bor (noto'g'ri indeks → crash)

=== 3. Tezlik ===
  tekshiruvsiz 2x kam ish (kirishda)

=== 4. Ehtiyot ===
  faqat ishonchli (test qilingan) siklda o'chir
  ⭐ Direktiva — tez, lekin xavfli (ehtiyot)

Nima ko'rsatdi: 2.4-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. Profilsiz optimallashtirish

# noto'g'ri joyga cdef (foydasiz)                             # ⚠️
# profil 29.1-bob → annotatsiya → cdef                           # ✅

2. Annotatsiyani e'tiborsiz

# qaysi qator sariq bilmasdan tur                             # ⚠️
# cython -a → to'q sariq joyga cdef                            # ✅

3. Hamma joyga statik tur

# har o'zgaruvchiga cdef (ortiqcha, o'qilmaydi)                # ⚠️
# faqat issiq sikl (annotatsiya sariq)                         # ✅

4. boundscheck=False sinovsiz

@cython.boundscheck(False)   # test qilinmagan (crash xavfi)  # ⚠️
# avval to'g'ri ishlashini tekshir, keyin o'chir               # ✅

5. nogil ichida Python obyekt

cdef f() nogil: x = []   # Python obyekt (xato)               # ⚠️
# nogil ichida faqat C (obyekt yo'q)                           # ✅

6. def funksiya issiq sikl ichida

for i in range(n): def_yordamchi(i)   # Python chaqiruv (sekin)  # ⚠️
# cdef yordamchi (C chaqiruv — tez)                            # ✅

7. Qayta o'lchamaslik

# cdef qo'shdim, tezlashdimi bilmayman                        # ⚠️
# qayta o'lcha (tsikl — tasdiqla)                              # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 30.7-dars (o'tilgan): Cython tushuncha — asos
• 29.1-dars (o'tilgan): Profil — o'lcha
• 29.2-dars (o'tilgan): Bottleneck — Amdahl
• 30.5-dars (o'tilgan): GIL — nogil
• 30.6-dars (o'tilgan): C kengaytma — Cython ostida

8. Eng yaxshi amaliyotlar

1. O'lcha (profil), keyin tezlashtir (taxmin emas).

2. Annotatsiya (cython -a — sariq joy top).

3. Issiq joyga cdef (to'q sariq, hamma emas).

4. cdef funksiya (sikl ichidagi chaqiruv).

5. memoryview (numpy massiv — tez).

6. Direktiva ehtiyot (test qilingan sikl).

7. nogil (parallel C — Python obyekt yo'q).

8. Qayta o'lcha (iterativ — tasdiqla).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # tezlashtirish tsikli?
2.  # avval nima?
3.  # annotatsiya nima?
4.  # sariq nima anglatadi?
5.  # to'q sariqqa nima?
6.  # cdef funksiya nima?
7.  # cpdef nima?
8.  # boundscheck=False nima?
9.  # direktiva xavfi?
10. # nogil nima?
11. # memoryview nima?
12. # oxirgi qadam?

Vazifa 2: Xatolarni tuzating

1.  # profilsiz cdef qo'shish

2.  # annotatsiyasiz tur

3.  # har o'zgaruvchiga cdef

4.  @cython.boundscheck(False)   # sinovsiz

5.  cdef f() nogil: x = []   # Python obyekt

1.  profil (29.1) → cdef

2.  cython -a → sariq joyga

3.  faqat issiq sikl

4.  avval test, keyin o'chir

5.  nogil ichida faqat C

Vazifa 3: Tsikl

Modellang:

1. O'lcha
2. Annotatsiya
3. Tur
4. Qayta o'lcha

Vazifa 4: Annotatsiya

Modellang:

1. Oq
2. Sariq
3. To'q sariq
4. Strategiya

Vazifa 5: Funksiya

Modellang:

1. def
2. cdef
3. cpdef
4. Tanlov

Vazifa 6: Direktiva

Modellang:

1. boundscheck
2. Tezlik
3. Xavf
4. Ehtiyot

Vazifa 7: O'ylash

Cython tezlashtirishda annotatsiya (cython -a) qaysi qator sekin ekanini ko'rsatadi (sariq rang) — taxmin qilmasdan. Nima uchun "ko'rish/vizualizatsiya" (murakkab ma'lumotni ranglar/grafik bilan) inson qarorini yaxshilaydi, va nega "sonlar jadvali"dan ko'ra "rangli annotatsiya" optimallashtirishda samaraliroq?

Nimani mustahkamlaydi: 2.1, 2.2-bo'limlar.

Xulosa

Bu darsda Cython tezlashtirinishni o'rgandik.

Eng muhim uch fikr:

1. Tezlashtirish tsikli va annotatsiya. Tezlashtirish tsikli — Cython amaliyotining tartibi: o'lcha (profil 29.1 — qayer sekin) → annotatsiya (cython -a — sariq qatorlar) → tur qo'sh (cdef — issiq joyga) → qayta o'lcha (tezlashdimi) → takrorla; ma'lumotga asoslangan (taxmin emas), iterativ. Annotatsiya (cython -a) — kalit: .pyx ni HTML sifatida, har qatorni rangli (oq — sof C tez, sariq — Python obyekt sekin, to'qroq = ko'proq); to'q sariq joyga cdef (oqartir), qayta annotatsiya (oqardimi).

2. cdef funksiya, direktiva, nogil/memoryview. cdef funksiyalar — chaqiruv tezlashtirish: def (Python — sekin), cdef (C — tez, faqat Cython), cpdef (ikkalasi — Python ham); sikl ichidagi chaqiruv cdef. Direktivalar — tekshiruv o'chirish: boundscheck=False (chegara), wraparound=False (manfiy indeks) — tez, lekin xavfli (crash), faqat ishonchli/test qilingan sikl. nogil (GIL bo'shatish — parallel C, Python obyekt yo'q) + memoryview (double[:] — numpy massivga tez C kirish); numpy og'ir hisob uchun birga.

3. Tuzoqlar va o'lchashga asoslangan muhandislik. Tuzoqlar: profilsiz (noto'g'ri joy), hamma joyga tur (ortiqcha), direktiva xavfi (crash — test qil), nogil ichida Python obyekt (xato), qayta o'lchamaslik. Cython tezlashtirish — o'lchashga asoslangan muhandislik: taxminga emas ma'lumotga (profil, annotatsiya), tanlab (issiq joy — 29.2 Amdahl, 3% kod), tsikl har qadamni tekshiradi; 29-qism (unumdorlik) ning Cython'ga tatbiqi. Natija: Python qulaylik (97% kod) + C tezlik (3% issiq joy). Annotatsiya (cython -a) vizualizatsiya (rang — sekin joy bir qarashda, sonlar jadvalidan samaraliroq — inson ko'rish kuchidan).

Keyingi darsda Rust — nega Python bilan degan savolni o'rganamiz: xotira xavfsizligi, unumdorlik va Python bilan integratsiya — Rust'ning nega C/C++ ga zamonaviy muqobil bo'lganini va PyO3 30.10-bob ga tayyorgarlik.