30.9-dars: Rust — nega Python bilan

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

1. Kirish va motivatsiya

C (30.3-8) Python'ni tezlashtirishning klassik yo'li, lekin C xavfli: pointer xatolari, xotira oqmasi, segfault. Yiliga minglab jiddiy xavfsizlik zaifligi (CVE) aynan C/C++ xotira xatolaridan. Rust — zamonaviy til: C darajasida tez, lekin xotira xavfsizligini kompilyatsiya vaqtida kafolatlaydi (ownership tizimi — egalik). Ya'ni: C tezligi, lekin C xavfisiz. Shuning uchun Python jamoasi Rust'ga qiziqadi: tez kengaytmalar yozish uchun C o'rniga Rust (PyO3 — 30.10). Zamonaviy Python kutubxonalari (pydantic-core, polars, ruff, cryptography qismlari) Rust bilan yozilmoqda — tez va xavfsiz. Bu dars Rust'ning nega Python uchun jozibali ekanini tushuntiradi (PyO3 30.10 ga tayyorgarlik).

Rust — xotira xavfsizligi va unumdorlikni birlashtiruvchi zamonaviy tizim tili: ownership (egalik — har qiymatning bir egasi, kompilyator xotirani boshqaradi — GC'siz, xavfsiz), xotira xavfsizligi (kompilyatsiya vaqtida — segfault/oqma yo'q), C daraja tezlik (mashina kodi, runtime yengil), Python integratsiya (PyO3 30.10 — Rust moduli Python'ga). Foydalanish: tez+xavfsiz kengaytma (C o'rniga), zamonaviy kutubxona (polars, ruff). Bu C (30.3-8 — tez, lekin xavfli) ga zamonaviy muqobil. Bu 30.10 (PyO3), 30.6 (C kengaytma) bilan bog'liq. Rust — tez + xavfsiz. Ownership — GC'siz.

Real vaziyat. pydantic (Python ma'lumot tekshirish) v2'da yadrosini Rust'ga ko'chirdi (pydantic-core). Sabab: tekshirish CPU-og'ir (29.2 bottleneck), Python sekin; C mumkin edi, lekin xavfli (xotira xatosi — CVE xavfi). Rust tanlandi: C daraja tez (tekshirish 5-50x tezroq), lekin xotira xavfsiz (ownership — segfault yo'q, oqma yo'q). Natija: pydantic v2 keskin tez, ishonchli. Foydalanuvchi Rust'ni ko'rmaydi (import pydantic). Rust — C tezlik + xotira xavfsizligi.

Bu darsda Rust nega Python bilan degan savolni o'rganamiz.

Bu darsda:

• Rust nima va nega
• Ownership (egalik) — xotira xavfsizligi
• C bilan taqqoslash (xavfsizlik)
• Nega Python jamoasi Rust
• Zamonaviy Rust kutubxonalar
• Rust amaliyoti (Python bilan)
• Rust vs muqobil
• Amaliy: Rust tushuncha modeli

ℹ Rust alohida til/kompilyator talab qiladi; misollar Rust tushunchalarini (ownership mantiqini) deterministik modellashtiradi.

2. Nazariya — chuqur tushuntirish

2.1. Rust nima va nega

Tez va xavfsiz:

// Rust — C darajada tez, lekin xotira xavfsiz
fn qoshish(a: i32, b: i32) -> i32 {
    a + b                    // tez (mashina kodi)
}

// ownership: har qiymatning bir egasi
fn main() {
    let s = String::from("salom");   // s — egasi
    let t = s;                        // egalik t'ga o'tdi (s endi yaroqsiz)
    // println!("{}", s);   // XATO (kompilyatsiyada) — s yo'q
}

Rust — xotira xavfsizligi va unumdorlikni birlashtiruvchi zamonaviy tizim tili (system programming — C/C++ o'rni): C daraja tez (mashina kodi, runtime yengil — GC yo'q), lekin xotira xavfsiz (kompilyatsiya vaqtida kafolat — segfault, oqma, poyga yo'q). Sabab: C/C++ tez, lekin xavfli (xotira xatosi — CVE'lar ko'p); Rust bu muammoni ownership (2.2 — egalik tizimi) bilan hal qiladi (kompilyator tekshiradi). "Nega": tez kutubxona/kengaytma yozishda C o'rniga (tez + xavfsiz). Rust — C tezlik + xavfsizlik. Ownership. GC'siz.

2.2. Ownership (egalik)

Xotirani kompilyator boshqaradi:

Ownership qoidalari (Rust):
   1. Har qiymatning BIR egasi (owner) bor
   2. Ega scope'dan chiqsa — qiymat o'chadi (avtomatik)
   3. Egalik ko'chirilishi mumkin (move) yoki qarz (borrow)

Natija: xotira avtomatik boshqariladi (GC'siz),
        kompilyatsiya vaqtida (runtime yuk yo'q),
        xavfsiz (oqma/segfault yo'q)

Ownership (egalik) — Rust'ning asosiy g'oyasi va xotira xavfsizligi manbai: qoidalar — (1) har qiymatning bir egasi (owner); (2) ega scope'dan chiqsa — qiymat o'chadi (avtomatik, aniq); (3) egalik ko'chadi (move) yoki qarz olinadi (borrow — vaqtincha). Sabab: C da xotira qo'lda (malloc/free — xato: oqma/ikki marta free); Python'da GC (avtomatik, lekin runtime yuk — 30.5); Rust uchinchi yo'l — kompilyator ownership orqali xotira boshqaradi (GC'siz, aniq, kompilyatsiya vaqtida). Natija: oqma yo'q (ega chiqsa o'chadi), segfault yo'q (yaroqsiz havola — kompilyatsiya xatosi). Ownership — bir ega, avtomatik o'chish. Kompilyator tekshiradi. GC'siz xavfsizlik.

2.3. C bilan taqqoslash (xavfsizlik)

C bilan taqqoslash: C (eng tez, lekin xotira qo'lda — malloc/free, xato: segfault, oqma, buffer overflow — CVE manbai, ish vaqtida crash); Rust (bir xil tez — C daraja, lekin xotira ownership — avtomatik, xavfsiz; xatolar kompilyatsiya vaqtida tutiladi — ish vaqtida emas). Sabab: C tezligi zamonaviy (pastda), lekin xavfsizligi emas (1970-lar); Rust tezlikni saqlab, zamonaviy xavfsizlik qo'shadi (ownership, tur tizimi). Ikkalasi ham GC'siz (yengil runtime — kengaytmaga mos). Farq: C xavfsizlikni dasturchiga yuklaydi, Rust kompilyatorga. Bu Rust'ning C dan asosiy afzalligi. C vs Rust — bir tez, Rust xavfsiz. Kompilyatsiya vaqtida. GC'siz ikkalasi.

2.4. Nega Python jamoasi Rust

Nega Python jamoasi Rust'ga qiziqadi: (1) tez kengaytma — Python sekin 29.2-bob, kengaytma kerak; C mumkin 30.6-bob, lekin xavfli; Rust tez va xavfsiz (ideal kengaytma tili); (2) xavfsizlik — Python kutubxona keng ishlatiladi (millionlab foydalanuvchi); xotira xatosi (C) — xavfsizlik zaifligi (CVE); Rust bu xavfni yo'qotadi (ownership); (3) PyO3 (30.10 — Rust'ni Python'ga bog'lash oson, qulay); (4) zamonaviy — Rust vositalari (cargo, maturin — 30.11) qulay. Sabab: Python jamoasi tez + xavfsiz kengaytma istaydi; Rust ikkalasini beradi (C tez, lekin xavfli; Rust tez va xavfsiz). Shuning uchun yangi tez kutubxonalar Rust'da (polars, ruff, pydantic-core). Nega Rust — tez + xavfsiz kengaytma. C o'rniga. PyO3 bilan.

2.5. Zamonaviy Rust kutubxonalar

Zamonaviy Rust kutubxonalar (Python ekotizimida): polars (DataFrame — pandas muqobili, Rust yadro, keskin tez), ruff (Python linter/formatter — Rust, 100x tez flake8/black'dan), pydantic-core (pydantic v2 yadro — Rust, tekshirish tez), cryptography (qismlar — Rust, xavfsiz), tokenizers (HuggingFace — Rust, ML), orjson (JSON — tez). Sabab: bu kutubxonalar CPU-og'ir (DataFrame, linting, tekshirish — 29.2); Rust tez (C daraja) va xavfsiz (ownership — ishonchli kutubxona); jamoalar C o'rniga Rust tanlaydi (zamonaviy, xavfsiz). Bu trend (yangi tez Python kutubxonalar ko'pincha Rust). Foydalanuvchi Rust'ni ko'rmaydi (import polars — oddiy). Zamonaviy kutubxona — Rust yadro + Python interfeys. Trend. Tez + xavfsiz.

2.6. Rust amaliyoti (Python bilan)

Rust'ni Python bilan ishlatish amaliyotlari: PyO3 (30.10 — Rust funksiya/klass Python'ga, dekoratorlar #[pyfunction]); maturin (30.11 — Rust modulini Python paketga yig'ish, oson); ownership tushunish (Rust'ni o'rganish — egalik, qarz, kompilyator bilan "kurash"); bottleneck (29.2 — faqat sekin joy Rust'da, Cython kabi tanlab); PyPI (Rust kengaytma tayyor .whl — foydalanuvchi Rust o'rnatmaydi); xavfsizlik (Rust kafolati — lekin unsafe blok ehtiyot). Tuzoqlar: Rust o'rganish qiyin (ownership — vaqt), ortiqcha (oddiy ishga Rust — Cython 30.7 osonroq), unsafe (xavfsizlikni buzadi — ehtiyot). Amaliyot — PyO3, maturin, tanlab, ownership. Rust — tez+xavfsiz, lekin o'rganish.

2.7. Rust vs muqobil

Rust vs muqobil: Rust (PyO3 — eng tez, eng xavfsiz — ownership, lekin o'rganish qiyin), C kengaytma (30.6 — eng tez, lekin xavfsiz emas — qo'lda, qiyin), Cython (30.7 — tez, o'rta xavfsizlik, oson — Python'ga o'xshash), cffi (30.4 — tez, mavjud C). Tanlov: yangi tez+xavfsiz yadro (Rust — polars kabi, uzoq muddat), oson tezlashtirish (Cython — o'z kod, tez boshlanish), mavjud C (cffi/ctypes). Rust kuchli, lekin sarmoya (o'rganish vaqti); Cython amaliyroq (tez natija). Ko'pchilik uchun Cython 30.7-bob boshlanish, Rust — jiddiy/uzoq loyiha (xavfsizlik kritik). Rust vs muqobil — tez+xavfsiz, lekin o'rganish. Cython osonroq.

2.8. Rust — xavfsizlik va tezlik birga

Rust asosiy g'oyasi (Python kontekstida) — xavfsizlik va tezlikni birga olish: an'anaviy savdo (30.5 GC — xavfsiz lekin sekin/nazoratsiz, C — tez lekin xavfli); Rust bu savdoni buzadi (ownership orqali tez va xavfsiz, kompilyatsiya vaqtida). Bu Python uchun ideal kengaytma tili (C tezlik, lekin C xavfsiz emas muammosiz). Ownership 2.2-bob kalit: kompilyator xotirani boshqaradi (GC'siz, aniq), xatolarni kompilyatsiyada tutadi (ish vaqtida emas). Zamonaviy Python kutubxonalar (polars, ruff, pydantic-core) shu sababli Rust'da (tez + xavfsiz). Bu 30.1 (to'g'ri til to'g'ri ishga) ning zamonaviy amaliyoti — yadro uchun Rust (C o'rniga). Amalda o'rganish sarmoya (ownership qiyin), Cython 30.7-bob osonroq boshlanish. Rust — tez + xavfsiz (savdoni buzadi). Zamonaviy yadro tili.

3. Tez ma'lumotnoma

// RUST — tez + xavfsiz (Python kengaytmasi uchun)

// Tez funksiya (C darajada)
fn qoshish(a: i32, b: i32) -> i32 { a + b }

// OWNERSHIP (egalik):
//   1. Har qiymat — bir egasi
//   2. Ega scope'dan chiqsa → o'chadi (avtomatik)
//   3. move (ko'chirish) yoki borrow (qarz)
let s = String::from("salom");
let t = s;   // egalik ko'chdi (s yaroqsiz)

C vs RUST:
   C — eng tez, xotira qo'lda (segfault, oqma — ish vaqtida)
   Rust — eng tez, ownership (xavfsiz — kompilyatsiya vaqtida)
   ikkalasi GC'siz (kengaytmaga mos)

NEGA PYTHON + RUST:
   tez (C daraja) + xavfsiz (ownership) kengaytma
   PyO3 (30.10) — Rust'ni Python'ga · maturin (30.11) — yig'ish

ZAMONAVIY RUST KUTUBXONALAR:
   polars (pandas), ruff (linter), pydantic-core, cryptography

QOIDA: yangi tez+xavfsiz yadro → Rust · oson tezlashtirish → Cython

Rust xulosasi

Rust — xotira xavfsizligi + C tezligi (zamonaviy tizim tili)
Ownership — bir ega, avtomatik o'chish (GC'siz, xavfsiz)
C vs Rust — bir tez, Rust xavfsiz (kompilyatsiya vaqtida)
Python + Rust — tez + xavfsiz kengaytma (PyO3, C o'rniga)
Cython (30.7) osonroq boshlanish · Rust — jiddiy/uzoq loyiha

4. Batafsil misollar

Rust alohida til/kompilyator talab qiladi; misollar Rust tushunchalarini (ownership mantiqini) deterministik modellashtiradi.

Misol 1 — Ownership (egalik ko'chishi)

"""Ownership: bir ega, ko'chirish (move) modeli."""


class Qiymat:
    def __init__(self, nom: str) -> None:
        self.nom = nom
        self.egasi = None
        self.yaroqli = True

    def egalik_ber(self, ega: str) -> None:
        self.egasi = ega

    def kochir(self, yangi_ega: str) -> None:
        self.egasi = yangi_ega
        # eski ega endi yaroqsiz (Rust: move)


def main() -> None:
    s = Qiymat("salom")
    s.egalik_ber("s")
    print("=== 1. Yaratish ===")
    print(f"  qiymat: {s.nom}, egasi: {s.egasi}")

    print("\n=== 2. Egalik ko'chishi (move) ===")
    s.kochir("t")
    print(f"  yangi egasi: {s.egasi}")
    print("  eski ega (s) endi yaroqsiz")

    print("\n=== 3. Rust qoidasi ===")
    print("  bir qiymat — bir ega (move → eski yaroqsiz)")

    print("\n=== 4. Kompilyatsiya tekshiruvi ===")
    print("  eski ega ishlatilsa → kompilyatsiya XATOSI")
    print("  ⭐ Ownership — bir ega (xavfsizlik)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Yaratish ===
  qiymat: salom, egasi: s

=== 2. Egalik ko'chishi (move) ===
  yangi egasi: t
  eski ega (s) endi yaroqsiz

=== 3. Rust qoidasi ===
  bir qiymat — bir ega (move → eski yaroqsiz)

=== 4. Kompilyatsiya tekshiruvi ===
  eski ega ishlatilsa → kompilyatsiya XATOSI
  ⭐ Ownership — bir ega (xavfsizlik)

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

Misol 2 — C vs Rust (xavfsizlik)

"""C vs Rust: xato qachon tutiladi (model)."""


TILLAR = {
    "C": {"tezlik": "eng tez", "xato": "ish vaqtida (crash)", "xotira": "qo'lda"},
    "Rust": {"tezlik": "eng tez", "xato": "kompilyatsiya vaqtida", "xotira": "ownership"},
}


def main() -> None:
    print("=== 1. C ===")
    c = TILLAR["C"]
    print(f"  tezlik: {c['tezlik']}, xotira: {c['xotira']}")
    print(f"  xato: {c['xato']}")

    print("\n=== 2. Rust ===")
    r = TILLAR["Rust"]
    print(f"  tezlik: {r['tezlik']}, xotira: {r['xotira']}")
    print(f"  xato: {r['xato']}")

    print("\n=== 3. Asosiy farq ===")
    print("  C — xato ish vaqtida (kech, crash)")
    print("  Rust — xato kompilyatsiyada (erta, xavfsiz)")

    print("\n=== 4. Tezlik ===")
    print("  ikkalasi bir xil tez (C daraja)")
    print("  ⭐ Rust — C tez + xavfsiz (erta xato)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. C ===
  tezlik: eng tez, xotira: qo'lda
  xato: ish vaqtida (crash)

=== 2. Rust ===
  tezlik: eng tez, xotira: ownership
  xato: kompilyatsiya vaqtida

=== 3. Asosiy farq ===
  C — xato ish vaqtida (kech, crash)
  Rust — xato kompilyatsiyada (erta, xavfsiz)

=== 4. Tezlik ===
  ikkalasi bir xil tez (C daraja)
  ⭐ Rust — C tez + xavfsiz (erta xato)

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Zamonaviy Rust kutubxonalar

"""Zamonaviy Rust kutubxonalar: Python ekotizimida (model)."""


KUTUBXONALAR = [
    {"nom": "polars", "soha": "DataFrame (pandas muqobili)"},
    {"nom": "ruff", "soha": "linter/formatter (100x tez)"},
    {"nom": "pydantic-core", "soha": "ma'lumot tekshirish"},
    {"nom": "tokenizers", "soha": "ML (HuggingFace)"},
]


def main() -> None:
    print("=== 1. Rust kutubxonalar ===")
    for k in KUTUBXONALAR:
        print(f"  {k['nom']}: {k['soha']}")

    print("\n=== 2. Umumiy sabab ===")
    print("  CPU-og'ir 29.2-bob — Rust tez + xavfsiz")

    print("\n=== 3. Foydalanuvchi ===")
    print("  import polars (Rust ko'rinmaydi)")

    print("\n=== 4. Trend ===")
    print("  yangi tez Python kutubxonalar — ko'pincha Rust")
    print("  ⭐ Zamonaviy kutubxona — Rust yadro + Python interfeys")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Rust kutubxonalar ===
  polars: DataFrame (pandas muqobili)
  ruff: linter/formatter (100x tez)
  pydantic-core: ma'lumot tekshirish
  tokenizers: ML (HuggingFace)

=== 2. Umumiy sabab ===
  CPU-og'ir 29.2-bob — Rust tez + xavfsiz

=== 3. Foydalanuvchi ===
  import polars (Rust ko'rinmaydi)

=== 4. Trend ===
  yangi tez Python kutubxonalar — ko'pincha Rust
  ⭐ Zamonaviy kutubxona — Rust yadro + Python interfeys

Nima ko'rsatdi: 2.5-bo'lim.

Misol 4 — Muqobillar (tanlov)

"""Muqobillar: tezlik/xavfsizlik/qiyinlik (tanlov modeli)."""


VOSITALAR = {
    "Rust (PyO3)": {"xavfsizlik": 3, "qiyinlik": 3},
    "C kengaytma": {"xavfsizlik": 1, "qiyinlik": 3},
    "Cython": {"xavfsizlik": 2, "qiyinlik": 1},
}


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

    print("\n=== 2. Eng xavfsiz ===")
    eng = max(VOSITALAR.items(), key=lambda x: x[1]["xavfsizlik"])
    print(f"  {eng[0]} (ownership)")

    print("\n=== 3. Eng oson ===")
    oson = min(VOSITALAR.items(), key=lambda x: x[1]["qiyinlik"])
    print(f"  {oson[0]} (Python'ga o'xshash)")

    print("\n=== 4. Tanlov ===")
    print("  jiddiy/uzoq yadro → Rust (xavfsiz)")
    print("  tez boshlanish → Cython (oson)")
    print("  ⭐ Muqobil — tez+xavfsiz (Rust) yoki oson (Cython)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Vositalar (xavfsizlik/qiyinlik 1-3) ===
  Rust (PyO3): xavfsizlik 3, qiyinlik 3
  C kengaytma: xavfsizlik 1, qiyinlik 3
  Cython: xavfsizlik 2, qiyinlik 1

=== 2. Eng xavfsiz ===
  Rust (PyO3) (ownership)

=== 3. Eng oson ===
  Cython (Python'ga o'xshash)

=== 4. Tanlov ===
  jiddiy/uzoq yadro → Rust (xavfsiz)
  tez boshlanish → Cython (oson)
  ⭐ Muqobil — tez+xavfsiz (Rust) yoki oson (Cython)

Nima ko'rsatdi: 2.7-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. Oddiy ishga Rust (ortiqcha)

# kichik tezlashtirishga Rust (o'rganish narxi)               # ⚠️
# Cython 30.7-bob — osonroq, tez natija                          # ✅

2. Rust = sekin deb o'ylash

# xavfsizlik sekinlashtiradi deb                              # ⚠️
# ownership kompilyatsiya vaqtida (runtime tez)                # ✅

3. unsafe ni yengil ishlatish

unsafe { ... }   // xavfsizlik kafolatini buzadi              // ⚠️
// unsafe faqat zarur, minimal, tekshirilgan                   // ✅

4. Ownership'ni tushunmaslik

let t = s; use(s);   // s ko'chgan (kompilyatsiya xatosi)     // ⚠️
// clone yoki borrow (&s) — ownership qoidasi                  // ✅

5. Butun dasturni Rust'da

# hamma kod Rust (Python qulaylik yo'qoladi)                  # ⚠️
# bottleneck 29.2-bob Rust, qolgani Python                       # ✅

6. Foydalanuvchiga Rust o'rnatish

# foydalanuvchi Rust kompilyator o'rnatsin (noqulay)          # ⚠️
# maturin 30.11-bob tayyor .whl (Rust ko'rinmaydi)               # ✅

7. Cython o'rniga doim Rust

# tez natija kerak, lekin Rust o'rganish (sekin)              # ⚠️
# maqsadga qarab (Cython tez, Rust uzoq muddat)                # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 30.10-dars: PyO3 — Rust modul Python'ga
• 30.11-dars: maturin — Rust yig'ish
• 30.6-dars (o'tilgan): C kengaytma — xavfli muqobil
• 30.7-dars (o'tilgan): Cython — oson muqobil
• 30.5-dars (o'tilgan): GC — Rust ownership farqi

8. Eng yaxshi amaliyotlar

1. Rust — tez + xavfsiz (yangi yadro, uzoq loyiha).

2. Cython 30.7-bob — oson boshlanish (ko'p holat).

3. Bottleneck 29.2-bob Rust, qolgani Python.

4. unsafe minimal (kafolatni buzadi).

5. Ownership tushun (move, borrow, clone).

6. maturin 30.11-bob — tayyor .whl.

7. Xavfsizlik kritik → Rust (CVE oldini).

8. Maqsadga qarab (Rust sarmoya, Cython tez).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # Rust nima?
2.  # Rust nega tez+xavfsiz?
3.  # ownership nima?
4.  # ownership 1-qoida?
5.  # ega chiqsa nima?
6.  # move nima?
7.  # C vs Rust xato qachon?
8.  # nega Python jamoasi Rust?
9.  # polars nima?
10. # ruff nima?
11. # Rust vs Cython?
12. # unsafe nima?

Vazifa 2: Xatolarni tuzating

1.  # kichik ishga Rust

2.  # xavfsizlik sekinlashtiradi deb

3.  unsafe { ... }   # yengil

4.  let t = s; use(s)   # ko'chgan

5.  # butun dastur Rust

1.  Cython (osonroq)

2.  ownership kompilyatsiya vaqtida (runtime tez)

3.  unsafe minimal, tekshirilgan

4.  clone yoki borrow (&s)

5.  bottleneck Rust, qolgani Python

Vazifa 3: Ownership

Modellang:

1. Bir ega
2. Scope
3. Move
4. Xavfsizlik

Vazifa 4: C vs Rust

Modellang:

1. Tezlik
2. Xotira
3. Xato qachon
4. Farq

Vazifa 5: Kutubxonalar

Modellang:

1. polars
2. ruff
3. Sabab
4. Trend

Vazifa 6: Muqobil

Modellang:

1. Rust
2. Cython
3. Xavfsizlik
4. Tanlov

Vazifa 7: O'ylash

Rust "xotira xavfsizligi" va "tezlik" o'rtasidagi an'anaviy savdoni (trade-off) buzadi — ilgari ikkalasini birga olib bo'lmasdi (C tez lekin xavfli, GC-tillar xavfsiz lekin sekin/nazoratsiz). Nima uchun muhandislikda "an'anaviy savdoni buzuvchi" innovatsiya (ikki qarama-qarshi xususiyatni birga berish) katta ta'sir qiladi, va nega bu "sehr" emas, balki muammoni boshqa darajada (kompilyatsiya vaqti) hal qilish?

Nimani mustahkamlaydi: 2.2, 2.8-bo'limlar.

Xulosa

Bu darsda Rust nega Python bilan degan savolni o'rgandik.

Eng muhim uch fikr:

1. Rust va ownership. Rust — xotira xavfsizligi va unumdorlikni birlashtiruvchi zamonaviy tizim tili: C daraja tez (mashina kodi, GC yo'q), lekin xotira xavfsiz (kompilyatsiya vaqtida kafolat — segfault, oqma, poyga yo'q). Ownership (egalik) — asosiy g'oya: (1) har qiymatning bir egasi; (2) ega scope'dan chiqsa — qiymat o'chadi (avtomatik); (3) egalik ko'chadi (move) yoki qarz (borrow); kompilyator xotirani boshqaradi (GC'siz, kompilyatsiya vaqtida) — oqma/segfault yo'q.

2. C taqqoslash va nega Python jamoasi Rust. C vs Rust: C (eng tez, lekin xotira qo'lda — segfault/oqma, xato ish vaqtida crash), Rust (bir xil tez, xotira ownership — xavfsiz, xato kompilyatsiya vaqtida); ikkalasi GC'siz (kengaytmaga mos); C xavfsizlikni dasturchiga, Rust kompilyatorga yuklaydi. Nega Python jamoasi Rust: tez va xavfsiz kengaytma (C tez, lekin xavfli; Rust ikkalasi), kutubxona keng ishlatiladi (CVE xavfi — Rust yo'qotadi), PyO3 30.10-bob qulay; yangi tez kutubxonalar Rust'da (polars, ruff, pydantic-core).

3. Muqobil va savdoni buzish. Rust vs muqobil: Rust (PyO3 — eng tez+xavfsiz, lekin o'rganish qiyin — ownership sarmoya), C kengaytma (30.6 — tez, xavfsiz emas), Cython (30.7 — tez, oson — ko'p holatda boshlanish), cffi 30.4-bob; tanlov — yangi tez+xavfsiz yadro (Rust, uzoq loyiha), oson tezlashtirish (Cython). Rust xotira xavfsizligi va tezlikni birga oladi (an'anaviy savdoni buzadi — C tez lekin xavfli, GC xavfsiz lekin sekin); bu sehr emas, muammoni boshqa darajada (kompilyatsiya vaqtida — ownership) hal qilish. Zamonaviy Python yadrolari uchun Rust (C o'rniga); amalda Cython 30.7-bob osonroq boshlanish.

Keyingi darsda PyO3 — Rust moduli ni amaliyotda o'rganamiz: Rust funksiya/klasslarini Python'ga bog'lash — #[pyfunction], #[pymodule] dekoratorlari va Rust yadro + Python interfeys yaratish.