Python kursi30.4-dars: cffi
Python kursi · Python va boshqa tillar

30.4-dars: cffi

19 daqiqa4/16-dars

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


1. Kirish va motivatsiya

ctypes 30.3-bob C kutubxonalarini chaqiradi, lekin bir kamchiligi bor: siz har funksiyaning turlarini qo'lda belgilaysiz (argtypes, restype) — bu zerikarli, xatolarga moyil (bir turni unutsangiz — crash). Katta C kutubxona (yuzlab funksiya) uchun bu koshmar. Bundan tashqari, ctypes ba'zan sekin va murakkab (pointerlar, strukturalar qo'lda). cffi boshqacha yondashadi: siz C deklaratsiyalarini (funksiya imzolari, struct'lar — C sintaksisida) be20rasiz, cffi ularni o'zi parse qiladi (turlarni tushunadi) — qo'lda belgilash yo'q. Bu ancha soddaroq, xavfsizroq va tezroq. cffi — C kodini C sintaksisida ishlatish.

cffi — Python uchun FFI kutubxonasi (C Foreign Function Interface), ctypes'ga muqobil: C deklaratsiyalari (cdef — C sintaksisida funksiya imzolari, struct'lar), ikki rejim (ABI — tayyor kutubxonani yuklash, ctypes kabi; API — C kod kompilyatsiya, tezroq/xavfsizroq), avtomatik tur muvofiqligi (cffi C deklaratsiyadan turlarni biladi — qo'lda argtypes yo'q), inline C (kichik C kodni to'g'ridan yozish). Foydalanish: mavjud C kutubxona (ABI), C kod yozish (API). Bu ctypes'dan 30.3-bob soddaroq (deklaratsiya parse), xavfsizroq (API rejim). Bu 30.1 (birlashtirish), 30.3 (ctypes), 30.5 (kengaytma) bilan bog'liq. cffi — C ni C sintaksisida. Deklaratsiya — avtomatik turlar.

Real vaziyat. Bir jamoa katta C kutubxonasini (200 funksiya) Python'da ishlatishi kerak edi. ctypes bilan — har funksiyaga argtypes/restype qo'lda (200 marta, xato xavfi). cffi qo'llanildi: kutubxonaning C header fayli (cdef — funksiya imzolari) berildi, cffi hammasini avtomatik tushundi (turlar C deklaratsiyadan). 200 funksiya qo'lda belgilashsiz ishladi (deklaratsiya bir marta). cffi — C header'dan avtomatik bog'lash yaratdi.

Bu darsda cffi ni o'rganamiz.

Bu darsda:

  • cffi nima (ctypes farqi)
  • C deklaratsiyalari (cdef)
  • ABI vs API rejim
  • Avtomatik tur muvofiqligi
  • Inline C kod
  • cffi vs ctypes taqqoslash
  • cffi amaliyoti
  • Amaliy: cffi modeli

ℹ cffi kutubxona/kompilyator talab qiladi; misollar C deklaratsiya parse mantiqini (deterministik) modellashtiradi.


2. Nazariya — chuqur tushuntirish

2.1. cffi nima (ctypes farqi)

C ni C sintaksisida:

python
from cffi import FFI
ffi = FFI()

# C deklaratsiyasi (C sintaksisida — cffi parse qiladi)
ffi.cdef("int qoshish(int a, int b);")

# kutubxonani yuklash
lib = ffi.dlopen("./mening.so")
natija = lib.qoshish(3, 5)   # turlar avtomatik (deklaratsiyadan)

cffi — Python uchun FFI kutubxonasi (ctypes'ga muqobil): C kodini C sintaksisida ishlatish. Farqi ctypes'dan: ctypes'da turlar qo'lda (argtypes/restype — 30.3), cffi'da C deklaratsiya (cdef — funksiya imzosi C sintaksisida) beriladi, cffi o'zi parse qiladi (turlarni tushunadi — qo'lda yo'q). Sabab: qo'lda tur belgilash zerikarli, xatoga moyil (katta kutubxona — yuzlab funksiya); cffi deklaratsiyadan avtomatik (soddaroq, xavfsizroq). cffi — C ni C sintaksisida (deklaratsiya parse). Deklaratsiya — avtomatik turlar. ctypes'dan soddaroq.

2.2. C deklaratsiyalari (cdef)

C imzolarini berish:

python
from cffi import FFI
ffi = FFI()

# C deklaratsiyalari (funksiya, struct, tur — C sintaksisida)
ffi.cdef("""
    int qoshish(int a, int b);
    double kvadrat(double x);
    struct Nuqta { int x; int y; };
""")
# cffi bu deklaratsiyalarni parse qiladi (turlarni biladi)

C deklaratsiyalari (cdef) — cffi'ga C imzolarini aytish (C sintaksisida): funksiya imzolari (int qoshish(int a, int b);), struct'lar (struct Nuqta { int x; int y; };), turlar (typedef). Sabab: cffi turlarni deklaratsiyadan biladi (C header fayli kabi — 30.4 real C) — qo'lda belgilash yo'q (ctypes farqi). cdef — C header'ning bir qismi (funksiya imzolari, e'lonlar). Bu C sintaksisida (dasturchi C bilsa — tanish). cffi deklaratsiyani parse qiladi (compiler kabi — turlar). cdef — C imzolari. Deklaratsiya — cffi tushunadi.

2.3. ABI vs API rejim

Ikki yondashuv:

ABI rejim (dlopen) — tayyor kutubxonani yuklash
   ctypes kabi (kompilyatsiyasiz), lekin xavfliroq
   lib = ffi.dlopen("./mening.so")

API rejim (set_source + compile) — C kod kompilyatsiya
   cffi C kodni kompilyatsiya qiladi (tezroq, xavfsizroq)
   ffi.set_source(...) + ffi.compile()

ABI vs API rejim — cffi ikki usulda: ABI (Application Binary Interface — dlopen — tayyor kutubxonani yuklash, kompilyatsiyasiz — ctypes kabi, oddiy, lekin xavfliroq — ABI o'zgarsa muammo); API (Application Programming Interface — set_source + compile — cffi C kodni kompilyatsiya qiladi, C kompilyator ishlatadi — tezroq, xavfsizroq — compiler turlarni tekshiradi). Sabab: ABI — tez sinash (mavjud kutubxona), API — ishlab chiqarish (tezroq, ishonchli — 30.5 kengaytmaga o'xshash). Farqi: ABI yuklaydi (kompilyatsiyasiz), API kompilyatsiya (xavfsizroq). Tanlov: oddiy (ABI) yoki ishonchli (API). Rejim — yuklash yoki kompilyatsiya. API — xavfsizroq.

2.4. Avtomatik tur muvofiqligi

Qo'lda belgilash yo'q:

python
# ctypes — qo'lda (har funksiyaga):
lib.func.argtypes = [ctypes.c_int, ctypes.c_int]
lib.func.restype = ctypes.c_int

# cffi — avtomatik (deklaratsiyadan):
ffi.cdef("int func(int a, int b);")   # bir marta
lib.func(3, 5)   # turlar deklaratsiyadan (qo'lda yo'q)

Avtomatik tur muvofiqligi — cffi'ning asosiy afzalligi: C deklaratsiyadan turlarni biladi (ctypes qo'lda argtypes/restype — 30.3, cffi avtomatik). Sabab: cdefda imzo berilgan (int func(int, int)) — cffi bundan argument va natija turlarini oladi (qo'lda belgilash yo'q); ctypes'da har funksiyaga qo'lda (yuzlab funksiya — koshmar). Bu kamroq xato (qo'lda — unutish, noto'g'ri), soddaroq (deklaratsiya bir marta). Katta kutubxona uchun keskin farq (200 funksiya — cffi bir cdef, ctypes 200 qo'lda). Avtomatik tur — cffi qulayligi. Deklaratsiyadan — qo'lda emas.

2.5. Inline C kod

Kichik C kod to'g'ridan:

python
from cffi import FFI
ffi = FFI()

# API rejim: C kodni to'g'ridan yozish
ffi.set_source("_mening", """
    int qoshish(int a, int b) { return a + b; }
""")
ffi.cdef("int qoshish(int a, int b);")
ffi.compile()   # C kodni kompilyatsiya (Python moduli)

Inline C kod — cffi (API rejim) bilan kichik C kodni to'g'ridan yozish va kompilyatsiya: set_source (C kod — implementatsiya), cdef (deklaratsiya), compile (kompilyatsiya — Python moduli). Sabab: ba'zan mavjud kutubxona yo'q — kichik C funksiya yozish kerak (tez, past daraja); cffi buni oson qiladi (C kod inline, kompilyatsiya). Bu 30.5 (kengaytma) ga o'xshash (C kod → Python modul), lekin cffi soddaroq. Foydalanish: tez C funksiya (Python sekin — bottleneck 29.2), mavjud C kodni o'rash. Inline C — kichik C kod (cffi bilan). To'g'ridan C — kompilyatsiya.

2.6. cffi vs ctypes taqqoslash

Jihat ctypes cffi
Turlar Qo'lda (argtypes) Avtomatik (cdef)
Rejim Yuklash ABI (yuklash) + API (kompilyatsiya)
Xavfsizlik Xavfliroq Xavfsizroq (API)
Standart Standart kutubxona O'rnatish kerak (pip)
Qulaylik Oddiy holatga Katta/murakkab holatga

cffi vs ctypes: ctypes (standart kutubxona — o'rnatish yo'q, turlar qo'lda — argtypes, oddiy holatga qulay — kichik kutubxona, tez sinash); cffi (o'rnatish kerak — pip install cffi, turlar avtomatik — cdef, ABI+API rejim, xavfsizroq — API kompilyatsiya, katta/murakkab holatga — yuzlab funksiya, ishlab chiqarish). Tanlov: kichik/tez (ctypes — standart, oddiy), katta/ishonchli (cffi — avtomatik, xavfsiz). Ko'p loyiha cffi tavsiya qiladi (soddaroq, xavfsizroq — 30.4). Ikkalasi FFI 30.1-bob, lekin cffi zamonaviyroq. cffi vs ctypes — avtomatik vs qo'lda. cffi — soddaroq, xavfsizroq.

2.7. cffi amaliyoti

cffi amaliyotlari: API rejim (ishlab chiqarish — kompilyatsiya, xavfsizroq — 30.4.3); ABI rejim (tez sinash — mavjud kutubxona); cdef (C header'dan — deklaratsiya bir marta); avtomatik turlar (qo'lda emas — cffi); inline C (kichik funksiya — set_source); xato boshqarish (C xatosi — crash 30.3 kabi, ehtiyot); kompilyatsiya (API — C kompilyator kerak). Tuzoqlar: ABI xavfliroq (ctypes kabi — API afzal), C xatosi (crash), o'rnatish (standart emas). Yaxshi cffi — API rejim, cdef, avtomatik. Bu ctypes 30.3-bob va kengaytma 30.5-bob orasida (soddaroq FFI). Amaliyot — soddaroq, xavfsizroq FFI. API + cdef — ishonchli.

2.8. cffi — deklaratsiyaga asoslangan FFI

cffi asosiy g'oyasi — deklaratsiyaga asoslangan FFI: C deklaratsiyalarini (C sintaksisida) berib, cffi turlarni avtomatik tushunadi (qo'lda belgilash yo'q — ctypes farqi). Bu FFI (30.1 — bir jarayonda til) ni soddaroq, xavfsizroq qiladi (deklaratsiya parse, API kompilyatsiya). cffi ctypes (30.3 — qo'lda, standart) va kengaytma (30.5 — to'liq C modul) orasida: soddaroq (deklaratsiya), xavfsizroq (API), lekin o'rnatish kerak. Zamonaviy Python loyihalar cffi'ni tavsiya qiladi (PyPy ham cffi'ni yaxshi qo'llaydi). Bu 30.1 (til birlashtirish) ning takomillashgan usuli. cffi — C header'dan avtomatik bog'lash. Deklaratsiya — FFI asosi.


3. Tez ma'lumotnoma

python
from cffi import FFI
ffi = FFI()

# C DEKLARATSIYALARI (cdef — C sintaksisida):
ffi.cdef("""
    int qoshish(int a, int b);
    double kvadrat(double x);
    struct Nuqta { int x; int y; };
""")

# ABI REJIM (dlopen — tayyor kutubxona, kompilyatsiyasiz):
lib = ffi.dlopen("./mening.so")
natija = lib.qoshish(3, 5)   # turlar avtomatik (cdef)

# API REJIM (set_source + compile — C kod, xavfsizroq):
ffi.set_source("_mening", "int qoshish(int a, int b){return a+b;}")
ffi.compile()

# CFFI vs CTYPES:
# ctypes — qo'lda (argtypes), standart · cffi — avtomatik (cdef)
# ctypes — oddiy holatga · cffi — katta/ishonchli (API)

# QOIDA: API rejim (xavfsizroq), cdef (deklaratsiya), avtomatik turlar

cffi xulosasi

cffi — Python FFI (ctypes muqobili) — C ni C sintaksisida
cdef (C deklaratsiya) — cffi parse qiladi (avtomatik turlar)
ABI (dlopen — yuklash) vs API (compile — xavfsizroq)
Avtomatik tur (qo'lda argtypes yo'q — ctypes farqi)
ctypes (qo'lda, standart) vs cffi (avtomatik, xavfsizroq)

4. Batafsil misollar

cffi kutubxona/kompilyator talab qiladi; misollar C deklaratsiya parse mantiqini (deterministik) modellashtiradi.

Misol 1 — C deklaratsiya (parse)

python
"""C deklaratsiya: funksiya imzosini parse qilish (cffi cdef modeli)."""


def cdef_parse(deklaratsiya: str) -> dict:
    # oddiy parse: "int qoshish(int a, int b)" → nom, natija, argumentlar
    natija_turi, qolgan = deklaratsiya.strip().rstrip(";").split(None, 1)
    nom = qolgan.split("(")[0].strip()
    args_str = qolgan.split("(")[1].rstrip(")")
    argumentlar = [a.strip() for a in args_str.split(",") if a.strip()]
    return {"nom": nom, "natija_turi": natija_turi, "argumentlar": argumentlar}


def main() -> None:
    print("=== 1. Funksiya deklaratsiyasi ===")
    d = cdef_parse("int qoshish(int a, int b);")
    print(f"  nom: {d['nom']}")
    print(f"  natija: {d['natija_turi']}")
    print(f"  argumentlar: {d['argumentlar']}")

    print("\n=== 2. Boshqa deklaratsiya ===")
    d = cdef_parse("double kvadrat(double x);")
    print(f"  nom: {d['nom']}, natija: {d['natija_turi']}")
    print(f"  argumentlar: {d['argumentlar']}")

    print("\n=== 3. cffi avtomatik tushunadi ===")
    print("  deklaratsiyadan turlar (qo'lda argtypes yo'q)")

    print("\n=== 4. ctypes farqi ===")
    print("  ctypes: argtypes = [c_int, c_int] (qo'lda)")
    print("  cffi: cdef('int qoshish(int, int)') (avtomatik)")
    print("  ⭐ cdef — C deklaratsiya (avtomatik turlar)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Funksiya deklaratsiyasi ===
  nom: qoshish
  natija: int
  argumentlar: ['int a', 'int b']

=== 2. Boshqa deklaratsiya ===
  nom: kvadrat, natija: double
  argumentlar: ['double x']

=== 3. cffi avtomatik tushunadi ===
  deklaratsiyadan turlar (qo'lda argtypes yo'q)

=== 4. ctypes farqi ===
  ctypes: argtypes = [c_int, c_int] (qo'lda)
  cffi: cdef('int qoshish(int, int)') (avtomatik)
  ⭐ cdef — C deklaratsiya (avtomatik turlar)

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

Misol 2 — ABI vs API rejim

python
"""ABI vs API: yuklash (kompilyatsiyasiz) vs kompilyatsiya (xavfsizroq)."""


REJIMLAR = {
    "ABI (dlopen)": {"kompilyatsiya": False, "xavfsizlik": "past", "tezlik": "o'rta"},
    "API (compile)": {"kompilyatsiya": True, "xavfsizlik": "yuqori", "tezlik": "tez"},
}


def main() -> None:
    print("=== 1. ABI rejim (dlopen) ===")
    abi = REJIMLAR["ABI (dlopen)"]
    print(f"  kompilyatsiya: {abi['kompilyatsiya']} (tayyor kutubxona)")
    print(f"  xavfsizlik: {abi['xavfsizlik']} (ctypes kabi)")

    print("\n=== 2. API rejim (compile) ===")
    api = REJIMLAR["API (compile)"]
    print(f"  kompilyatsiya: {api['kompilyatsiya']} (C kod)")
    print(f"  xavfsizlik: {api['xavfsizlik']} (compiler tekshiradi)")

    print("\n=== 3. Taqqoslash ===")
    print("  ABI: yuklash (tez sinash, oddiy)")
    print("  API: kompilyatsiya (ishlab chiqarish, xavfsiz)")

    print("\n=== 4. Tanlov ===")
    print("  tez sinash → ABI (kompilyatsiyasiz)")
    print("  ishlab chiqarish → API (xavfsizroq)")
    print("  ⭐ ABI (yuklash) vs API (kompilyatsiya)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. ABI rejim (dlopen) ===
  kompilyatsiya: False (tayyor kutubxona)
  xavfsizlik: past (ctypes kabi)

=== 2. API rejim (compile) ===
  kompilyatsiya: True (C kod)
  xavfsizlik: yuqori (compiler tekshiradi)

=== 3. Taqqoslash ===
  ABI: yuklash (tez sinash, oddiy)
  API: kompilyatsiya (ishlab chiqarish, xavfsiz)

=== 4. Tanlov ===
  tez sinash → ABI (kompilyatsiyasiz)
  ishlab chiqarish → API (xavfsizroq)
  ⭐ ABI (yuklash) vs API (kompilyatsiya)

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Avtomatik vs qo'lda tur (taqqoslash)

python
"""Avtomatik tur: cffi deklaratsiyadan, ctypes qo'lda (ish miqdori farqi)."""


def qol_ish_soni(funksiyalar_soni: int, usul: str) -> dict:
    if usul == "ctypes":
        # har funksiyaga argtypes + restype (qo'lda)
        qol_ish = funksiyalar_soni * 2   # argtypes + restype
    else:  # cffi
        # bir cdef (barcha funksiya)
        qol_ish = 1
    return {"usul": usul, "qol_ish": qol_ish}


def main() -> None:
    print("=== 1. 10 funksiya — ctypes ===")
    c = qol_ish_soni(10, "ctypes")
    print(f"  qo'lda belgilash: {c['qol_ish']} marta (argtypes + restype)")

    print("\n=== 2. 10 funksiya — cffi ===")
    f = qol_ish_soni(10, "cffi")
    print(f"  qo'lda belgilash: {f['qol_ish']} marta (bir cdef)")

    print("\n=== 3. 200 funksiya (katta kutubxona) ===")
    c200 = qol_ish_soni(200, "ctypes")
    f200 = qol_ish_soni(200, "cffi")
    print(f"  ctypes: {c200['qol_ish']} marta (koshmar)")
    print(f"  cffi: {f200['qol_ish']} marta (deklaratsiya)")

    print("\n=== 4. Farq ===")
    print("  ctypes — har funksiyaga qo'lda (xato xavfi)")
    print("  cffi — deklaratsiya bir marta (avtomatik)")
    print("  ⭐ Avtomatik tur — cffi qulayligi (katta kutubxona)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. 10 funksiya — ctypes ===
  qo'lda belgilash: 20 marta (argtypes + restype)

=== 2. 10 funksiya — cffi ===
  qo'lda belgilash: 1 marta (bir cdef)

=== 3. 200 funksiya (katta kutubxona) ===
  ctypes: 400 marta (koshmar)
  cffi: 1 marta (deklaratsiya)

=== 4. Farq ===
  ctypes — har funksiyaga qo'lda (xato xavfi)
  cffi — deklaratsiya bir marta (avtomatik)
  ⭐ Avtomatik tur — cffi qulayligi (katta kutubxona)

Nima ko'rsatdi: 2.4, 2.6-bo'limlar.

Misol 4 — Inline C (API rejim modeli)

python
"""Inline C: API rejim — C kod yozish, kompilyatsiya (Python moduli)."""


def api_oqim(c_kod: str, deklaratsiya: str) -> dict:
    # API rejim qadamlari (model)
    qadamlar = [
        "set_source (C kod)",
        "cdef (deklaratsiya)",
        "compile (kompilyatsiya)",
        "import (Python moduli)",
    ]
    return {"c_kod": c_kod, "deklaratsiya": deklaratsiya, "qadamlar": qadamlar}


def main() -> None:
    c_kod = "int qoshish(int a, int b) { return a + b; }"
    dekl = "int qoshish(int a, int b);"

    print("=== 1. C kod (implementatsiya) ===")
    print(f"  {c_kod}")

    print("\n=== 2. Deklaratsiya (imzo) ===")
    print(f"  {dekl}")

    print("\n=== 3. API oqimi (qadamlar) ===")
    oqim = api_oqim(c_kod, dekl)
    for i, qadam in enumerate(oqim["qadamlar"], 1):
        print(f"  {i}. {qadam}")

    print("\n=== 4. Natija ===")
    print("  C kod → kompilyatsiya → Python moduli")
    print("  kichik C funksiya (tez — bottleneck 29.2)")
    print("  ⭐ Inline C — C kod yozish (cffi API)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. C kod (implementatsiya) ===
  int qoshish(int a, int b) { return a + b; }

=== 2. Deklaratsiya (imzo) ===
  int qoshish(int a, int b);

=== 3. API oqimi (qadamlar) ===
  1. set_source (C kod)
  2. cdef (deklaratsiya)
  3. compile (kompilyatsiya)
  4. import (Python moduli)

=== 4. Natija ===
  C kod → kompilyatsiya → Python moduli
  kichik C funksiya (tez — bottleneck 29.2)
  ⭐ Inline C — C kod yozish (cffi API)

Nima ko'rsatdi: 2.5-bo'lim.


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

Noto'g'ri fikr To'g'risi
"cffi = ctypes" cffi avtomatik (cdef), ctypes qo'lda
"Turlarni qo'lda belgila" cffi avtomatik (deklaratsiyadan)
"cffi faqat yuklash" ABI (yuklash) + API (kompilyatsiya)
"ABI doim yaxshi" API xavfsizroq
"cffi standart" O'rnatish kerak (pip)
"cffi murakkab" Katta kutubxonaga soddaroq
"C yozib bo'lmaydi" Inline C (API rejim)
"ctypes yetadi" Katta/murakkab — cffi

6. Keng tarqalgan xatolar va yechimlari

1. ABI rejim ishlab chiqarishda

python
lib = ffi.dlopen(...)   # xavfliroq (ABI)             # ⚠️
# API rejim (set_source + compile — xavfsizroq)        # ✅

2. Noto'g'ri cdef (parse xatosi)

python
ffi.cdef("int qoshish(a, b)")   # tur yo'q (xato)     # ⚠️
ffi.cdef("int qoshish(int a, int b);")   # to'liq      # ✅

3. cffi o'rnatilmagan deb kutish

python
import cffi   # standart deb (ImportError)            # ⚠️
# pip install cffi (o'rnatish)                          # ✅

4. C xatosini istisno deb kutish

python
try: lib.func(...)   # C crash try/except tutmaydi     # ⚠️
# turlar deklaratsiyadan (crash oldini)                 # ✅

5. Kompilyator yo'q (API)

python
ffi.compile()   # C kompilyator yo'q (xato)           # ⚠️
# C kompilyator o'rnatilgan bo'lsin (API)               # ✅

6. Satr o'girish (C char)*

python
lib.func("salom")   # Python str (C char*)            # ⚠️
lib.func(ffi.new("char[]", b"salom"))                  # ✅

7. Oddiy holatga cffi (ortiqcha)

python
# bir funksiyaga cffi + kompilyatsiya (ortiqcha)       # ⚠️
# oddiy — ctypes (standart, tez)                        # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 30.3-dars (o'tilgan): ctypes — qo'lda FFI
  • 30.1-dars (o'tilgan): Tillar birlashtirish
  • 30.5-dars: C kengaytmasi — to'liq modul
  • 30.7-dars: Cython — boshqa yondashuv
  • 29.2-dars (o'tilgan): Bottleneck — C tezlik

8. Eng yaxshi amaliyotlar

  1. API rejim (ishlab chiqarish — xavfsizroq).

  2. cdef (C header'dan — deklaratsiya).

  3. Avtomatik turlar (qo'lda emas).

  4. ABI (tez sinash — mavjud kutubxona).

  5. Inline C (kichik funksiya — API).

  6. C xatosi ehtiyot (crash — turlar aniq).

  7. Katta/murakkab — cffi (ctypes emas).

  8. Oddiy — ctypes (standart, tez).


9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # cffi nima?
2.  # cffi vs ctypes?
3.  # cdef nima?
4.  # cdef nima beradi?
5.  # ABI rejim nima?
6.  # API rejim nima?
7.  # ABI vs API?
8.  # avtomatik tur nima?
9.  # nega cffi soddaroq?
10. # inline C nima?
11. # cffi standartmi?
12. # qachon cffi?
Javoblar
  1. Python FFI (ctypes muqobili)
  2. cffi avtomatik (cdef), ctypes qo'lda
  3. C deklaratsiya (funksiya imzosi)
  4. cffi turlarni avtomatik biladi
  5. Tayyor kutubxonani yuklash (kompilyatsiyasiz)
  6. C kod kompilyatsiya (xavfsizroq)
  7. ABI yuklash, API kompilyatsiya
  8. Turlar deklaratsiyadan (qo'lda emas)
  9. Deklaratsiya parse (qo'lda argtypes yo'q)
  10. C kod to'g'ridan yozish (API)
  11. Yo'q (pip install)
  12. Katta/murakkab kutubxona

Vazifa 2: Xatolarni tuzating

python
1.  lib = ffi.dlopen(...)   # ishlab chiqarish

2.  ffi.cdef("int qoshish(a, b)")   # tur yo'q

3.  # ctypes kabi qo'lda argtypes

4.  # oddiy funksiyaga cffi kompilyatsiya

5.  lib.func("salom")   # str
Javoblar
python
1.  API rejim (set_source + compile)

2.  ffi.cdef("int qoshish(int a, int b);")

3.  cdef (avtomatik turlar)

4.  oddiy — ctypes (standart)

5.  ffi.new("char[]", b"salom")

Vazifa 3: cdef

Modellang:

  1. Deklaratsiya
  2. Parse
  3. Turlar
  4. Avtomatik

Vazifa 4: ABI/API

Modellang:

  1. ABI
  2. API
  3. Kompilyatsiya
  4. Tanlov

Vazifa 5: Tur farqi

Modellang:

  1. ctypes qo'lda
  2. cffi avtomatik
  3. Ish miqdori
  4. Katta kutubxona

Vazifa 6: Inline C

Modellang:

  1. C kod
  2. Deklaratsiya
  3. Kompilyatsiya
  4. Modul

Vazifa 7: O'ylash

cffi ctypes'ga muqobil — asosiy farqi C deklaratsiyani avtomatik parse qilishi (qo'lda tur belgilash yo'q). Nima uchun "avtomatlashtirish" (qo'lda ishni mashina qiladi) muhandislikda takrorlanadigan yaxshilanish (ctypes → cffi kabi), va nega "qo'lda takroriy ish" (200 funksiyaga argtypes) nafaqat zerikarli, balki xato manbai?

Javob

Qisqa javob: "Avtomatlashtirish" takrorlanadigan yaxshilanish, chunki: qo'lda takroriy ish (bir xil naqshni ko'p marta — 200 funksiyaga argtypes/restype) inson uchun yomon (zerikarli, sekin), lekin mashina uchun oson (aniq, tez, xatosiz — kompyuter takrorlashda charchamaydi). Avtomatlashtirish (cffi — deklaratsiyadan turlar) qo'lda ishni mashinaga topshiradi (cffi C deklaratsiyani parse qiladi — inson o'rniga). Bu 26-qism (avtomatlashtirish — takroriy ishni skript), CI/CD (28.7-8 — qo'lda deploy → avtomatik) bilan bir tamoyil: takroriy, aniq qoidali ishni avtomatlashtir (inson faqat qaror/ijod). "Qo'lda takroriy ish" nafaqat zerikarli, balki xato manbai, chunki: (1) inson charchaydi (200 marta bir xil ish — e'tibor pasayadi, xato ehtimoli oshadi); (2) bir xatoni sezmaslik oson (199 to'g'ri, 1 noto'g'ri — ko'zdan qochadi, lekin o'sha 1 crash beradi); (3) DRY buzilishi (27.1 — takror kod, bir o'zgarish ko'p joyda); (4) ko'r ishlab chiqarish (mexanik takror — tushunmasdan). Avtomatlashtirish bularni yo'q qiladi: mashina 200 marta ham xatosiz (charchamaydi), bir manbadan (deklaratsiya — DRY), o'zgarish bir joyda. cffi misolida: C header (deklaratsiya) allaqachon turlarni bilaydi — cffi undan oladi (inson qo'lda ko'chirishi shart emas, xato ehtimoli yo'q). Bu "haqiqat manbasi" (28.14 — source of truth) bilan bog'liq: deklaratsiya — yagona manba (undan turlar); qo'lda argtypes — ikkinchi nusxa (deklaratsiya bilan mos kelmasligi mumkin — 29.3 kesh kabi). Muhandislik saboqlari: takroriy, aniq ishni avtomatlashtir (inson ijodga, mashina takrorga); qo'lda takror — xato manbai (charchash, ko'zdan qochish, DRY buzilishi); yagona haqiqat manbasi (deklaratsiya) — nusxa emas; avtomatlashtirish — kamroq xato, kamroq ish.

1. Nega avtomatlashtirish yaxshilanish

Qo'lda takror — inson uchun yomon (zerikarli, xato). Mashina uchun oson (aniq, xatosiz). Avtomatlashtir — qo'lda ishni mashinaga.

2. Nega qo'lda takror xato manbai

  • Inson charchaydi (e'tibor pasayadi)
  • Bir xatoni sezmaslik oson (199/200)
  • DRY buzilishi (takror)
  • Ko'r ishlab chiqarish (mexanik)

3. cffi yechimi

Usul Manba
ctypes Qo'lda argtypes (nusxa)
cffi Deklaratsiyadan (yagona manba)

Deklaratsiya biladi → cffi oladi (qo'lda emas).

4. Yagona haqiqat manbasi

Deklaratsiya — yagona manba (turlar). Qo'lda argtypes — ikkinchi nusxa (mos kelmaslik xavfi).

5. Muhandislik saboqlari

  1. Takroriy ishni avtomatlashtir (inson ijodga)
  2. Qo'lda takror — xato manbai (charchash, DRY)
  3. Yagona haqiqat manbasi (nusxa emas)
  4. Avtomatlashtirish — kamroq xato/ish

6. Xulosa

  1. Avtomatlashtirish — qo'lda ishni mashinaga (takroriy)
  2. Qo'lda takror — xato manbai (inson charchaydi)
  3. cffi — deklaratsiyadan (yagona manba)
  4. Kamroq xato, kamroq ish

Nimani mustahkamlaydi: 2.4, 2.6-bo'limlar.


Xulosa

Bu darsda cffi ni o'rgandik.

Eng muhim uch fikr:

  1. cffi va deklaratsiya. cffi — Python uchun FFI kutubxonasi (ctypes'ga muqobil): C kodini C sintaksisida ishlatish. Farqi ctypes'dan: ctypes'da turlar qo'lda (argtypes/restype), cffi'da C deklaratsiya (cdef) beriladi, cffi o'zi parse qiladi (turlarni tushunadi — qo'lda yo'q). C deklaratsiyalari (cdef) — cffi'ga C imzolarini aytish (C sintaksisida — int qoshish(int a, int b);, struct'lar); cffi turlarni deklaratsiyadan biladi (C header kabi).

  2. ABI/API va avtomatik tur. ABI vs API rejim: ABI (dlopen — tayyor kutubxonani yuklash, kompilyatsiyasiz — ctypes kabi, oddiy, xavfliroq), API (set_source + compile — cffi C kodni kompilyatsiya, C compiler — tezroq, xavfsizroq, tekshiradi). Avtomatik tur muvofiqligi — cffi asosiy afzalligi: C deklaratsiyadan turlarni biladi (ctypes qo'lda — yuzlab funksiya koshmar, cffi bir cdef); kamroq xato, soddaroq. Inline C — cffi (API) bilan kichik C kodni to'g'ridan yozish/kompilyatsiya (set_source).

  3. Taqqoslash va deklaratsiyaga asoslangan FFI. cffi vs ctypes: ctypes (standart — o'rnatish yo'q, qo'lda turlar, oddiy holatga), cffi (o'rnatish — pip, avtomatik turlar, ABI+API, xavfsizroq, katta/murakkab holatga); tanlov — kichik/tez (ctypes) yoki katta/ishonchli (cffi). cffi deklaratsiyaga asoslangan FFI (C deklaratsiyalarini berib, avtomatik turlar) — ctypes 30.3-bob va kengaytma 30.5-bob orasida (soddaroq, xavfsizroq, lekin o'rnatish); zamonaviy loyihalar tavsiya qiladi (PyPy ham). Avtomatlashtirish (qo'lda ishni mashinaga — cffi deklaratsiya) takrorlanadigan yaxshilanish; qo'lda takror — xato manbai (inson charchaydi, DRY buziladi, yagona haqiqat manbasi emas). FFI 30.1-bob ning takomillashgan usuli.

Keyingi darsda CPython C API asoslarini o'rganamiz: Python interpretatori bilan C darajasida ishlash — Python obyektlari (PyObject), havolalar hisobi (reference counting) va C kengaytmalarining ichki mexanizmi.

Python va boshqa tillar · 4-dars yakunlandi

30.4-dars: cffi

19 daqvaqt
0belgi
Keyingi dars: 30.5-dars: CPython C API asoslari
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0