Python kursi22.3-dars: Litestar / Starlette
Python kursi · Boshqa freymvorklar

22.3-dars: Litestar / Starlette

15 daqiqa3/6-dars

22-QISM — BOSHQA FREYMVORKLAR · 3-dars


1. Kirish va motivatsiya

Flask an'anaviy (sinxron), FastAPI zamonaviy. Endi zamonaviy ASGI freymvorklarini ko'ramiz: Starlette (FastAPI'ning asosi) va Litestar (FastAPI'ga muqobil). Bular async (asinxron), tez, tip belgilariga tayanadigan freymvorklar — zamonaviy yuqori unumli veb-ilova uchun.

Starlette — yengil ASGI toolkit (FastAPI uning ustiga qurilgan); Litestar — FastAPI'ga o'xshash, lekin ba'zi joylarda tezroq va boyroq (ichida ORM, DTO, plugin tizimi). Bularni bilish — zamonaviy Python veb ekotizimini tushunish (ASGI, async, tip).

Real vaziyat. Bir jamoa yuqori yuklamali (high-load) API kerak edi — minglab bir vaqtdagi ulanish (WebSocket, real-time). Sinxron Flask yetmasdi (har so'rov oqimni bloklaydi). Ular ASGI freymvork (Litestar) ga o'tdi: async view'lar, bir oqimda ko'p ulanish (I/O kutishda boshqa so'rovga o'tadi). Unumdorlik oshdi. Zamonaviy ASGI — async, tez, yuqori yuklama uchun.

Bu darsda Starlette va Litestar'ni — ASGI, async va zamonaviy freymvorklarni o'rganamiz.

Bu darsda:

  • Starlette (ASGI toolkit)
  • Litestar (zamonaviy freymvork)
  • Async view'lar
  • Marshrutlash (Route, dekorator)
  • Tip belgilariga tayanish
  • FastAPI bilan aloqa
  • Qachon ishlatiladi
  • Amaliy: ASGI ilova

ℹ Misollarda Starlette va Litestar TestClient bilan sinaladi.


2. Nazariya — chuqur tushuntirish

2.1. Starlette

Starlette — yengil ASGI toolkit (FastAPI'ning asosi):

python
from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.routing import Route

async def salom(request):
    return JSONResponse({"xabar": "salom"})

app = Starlette(routes=[Route("/salom", salom)])

Starlette — minimal ASGI freymvork (async, WebSocket, marshrutlash). FastAPI uning ustiga qurilgan — FastAPI = Starlette + Pydantic + tip. Starlette to'g'ridan ishlatiladi (yengil, maxsus holatda) yoki FastAPI orqali (validatsiya bilan).

2.2. Litestar

Litestar — FastAPI'ga muqobil, boyroq zamonaviy freymvork:

python
from litestar import Litestar, get

@get("/salom")
async def salom() -> dict:
    return {"xabar": "salom"}

app = Litestar(route_handlers=[salom])

Litestar — FastAPI'ga o'xshash (tip belgilari, async, hujjat), lekin qo'shimcha: ichida DTO, ORM plugin, ba'zi joylarda tezroq. @get/@post dekoratorlari, tip belgilariga tayanadi. Zamonaviy, tez rivojlanayotgan muqobil.

2.3. Async view'lar

ASGI freymvorklar async (14-qism):

python
@get("/kurslar")
async def kurslar() -> dict:
    # async — I/O kutishda boshqa so'rovga o'tadi
    return {"kurslar": [...]}

async def — asinxron view: I/O (baza, tarmoq) kutishda oqim bloklanmaydi (boshqa so'rovga o'tadi). Bu yuqori yuklamada muhim (ko'p ulanish, bir oqim). Sinxron Flask'dan farqi — async bir oqimda ko'p ish qiladi.

2.4. Marshrutlash

Starlette — Route ro'yxati; Litestar — dekorator:

python
# Starlette (Route ro'yxati):
Starlette(routes=[
    Route("/salom", salom),
    Route("/kurslar/{kid:int}", kurs),
])

# Litestar (dekorator):
@get("/kurslar/{kid:int}")
async def kurs(kid: int) -> dict: ...

Starlette — Route(yo'l, view) ro'yxati (aniq); Litestar — @get/@post dekorator (FastAPI kabi). URL parametrlari {nom:tur} ({kid:int}). Har biri o'z uslubi.

2.5. Tip belgilariga tayanish

Litestar (va FastAPI) tip belgilarini ishlatadi:

python
@get("/kurslar/{kid:int}")
async def kurs(kid: int) -> dict:       # kid avtomatik int
    return {"id": kid}

@post("/kurslar")
async def yarat(data: dict) -> dict:    # data — so'rov tanasi
    return {"nom": data["nom"]}

Litestar tip belgilarini (20.4 FastAPI kabi) ishlatadi: parametr turi (kid: int), so'rov tanasi (data: dict yoki Pydantic model). Bu validatsiya va hujjatni avtomatik beradi. Starlette esa yengilroq (tip'siz, qo'lda).

2.6. FastAPI bilan aloqa

Uch freymvork bir oilada:

Freymvork Aloqa
Starlette ASGI asos (FastAPI ostida)
FastAPI Starlette + Pydantic + tip
Litestar Mustaqil muqobil (o'xshash)

Starlette — asos (yengil ASGI); FastAPI — Starlette + Pydantic + tip (validatsiya, hujjat); Litestar — mustaqil muqobil (FastAPI'ga o'xshash, boyroq). Hammasi ASGI, async, zamonaviy. FastAPI eng mashhur; Litestar tez o'sayotgan.

2.7. Qachon ishlatiladi

Freymvork Qachon
Starlette Yengil, maxsus (FastAPI ortiqcha)
FastAPI Zamonaviy API (mashhur, hujjat)
Litestar FastAPI muqobil (DTO, plugin, tez)

Starlette — juda yengil, maxsus holat (WebSocket-only, minimal). FastAPI — standart zamonaviy API (mashhur, katta jamoa). Litestar — FastAPI'ga muqobil (qo'shimcha imkoniyat, ba'zan tezroq). Ko'p holda FastAPI (standart); maxsus ehtiyoj — Starlette/Litestar.

2.8. ASGI ekotizimi

ASGI — zamonaviy Python veb standarti (WSGI'ning async versiyasi, 22.5):

ASGI (Asynchronous Server Gateway Interface) — async veb standarti (WebSocket, async view). Starlette, FastAPI, Litestar — ASGI freymvorklar; Uvicorn — ASGI server (Gunicorn WSGI kabi). Bu 22.5 dagi WSGI/ASGI'ning zamonaviy tomoni — async, yuqori unumli veb.


3. Tez ma'lumotnoma

python
# STARLETTE (ASGI toolkit):
from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.routing import Route

async def salom(request):
    return JSONResponse({"xabar": "salom"})

app = Starlette(routes=[Route("/salom", salom)])

# LITESTAR (zamonaviy):
from litestar import Litestar, get, post

@get("/kurslar/{kid:int}")
async def kurs(kid: int) -> dict:
    return {"id": kid}

app = Litestar(route_handlers=[kurs])

ASGI oilasi

Starlette — ASGI asos · FastAPI — Starlette+Pydantic · Litestar — muqobil
async def — asinxron · Uvicorn — ASGI server

4. Batafsil misollar

Misollarda Starlette va Litestar TestClient bilan sinaladi.

Misol 1 — Starlette (ASGI toolkit)

python
"""Starlette (ASGI); async view; Route ro'yxati; JSONResponse; query_params, path_params."""

import warnings
warnings.filterwarnings("ignore")

import logging
logging.disable(logging.CRITICAL)

from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.routing import Route
from starlette.testclient import TestClient


async def salom(request):
    til = request.query_params.get("til", "uz")
    return JSONResponse({"framework": "Starlette", "til": til})


async def kurs(request):
    kid = int(request.path_params["kid"])
    return JSONResponse({"id": kid, "nom": f"Kurs-{kid}"})


app = Starlette(routes=[
    Route("/salom", salom),
    Route("/kurslar/{kid:int}", kurs),
])


def main() -> None:
    client = TestClient(app)

    print("=== 1. Async view (Route) ===")
    print(f"  /salom → {client.get('/salom').json()}")

    print("\n=== 2. So'rov parametri (query_params) ===")
    print(f"  /salom?til=en → {client.get('/salom?til=en').json()}")

    print("\n=== 3. URL parametri (path_params) ===")
    print(f"  /kurslar/5 → {client.get('/kurslar/5').json()}")

    print("\n=== 4. ASGI asos ===")
    print(f"  /salom status: {client.get('/salom').status_code}")
    print("  ⭐ Starlette — yengil ASGI toolkit (FastAPI ostida)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Async view (Route) ===
  /salom → {'framework': 'Starlette', 'til': 'uz'}

=== 2. So'rov parametri (query_params) ===
  /salom?til=en → {'framework': 'Starlette', 'til': 'en'}

=== 3. URL parametri (path_params) ===
  /kurslar/5 → {'id': 5, 'nom': 'Kurs-5'}

=== 4. ASGI asos ===
  /salom status: 200
  ⭐ Starlette — yengil ASGI toolkit (FastAPI ostida)

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

Misol 2 — Litestar (dekorator, tip)

python
"""Litestar; @get/@post dekorator; tip belgilariga tayanish; async; avtomatik tur aylantirish."""

import warnings
warnings.filterwarnings("ignore")

import logging
logging.disable(logging.CRITICAL)

from litestar import Litestar, get, post
from litestar.testing import TestClient


@get("/salom")
async def salom() -> dict:
    return {"framework": "Litestar"}


@get("/kurslar/{kurs_id:int}")
async def kurs(kurs_id: int) -> dict:
    return {"id": kurs_id, "tur": type(kurs_id).__name__}


@post("/kurslar")
async def yarat(data: dict) -> dict:
    return {"yaratildi": data["nom"], "narx": data.get("narx", 0)}


app = Litestar(route_handlers=[salom, kurs, yarat])


def main() -> None:
    with TestClient(app=app) as client:
        print("=== 1. @get dekorator ===")
        print(f"  /salom → {client.get('/salom').json()}")

        print("\n=== 2. Tip belgilari (kurs_id: int) ===")
        javob = client.get("/kurslar/5").json()
        print(f"  /kurslar/5 → {javob} (avtomatik int)")

        print("\n=== 3. @post (so'rov tanasi) ===")
        javob = client.post("/kurslar", json={"nom": "Python", "narx": 100})
        print(f"  status {javob.status_code} → {javob.json()}")

        print("\n=== 4. Zamonaviy (FastAPI kabi) ===")
        print("  @get/@post + tip belgilari — validatsiya, hujjat avtomatik")
        print("  ⭐ Litestar — FastAPI muqobil (dekorator, tip, async)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. @get dekorator ===
  /salom → {'framework': 'Litestar'}

=== 2. Tip belgilari (kurs_id: int) ===
  /kurslar/5 → {'id': 5, 'tur': 'int'} (avtomatik int)

=== 3. @post (so'rov tanasi) ===
  status 201 → {'yaratildi': 'Python', 'narx': 100}

=== 4. Zamonaviy (FastAPI kabi) ===
  @get/@post + tip belgilari — validatsiya, hujjat avtomatik
  ⭐ Litestar — FastAPI muqobil (dekorator, tip, async)

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

Misol 3 — Starlette vs Litestar taqqoslash

python
"""Starlette va Litestar taqqoslash; bir xil API ikki freymvorkda; uslub farqi."""

import warnings
warnings.filterwarnings("ignore")

import logging
logging.disable(logging.CRITICAL)

from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.routing import Route
from starlette.testclient import TestClient as StarletteClient

from litestar import Litestar, get
from litestar.testing import TestClient as LitestarClient


# Starlette — Route ro'yxati, request obyekti
async def star_kurs(request):
    return JSONResponse({"framework": "Starlette", "id": int(request.path_params["kid"])})


star_app = Starlette(routes=[Route("/kurslar/{kid:int}", star_kurs)])


# Litestar — dekorator, tip belgisi
@get("/kurslar/{kid:int}")
async def lite_kurs(kid: int) -> dict:
    return {"framework": "Litestar", "id": kid}


lite_app = Litestar(route_handlers=[lite_kurs])


def main() -> None:
    print("=== 1. Starlette (Route + request) ===")
    sc = StarletteClient(star_app)
    print(f"  /kurslar/5 → {sc.get('/kurslar/5').json()}")

    print("\n=== 2. Litestar (dekorator + tip) ===")
    with LitestarClient(app=lite_app) as lc:
        print(f"  /kurslar/5 → {lc.get('/kurslar/5').json()}")

    print("\n=== 3. Uslub farqi ===")
    print("  Starlette: Route ro'yxati, request.path_params (qo'lda)")
    print("  Litestar: @get dekorator, tip belgisi (avtomatik)")

    print("\n=== 4. Bir xil natija ===")
    print("  ikkalasi ham async, ASGI, JSON")
    print("  ⭐ Starlette — yengil (qo'lda); Litestar — boy (tip, dekorator)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Starlette (Route + request) ===
  /kurslar/5 → {'framework': 'Starlette', 'id': 5}

=== 2. Litestar (dekorator + tip) ===
  /kurslar/5 → {'framework': 'Litestar', 'id': 5}

=== 3. Uslub farqi ===
  Starlette: Route ro'yxati, request.path_params (qo'lda)
  Litestar: @get dekorator, tip belgisi (avtomatik)

=== 4. Bir xil natija ===
  ikkalasi ham async, ASGI, JSON
  ⭐ Starlette — yengil (qo'lda); Litestar — boy (tip, dekorator)

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

Misol 4 — Amaliy: Litestar mini-API

Litestar bilan to'liq mini-API (kurslar CRUD) — zamonaviy, tip asosli. Bu FastAPI'ga muqobil ASGI freymvorkning namunasi.

python
"""Litestar mini-API: CRUD (ro'yxat, bitta, yaratish, o'chirish); tip belgilari; async; TestClient."""

import warnings
warnings.filterwarnings("ignore")

import logging
logging.disable(logging.CRITICAL)

from litestar import Litestar, delete, get, post
from litestar.exceptions import NotFoundException
from litestar.testing import TestClient

KURSLAR = {1: {"nom": "Python", "narx": 100}}
KEYINGI = [2]


@get("/kurslar")
async def royxat() -> list:
    return [{"id": k, **v} for k, v in KURSLAR.items()]


@get("/kurslar/{kurs_id:int}")
async def bitta(kurs_id: int) -> dict:
    if kurs_id not in KURSLAR:
        raise NotFoundException(detail="kurs topilmadi")
    return {"id": kurs_id, **KURSLAR[kurs_id]}


@post("/kurslar")
async def yarat(data: dict) -> dict:
    yangi_id = KEYINGI[0]
    KURSLAR[yangi_id] = {"nom": data["nom"], "narx": data["narx"]}
    KEYINGI[0] += 1
    return {"id": yangi_id, **KURSLAR[yangi_id]}


@delete("/kurslar/{kurs_id:int}")
async def ochir(kurs_id: int) -> None:
    KURSLAR.pop(kurs_id, None)


app = Litestar(route_handlers=[royxat, bitta, yarat, ochir])


def main() -> None:
    with TestClient(app=app) as client:
        print("=== 1. Yaratish (POST 201) ===")
        javob = client.post("/kurslar", json={"nom": "Go", "narx": 120})
        print(f"  status {javob.status_code} → {javob.json()}")

        print("\n=== 2. Ro'yxat (GET) ===")
        print(f"  kurslar: {[k['nom'] for k in client.get('/kurslar').json()]}")

        print("\n=== 3. Bitta va 404 ===")
        print(f"  /kurslar/1 → {client.get('/kurslar/1').json()['nom']}")
        print(f"  /kurslar/999 → status {client.get('/kurslar/999').status_code}")

        print("\n=== 4. O'chirish (DELETE 204) ===")
        print(f"  DELETE /kurslar/2 → status {client.delete('/kurslar/2').status_code}")
        print(f"  qolgan: {[k['nom'] for k in client.get('/kurslar').json()]}")
        print("  ⭐ Litestar mini-API — tip asosli, async, CRUD")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Yaratish (POST 201) ===
  status 201 → {'id': 2, 'nom': 'Go', 'narx': 120}

=== 2. Ro'yxat (GET) ===
  kurslar: ['Python', 'Go']

=== 3. Bitta va 404 ===
  /kurslar/1 → Python
  /kurslar/999 → status 404

=== 4. O'chirish (DELETE 204) ===
  DELETE /kurslar/2 → status 204
  qolgan: ['Python']
  ⭐ Litestar mini-API — tip asosli, async, CRUD

Nima ko'rsatdi: 2.2–2.8-bo'limlar.


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

Noto'g'ri fikr To'g'risi
"FastAPI — mustaqil" Starlette ustiga qurilgan
"Starlette = FastAPI" Starlette — asos (tip'siz)
"Litestar — FastAPI kloni" Muqobil (o'z imkoniyati)
"ASGI = WSGI" ASGI — async versiya
"async doim tezroq" I/O ko'p bo'lsa (14-qism)
"Litestar mashhurroq" FastAPI mashhurroq (hozir)
"Starlette to'liq freymvork" Yengil toolkit
"Bittasi yetarli" Vazifaga qarab

6. Keng tarqalgan xatolar va yechimlari

1. Starlette view'ni async qilmaslik

python
def salom(request): ...                      # ⚠️ async yaxshiroq
async def salom(request): ...                # ✅

2. Litestar route_handlers unutish

python
app = Litestar()                             # ⚠️ handler yo'q
app = Litestar(route_handlers=[salom])       # ✅

3. Starlette JSON'ni return dict

python
async def v(request): return {"a": 1}        # ❌ Response kerak
return JSONResponse({"a": 1})                # ✅

4. Litestar qaytarish turini bermaslik

python
async def salom():                           # ⚠️ tur belgisi yo'q
async def salom() -> dict:                   # ✅

5. ASGI'ni WSGI server bilan

bash
gunicorn app                                 # ⚠️ WSGI server
uvicorn app:app                              # ✅ ASGI server

6. Litestar TestClientni withsiz

python
client = TestClient(app=app)                 # ⚠️ lifecycle
with TestClient(app=app) as client: ...      # ✅

7. FastAPI o'rniga Starlette (validatsiya kerak)

python
# Starlette (qo'lda validatsiya)              # ⚠️ ko'p ish
# FastAPI (Pydantic — avtomatik)              # ✅ validatsiya kerak bo'lsa

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 20-qism (o'tilgan): FastAPI — Starlette ustida
  • 14-qism (o'tilgan): async/await — ASGI asosi
  • 22.5-dars: WSGI va ASGI — chuqurroq
  • 22.4-dars: qaysi freymvork qachon
  • 22.1-dars (o'tilgan): Flask — sinxron taqqoslash

8. Eng yaxshi amaliyotlar

  1. Standart zamonaviy API uchun FastAPI (mashhur).

  2. Yengil/maxsus holat uchun Starlette.

  3. FastAPI muqobili sifatida Litestar (DTO, plugin).

  4. ASGI view'larni async qiling.

  5. Litestar'da tip belgilari bering (-> dict).

  6. ASGI server (Uvicorn) ishlating (Gunicorn WSGI emas).

  7. Litestar TestClientni with bilan.

  8. Validatsiya kerak bo'lsa FastAPI/Litestar (Starlette qo'lda).


9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # Starlette nima?
2.  # FastAPI Starlette'ga qanday bog'liq?
3.  # Litestar nima?
4.  # ASGI nima?
5.  # async view nima?
6.  # Starlette marshruti qanday?
7.  # Litestar marshruti qanday?
8.  # ASGI server nima?
9.  # Litestar tip ishlatadimi?
10. # Starlette JSON qanday?
11. # async doim tezroqmi?
12. # qaysi mashhurroq?
Javoblar
  1. Yengil ASGI toolkit (FastAPI asosi)
  2. FastAPI = Starlette + Pydantic + tip
  3. FastAPI'ga muqobil zamonaviy freymvork
  4. Async veb standarti (WSGI async versiya)
  5. Asinxron view (async def)
  6. Route(yo'l, view) ro'yxati
  7. @get/@post dekorator
  8. Uvicorn (async server)
  9. Ha (FastAPI kabi)
  10. JSONResponse({...})
  11. Yo'q (I/O ko'p bo'lsa)
  12. FastAPI (hozir)

Vazifa 2: Xatolarni tuzating

python
1.  def salom(request): ...           # async

2.  app = Litestar()                  # route_handlers

3.  async def v(request): return {}   # JSONResponse

4.  async def salom():                # tur

5.  gunicorn app                      # ASGI server
Javoblar
python
1.  async def salom(request): ...

2.  app = Litestar(route_handlers=[salom])

3.  return JSONResponse({})

4.  async def salom() -> dict:

5.  uvicorn app:app

Vazifa 3: Starlette API

Starlette bilan:

  1. Route ro'yxati
  2. Async view'lar
  3. query_params, path_params
  4. TestClient bilan test

Vazifa 4: Litestar API

Litestar bilan:

  1. @get/@post dekorator
  2. Tip belgilari
  3. CRUD
  4. Test

Vazifa 5: Taqqoslash

Bir API uch freymvorkda:

  1. Flask (sinxron)
  2. FastAPI
  3. Litestar
  4. Kod va uslub taqqoslash

Vazifa 6: Async ustunligi

Async namoyish:

  1. Sinxron vs async view
  2. I/O kutish (async yaxshiroq)
  3. Ko'p ulanish
  4. Farqni tushuntirish

Vazifa 7: O'ylash

Starlette, FastAPI, Litestar — bir ekotizim (ASGI, async), lekin turli darajada: Starlette asos (yengil), FastAPI Starlette + tip (mashhur), Litestar mustaqil muqobil. Bu "qatlamli ekotizim" (asos ustiga qurish) tamoyili — FastAPI Starlette'ni qayta yozmaydi, undan foydalanadi. Mavjud asoslar ustiga qurishning (noldan emas) afzalligi nima, va bu "yelka ustiga chiqish" (stand on shoulders) dasturlashda qanday keng uchraydi?

Javob

Qisqa javob: FastAPI Starlette'ni (ASGI, marshrutlash, async) qayta yozmaydi — undan foydalanadi, ustiga Pydantic va tip qo'shadi. Bu "mavjud asos ustiga qurish": Starlette sinalgan ASGI asosini beradi, FastAPI unga qiymat (validatsiya) qo'shadi. Afzalligi: kam ish (asos tayyor), ishonchli (asos sinalgan), e'tibor (o'z qiymatiga — FastAPI validatsiyaga, ASGI'ga emas). "Yelka ustiga chiqish" — dasturlashda keng: kutubxonalar (mavjud kod ustiga), freymvorklar (til/kutubxona ustiga), standartlar (protokol ustiga). Noldan qurish kam — deyarli hamma narsa mavjud narsa ustiga quriladi.

1. Qatlamli ekotizim

Qatlam Beradi
Uvicorn ASGI server
Starlette ASGI freymvork (marshrut, async)
FastAPI + Pydantic, tip, hujjat

2. Asos ustiga qurish afzalligi

Afzallik Sabab
Kam ish Asos tayyor
Ishonchli Asos sinalgan
E'tibor O'z qiymatiga
Tez Noldan emas

3. FastAPI misoli

FastAPI ASGI, marshrutlash, async'ni qayta yozmaydi (Starlette beradi) — u faqat validatsiya, tip, hujjatni qo'shadi (o'z qiymati). Kam kod, ko'p qiymat.

4. "Yelka ustiga chiqish" boshqa joyda

Qatlam Asos
FastAPI Starlette
Kutubxona Til/stdlib
Ilova Freymvork
Protokol TCP/IP

5. Muhandislik saboqlari

  1. Mavjud asos ustiga qur (noldan emas)
  2. Asos sinalgan — ishonchli, kam ish
  3. O'z qiymatiga e'tibor (asosni qayta yozma)
  4. "Yelka ustiga chiqish" — dasturlashda universal

6. Xulosa

  1. FastAPI — Starlette ustiga (qatlamli)
  2. Asos ustiga qurish — kam ish, ishonchli
  3. O'z qiymatiga e'tibor (validatsiya)
  4. Noldan qurish kam — mavjud ustiga

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.


Xulosa

Bu darsda Starlette va Litestar'ni — zamonaviy ASGI freymvorklarni o'rgandik.

Eng muhim uch fikr:

  1. Starlette — ASGI asos. Starlette — yengil ASGI toolkit (async, WebSocket, marshrutlash). FastAPI uning ustiga qurilgan (FastAPI = Starlette + Pydantic + tip). Starlette Route(yo'l, view) ro'yxati bilan marshrutlaydi, async def view va JSONResponse ishlatadi, request.query_params/request.path_params bilan so'rov ma'lumoti. To'g'ridan (yengil, maxsus holat) yoki FastAPI orqali ishlatiladi.

  2. Litestar — zamonaviy muqobil. Litestar — FastAPI'ga muqobil (o'xshash: tip belgilari, async, hujjat), lekin boyroq (ichida DTO, ORM plugin, ba'zan tezroq). @get/@post dekoratorlari, tip belgilariga tayanadi (kurs_id: int — avtomatik aylantirish, data: dict — so'rov tanasi). Bu 20.4 FastAPI kabi validatsiya va hujjatni avtomatik beradi.

  3. ASGI ekotizimi. Starlette (asos), FastAPI (Starlette + tip, mashhur), Litestar (mustaqil muqobil) — hammasi ASGI, async, zamonaviy. Ular async view'lar bilan yuqori yuklamani (ko'p ulanish, bir oqim) boshqaradi. Uvicorn — ASGI server (Gunicorn WSGI kabi). FastAPI Starlette'ni qayta yozmaydi — undan foydalanadi (qatlamli ekotizim, "yelka ustiga chiqish"): mavjud sinalgan asos ustiga qurish — kam ish, ishonchli, o'z qiymatiga e'tibor.

Keyingi darsda qaysi freymvork qachon ni o'rganamiz: Flask, Django, FastAPI, Litestar — har birining kuchli/zaif tomonlari va vazifaga qarab tanlash.

Boshqa freymvorklar · 3-dars yakunlandi

22.3-dars: Litestar / Starlette

15 daqvaqt
0belgi
Keyingi dars: 22.4-dars: Qaysi freymvork qachon
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0