30.3-dars: ctypes — C kutubxonasini chaqirish

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

1. Kirish va motivatsiya

subprocess 30.2-bob boshqa dasturni ishga tushiradi — lekin bu ajratilgan jarayon (matn orqali aloqa, sekinroq). Ba'zan mavjud C kutubxonasi (.so Linux'da, .dll Windows'da) funksiyasini to'g'ridan-to'g'ri chaqirish kerak: tez, bir jarayonda, matn parse qilmasdan. Masalan mavjud tasvir qayta ishlash kutubxonasi (C'da yozilgan) yoki apparat drayveri — uni Python'dan bevosita chaqirish. ctypes bu imkonni beradi: Python'dan C kutubxonasi funksiyalarini chaqiradi — kompilyatsiya kerak emas (tayyor kutubxonani yuklaydi). Bu FFI (Foreign Function Interface) — tillarni bir jarayonda birlashtirish.

ctypes — Python standart kutubxonasidagi FFI (Foreign Function Interface) moduli: C kutubxonasini yuklash (CDLL — .so/.dll yuklash), funksiya chaqirish (C funksiyasini Python'dan), turlar (C turlari — c_int, c_double, c_char_p — Python va C orasida), tur muvofiqligi (argtypes, restype — argument va natija turlari), strukturalar (Structure — C struct), pointerlar (POINTER, byref). Foydalanish: mavjud C kutubxonasi (qayta yozmasdan), tizim API. Bu subprocess'dan 30.2-bob farqli — bir jarayon (tez, to'g'ridan), lekin tur muvofiqligi kerak. Bu 30.1 (birlashtirish), 30.4 (cffi) bilan bog'liq. ctypes — C funksiyasini chaqirish. FFI — bir jarayonda birlashtirish.

Real vaziyat. Bir Python dastur ixtisoslashgan matematik kutubxonaga (C'da yozilgan, .so fayl) muhtoj edi — u tez, sinalgan, lekin Python bog'lovchisi yo'q edi. Butun kutubxonani Python'da qayta yozish — imkonsiz (yillar ish, sekin). Yechim: ctypes bilan .so yuklandi, funksiyalar chaqirildi (turlar to'g'ri belgilandi — argtypes, restype). Python C kutubxonasidan bevosita foydalandi (tez, qayta yozmasdan). ctypes — mavjud C kuchini ochdi.

Bu darsda ctypes ni o'rganamiz.

Bu darsda:

• ctypes va FFI nima
• C kutubxonasini yuklash
• C turlari (c_int, c_double)
• Tur muvofiqligi (argtypes, restype)
• Strukturalar (Structure)
• Pointerlar va xotira
• ctypes cheklovlari va xavfsizlik
• Amaliy: ctypes modeli

ℹ ctypes C kutubxona talab qiladi; misollar ctypes turlari (deterministik) bilan FFI mantiqini modellashtiradi.

2. Nazariya — chuqur tushuntirish

2.1. ctypes va FFI nima

C funksiyasini to'g'ridan chaqirish:

import ctypes
# C kutubxonasini yuklash (tayyor .so/.dll)
libm = ctypes.CDLL("libm.so.6")   # matematik kutubxona
# C funksiyasini chaqirish
natija = libm.sqrt(...)   # C'ning sqrt funksiyasi

ctypes — Python standart kutubxonasidagi FFI (Foreign Function Interface — chet til interfeysi): Python'dan C kutubxonasi (.so/.dll) funksiyalarini to'g'ridan chaqirish. Sabab: mavjud C kutubxonasi (tez, sinalgan) — qayta yozmasdan ishlatish; subprocess'dan farqli — bir jarayon (matn parse yo'q, tez, to'g'ridan). Kompilyatsiya kerak emas (tayyor kutubxonani yuklaydi — 30.5 kengaytmadan farqli, u kompilyatsiya). FFI — tillar bir jarayonda funksiya darajasida (30.1 — yaqin integratsiya). ctypes — C funksiyasini chaqirish (Python standart). FFI — bir jarayonda til aloqasi.

2.2. C kutubxonasini yuklash

import ctypes

# platformaga qarab:
libc = ctypes.CDLL("libc.so.6")        # Linux
# libc = ctypes.CDLL("msvcrt.dll")     # Windows

# yoki topilgan kutubxonani yuklash:
# lib = ctypes.CDLL("./mening_kutubxonam.so")

C kutubxonasini yuklash — ctypes.CDLL(yo'l) (kutubxonani xotiraga yuklaydi): .so (Linux — shared object), .dll (Windows — dynamic link library), .dylib (macOS). Yuklangach, funksiyalar atribut sifatida (lib.funksiya_nomi). Sabab: kutubxona oldindan kompilyatsiya qilingan (C'dan — tayyor mashina kodi); ctypes uni yuklaydi (kompilyatsiya emas — 30.5 kengaytmadan farq). Platforma farqi (.so/.dll) — kod platformaga bog'liq. CDLL (cdecl konvensiya), WinDLL (Windows stdcall). Yuklash — kutubxonani ochish. Kutubxona — tayyor funksiyalar.

2.3. C turlari (c_int, c_double)

Python va C orasida:

import ctypes

# C turlari (Python obyektlari):
ctypes.c_int(42)          # C int
ctypes.c_double(3.14)     # C double
ctypes.c_char_p(b"salom") # C char* (satr)
ctypes.c_bool(True)       # C bool

# Python int → c_int (avtomatik ba'zan, aniq yaxshiroq)

C turlari — Python va C orasidagi turlar (ctypes obyektlari): c_int (C int — butun), c_double (C double — kasr), c_char_p (C char* — satr, baytlar), c_bool, c_float, c_void_p (pointer). Sabab: C qat'iy turli (har tur aniq hajm — 30.3.4), Python dinamik (tur o'zgaruvchan) — ctypes turlari ko'prik (Python qiymatini C turiga o'giradi). Masalan Python 42 → c_int(42) (C int). Har C turi — ctypes obyekti. Turlar — Python/C ko'prigi. Tur muvofiqligi — muhim (30.3.4).

2.4. Tur muvofiqligi (argtypes, restype)

Argument va natija turlari:

# funksiya turlarini belgilash (MUHIM — xato oldini oladi)
lib.qoshish.argtypes = [ctypes.c_int, ctypes.c_int]   # argumentlar
lib.qoshish.restype = ctypes.c_int                     # natija

natija = lib.qoshish(3, 5)   # to'g'ri turlar → to'g'ri natija
# belgilanmasa: noto'g'ri talqin (xato natija, crash)

Tur muvofiqligi — C funksiyasining argument va natija turlarini belgilash: argtypes (argumentlar ro'yxati — [c_int, c_int]), restype (natija turi — c_int). Sabab: C funksiya turlarni biladi (kompilyatsiyada), lekin Python bilmaydi — ctypes'ga aytish kerak (aks holda noto'g'ri talqin — xato natija yoki crash!). Masalan restype belgilanmasa, ctypes natijani int deb oladi (double bo'lsa — noto'g'ri). Bu ctypes'ning eng muhim va xatoga moyil qismi (turlar aniq bo'lishi kerak). Tur muvofiqligi — to'g'ri talqin. argtypes/restype — turlarni aytish.

2.5. Strukturalar (Structure)

C struct:

import ctypes

# C struct'ni Python'da:
class Nuqta(ctypes.Structure):
    _fields_ = [("x", ctypes.c_int), ("y", ctypes.c_int)]

n = Nuqta(3, 5)
print(n.x, n.y)   # 3 5
# C funksiyaga struct berish/olish mumkin

Strukturalar — C struct ni Python'da ifodalash: ctypes.Structure dan meros, _fields_ (maydonlar — nom va tur: [("x", c_int), ("y", c_int)]). Sabab: C funksiyalari ko'pincha struct qabul qiladi/qaytaradi (murakkab ma'lumot — nuqta, konfiguratsiya) — Python ekvivalenti kerak (C xotira joylashuviga mos). ctypes struct C bilan bir xil xotira (mos maydonlar). Bu C API bilan ishlashda muhim (struct — keng tarqalgan). Struct — C ma'lumot tuzilmasi. Structure — C struct ekvivalenti.

2.6. Pointerlar va xotira

Pointerlar va xotira — C past daraja (xotira manzillari bilan ishlaydi): POINTER(tur) (pointer turi), byref(obyekt) (obyekt manzilini berish — funksiya o'zgartirsin), ctypes.pointer(obyekt) (pointer yaratish), ctypes.addressof (manzil). Sabab: C funksiyalari ko'pincha pointer oladi (natijani o'zgaruvchiga yozish, massiv uzatish) — Python ekvivalenti kerak. Ehtiyot: pointerlar xavfli (noto'g'ri manzil — crash, xotira buzilishi); ctypes past daraja (C kabi — 30.1 C xavfi). Bu ctypes'ning eng murakkab va xavfli qismi (xotira bilan bevosita). Pointer — xotira manzili. ctypes — past daraja (ehtiyot).

2.7. ctypes cheklovlari va xavfsizlik

ctypes cheklovlari va xavfsizlik: tur muvofiqligi (argtypes/restype noto'g'ri — crash, xato — 30.3.4; eng ko'p muammo); xotira xavfi (pointerlar, past daraja — noto'g'ri manzil crash, xotira buzilishi — 30.1 C xavfi); platforma bog'liqlik (.so/.dll — platformaga xos); crash (C xatosi — Python istisno emas, butun jarayon o'ladi — segfault); murakkablik (turlar, pointerlar — qo'lda). Yechimlar: turlarni aniq belgila (argtypes/restype), sinovdan o'tkaz (crash — ehtiyot), cffi (30.4 — soddaroq), kengaytma (30.5 — kompilyatsiya, xavfsizroq). ctypes — kuchli, lekin xavfli (past daraja, crash). Yaxshi ctypes — turlar aniq, ehtiyot. Xavf — tur, xotira, crash.

2.8. ctypes — tayyor C kutubxonalarini ochish

ctypes asosiy g'oyasi — tayyor C kutubxonalarini (kompilyatsiya qilingan) Python'dan ochish: mavjud C kuchini (tez funksiyalar, tizim API, kutubxona) qayta yozmasdan ishlatish. Bu subprocess (30.2 — dastur, ajratilgan) va kengaytma (30.5 — kompilyatsiya) orasida: bir jarayon (tez), lekin kompilyatsiyasiz (tayyor kutubxona). Farqi: subprocess — dastur (matn), ctypes — funksiya (to'g'ridan), kengaytma — kompilyatsiya (yaqin). ctypes qulay (kompilyatsiyasiz), lekin xavfli (tur, crash — 30.4 cffi soddaroq, 30.5 kengaytma xavfsizroq). Bu FFI (30.1 — bir jarayonda til) ning oddiy usuli. ctypes — C funksiyalarni ochish (kompilyatsiyasiz). Tayyor kutubxona — Python'dan.

3. Tez ma'lumotnoma

import ctypes

# KUTUBXONA YUKLASH:
lib = ctypes.CDLL("libm.so.6")        # Linux (.so)
# lib = ctypes.CDLL("msvcrt.dll")     # Windows (.dll)

# C TURLARI:
ctypes.c_int(42)          # int
ctypes.c_double(3.14)     # double
ctypes.c_char_p(b"text")  # char* (baytlar)
ctypes.c_bool(True)       # bool

# TUR MUVOFIQLIGI (MUHIM):
lib.func.argtypes = [ctypes.c_int, ctypes.c_int]   # argumentlar
lib.func.restype = ctypes.c_int                     # natija
natija = lib.func(3, 5)

# STRUKTURA (C struct):
class Nuqta(ctypes.Structure):
    _fields_ = [("x", ctypes.c_int), ("y", ctypes.c_int)]

# POINTER (xotira — ehtiyot):
ctypes.byref(obyekt)      # manzil berish
ctypes.POINTER(ctypes.c_int)

# XAVF: tur muvofiqligi (crash), pointer (xotira), segfault
# QOIDA: argtypes/restype aniq, ehtiyot (past daraja)

ctypes xulosasi

ctypes — Python'dan C kutubxonasi (.so/.dll) funksiyasi (FFI)
CDLL (yuklash) · c_int/c_double (turlar — Python/C ko'prigi)
argtypes/restype (tur muvofiqligi — MUHIM, crash oldini)
Structure (C struct) · pointer/byref (xotira — ehtiyot)
Bir jarayon (tez), kompilyatsiyasiz (tayyor) · xavfli (crash)

4. Batafsil misollar

ctypes C kutubxona talab qiladi; misollar ctypes turlari (deterministik) bilan FFI mantiqini modellashtiradi.

Misol 1 — C turlari (Python/C ko'prigi)

"""C turlari: Python qiymatlarini C turlariga o'girish (ctypes)."""
import ctypes


def main() -> None:
    print("=== 1. C butun (c_int) ===")
    c_int_qiymat = ctypes.c_int(42)
    print(f"  c_int(42).value: {c_int_qiymat.value}")

    print("\n=== 2. C kasr (c_double) ===")
    c_double_qiymat = ctypes.c_double(3.14)
    print(f"  c_double(3.14).value: {c_double_qiymat.value}")

    print("\n=== 3. C satr (c_char_p — baytlar) ===")
    c_str = ctypes.c_char_p(b"salom")
    print(f"  c_char_p(b'salom').value: {c_str.value}")

    print("\n=== 4. Tur hajmlari (C aniq turlari) ===")
    print(f"  c_int hajmi: {ctypes.sizeof(ctypes.c_int)} bayt")
    print(f"  c_double hajmi: {ctypes.sizeof(ctypes.c_double)} bayt")
    print("  C qat'iy turli (aniq hajm), Python dinamik")
    print("  ⭐ C turlari — Python/C ko'prigi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. C butun (c_int) ===
  c_int(42).value: 42

=== 2. C kasr (c_double) ===
  c_double(3.14).value: 3.14

=== 3. C satr (c_char_p — baytlar) ===
  c_char_p(b'salom').value: b'salom'

=== 4. Tur hajmlari (C aniq turlari) ===
  c_int hajmi: 4 bayt
  c_double hajmi: 8 bayt
  C qat'iy turli (aniq hajm), Python dinamik
  ⭐ C turlari — Python/C ko'prigi

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

Misol 2 — Struktura (C struct)

"""Structure: C struct'ni Python'da ifodalash (maydonlar bilan)."""
import ctypes


class Nuqta(ctypes.Structure):
    _fields_ = [("x", ctypes.c_int), ("y", ctypes.c_int)]


class Rang(ctypes.Structure):
    _fields_ = [("r", ctypes.c_int), ("g", ctypes.c_int), ("b", ctypes.c_int)]


def main() -> None:
    print("=== 1. Nuqta struct yaratish ===")
    n = Nuqta(3, 5)
    print(f"  Nuqta(3, 5): x={n.x}, y={n.y}")

    print("\n=== 2. Maydonlarni o'zgartirish ===")
    n.x = 10
    print(f"  x o'zgardi: x={n.x}, y={n.y}")

    print("\n=== 3. Boshqa struct (Rang) ===")
    rang = Rang(255, 128, 0)
    print(f"  Rang: r={rang.r}, g={rang.g}, b={rang.b}")

    print("\n=== 4. Struct hajmi (C xotira joylashuvi) ===")
    print(f"  Nuqta hajmi: {ctypes.sizeof(Nuqta)} bayt (2 x c_int)")
    print(f"  Rang hajmi: {ctypes.sizeof(Rang)} bayt (3 x c_int)")
    print("  C funksiyaga struct berish/olish mumkin")
    print("  ⭐ Structure — C struct ekvivalenti")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Nuqta struct yaratish ===
  Nuqta(3, 5): x=3, y=5

=== 2. Maydonlarni o'zgartirish ===
  x o'zgardi: x=10, y=5

=== 3. Boshqa struct (Rang) ===
  Rang: r=255, g=128, b=0

=== 4. Struct hajmi (C xotira joylashuvi) ===
  Nuqta hajmi: 8 bayt (2 x c_int)
  Rang hajmi: 12 bayt (3 x c_int)
  C funksiyaga struct berish/olish mumkin
  ⭐ Structure — C struct ekvivalenti

Nima ko'rsatdi: 2.5-bo'lim.

Misol 3 — Tur muvofiqligi (argtypes/restype modeli)

"""Tur muvofiqligi: funksiya turlarini belgilash muhim (xato oldini)."""
import ctypes


def tur_tekshir(argumentlar: list, kutilgan_turlar: list) -> dict:
    """C funksiyasiga berilgan turlar to'g'rimi (argtypes tekshiruvi)."""
    mos = len(argumentlar) == len(kutilgan_turlar)
    natija = []
    for arg, kutilgan in zip(argumentlar, kutilgan_turlar):
        arg_turi = type(arg).__name__
        tur_mos = (kutilgan == "int" and isinstance(arg, int)) or \
                  (kutilgan == "float" and isinstance(arg, float))
        natija.append({"qiymat": arg, "kutilgan": kutilgan, "mos": tur_mos})
        if not tur_mos:
            mos = False
    return {"barcha_mos": mos, "tafsilot": natija}


def main() -> None:
    print("=== 1. To'g'ri turlar (argtypes: int, int) ===")
    r = tur_tekshir([3, 5], ["int", "int"])
    print(f"  argumentlar: [3, 5], barcha mos: {r['barcha_mos']}")

    print("\n=== 2. Noto'g'ri tur (float kutilganda int) ===")
    r = tur_tekshir([3, 5], ["float", "float"])
    for t in r["tafsilot"]:
        print(f"  {t['qiymat']} ({t['kutilgan']} kutilgan): mos={t['mos']}")

    print("\n=== 3. Nega muhim ===")
    print("  restype belgilanmasa → noto'g'ri talqin")
    print("  argtypes noto'g'ri → xato natija yoki crash")

    print("\n=== 4. Qoida ===")
    print("  argtypes = [c_int, c_int]  (argumentlar)")
    print("  restype = c_int  (natija)")
    print("  turlarni ANIQ belgilash (crash oldini)")
    print("  ⭐ Tur muvofiqligi — to'g'ri talqin")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. To'g'ri turlar (argtypes: int, int) ===
  argumentlar: [3, 5], barcha mos: True

=== 2. Noto'g'ri tur (float kutilganda int) ===
  3 (float kutilgan): mos=False
  5 (float kutilgan): mos=False

=== 3. Nega muhim ===
  restype belgilanmasa → noto'g'ri talqin
  argtypes noto'g'ri → xato natija yoki crash

=== 4. Qoida ===
  argtypes = [c_int, c_int]  (argumentlar)
  restype = c_int  (natija)
  turlarni ANIQ belgilash (crash oldini)
  ⭐ Tur muvofiqligi — to'g'ri talqin

Nima ko'rsatdi: 2.4-bo'lim.

Misol 4 — Massiv (C array)

"""C array: ctypes bilan C massivini yaratish (funksiyaga uzatish uchun)."""
import ctypes


def main() -> None:
    print("=== 1. C butun massiv yaratish ===")
    # 5 ta int massiv (c_int * 5)
    ArrayTuri = ctypes.c_int * 5
    massiv = ArrayTuri(10, 20, 30, 40, 50)
    print(f"  massiv: {[massiv[i] for i in range(5)]}")

    print("\n=== 2. Elementga murojaat ===")
    print(f"  massiv[2]: {massiv[2]}")
    massiv[2] = 99
    print(f"  o'zgartirilgan massiv[2]: {massiv[2]}")

    print("\n=== 3. Massiv hajmi ===")
    print(f"  hajm: {ctypes.sizeof(massiv)} bayt (5 x c_int)")

    print("\n=== 4. C funksiyaga uzatish ===")
    print("  C funksiya massivni pointer sifatida oladi")
    print("  ctypes massiv — C xotira joylashuvi (mos)")
    print("  ⭐ C array — ctypes massiv (funksiyaga uzatish)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. C butun massiv yaratish ===
  massiv: [10, 20, 30, 40, 50]

=== 2. Elementga murojaat ===
  massiv[2]: 30
  o'zgartirilgan massiv[2]: 99

=== 3. Massiv hajmi ===
  hajm: 20 bayt (5 x c_int)

=== 4. C funksiyaga uzatish ===
  C funksiya massivni pointer sifatida oladi
  ctypes massiv — C xotira joylashuvi (mos)
  ⭐ C array — ctypes massiv (funksiyaga uzatish)

Nima ko'rsatdi: 2.6-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. argtypes/restype belgilamaslik

lib.func(3, 5)   # noto'g'ri talqin (crash)          # ⚠️
lib.func.argtypes = [c_int, c_int]; restype = c_int   # ✅

2. Noto'g'ri tur (crash)

lib.func(3.14)   # int kutilganda double             # ⚠️
lib.func(c_int(3))   # to'g'ri tur                     # ✅

3. Satrni to'g'ridan uzatish (baytlar)

lib.func("salom")   # str (C char* baytlar kutadi)    # ⚠️
lib.func(b"salom")   # baytlar                          # ✅

4. Pointer noto'g'ri (xotira)

lib.func(noto'g'ri_manzil)   # crash (xotira buzilishi)  # ⚠️
lib.func(ctypes.byref(obyekt))   # to'g'ri manzil        # ✅

5. Platforma qat'iy nom

ctypes.CDLL("libm.so.6")   # faqat Linux              # ⚠️
# platformaga qarab (.so/.dll) yoki ctypes.util         # ✅

6. Crash ni istisno deb kutish

try: lib.func(...)   # crash try/except tutmaydi       # ⚠️
# turlarni aniq belgila (crash oldini)                   # ✅

7. Murakkab holatga ctypes

# ko'p struct, pointer (ctypes murakkab)               # ⚠️
# cffi 30.4-bob yoki kengaytma (30.5 — soddaroq)          # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 30.1-dars (o'tilgan): Tillar birlashtirish — FFI
• 30.2-dars (o'tilgan): subprocess — alohida jarayon
• 30.4-dars: cffi — soddaroq FFI
• 30.5-dars: C kengaytmasi — kompilyatsiya
• 16-qism (o'tilgan): OOP — Structure (sinf)

8. Eng yaxshi amaliyotlar

1. argtypes/restype aniq belgila (MUHIM).

2. C turlari (c_int, c_double — ko'prik).

3. Satr — baytlar (b"...").

4. Pointer ehtiyot (xotira — crash).

5. Platforma (.so/.dll — ctypes.util).

6. Sinovdan o'tkaz (crash xavfi).

7. Murakkab — cffi 30.4-bob yoki kengaytma.

8. Struct — _fields_ (C mos joylashuv).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # ctypes nima?
2.  # FFI nima?
3.  # ctypes vs subprocess?
4.  # ctypes kompilyatsiya qiladimi?
5.  # CDLL nima?
6.  # c_int nima?
7.  # argtypes nima?
8.  # restype nima?
9.  # nega tur muvofiqligi?
10. # Structure nima?
11. # pointer xavfi?
12. # crash nima?

Vazifa 2: Xatolarni tuzating

1.  lib.func(3, 5)   # turlarsiz

2.  lib.func(3.14)   # int kutilganda

3.  lib.func("salom")   # str

4.  ctypes.CDLL("libm.so.6")   # faqat Linux

5.  try: lib.func()   # crash

1.  argtypes, restype belgila

2.  to'g'ri tur (c_int)

3.  b"salom" (baytlar)

4.  platformaga qarab (ctypes.util)

5.  turlarni aniq (crash oldini)

Vazifa 3: C turlari

Modellang:

1. c_int
2. c_double
3. c_char_p
4. Hajm

Vazifa 4: Structure

Modellang:

1. fields
2. Yaratish
3. Maydon
4. Hajm

Vazifa 5: Tur muvofiqligi

Modellang:

1. argtypes
2. restype
3. To'g'ri
4. Noto'g'ri

Vazifa 6: Massiv

Modellang:

1. Array turi
2. Yaratish
3. Element
4. Hajm

Vazifa 7: O'ylash

ctypes C kutubxonasini chaqiradi, lekin tur muvofiqligi (argtypes/restype) noto'g'ri bo'lsa — crash (segfault, jarayon o'ladi). Nima uchun "C xatosi Python istisnosi emas, balki crash" (try/except tutmaydi) — bu ikki tilning tub farqi haqida nima aytadi, va nega FFI (til chegarasini kesib o'tish) tur muvofiqligiga shunchalik bog'liq?

Nimani mustahkamlaydi: 2.4, 2.7-bo'limlar.

Xulosa

Bu darsda ctypes ni o'rgandik.

Eng muhim uch fikr:

1. ctypes/FFI va kutubxona. ctypes — Python standart kutubxonasidagi FFI (Foreign Function Interface): Python'dan C kutubxonasi (.so/.dll) funksiyalarini to'g'ridan chaqirish; mavjud C kuchini qayta yozmasdan (subprocess'dan farqli — bir jarayon, tez, matn parse yo'q); kompilyatsiya kerak emas (tayyor kutubxonani yuklaydi). Yuklash — ctypes.CDLL(yo'l) (.so Linux, .dll Windows, .dylib macOS); funksiyalar atribut sifatida (lib.func); platformaga bog'liq.

2. Turlar va tur muvofiqligi. C turlari — Python va C orasidagi (ctypes obyektlari): c_int (int), c_double (double), c_char_p (char* — baytlar), c_bool; C qat'iy turli, Python dinamik — ctypes ko'prik (Python qiymati → C tur). Tur muvofiqligi — funksiya argument (argtypes = [c_int, c_int]) va natija (restype = c_int) turlarini belgilash; MUHIM (C turlarni biladi, Python bilmaydi — aytish kerak; noto'g'ri bo'lsa — noto'g'ri talqin yoki crash); ctypes'ning eng muhim va xatoga moyil qismi.

3. Struct, pointer, xavfsizlik. Strukturalar — C struct (ctypes.Structure, _fields_ = [("x", c_int), ...] — C xotira joylashuviga mos). Pointerlar — C past daraja (POINTER, byref — manzil berish); xavfli (noto'g'ri manzil — crash, xotira buzilishi). Xavfsizlik: tur muvofiqligi (crash), xotira xavfi (pointer), platforma bog'liqlik, crash (C xatosi — Python istisno emas, segfault — jarayon o'ladi; try/except tutmaydi — C Python muhitidan tashqarida). ctypes tayyor C kutubxonalarini ochadi (kompilyatsiyasiz — subprocess va kengaytma orasida); kuchli, lekin xavfli (past daraja — cffi 30.4 soddaroq, kengaytma 30.5 xavfsizroq). Til chegarasi xavfli (ma'lumot tarjimasi — tur muvofiqligi; Python xavfsiz/managed, C xavfsiz emas).

Keyingi darsda **cffi**ni o'rganamiz: ctypes'ga muqobil, C kodini to'g'ridan yozib ishlatish imkoni beruvchi FFI kutubxona — C deklaratsiyalarini parse qilish va soddaroq, xavfsizroq til birlashtirish.