30.4-dars: cffi
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:
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:
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:
# 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:
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
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 turlarcffi 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)
"""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:
=== 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
"""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:
=== 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)
"""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:
=== 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)
"""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:
=== 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
lib = ffi.dlopen(...) # xavfliroq (ABI) # ⚠️
# API rejim (set_source + compile — xavfsizroq) # ✅2. Noto'g'ri cdef (parse xatosi)
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
import cffi # standart deb (ImportError) # ⚠️
# pip install cffi (o'rnatish) # ✅4. C xatosini istisno deb kutish
try: lib.func(...) # C crash try/except tutmaydi # ⚠️
# turlar deklaratsiyadan (crash oldini) # ✅5. Kompilyator yo'q (API)
ffi.compile() # C kompilyator yo'q (xato) # ⚠️
# C kompilyator o'rnatilgan bo'lsin (API) # ✅6. Satr o'girish (C char)*
lib.func("salom") # Python str (C char*) # ⚠️
lib.func(ffi.new("char[]", b"salom")) # ✅7. Oddiy holatga cffi (ortiqcha)
# 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
API rejim (ishlab chiqarish — xavfsizroq).
cdef (C header'dan — deklaratsiya).
Avtomatik turlar (qo'lda emas).
ABI (tez sinash — mavjud kutubxona).
Inline C (kichik funksiya — API).
C xatosi ehtiyot (crash — turlar aniq).
Katta/murakkab — cffi (ctypes emas).
Oddiy — ctypes (standart, tez).
9. Amaliy topshiriq
Vazifa 1: Bashorat qiling
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
- Python FFI (ctypes muqobili)
- cffi avtomatik (cdef), ctypes qo'lda
- C deklaratsiya (funksiya imzosi)
- cffi turlarni avtomatik biladi
- Tayyor kutubxonani yuklash (kompilyatsiyasiz)
- C kod kompilyatsiya (xavfsizroq)
- ABI yuklash, API kompilyatsiya
- Turlar deklaratsiyadan (qo'lda emas)
- Deklaratsiya parse (qo'lda argtypes yo'q)
- C kod to'g'ridan yozish (API)
- Yo'q (pip install)
- Katta/murakkab kutubxona
Vazifa 2: Xatolarni tuzating
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") # strJavoblar
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:
- Deklaratsiya
- Parse
- Turlar
- Avtomatik
Vazifa 4: ABI/API
Modellang:
- ABI
- API
- Kompilyatsiya
- Tanlov
Vazifa 5: Tur farqi
Modellang:
- ctypes qo'lda
- cffi avtomatik
- Ish miqdori
- Katta kutubxona
Vazifa 6: Inline C
Modellang:
- C kod
- Deklaratsiya
- Kompilyatsiya
- 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
- Takroriy ishni avtomatlashtir (inson ijodga)
- Qo'lda takror — xato manbai (charchash, DRY)
- Yagona haqiqat manbasi (nusxa emas)
- Avtomatlashtirish — kamroq xato/ish
6. Xulosa
- Avtomatlashtirish — qo'lda ishni mashinaga (takroriy)
- Qo'lda takror — xato manbai (inson charchaydi)
- cffi — deklaratsiyadan (yagona manba)
- Kamroq xato, kamroq ish
Nimani mustahkamlaydi: 2.4, 2.6-bo'limlar.
Xulosa
Bu darsda cffi ni o'rgandik.
Eng muhim uch fikr:
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).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).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.
Izohlar · 0
Izoh yozish uchun kiring.