30.7-dars: Cython tushuncha

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

1. Kirish va motivatsiya

C kengaytmasi 30.6-bob tez, lekin qiyin — PyObject, havolalar hisobi, funksiya jadvallari qo'lda. Ko'pchilik dasturchi bu murakkablikni xohlamaydi, lekin Python tezligini oshirmoqchi. Cython shu bo'shliqni to'ldiradi: Python'ga deyarli o'xshash sintaksisda yozasiz, Cython uni C ga o'giradi va C kengaytmasi kabi kompilyatsiya qiladi. Sehr — statik turlar: oddiy Python o'zgaruvchisiga cdef int x deb tur bersangiz, Cython uni C int sifatida ishlatadi (Python obyekti emas — 100x tez sikllar). Cython — Python qulayligi + C tezligi, C API murakkabligisiz. numpy, scipy, scikit-learn qismlari Cython bilan yozilgan. Bu tezlashtirinishning eng amaliy usuli.

Cython — Python'ga o'xshash sintaksisda yozib, C ga kompilyatsiya qilinadigan til (Python superseti): statik turlar (cdef int x — Python obyekti emas, C turi — tez), Python moslik (deyarli har Python kodi Cython'da ishlaydi), kompilyatsiya (.pyx → C → .so/.pyd), tez sikllar (turli sikl C tezligida). Foydalanish: Python tezlashtirish (bottleneck 29.2), C kutubxona o'rash. Bu C kengaytma (30.6 — qiyin) ga soddaroq muqobil. Bu 30.6 (C kengaytma), 30.8 (Cython tezlashtirish) bilan bog'liq. Cython — Python + statik turlar. C ga kompilyatsiya.

Real vaziyat. Bir jamoada Python funksiya sekin edi (sonli hisob — 29.2 bottleneck). C kengaytma 30.6-bob yozish qiyin (C API, havola). Cython qo'llandi: funksiyani .pyx fayliga ko'chirdi (deyarli o'zgarishsiz — Python moslik), sikl o'zgaruvchilariga cdef int (statik tur) qo'shdi, kompilyatsiya qildi. Natija 80x tez (C tezligi), lekin kod deyarli Python (o'qilishi oson). Jamoa C API ni ko'rmadi (Cython yashirdi). Cython — Python qulaylik + C tezlik, murakkablikisiz.

Bu darsda Cython tushunchasini o'rganamiz.

Bu darsda:

• Cython nima
• Statik turlar (cdef)
• Python moslik (superset)
• Kompilyatsiya (.pyx → C)
• Nega tez (turlar)
• Cython amaliyoti
• Cython vs muqobil
• Amaliy: Cython modeli

ℹ Cython kompilyator talab qiladi; misollar Cython mantiqini (statik tur ta'siri) deterministik modellashtiradi.

2. Nazariya — chuqur tushuntirish

2.1. Cython nima

Python yozib, C tezligi:

# mening.pyx — Cython fayl (Python'ga o'xshash)
def yigindi(int n):        # int — statik tur (C)
    cdef int s = 0         # cdef — C o'zgaruvchi
    cdef int i
    for i in range(n):     # C sikl (tez)
        s += i
    return s
# Cython bu kodni C ga o'giradi, kompilyatsiya qiladi

Cython — Python'ga o'xshash sintaksisda yozib, C ga kompilyatsiya qilinadigan til (Python superseti — har Python kodi Cython ham): siz deyarli Python yozasiz, Cython C ga o'giradi va C kengaytmasi 30.6-bob kabi kompilyatsiya qiladi. Sabab: C kengaytma 30.6-bob tez, lekin qiyin (C API — PyObject, havola); Cython bu murakkablikni yashiradi (Python yozasiz, Cython C API ni yaratadi). Sehr: statik turlar (2.2 — cdef int) Python obyektini C turiga aylantiradi (tez). numpy, scipy qismlari Cython. Cython — Python qulaylik + C tezlik (C API yashirin). .pyx fayl. Kompilyatsiya qilinadi.

2.2. Statik turlar (cdef)

C turlarini berish:

# statik tur yo'q (Python obyekt — sekin):
def sekin(n):
    s = 0              # Python int obyekti (har amal — obyekt)
    for i in range(n):
        s += i
    return s

# statik tur bilan (C — tez):
def tez(int n):
    cdef int s = 0     # C int (obyekt emas — tez)
    cdef int i
    for i in range(n):
        s += i
    return s

Statik turlar (cdef) — Cython'ning asosiy sehri: Python o'zgaruvchisiga C turi berish (cdef int x, cdef double y). Sabab: oddiy Python'da har son obyekt (PyObject — 30.5, har amal obyekt yaratadi/yo'q qiladi — sekin); cdef int bilan o'zgaruvchi C int bo'ladi (obyekt emas — to'g'ridan mashina amali, 100x tez). Ayniqsa sikllarda (millionlab amal — har biri C, obyektsiz). cdef — C darajasida o'zgaruvchi (Python emas). Bu tezlashtirinishning kaliti (statik tur → C amal). Statik tur — obyekt emas, C turi. cdef — tez. Sikllarda keskin.

2.3. Python moslik (superset)

Python kodi Cython'da ishlaydi:

# oddiy Python kodi Cython'da ham ishlaydi (superset)
def salomlash(ism):        # tursiz — Python obyekt (ishlaydi)
    return f"Salom, {ism}"

# asta-sekin tur qo'shish mumkin (kerakli joyga):
def salomlash2(str ism):   # str — statik tur (tezroq)
    return f"Salom, {ism}"

Python moslik (superset) — Cython Python'ning kengaytmasi: deyarli har Python kodi Cython'da o'zgarishsiz ishlaydi (Cython Python superseti). Sabab: mavjud Python kodni Cython'ga ko'chirish oson (o'zgarishsiz), keyin asta-sekin tur qo'shiladi (faqat sekin joyga — 29.2 bottleneck, statik tur); butun kodni qayta yozmaslik. Bu bosqichma-bosqich optimallashtirish (avval ishlaydi, keyin tezlashadi — 29.1 avval o'lcha). Farq C kengaytmadan (30.6 — noldan C API); Cython'da Python'dan boshlanadi. Python moslik — mavjud kod ishlaydi. Superset. Asta-sekin tur.

2.4. Kompilyatsiya (.pyx → C)

Cython'ning ish oqimi:

mening.pyx (Cython kod)
   ↓ Cython (o'giradi)
mening.c (C kod — avtomatik yaratiladi)
   ↓ C kompilyator
mening.so / .pyd (Python moduli)
   ↓
import mening (oddiy modul kabi)

Kompilyatsiya (.pyx → C → .so/.pyd) — Cython ish oqimi: .pyx (Cython kod) → Cython uni C kodga o'giradi (.c — avtomatik, C API bilan) → C kompilyator .so/.pyd yaratadi → import. Sabab: Cython o'zi Python emas — kompilyatsiya kerak (C ga, keyin mashinaga); bu C kengaytma 30.6-bob bilan bir xil oxir (.so/.pyd), lekin C ni Cython yozadi (dasturchi emas). Vosita: cythonize (setup.py) yoki pyximport. C kompilyator kerak (30.6 kabi). Yig'ilgach — oddiy modul. Kompilyatsiya — .pyx → C → .so. Cython C yozadi. import.

2.5. Nega tez (turlar)

Python (obyekt) sikl:
   for i in range(n): s += i
   har amal: PyObject yaratish, tur tekshirish, havola (30.5) — sekin

Cython (cdef int) sikl:
   cdef int i, s
   for i in range(n): s += i
   har amal: C int qo'shish (obyektsiz, to'g'ridan) — 100x tez

Nega tez — Cython tezligining sababi statik turlar (obyekt yo'qligi): oddiy Python'da har amal PyObject bilan (yaratish, tur tekshirish ish vaqtida, havola hisobi — 30.5, hammasi qo'shimcha ish — sekin); Cython'da cdef int bilan amal to'g'ridan C (mashina int qo'shish — obyektsiz, tur ma'lum, havola yo'q — tez). Farq ayniqsa sikllarda (millionlab amal — har biri obyekt vs C). Shuning uchun statik tur asosiy 2.2-bob. Lekin: Python obyekt kerak joyda (dinamik) Cython Python kabi (statik tur faqat kerakli joyga). Nega tez — obyekt yo'q (C amal). Statik tur — kalit. Sikl — keskin.

2.6. Cython amaliyoti

Cython amaliyotlari: avval o'lcha (29.1 — profil, sekin joyni top); statik tur qo'sh (cdef — faqat sekin joyga, sikllar); bosqichma-bosqich (Python'dan boshla, asta tur); annotatsiya (cython -a — qaysi qator Python obyekt ishlatadi, sariq — sekin); numpy bilan (cdef numpy massiv — tez); kompilyatsiya (cythonize — setup.py); Python moslik (mavjud kod ishlaydi). Tuzoqlar: turlarni hamma joyga (ortiqcha — faqat sekin joy), C kompilyator (kerak), profil qilmasdan (noto'g'ri joy — 29.1). Cython amaliy tezlashtirish (C kengaytmadan 30.6 oson, ctypes/cffi 30.3-4 dan boshqa maqsad — o'z kodni tezlashtirish). Amaliyot — o'lcha, tur qo'sh, bosqichma. Cython — oson, tez.

2.7. Cython vs muqobil

Cython vs muqobil: Cython (o'z Python kodni tezlashtirish — statik tur, oson), C kengaytma (30.6 — maksimal nazorat, qiyin), ctypes/cffi (30.3-4 — mavjud C kutubxona chaqirish, boshqa maqsad), PyPy (JIT interpretator — kodni o'zgartirmasdan tezlashtirish, lekin butun muhit almashtiradi). Tanlov: o'z kodni tezlashtirish (Cython — eng amaliy), mavjud C (ctypes/cffi), maksimal nazorat (C kengaytma), butun dastur (PyPy — moslik cheklovi bilan). Ko'pchilik uchun Cython eng yaxshi boshlanish (Python yozasiz, C tez, bosqichma). Cython — amaliy tanlov. Muqobil — maqsadga qarab.

2.8. Cython — Python va C ko'prigi

Cython asosiy g'oyasi — Python va C ko'prigi: Python qulayligi (o'qish, yozish oson) va C tezligi (statik tur, obyektsiz) ni birlashtiradi — Python yozasiz, C ni olasiz. Bu C kengaytma (30.6 — qiyin C API) ni avtomatlashtiradi (Cython C yozadi, dasturchi Python). Statik turlar 2.2-bob kalit: cdef bilan tanlangan joyni C ga aylantirasiz (sekin joy — 29.2 bottleneck), qolgani Python (qulay). Bu 30.1 (to'g'ri til to'g'ri ishga) ning bir tildagi amalga oshirilishi (bir faylda Python va C daraja). numpy, scipy Cython bilan (tez yadro). Cython — bosqichma tezlashtirinishning eng amaliy vositasi (avval Python, keyin kerakli joyga tur). Cython — Python + C (bir tilda). Ko'prik. Bosqichma.

3. Tez ma'lumotnoma

# CYTHON (mening.pyx)

# STATIK TUR YO'Q (Python obyekt — sekin):
def sekin(n):
    s = 0
    for i in range(n):
        s += i
    return s

# STATIK TUR (cdef — C, tez):
def tez(int n):
    cdef int s = 0      # C int (obyekt emas)
    cdef int i
    for i in range(n):
        s += i          # C amal (100x tez)
    return s

# KOMPILYATSIYA (.pyx → C → .so/.pyd)
#   cythonize (setup.py) yoki pyximport
#   import mening; mening.tez(1000000)

# ANNOTATSIYA (sekin joyni topish):
#   cython -a mening.pyx  → sariq qatorlar (Python obyekt)

# QOIDA: avval o'lcha 29.1-bob, keyin cdef (faqat sekin joyga)

Cython xulosasi

Cython — Python yozib, C ga kompilyatsiya (Python superset)
Statik turlar (cdef int) — obyekt emas, C turi (100x tez)
Python moslik — mavjud kod ishlaydi, asta tur qo'sh
Kompilyatsiya — .pyx → C → .so/.pyd (import)
Nega tez — obyekt yo'q (C amal) · sikllarda keskin

4. Batafsil misollar

Cython kompilyator talab qiladi; misollar Cython mantiqini (statik tur ta'siri) deterministik modellashtiradi.

Misol 1 — Statik tur ta'siri (amal soni)

"""Statik tur: Python obyekt vs C amal (qo'shimcha ish soni modeli)."""


def amal_soni(n: int, statik: bool) -> dict:
    if statik:
        # cdef int — har amal 1 ta (C qo'shish)
        ish = n
    else:
        # Python obyekt — har amal: obyekt + tur + havola (~3)
        ish = n * 3
    return {"statik": statik, "amal": ish}


def main() -> None:
    n = 1000

    print("=== 1. Python obyekt (statik tur yo'q) ===")
    p = amal_soni(n, statik=False)
    print(f"  qo'shimcha ish: {p['amal']} (obyekt + tur + havola)")

    print("\n=== 2. Cython cdef (statik tur) ===")
    c = amal_soni(n, statik=True)
    print(f"  qo'shimcha ish: {c['amal']} (C qo'shish)")

    print("\n=== 3. Nisbat ===")
    print(f"  Python / Cython ish: {p['amal'] // c['amal']}x kamroq")

    print("\n=== 4. Xulosa ===")
    print("  cdef — obyekt yo'q (C amal, tez)")
    print("  ⭐ Statik tur — obyektsiz (sikllarda keskin)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Python obyekt (statik tur yo'q) ===
  qo'shimcha ish: 3000 (obyekt + tur + havola)

=== 2. Cython cdef (statik tur) ===
  qo'shimcha ish: 1000 (C qo'shish)

=== 3. Nisbat ===
  Python / Cython ish: 3x kamroq

=== 4. Xulosa ===
  cdef — obyekt yo'q (C amal, tez)
  ⭐ Statik tur — obyektsiz (sikllarda keskin)

Nima ko'rsatdi: 2.2, 2.5-bo'limlar.

Misol 2 — Python moslik (bosqichma-bosqich)

"""Python moslik: Python'dan boshla, asta tur qo'sh (bosqichma model)."""


BOSQICHLAR = [
    {"bosqich": 1, "kod": "sof Python (Cython'ga ko'chirildi)", "tezlik": 1},
    {"bosqich": 2, "kod": "cdef int (sikl o'zgaruvchisi)", "tezlik": 30},
    {"bosqich": 3, "kod": "cdef barcha (funksiya)", "tezlik": 80},
]


def main() -> None:
    print("=== 1. Bosqichlar ===")
    for b in BOSQICHLAR:
        print(f"  {b['bosqich']}. {b['kod']} — {b['tezlik']}x")

    print("\n=== 2. Boshlanish (Python moslik) ===")
    print("  mavjud Python kodi o'zgarishsiz ishlaydi")

    print("\n=== 3. Asta-sekin tur ===")
    print("  faqat sekin joyga cdef (29.1 profil)")

    print("\n=== 4. Superset ===")
    print("  Cython — Python + statik tur (kengaytma)")
    print("  ⭐ Python moslik — bosqichma-bosqich tezlashtirish")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Bosqichlar ===
  1. sof Python (Cython'ga ko'chirildi) — 1x
  2. cdef int (sikl o'zgaruvchisi) — 30x
  3. cdef barcha (funksiya) — 80x

=== 2. Boshlanish (Python moslik) ===
  mavjud Python kodi o'zgarishsiz ishlaydi

=== 3. Asta-sekin tur ===
  faqat sekin joyga cdef (29.1 profil)

=== 4. Superset ===
  Cython — Python + statik tur (kengaytma)
  ⭐ Python moslik — bosqichma-bosqich tezlashtirish

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Kompilyatsiya oqimi (.pyx → C → .so)

"""Kompilyatsiya: .pyx → C → .so/.pyd → import (oqim modeli)."""


def cython_oqim(pyx: str, platforma: str) -> list:
    kengaytma = ".pyd" if platforma == "windows" else ".so"
    modul = pyx.replace(".pyx", "")
    return [
        f"{pyx} (Cython kod)",
        f"{modul}.c (Cython C ga o'giradi)",
        f"{modul}{kengaytma} (C kompilyator)",
        f"import {modul} (oddiy modul)",
    ]


def main() -> None:
    print("=== 1. Cython oqimi (Linux) ===")
    for i, qadam in enumerate(cython_oqim("mening.pyx", "linux"), 1):
        print(f"  {i}. {qadam}")

    print("\n=== 2. C ni kim yozadi ===")
    print("  Cython (avtomatik) — dasturchi emas")

    print("\n=== 3. C kengaytma farqi 30.6-bob ===")
    print("  C kengaytma: dasturchi C yozadi (qiyin)")
    print("  Cython: Python yozadi, Cython C yaratadi")

    print("\n=== 4. Vosita ===")
    print("  cythonize (setup.py) yoki pyximport")
    print("  ⭐ Kompilyatsiya — .pyx → C → .so (Cython C yozadi)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Cython oqimi (Linux) ===
  1. mening.pyx (Cython kod)
  2. mening.c (Cython C ga o'giradi)
  3. mening.so (C kompilyator)
  4. import mening (oddiy modul)

=== 2. C ni kim yozadi ===
  Cython (avtomatik) — dasturchi emas

=== 3. C kengaytma farqi 30.6-bob ===
  C kengaytma: dasturchi C yozadi (qiyin)
  Cython: Python yozadi, Cython C yaratadi

=== 4. Vosita ===
  cythonize (setup.py) yoki pyximport
  ⭐ Kompilyatsiya — .pyx → C → .so (Cython C yozadi)

Nima ko'rsatdi: 2.4-bo'lim.

Misol 4 — Muqobillar (maqsad bo'yicha)

"""Muqobillar: har vosita qaysi maqsadga (tanlov modeli)."""


VOSITALAR = {
    "Cython": {"maqsad": "o'z Python kodini tezlashtirish", "qiyinlik": "past"},
    "C kengaytma": {"maqsad": "maksimal nazorat", "qiyinlik": "yuqori"},
    "cffi": {"maqsad": "mavjud C kutubxona", "qiyinlik": "o'rta"},
    "PyPy": {"maqsad": "butun dastur (JIT)", "qiyinlik": "almashtirish"},
}


def tanlov(maqsad: str) -> str:
    for nom, info in VOSITALAR.items():
        if maqsad in info["maqsad"]:
            return nom
    return "aniqlanmadi"


def main() -> None:
    print("=== 1. Vositalar ===")
    for nom, info in VOSITALAR.items():
        print(f"  {nom}: {info['maqsad']} ({info['qiyinlik']})")

    print("\n=== 2. O'z kodni tezlashtirish ===")
    print(f"  tanlov: {tanlov('o.z Python kodini tezlashtirish')}")

    print("\n=== 3. Mavjud C kutubxona ===")
    print(f"  tanlov: {tanlov('mavjud C kutubxona')}")

    print("\n=== 4. Tavsiya ===")
    print("  ko'pchilik uchun Cython (oson, tez, bosqichma)")
    print("  ⭐ Muqobil — maqsadga qarab (Cython amaliy)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Vositalar ===
  Cython: o'z Python kodini tezlashtirish (past)
  C kengaytma: maksimal nazorat (yuqori)
  cffi: mavjud C kutubxona (o'rta)
  PyPy: butun dastur (JIT) (almashtirish)

=== 2. O'z kodni tezlashtirish ===
  tanlov: aniqlanmadi

=== 3. Mavjud C kutubxona ===
  tanlov: cffi

=== 4. Tavsiya ===
  ko'pchilik uchun Cython (oson, tez, bosqichma)
  ⭐ Muqobil — maqsadga qarab (Cython amaliy)

Nima ko'rsatdi: 2.7-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. Profil qilmasdan tur qo'shish

# hamma funksiyaga cdef (noto'g'ri joy)                       # ⚠️
# avval o'lcha 29.1-bob, sekin joyga cdef                        # ✅

2. Hamma joyga statik tur

# har o'zgaruvchiga cdef (ortiqcha, o'qilmaydi)                # ⚠️
# faqat sikl/hisob (sekin joy)                                 # ✅

3. cdef unutish (sekin qoladi)

def f(n): s = 0; ...   # tursiz (Python obyekt — sekin)       # ⚠️
def f(int n): cdef int s = 0   # statik tur (tez)              # ✅

4. Kompilyatorsiz kutish

import mening   # .pyx yig'ilmagan (C kompilyator yo'q)        # ⚠️
# cythonize (setup.py) + C kompilyator                          # ✅

5. Annotatsiyani e'tiborsiz

# qaysi qator sekin bilmasdan tur qo'shish                     # ⚠️
# cython -a (sariq qator — Python obyekt)                       # ✅

6. Dinamik joyga statik tur

cdef int x = obyekt   # dinamik qiymatga C tur (xato)          # ⚠️
# dinamik joy Python qoldir (statik faqat kerakli)              # ✅

7. ctypes bilan aralashtirish

# Cython — o'z kod tezlashtirish (ctypes — mavjud C)           # ⚠️
# maqsadga qarab tanla (Cython vs ctypes)                       # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 30.8-dars: Cython tezlashtirish — amaliy
• 30.6-dars (o'tilgan): C kengaytma — Cython yashiradi
• 29.1-dars (o'tilgan): Profil — avval o'lcha
• 29.2-dars (o'tilgan): Bottleneck — sekin joy
• 30.1-dars (o'tilgan): To'g'ri til to'g'ri ishga

8. Eng yaxshi amaliyotlar

1. Avval o'lcha (29.1 profil), keyin cdef.

2. Statik tur faqat sekin joyga (sikllar).

3. Python'dan boshla (moslik), asta tur.

4. Annotatsiya (cython -a — sariq qator).

5. Dinamik joy Python qoldir.

6. numpy massiv cdef (tez).

7. Ko'pchilik uchun Cython (oson, tez).

8. Maqsadga qarab (Cython o'z kod, ctypes mavjud C).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # Cython nima?
2.  # Cython vs Python?
3.  # cdef nima?
4.  # cdef nega tez?
5.  # Python moslik nima?
6.  # superset nima?
7.  # kompilyatsiya oqimi?
8.  # C ni kim yozadi?
9.  # nega Cython tez?
10. # annotatsiya nima?
11. # qachon cdef?
12. # Cython vs C kengaytma?

Vazifa 2: Xatolarni tuzating

1.  # profil qilmasdan hamma joyga cdef

2.  # har o'zgaruvchiga cdef

3.  def f(n): s = 0   # tursiz sikl

4.  import mening   # yig'ilmagan

5.  # qaysi qator sekin bilmasdan

1.  avval o'lcha 29.1-bob, sekin joyga

2.  faqat sikl/hisob (sekin joy)

3.  def f(int n): cdef int s = 0

4.  cythonize (setup.py) + kompilyator

5.  cython -a (sariq qator)

Vazifa 3: Statik tur

Modellang:

1. Obyekt
2. C tur
3. Amal soni
4. Sikl

Vazifa 4: Python moslik

Modellang:

1. Boshlanish
2. Asta tur
3. Bosqich
4. Superset

Vazifa 5: Kompilyatsiya

Modellang:

1. .pyx
2. C
3. .so/.pyd
4. import

Vazifa 6: Muqobil

Modellang:

1. Cython
2. C kengaytma
3. cffi
4. Maqsad

Vazifa 7: O'ylash

Cython "bosqichma-bosqich optimallashtirish" imkonini beradi: Python'dan boshlaysiz (ishlaydi), keyin faqat sekin joyga statik tur qo'shasiz (tezlashadi). Nima uchun "avval ishlat, keyin optimallashtir" (make it work, then make it fast) tartibi teskarisidan (avval optimallashtir) deyarli har doim yaxshi, va nega "bosqichma-bosqich, o'lchab optimallashtirish" (Cython yondashuvi) "hammasini oldindan optimallashtirish"dan ustun?

Nimani mustahkamlaydi: 2.3, 2.6-bo'limlar.

Xulosa

Bu darsda Cython tushunchasini o'rgandik.

Eng muhim uch fikr:

1. Cython va statik turlar. Cython — Python'ga o'xshash sintaksisda yozib, C ga kompilyatsiya qilinadigan til (Python superseti): siz deyarli Python yozasiz, Cython C ga o'giradi va C kengaytmasi 30.6-bob kabi kompilyatsiya qiladi (C API murakkabligini yashiradi). Statik turlar (cdef) — asosiy sehr: Python o'zgaruvchisiga C turi berish (cdef int x); oddiy Python'da har son obyekt (PyObject — har amal obyekt, sekin), cdef int bilan C int (obyektsiz, to'g'ridan mashina amali, 100x tez), ayniqsa sikllarda.

2. Python moslik, kompilyatsiya, nega tez. Python moslik (superset) — deyarli har Python kodi Cython'da o'zgarishsiz ishlaydi; mavjud kodni ko'chirish oson, keyin asta-sekin tur qo'shiladi (faqat sekin joyga — bosqichma-bosqich optimallashtirish). Kompilyatsiya — .pyx (Cython kod) → Cython C ga o'giradi (.c) → C kompilyator .so/.pyd → import (cythonize/pyximport; C ni Cython yozadi, dasturchi emas). Nega tez — statik turlar (obyekt yo'qligi): Python amal PyObject bilan (yaratish, tur tekshirish, havola — sekin), Cython cdef amal to'g'ridan C (obyektsiz — tez), sikllarda keskin.

3. Muqobil va Python-C ko'prigi. Cython vs muqobil: Cython (o'z Python kodni tezlashtirish — oson), C kengaytma (30.6 — maksimal nazorat, qiyin), ctypes/cffi (30.3-4 — mavjud C kutubxona — boshqa maqsad), PyPy (JIT — butun dastur, moslik cheklovi); ko'pchilik uchun Cython eng amaliy boshlanish. Cython — Python va C ko'prigi (Python qulaylik + C tezlik bir tilda), C kengaytmani avtomatlashtiradi (Cython C yozadi). Avval ishlat, keyin optimallashtir (to'g'rilik birinchi, erta optimallashtirish — ildiz yovuzlik); Cython bosqichma-bosqich, o'lchab optimallashtirinishni quradi (Python'dan boshla, o'lcha, tanlab cdef — bottleneck 29.2 Amdahl, 3% ga).

Keyingi darsda Cython tezlashtirinishni amaliyotda o'rganamiz: haqiqiy sekin funksiyani olib, profil qilib, statik turlar (cdef) va cython -a annotatsiya bilan bosqichma-bosqich tezlashtirish.