Python kursi30.13-dars: Go tili
Python kursi · Python va boshqa tillar

30.13-dars: Go tili

19 daqiqa13/16-dars

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


1. Kirish va motivatsiya

C, Rust, C++ (30.3-12) Python'ni ichkaridan tezlashtiradi (kengaytma — bir jarayonda). Lekin boshqa integratsiya usuli ham bor: alohida xizmatlar (mikroservis — 25-qism) turli tillarda, ular tarmoq orqali gaplashadi. Bu yerda Go (Golang) mashhur — Google yaratgan til, ayniqsa tarmoq xizmatlari, parallel tizimlar uchun. Go'ning kuchi: goroutine (yengil parallel iplar — millionlab, GIL yo'q — 30.5 Python farqi), oddiy sintaksis, tez kompilyatsiya, yaxshi tarmoq kutubxonalari. Ko'p kompaniyalar Python (ML, ma'lumot) va Go (yuqori yuk tarmoq xizmatlari) ni birga ishlatadi — har biri o'z kuchida. Docker, Kubernetes, Prometheus (28-qism vositalari) Go'da yozilgan. Bu dars Go'ning nega Python bilan birga ishlatilishini tushuntiradi (gRPC 30.14 ga tayyorgarlik).

Go (Golang) — Google'ning parallel va tarmoq dasturlash tili: goroutine (yengil parallel iplar — millionlab, GIL'siz — 30.5 farqi), oddiy (kam kalit so'z, tez o'rganish), tez kompilyatsiya (kompilyatsiyali, statik binar), tarmoq (kuchli standart kutubxona — HTTP, gRPC). Foydalanish: yuqori yuk tarmoq xizmati, mikroservis (25-qism). Bu Python (kengaytma — bir jarayon) dan farqli (alohida xizmat — tarmoq). Bu 25-qism (mikroservis), 30.14 (gRPC — Go+Python aloqa) bilan bog'liq. Go — parallel, tarmoq. goroutine. Python bilan birga.

Real vaziyat. Kompaniyada Python API bor edi (ML modellar — 25-qism), lekin bir xizmat juda yuqori yuk (soniyaga 100 ming so'rov — real vaqt bildirishnoma) ni ko'tarolmaydi edi (Python GIL — 30.5, bir ip). Bu xizmat Go'da qayta yozildi: goroutine bilan (millionlab yengil ip — GIL'siz parallel) yuqori yukni ko'tardi (10x kamroq server). Python ML xizmati va Go bildirishnoma xizmati birga ishladi (tarmoq — gRPC 30.14). Har biri o'z kuchida: Python (ML), Go (parallel tarmoq). Go — yuqori yuk, Python bilan birga.

Bu darsda Go tilini o'rganamiz.

Bu darsda:

  • Go nima va nega
  • goroutine — yengil parallel
  • GIL farqi (Go vs Python)
  • Go kuchli tomonlari
  • Python va Go birga
  • Go amaliyoti
  • Go vs kengaytma yondashuvi
  • Amaliy: Go tushuncha modeli

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


2. Nazariya — chuqur tushuntirish

2.1. Go nima va nega

Parallel va tarmoq tili:

go
// Go (Golang) — parallel, tarmoq
package main
import "fmt"

func salom(kim string) {
    fmt.Println("Salom,", kim)
}

func main() {
    go salom("dunyo")   // goroutine — parallel (yengil ip)
    salom("Go")
}

Go (Golang) — Google yaratgan parallel va tarmoq dasturlash tili: yuqori yuk xizmatlar, mikroservislar (25-qism) uchun. Sabab: Google'ga kerak edi — oddiy (C++ murakkab), tez (Python sekin), parallel (ko'p yadro, tarmoq). Go oraliq: C kabi tez (kompilyatsiyali), Python kabi oddiy (kam kalit so'z), parallel (goroutine — 2.2). "Nega Python bilan": Go yuqori yuk tarmoq xizmatida kuchli (goroutine — GIL'siz), Python ML/ma'lumotda; birga ishlatiladi (har biri o'z kuchida). Docker, Kubernetes Go'da. Go — parallel, tarmoq, oddiy. goroutine. Python bilan birga.

2.2. goroutine — yengil parallel

Millionlab yengil iplar:

go
// goroutine — juda yengil parallel ip
func main() {
    for i := 0; i < 1000000; i++ {
        go ishla(i)   // million goroutine (yengil — mumkin!)
    }
}

// OS ip: og'ir (~1MB) — minglab mumkin
// goroutine: yengil (~2KB) — millionlab mumkin

goroutine — Go'ning asosiy kuchi: juda yengil parallel ip (go funksiya() — bir kalit so'z). Sabab: OS iplari (thread) og'ir (1MB har biri — minglab mumkin, ko'p emas); goroutine yengil (2KB — millionlab mumkin). Go runtime ularni OS iplariga taqsimlaydi (scheduler — ko'p goroutine oz OS ipda). Natija: Go yuqori yukni (million ulanish) yengil ko'taradi (har ulanish — goroutine). Bu Python'dan keskin farqli (Python GIL — 2.3, bir ip; yoki og'ir OS ip). goroutine — yengil parallel (millionlab). go kalit so'z. Yuqori yuk kaliti.

2.3. GIL farqi (Go vs Python)

Haqiqiy parallellik:

Python (CPython):
   GIL — bir vaqtda BIR ip Python kodini (30.5)
   ko'p yadro → parallel EMAS (CPU-og'ir)
   yechim: multiprocessing (jarayonlar — og'ir)

Go:
   GIL YO'Q — goroutine haqiqiy parallel
   ko'p yadro → to'liq foydalanadi
   millionlab goroutine (yengil)

GIL farqi (Go vs Python) — asosiy ajralish: Python (CPython — GIL 30.5, bir vaqtda bir ip Python kodi, ko'p yadro CPU-og'irda parallel emas, yechim multiprocessing — og'ir jarayonlar), Go (GIL yo'q — goroutine haqiqiy parallel, ko'p yadroni to'liq ishlatadi, millionlab yengil goroutine). Sabab: CPython GIL'ni havola hisobi xavfsizligi uchun 30.5-bob; Go boshqacha qurilgan (GIL'siz — parallellik asosiy). Natija: CPU-og'ir parallel ishda Go tabiiy (goroutine), Python qiyin (GIL — jarayonlar). Shuning uchun yuqori yuk parallel xizmat Go'da afzal. GIL farqi — Go parallel (GIL'siz), Python bir ip (GIL). Yuqori yuk — Go. Python — jarayonlar.

2.4. Go kuchli tomonlari

Go kuchli tomonlari: goroutine (yengil parallel — millionlab, GIL'siz 2.2-3); oddiy (kam kalit so'z ~25 — tez o'rganish, o'qiladi); tez kompilyatsiya (soniyalarda — C/C++ dan tez); statik binar (bir fayl — bog'liqliksiz deploy, Docker'ga mos 28-qism); tarmoq kutubxonasi (HTTP, gRPC standart — kuchli); standart formatlash (gofmt — bir uslub, bahs yo'q); tez ishlashi (kompilyatsiyali — Python'dan tez). Sabab: Go amaliy tizim tili (tarmoq, xizmat — soddalik + parallellik + tezlik). Kamchilik: Python'dan kam kutubxona (ML/ma'lumot — Python boy), til soddaligi (ba'zan juda oddiy — generic kech qo'shildi). Go kuchi — parallel, oddiy, tez deploy. Tarmoq xizmati. Statik binar.

2.5. Python va Go birga

Har biri o'z kuchida:

Python xizmat            Go xizmat
   ML modellar              yuqori yuk tarmoq
   ma'lumot ishlash         real vaqt (million ulanish)
   tez ishlab chiqish       parallel (goroutine)
        │                        │
        └──── gRPC / HTTP ───────┘
              (tarmoq aloqasi — 30.14)

Python va Go birga — polyglot arxitektura (30.16 — ko'p til): Python (ML, ma'lumot, tez ishlab chiqish — o'z kuchida) va Go (yuqori yuk tarmoq, real vaqt, parallel — o'z kuchida) alohida xizmatlar sifatida, tarmoq orqali gaplashadi (gRPC 30.14 yoki HTTP). Sabab: har til o'z sohasida kuchli (Python — ML ekotizim, Go — parallel tarmoq); birini tanlash o'rniga ikkalasini ishlatish (to'g'ri til to'g'ri ishga — 30.1). Bu mikroservis (25-qism — alohida xizmatlar) g'oyasi: xizmatlar mustaqil (til erkin), tarmoq orqali. Farq kengaytmadan (30.3-12 — bir jarayon): bu yerda alohida jarayon/xizmat. Python + Go — har biri o'z kuchida. Tarmoq aloqa. Polyglot.

2.6. Go amaliyoti

Go'ni Python bilan ishlatish amaliyotlari: alohida xizmat (Go — yuqori yuk, Python — ML, mikroservis 25-qism); gRPC (30.14 — Go+Python tez aloqa) yoki HTTP/REST; goroutine (parallel — har ulanish/vazifa); statik binar (Docker — 28-qism, yengil image); to'g'ri joy (parallel tarmoq → Go, ML/ma'lumot → Python); standart vositalar (gofmt, go test); kanal (channel — goroutine aloqasi, xavfsiz). Tuzoqlar: hammani Go'da (ML — Python boy, Go kam), hammani Python'da (yuqori yuk — GIL muammo), aloqa murakkabligi (tarmoq — 25-qism kechikish). Amaliyot — alohida xizmat, gRPC, to'g'ri til to'g'ri joyga. Go — parallel tarmoq, Python bilan.

2.7. Go vs kengaytma yondashuvi

Jihat Kengaytma (C/Rust/C++) Go (alohida xizmat)
Integratsiya Bir jarayon (import) Tarmoq (gRPC/HTTP)
Maqsad CPU-og'ir tezlashtirish Yuqori yuk parallel
Aloqa Funksiya chaqiruv Tarmoq so'rov
Deploy Python bilan birga Alohida xizmat
Til C/Rust/C++ Go

Go vs kengaytma yondashuvi — ikki xil integratsiya: kengaytma (C/Rust/C++ — 30.3-12, bir jarayon, import, funksiya chaqiruv, CPU-og'ir tezlashtirish, Python bilan birga deploy), Go (alohida xizmat, tarmoq — gRPC/HTTP, yuqori yuk parallel, mustaqil deploy). Sabab: kengaytma — Python ichida tezlik (funksiya — bir jarayon); Go — alohida tizim (tarmoq — yuqori yuk, parallel). Farq: kengaytma ichki (bir dastur tez), Go tashqi (alohida xizmat, mikroservis). Tanlov: CPU-og'ir funksiya (kengaytma — Cython/Rust), yuqori yuk xizmat (Go — alohida). Ikkalasi Python bilan, lekin boshqacha (ichki vs tashqi). Go vs kengaytma — tarmoq vs bir jarayon. Alohida xizmat vs import. Maqsadga qarab.

2.8. Go — parallel tarmoq xizmatlari uchun

Go asosiy g'oyasi (Python kontekstida) — parallel tarmoq xizmatlari uchun: Go goroutine bilan (yengil parallel — GIL'siz, millionlab) yuqori yuk tarmoq xizmatlarini (real vaqt, ko'p ulanish) tabiiy ko'taradi — Python GIL 30.5-bob qiyin joyda. Go kengaytma emas (bir jarayon — 30.3-12), alohida xizmat (tarmoq — mikroservis 25-qism); Python (ML, ma'lumot) va Go (parallel tarmoq) birga ishlaydi (har biri o'z kuchida — 30.1 to'g'ri til to'g'ri ishga). Bu 25-qism (mikroservis — alohida xizmatlar) va 30.16 (polyglot — ko'p til arxitektura) bilan bog'liq; gRPC 30.14-bob ular orasidagi tez aloqa. Docker, Kubernetes, Prometheus Go'da (28-qism). Go — parallel tarmoq (goroutine). Alohida xizmat. Python bilan birga.


3. Tez ma'lumotnoma

go
// GO (Golang) — parallel, tarmoq
package main
import "fmt"

// GOROUTINE — yengil parallel ip
func ishla(i int) { fmt.Println(i) }

func main() {
    go ishla(1)   // goroutine (yengil — millionlab mumkin)
    // OS ip: ~1MB (minglab) · goroutine: ~2KB (millionlab)
}
GIL FARQI (Go vs Python):
   Python — GIL (bir ip, CPU parallel emas — 30.5)
   Go — GIL'siz (goroutine haqiqiy parallel, ko'p yadro)

GO KUCHLI TOMONLARI:
   goroutine (parallel) · oddiy · tez kompilyatsiya
   statik binar (Docker) · tarmoq (HTTP, gRPC)

PYTHON + GO BIRGA (polyglot — 30.16):
   Python (ML, ma'lumot) + Go (yuqori yuk parallel)
   tarmoq aloqasi — gRPC 30.14-bob / HTTP

GO vs KENGAYTMA:
   kengaytma (C/Rust) — bir jarayon (import, CPU-og'ir)
   Go — alohida xizmat (tarmoq, yuqori yuk)

Go xulosasi

Go — Google'ning parallel/tarmoq tili (goroutine, oddiy)
goroutine — yengil parallel ip (millionlab, GIL'siz)
GIL farqi — Go parallel (ko'p yadro), Python bir ip (GIL)
Python + Go birga — ML (Python) + yuqori yuk (Go), tarmoq
Go — alohida xizmat (kengaytma emas — bir jarayon emas)

4. Batafsil misollar

Go alohida til/kompilyator talab qiladi; misollar Go tushunchalarini (goroutine mantiqini) deterministik modellashtiradi.

Misol 1 — goroutine vs OS ip (og'irlik)

python
"""goroutine vs OS ip: xotira og'irligi (model)."""


def iplar_xotira(son: int, tur: str) -> dict:
    # OS ip ~1MB, goroutine ~2KB
    kb = 1024 if tur == "OS ip" else 2
    return {"tur": tur, "son": son, "jami_mb": son * kb / 1024}


def main() -> None:
    son = 100000

    print("=== 1. 100,000 OS ip ===")
    os = iplar_xotira(son, "OS ip")
    print(f"  xotira: {os['jami_mb']:.0f} MB (og'ir — mumkin emas)")

    print("\n=== 2. 100,000 goroutine ===")
    go = iplar_xotira(son, "goroutine")
    print(f"  xotira: {go['jami_mb']:.0f} MB (yengil — oson)")

    print("\n=== 3. Nisbat ===")
    print(f"  OS ip / goroutine: {os['jami_mb'] / go['jami_mb']:.0f}x og'irroq")

    print("\n=== 4. Natija ===")
    print("  goroutine yengil → millionlab mumkin")
    print("  ⭐ goroutine — yengil parallel (yuqori yuk)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. 100,000 OS ip ===
  xotira: 100000 MB (og'ir — mumkin emas)

=== 2. 100,000 goroutine ===
  xotira: 195 MB (yengil — oson)

=== 3. Nisbat ===
  OS ip / goroutine: 512x og'irroq

=== 4. Natija ===
  goroutine yengil → millionlab mumkin
  ⭐ goroutine — yengil parallel (yuqori yuk)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 2 — GIL farqi (parallellik)

python
"""GIL farqi: Python bir ip vs Go parallel (yadro ishlatish model)."""


def yadro_ishlatish(yadrolar: int, til: str) -> dict:
    if til == "Python (GIL)":
        ishlatilgan = 1   # GIL — bir ip (CPU-og'ir)
    else:  # Go
        ishlatilgan = yadrolar   # goroutine — barcha yadro
    return {"til": til, "yadrolar": yadrolar, "ishlatilgan": ishlatilgan}


def main() -> None:
    yadrolar = 8

    print("=== 1. Python (GIL) — CPU-og'ir ===")
    p = yadro_ishlatish(yadrolar, "Python (GIL)")
    print(f"  {p['yadrolar']} yadrodan {p['ishlatilgan']} ishlatiladi (GIL)")

    print("\n=== 2. Go (goroutine) ===")
    g = yadro_ishlatish(yadrolar, "Go")
    print(f"  {g['yadrolar']} yadrodan {g['ishlatilgan']} ishlatiladi")

    print("\n=== 3. Farq ===")
    print("  Python — bir ip (GIL, 30.5), yechim jarayonlar")
    print("  Go — haqiqiy parallel (GIL'siz)")

    print("\n=== 4. Xulosa ===")
    print("  CPU-og'ir parallel → Go tabiiy")
    print("  ⭐ GIL farqi — Go parallel, Python bir ip")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Python (GIL) — CPU-og'ir ===
  8 yadrodan 1 ishlatiladi (GIL)

=== 2. Go (goroutine) ===
  8 yadrodan 8 ishlatiladi

=== 3. Farq ===
  Python — bir ip (GIL, 30.5), yechim jarayonlar
  Go — haqiqiy parallel (GIL'siz)

=== 4. Xulosa ===
  CPU-og'ir parallel → Go tabiiy
  ⭐ GIL farqi — Go parallel, Python bir ip

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Python va Go birga (rol taqsimi)

python
"""Python va Go birga: har biri o'z kuchida (model)."""


ROLLAR = {
    "Python": ["ML modellar", "ma'lumot ishlash", "tez ishlab chiqish"],
    "Go": ["yuqori yuk tarmoq", "real vaqt (million ulanish)", "parallel"],
}


def main() -> None:
    print("=== 1. Python roli ===")
    for r in ROLLAR["Python"]:
        print(f"  {r}")

    print("\n=== 2. Go roli ===")
    for r in ROLLAR["Go"]:
        print(f"  {r}")

    print("\n=== 3. Aloqa ===")
    print("  Python xizmat ↔ gRPC/HTTP ↔ Go xizmat")

    print("\n=== 4. G'oya ===")
    print("  har til o'z kuchida (to'g'ri til to'g'ri ishga)")
    print("  ⭐ Python + Go birga (polyglot — 30.16)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Python roli ===
  ML modellar
  ma'lumot ishlash
  tez ishlab chiqish

=== 2. Go roli ===
  yuqori yuk tarmoq
  real vaqt (million ulanish)
  parallel

=== 3. Aloqa ===
  Python xizmat ↔ gRPC/HTTP ↔ Go xizmat

=== 4. G'oya ===
  har til o'z kuchida (to'g'ri til to'g'ri ishga)
  ⭐ Python + Go birga (polyglot — 30.16)

Nima ko'rsatdi: 2.5-bo'lim.

Misol 4 — Go vs kengaytma (integratsiya turi)

python
"""Go vs kengaytma: integratsiya turi farqi (model)."""


YONDASHUVLAR = {
    "Kengaytma (C/Rust)": {"integratsiya": "bir jarayon (import)", "maqsad": "CPU-og'ir tezlashtirish"},
    "Go (xizmat)": {"integratsiya": "tarmoq (gRPC/HTTP)", "maqsad": "yuqori yuk parallel"},
}


def main() -> None:
    print("=== 1. Kengaytma yondashuvi ===")
    k = YONDASHUVLAR["Kengaytma (C/Rust)"]
    print(f"  integratsiya: {k['integratsiya']}")
    print(f"  maqsad: {k['maqsad']}")

    print("\n=== 2. Go yondashuvi ===")
    g = YONDASHUVLAR["Go (xizmat)"]
    print(f"  integratsiya: {g['integratsiya']}")
    print(f"  maqsad: {g['maqsad']}")

    print("\n=== 3. Farq ===")
    print("  kengaytma — ichki (bir dastur tez)")
    print("  Go — tashqi (alohida xizmat)")

    print("\n=== 4. Tanlov ===")
    print("  CPU-og'ir funksiya → kengaytma")
    print("  yuqori yuk xizmat → Go")
    print("  ⭐ Go vs kengaytma — tarmoq vs bir jarayon")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Kengaytma yondashuvi ===
  integratsiya: bir jarayon (import)
  maqsad: CPU-og'ir tezlashtirish

=== 2. Go yondashuvi ===
  integratsiya: tarmoq (gRPC/HTTP)
  maqsad: yuqori yuk parallel

=== 3. Farq ===
  kengaytma — ichki (bir dastur tez)
  Go — tashqi (alohida xizmat)

=== 4. Tanlov ===
  CPU-og'ir funksiya → kengaytma
  yuqori yuk xizmat → Go
  ⭐ Go vs kengaytma — tarmoq vs bir jarayon

Nima ko'rsatdi: 2.7-bo'lim.


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

Noto'g'ri fikr To'g'risi
"Go = Python kengaytma" Go alohida xizmat (tarmoq)
"goroutine = OS ip" goroutine yengil (millionlab)
"Go'da GIL bor" GIL yo'q (haqiqiy parallel)
"Go ML uchun" Go tarmoq/parallel (ML — Python)
"Bitta til yetadi" Python + Go (har biri o'z kuchida)
"Go murakkab (C kabi)" Go oddiy (kam kalit so'z)
"goroutine cheklangan" Millionlab mumkin (yengil)
"Go import qilinadi" Tarmoq (gRPC/HTTP)

6. Keng tarqalgan xatolar va yechimlari

1. Hammani Go'da (ML ham)

python
# ML'ni Go'da (kutubxona kam)                                 # ⚠️
# ML → Python (boy ekotizim), tarmoq → Go                      # ✅

2. Hammani Python'da (yuqori yuk ham)

python
# yuqori yuk parallel Python'da (GIL muammo)                  # ⚠️
# yuqori yuk → Go (goroutine), ML → Python                     # ✅

3. Go'ni kengaytma deb

python
# Go'ni import qilishga urinish (kengaytma emas)              # ⚠️
# Go alohida xizmat (gRPC/HTTP — tarmoq)                       # ✅

4. goroutine'ni OS ip deb

go
// minglab goroutine og'ir deb (aslida yengil)                // ⚠️
// goroutine yengil (~2KB) — millionlab mumkin                 // ✅

5. Kanal (channel) o'rniga umumiy o'zgaruvchi

go
// goroutine'lar umumiy o'zgaruvchi (poyga)                   // ⚠️
// channel (goroutine xavfsiz aloqa)                           // ✅

6. Tarmoq kechikishini e'tiborsiz

python
# har funksiya chaqiruv tarmoq (kechikish — 25-qism)          # ⚠️
# to'g'ri chegara (yirik so'rov, kam aloqa)                    # ✅

7. Xato joyga Go

python
# oddiy CPU funksiyaga Go xizmat (ortiqcha)                   # ⚠️
# CPU-og'ir → kengaytma (Cython), yuqori yuk → Go              # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 30.14-dars: gRPC — Go+Python tez aloqa
  • 30.16-dars: Polyglot arxitektura — ko'p til
  • 25-qism (o'tilgan): Mikroservis — alohida xizmat
  • 30.5-dars (o'tilgan): GIL — Go farqi
  • 28-qism (o'tilgan): Docker/K8s — Go'da yozilgan

8. Eng yaxshi amaliyotlar

  1. To'g'ri til to'g'ri joyga (Go parallel, Python ML).

  2. Go — alohida xizmat (tarmoq, kengaytma emas).

  3. goroutine (yengil parallel — yuqori yuk).

  4. channel (goroutine xavfsiz aloqa).

  5. gRPC 30.14-bob — Go+Python tez aloqa.

  6. Statik binar (Docker — 28-qism).

  7. Tarmoq chegarasi (yirik so'rov, kam aloqa).

  8. CPU-og'ir → kengaytma, yuqori yuk → Go.


9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # Go nima?
2.  # Go nega yaratildi?
3.  # goroutine nima?
4.  # goroutine og'irligi?
5.  # OS ip vs goroutine?
6.  # Go'da GIL bormi?
7.  # GIL farqi?
8.  # Go kuchli tomoni?
9.  # Python + Go rol?
10. # aloqa qanday?
11. # Go vs kengaytma?
12. # qachon Go?
Javoblar
  1. Google'ning parallel/tarmoq tili
  2. Oddiy + tez + parallel (C++ murakkab, Python sekin)
  3. Yengil parallel ip (go funksiya())
  4. Yengil (~2KB) — millionlab mumkin
  5. OS ip ~1MB (minglab), goroutine ~2KB (millionlab)
  6. Yo'q (haqiqiy parallel)
  7. Go parallel (ko'p yadro), Python bir ip (GIL)
  8. goroutine, oddiy, tez kompilyatsiya, tarmoq
  9. Python ML, Go yuqori yuk tarmoq
  10. Tarmoq (gRPC/HTTP)
  11. Go alohida xizmat, kengaytma bir jarayon
  12. Yuqori yuk parallel tarmoq xizmat

Vazifa 2: Xatolarni tuzating

python
1.  # ML'ni Go'da

2.  # yuqori yuk Python'da

3.  # Go'ni import qilish

4.  # minglab goroutine og'ir deb

5.  # umumiy o'zgaruvchi (goroutine)
Javoblar
python
1.  ML → Python, tarmoq → Go

2.  yuqori yuk → Go (goroutine)

3.  Go alohida xizmat (gRPC/HTTP)

4.  goroutine yengil (millionlab)

5.  channel (xavfsiz aloqa)

Vazifa 3: goroutine

Modellang:

  1. Yengil
  2. OS ip
  3. Og'irlik
  4. Millionlab

Vazifa 4: GIL farqi

Modellang:

  1. Python GIL
  2. Go GIL'siz
  3. Yadro
  4. Parallel

Vazifa 5: Python + Go

Modellang:

  1. Python roli
  2. Go roli
  3. Aloqa
  4. Kuch

Vazifa 6: Go vs kengaytma

Modellang:

  1. Kengaytma
  2. Go
  3. Integratsiya
  4. Tanlov

Vazifa 7: O'ylash

Go va Python "raqib" emas, balki "hamkor" — har biri o'z sohasida kuchli (Go parallel tarmoq, Python ML). Nima uchun "eng yaxshi til" degan savol noto'g'ri qo'yilgan, va nega "to'g'ri ish uchun to'g'ri vosita" (har til o'z kuchida) tajribali muhandisning yondashuvi, "hamma narsani bitta tilda" yondashuvidan ustun?

Javob

Qisqa javob: "Eng yaxshi til" savoli noto'g'ri qo'yilgan, chunki: til maqsaddan ajralib "yaxshi" bo'la olmaydi — yaxshilik kontekstga bog'liq (qaysi ish uchun?); Go parallel tarmoqda kuchli (goroutine), Python ML'da (ekotizim) — "eng yaxshi" savoli "nima uchun?"ni tashlab ketadi (universal yaxshi til yo'q). Har til muayyan savdolar bilan qurilgan (Go — soddalik+parallellik, lekin kam ML kutubxona; Python — qulaylik+ekotizim, lekin GIL/sekin); bu savdolar bir ishda afzallik, boshqasida kamchilik. "Nega to'g'ri vosita yondashuvi ustun": (1) har ish o'z talabiga ega — ML (Python ekotizim), yuqori yuk parallel (Go goroutine), CPU-og'ir funksiya (Rust/C); bitta til hammasida eng yaxshi bo'la olmaydi; (2) kuchdan foydalanish — har tilni o'z kuchida ishlatish (Go parallel, Python ML) — natija har ikkisidan yaxshi; (3) kamchilikdan qochish — Python'ni yuqori yukka majburlash (GIL kurashi) yoki Go'ni ML'ga (kutubxona qidirish) — kuch behuda; (4) pragmatizm — tajribali muhandis maqsadga xizmat qiladi (til sadoqati emas — "men faqat X tilida"). "Hamma narsani bitta tilda" yondashuvi kamchiliklari: bir til hamma ishda o'rtacha (hech qaysida eng yaxshi emas), kuchsiz sohada kurash (Python yuqori yuk), ekotizim cheklovi. Lekin muvozanat kerak: haddan tashqari ko'p til ham yomon (murakkablik — har til uchun bilim, vositalar, integratsiya — 30.16 polyglot narxi); "to'g'ri vosita" degani oqilona ko'p til (2-3, aniq sabab bilan), har biriga emas. Bu muhandislik yetukligi belgisi: vositani maqsadga moslash (til jangchisi emas — "faqat mening tilim"). Muhandislik saboqlari: "eng yaxshi til" noto'g'ri savol (kontekstsiz yaxshilik yo'q); har til savdolar bilan (bir ishda afzal, boshqada kamchilik); to'g'ri vosita to'g'ri ishga (kuchdan foydalanish, kamchilikdan qochish); til sadoqati emas — pragmatizm (maqsad); lekin oqilona ko'p til (haddan ko'p — murakkablik narxi). Go+Python misolida: Go (parallel tarmoq), Python (ML) — har biri o'z kuchida, tarmoq orqali birga; bitta tilga majburlash (yoki hammasi Go, yoki hammasi Python) — kuchsiz sohada kurash.

1. Nega "eng yaxshi til" noto'g'ri

  • Yaxshilik kontekstga bog'liq (qaysi ish?)
  • Til savdolar bilan (afzallik + kamchilik)
  • Universal yaxshi til yo'q (maqsad tashlab ketiladi)

2. Nega to'g'ri vosita ustun

  • Har ish o'z talabiga ega (ML, yuqori yuk, CPU)
  • Kuchdan foydalanish (Go parallel, Python ML)
  • Kamchilikdan qochish (majburlamaslik)
  • Pragmatizm (maqsad, til sadoqati emas)

3. Bitta til kamchiliklari

Yondashuv Natija
Bitta til hammaga O'rtacha (eng yaxshi emas)
To'g'ri vosita Har ishda kuchli

4. Muvozanat (haddan ko'p til ham yomon)

Oqilona ko'p til (2-3, aniq sabab). Haddan ko'p — murakkablik (30.16 polyglot narxi).

5. Muhandislik saboqlari

  1. "Eng yaxshi til" noto'g'ri savol (kontekstsiz)
  2. Har til savdolar bilan (afzal + kamchilik)
  3. To'g'ri vosita to'g'ri ishga (kuch, kamchilik)
  4. Pragmatizm (til sadoqati emas)
  5. Oqilona ko'p til (haddan ko'p — narx)

6. Xulosa

  1. "Eng yaxshi til" noto'g'ri (kontekst kerak)
  2. Har til o'z kuchida (Go parallel, Python ML)
  3. To'g'ri vosita — pragmatizm (maqsad)
  4. Oqilona ko'p til (muvozanat)

Nimani mustahkamlaydi: 2.5, 2.8-bo'limlar.


Xulosa

Bu darsda Go tilini o'rgandik.

Eng muhim uch fikr:

  1. Go va goroutine. Go (Golang) — Google yaratgan parallel va tarmoq dasturlash tili: yuqori yuk xizmatlar, mikroservislar (25-qism) uchun; C kabi tez (kompilyatsiyali), Python kabi oddiy (kam kalit so'z), parallel (goroutine). goroutine — asosiy kuch: juda yengil parallel ip (go funksiya()); OS iplari og'ir (1MB — minglab), goroutine yengil (2KB — millionlab); Go runtime ularni OS iplariga taqsimlaydi (scheduler). Natija: Go yuqori yukni (million ulanish) yengil ko'taradi.

  2. GIL farqi va Python bilan birga. GIL farqi (Go vs Python): Python (GIL 30.5 — bir vaqtda bir ip, CPU-og'irda parallel emas, yechim multiprocessing og'ir), Go (GIL yo'q — goroutine haqiqiy parallel, ko'p yadroni to'liq); CPU-og'ir parallel ishda Go tabiiy. Python va Go birga — polyglot: Python (ML, ma'lumot, tez ishlab chiqish) va Go (yuqori yuk tarmoq, real vaqt, parallel) alohida xizmatlar, tarmoq orqali (gRPC 30.14/HTTP); har til o'z kuchida (30.1 to'g'ri til to'g'ri ishga). Go kuchi: goroutine, oddiy, tez kompilyatsiya, statik binar (Docker), tarmoq kutubxonasi.

  3. Kengaytma farqi va parallel tarmoq. Go vs kengaytma: kengaytma (C/Rust/C++ 30.3-12 — bir jarayon, import, CPU-og'ir tezlashtirish), Go (alohida xizmat, tarmoq — gRPC/HTTP, yuqori yuk parallel); kengaytma ichki (bir dastur tez), Go tashqi (alohida xizmat — mikroservis); tanlov CPU-og'ir funksiya (kengaytma) yoki yuqori yuk xizmat (Go). Go — parallel tarmoq xizmatlari uchun (goroutine GIL'siz); Docker, Kubernetes, Prometheus Go'da. "Eng yaxshi til" noto'g'ri savol (kontekstsiz yaxshilik yo'q); to'g'ri vosita to'g'ri ishga (har til o'z kuchida — pragmatizm), lekin oqilona ko'p til (haddan ko'p — murakkablik narxi).

Keyingi darsda gRPC va Protocol Buffers ni o'rganamiz: xizmatlararo yuqori unumdor aloqa — Protocol Buffers (samarali binar format), xizmat ta'rifi (.proto) va Python bilan Go'ni tarmoq orqali tez bog'lash.

Python va boshqa tillar · 13-dars yakunlandi

30.13-dars: Go tili

19 daqvaqt
0belgi
Keyingi dars: 30.14-dars: gRPC va Protocol Buffers
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0