22.3-dars: Litestar / Starlette
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
TestClientbilan sinaladi.
2. Nazariya — chuqur tushuntirish
2.1. Starlette
Starlette — yengil ASGI toolkit (FastAPI'ning asosi):
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:
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):
@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:
# 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:
@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
# 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 server4. Batafsil misollar
Misollarda Starlette va Litestar
TestClientbilan sinaladi.
Misol 1 — Starlette (ASGI toolkit)
"""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:
=== 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)
"""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:
=== 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
"""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:
=== 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.
"""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:
=== 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, CRUDNima 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
def salom(request): ... # ⚠️ async yaxshiroq
async def salom(request): ... # ✅2. Litestar route_handlers unutish
app = Litestar() # ⚠️ handler yo'q
app = Litestar(route_handlers=[salom]) # ✅3. Starlette JSON'ni return dict
async def v(request): return {"a": 1} # ❌ Response kerak
return JSONResponse({"a": 1}) # ✅4. Litestar qaytarish turini bermaslik
async def salom(): # ⚠️ tur belgisi yo'q
async def salom() -> dict: # ✅5. ASGI'ni WSGI server bilan
gunicorn app # ⚠️ WSGI server
uvicorn app:app # ✅ ASGI server6. Litestar TestClientni withsiz
client = TestClient(app=app) # ⚠️ lifecycle
with TestClient(app=app) as client: ... # ✅7. FastAPI o'rniga Starlette (validatsiya kerak)
# Starlette (qo'lda validatsiya) # ⚠️ ko'p ish
# FastAPI (Pydantic — avtomatik) # ✅ validatsiya kerak bo'lsa7. 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
Standart zamonaviy API uchun FastAPI (mashhur).
Yengil/maxsus holat uchun Starlette.
FastAPI muqobili sifatida Litestar (DTO, plugin).
ASGI view'larni
asyncqiling.Litestar'da tip belgilari bering (
-> dict).ASGI server (Uvicorn) ishlating (Gunicorn WSGI emas).
Litestar
TestClientniwithbilan.Validatsiya kerak bo'lsa FastAPI/Litestar (Starlette qo'lda).
9. Amaliy topshiriq
Vazifa 1: Bashorat qiling
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
- Yengil ASGI toolkit (FastAPI asosi)
- FastAPI = Starlette + Pydantic + tip
- FastAPI'ga muqobil zamonaviy freymvork
- Async veb standarti (WSGI async versiya)
- Asinxron view (
async def) Route(yo'l, view)ro'yxati@get/@postdekorator- Uvicorn (async server)
- Ha (FastAPI kabi)
JSONResponse({...})- Yo'q (I/O ko'p bo'lsa)
- FastAPI (hozir)
Vazifa 2: Xatolarni tuzating
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 serverJavoblar
1. async def salom(request): ...
2. app = Litestar(route_handlers=[salom])
3. return JSONResponse({})
4. async def salom() -> dict:
5. uvicorn app:appVazifa 3: Starlette API
Starlette bilan:
Routero'yxati- Async view'lar
query_params,path_paramsTestClientbilan test
Vazifa 4: Litestar API
Litestar bilan:
@get/@postdekorator- Tip belgilari
- CRUD
- Test
Vazifa 5: Taqqoslash
Bir API uch freymvorkda:
- Flask (sinxron)
- FastAPI
- Litestar
- Kod va uslub taqqoslash
Vazifa 6: Async ustunligi
Async namoyish:
- Sinxron vs async view
- I/O kutish (async yaxshiroq)
- Ko'p ulanish
- 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
- Mavjud asos ustiga qur (noldan emas)
- Asos sinalgan — ishonchli, kam ish
- O'z qiymatiga e'tibor (asosni qayta yozma)
- "Yelka ustiga chiqish" — dasturlashda universal
6. Xulosa
- FastAPI — Starlette ustiga (qatlamli)
- Asos ustiga qurish — kam ish, ishonchli
- O'z qiymatiga e'tibor (validatsiya)
- 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:
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 defview vaJSONResponseishlatadi,request.query_params/request.path_paramsbilan so'rov ma'lumoti. To'g'ridan (yengil, maxsus holat) yoki FastAPI orqali ishlatiladi.Litestar — zamonaviy muqobil. Litestar — FastAPI'ga muqobil (o'xshash: tip belgilari, async, hujjat), lekin boyroq (ichida DTO, ORM plugin, ba'zan tezroq).
@get/@postdekoratorlari, tip belgilariga tayanadi (kurs_id: int— avtomatik aylantirish,data: dict— so'rov tanasi). Bu 20.4 FastAPI kabi validatsiya va hujjatni avtomatik beradi.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.
Izohlar · 0
Izoh yozish uchun kiring.