20.5-dars: Pydantic modellari
20-QISM — WEB-BACKEND (FastAPI) · 5-dars
1. Kirish va motivatsiya
O'tgan darsda parametrlarni (yo'l, so'rov) o'rgandik — ular oddiy qiymatlar (son, satr). Lekin real API murakkab ma'lumot qabul qiladi: yangi kurs yaratishda nom, narx, darslar ro'yxati, muallif — butun bir obyekt. Bu ma'lumot so'rov tanasida (body) JSON sifatida keladi. Uni qanday qabul qilamiz, tekshiramiz, aylantirami?
Javob — Pydantic. Pydantic model — ma'lumotning shakli va qoidalarini e'lon qiluvchi Python klassi. FastAPI Pydantic ustiga qurilgan: modelni parametr sifatida bersangiz, FastAPI JSON'ni o'qiydi, model bilan tekshiradi, xato bo'lsa 422 qaytaradi va sizga tayyor, validatsiyalangan obyekt beradi.
Real vaziyat. Bir jamoa registratsiya endpointini qo'lda yozdi: data = request.json(), keyin if "email" not in data, if not isinstance(data["yosh"], int) — o'nlab tekshiruv, har biri qo'lda, ba'zilari unutilgan. Bir kuni yosh="yigirma" (satr) bazaga tushdi va hisobotni buzdi. Ular Pydantic modelga o'tdi: yosh: int, email: EmailStr — bitta klass. Endi noto'g'ri ma'lumot endpointga kirmaydi ham (422), va model o'zi hujjat. Kod uch barobar qisqardi va xatolar yo'qoldi.
Bu darsda Pydantic modellarini — ma'lumot shaklini e'lon qilish, validatsiya va seriyalizatsiyani o'rganamiz.
Bu darsda:
- Pydantic model (
BaseModel) - So'rov tanasi (request body)
Fieldbilan validatsiya- Maxsus validatorlar (
field_validatorvamodel_validator) - Ichma-ich modellar
- ORM bilan ishlash (
ConfigDict(from_attributes=True)) - Hisoblangan maydonlar (
@computed_field) - Javob modeli (
response_model) - Seriyalizatsiya (
model_dump,model_validate) - Amaliy: to'liq CRUD modellari
ℹ Misollarda Pydantic va FastAPI
TestClientbilan sinaladi.
2. Nazariya — chuqur tushuntirish
2.1. Pydantic model nima
Pydantic model — ma'lumot shaklini tip belgilari bilan e'lon qiluvchi klass:
from pydantic import BaseModel
class Kurs(BaseModel):
nom: str
narx: float
til: str = "uz" # standart qiymat| Element | Ma'nosi |
|---|---|
BaseModel |
Pydantic asosiy klass |
nom: str |
Majburiy maydon |
til: str = "uz" |
Ixtiyoriy (standartli) |
Model — ma'lumotning sxemasi: qaysi maydonlar, qanday tip, majburiymi. Pydantic tekshiradi va aylantiradi.
2.2. Model yaratish va tekshirish
k = Kurs(nom="Python", narx=100) # to'g'ri
k.nom # "Python"
k.narx # 100.0 (float'ga aylandi)
Kurs(nom="P") # ⚠️ narx yo'q → ValidationError| Amal | Natija |
|---|---|
| To'g'ri ma'lumot | Obyekt |
| Maydon yetishmaydi | ValidationError |
| Noto'g'ri tip | Aylantiradi yoki xato |
Model yaratilganda Pydantic darrov tekshiradi. Xato bo'lsa ValidationError (maydon, sabab bilan).
2.3. So'rov tanasi (request body)
FastAPI'da modelni parametr qilsa — u so'rov tanasi (body) bo'ladi:
@app.post("/kurslar")
def yarat(kurs: Kurs): # kurs — so'rov tanasi (JSON)
return {"yaratildi": kurs.nom}| Parametr turi | Manba |
|---|---|
Oddiy tip (int, str) |
Yo'l/so'rov parametri |
| Pydantic model | So'rov tanasi (JSON) |
Pydantic model = so'rov tanasi. FastAPI JSON'ni o'qiydi, model bilan tekshiradi, xato bo'lsa 422, aks holda tayyor obyekt beradi.
2.4. Field bilan validatsiya
Field maydon uchun qo'shimcha qoida va metama'lumot beradi:
from pydantic import BaseModel, Field
class Kurs(BaseModel):
nom: str = Field(min_length=2, max_length=50)
narx: float = Field(ge=0)
daraja: int = Field(default=1, ge=1, le=5)| Cheklov | Ma'nosi |
|---|---|
min_length, max_length |
Satr uzunligi |
ge, gt, le, lt |
Son oralig'i |
default |
Standart qiymat |
description |
Hujjat matni |
Field — 20.4 dagi Query/Path ning model versiyasi. Buzilsa ValidationError (API'da 422).
2.5. Maxsus validatorlar
Murakkab qoida uchun field_validator:
from pydantic import BaseModel, field_validator
class Foydalanuvchi(BaseModel):
ism: str
yosh: int
parol: str
parol_tasdiq: str
@field_validator("yosh")
@classmethod
def yosh_tekshir(cls, v: int) -> int:
if v < 0 or v > 150:
raise ValueError("yosh 0-150 orasida bo'lsin")
return v
# Pydantic v2: bir nechta maydonni birga tekshirish
@model_validator(mode="after")
def parollarni_tekshir(self) -> "Foydalanuvchi":
if self.parol != self.parol_tasdiq:
raise ValueError("Parol va uning tasdig'i bir-biriga mos kelmadi")
return self field_validator — yakka maydon mantiqi uchun. model_validator(mode="after") — bir nechta maydon aloqasi (parol == parol_tasdiq yoki boshlanish < tugash) uchun (eski Pydantic v1 @root_validator o'rniga).
2.6. Ichma-ich modellar
Model boshqa modelni o'z ichiga oladi:
class Muallif(BaseModel):
ism: str
email: str
class Kurs(BaseModel):
nom: str
muallif: Muallif # ichma-ich model
teglar: list[str] = [] # ro'yxatIchma-ich modellar — murakkab, chuqur JSON'ni tekshiradi. FastAPI butun daraxtni validatsiya qiladi.
2.7. ORM bilan integratsiya (ConfigDict(from_attributes=True))
Bazada (SQLAlchemy, SQLModel, Tortoise) obyektlar lug'at emas, klass atributlari (kurs.nom, kurs.narx) bo'ladi. Pydantic ularni o'qishi uchun from_attributes=True yoqiladi:
from pydantic import BaseModel, ConfigDict
class KursDBJavob(BaseModel):
id: int
nom: str
narx: float
# Pydantic v2 da (eski orm_mode=True o'rniga):
model_config = ConfigDict(from_attributes=True) Pydantic v1 dagi class Config: orm_mode = True Pydantic v2 da model_config = ConfigDict(from_attributes=True) ga aylandi. Bu sozlama bilan KursDBJavob.model_validate(sqlalchemy_kurs) ORM obyektidan to'g'ridan-to'g'ri Pydantic model yasaydi.
2.8. Hisoblangan maydonlar (@computed_field)
Ba'zan bazada saqlanmaydigan, lekin API javobida (JSON'da) chiqishi kerak bo'lgan xususiyatlar bo'ladi:
from pydantic import BaseModel, computed_field
class Mahsulot(BaseModel):
nom: str
asl_narx: float
chegirma_foiz: float = 0.0
@computed_field
@property
def yakuniy_narx(self) -> float:
return round(self.asl_narx * (1 - self.chegirma_foiz / 100), 2) @computed_field — @property qiymatini model_dump() va JSON seriyalizatsiyaga avtomatik kiritadi. Mijoz (frontend) hisoblash mantiqini takrorlashi shart emas.
2.9. Javob modeli (response_model)
response_model — javob shaklini belgilaydi va filtrlaydi:
class KursYaratish(BaseModel):
nom: str
parol: str # kirish uchun
class KursJavob(BaseModel):
nom: str # parol YO'Q
@app.post("/kurslar", response_model=KursJavob)
def yarat(kurs: KursYaratish):
return kurs # parol javobda ko'rinmaydi response_model javobni filtrlaydi (maxfiy maydonni yashiradi) va hujjatlaydi. Kirish va chiqish modellarini ajratish — yaxshi amaliyot.
2.10. Seriyalizatsiya
Model va JSON/dict o'rtasida aylantirish:
| Metod | Vazifa |
|---|---|
model_dump() |
Model → dict |
model_dump(mode="json") |
Model → JSON-mos dict (sana/UUID satrga aylanadi) |
model_dump_json() |
Model → JSON satr |
model_validate(obj) |
dict yoki ORM obyektidan model |
model_validate_json(str) |
JSON satr → Model |
k.model_dump() # {'nom': 'Python', 'narx': 100.0, ...}
Kurs.model_validate_json('{"nom":"Go","narx":120}') # Kurs obyekti Pydantic v2'da: model_dump (eski dict()), model_validate (eski parse_obj). FastAPI bularni avtomatik ishlatadi.
3. Tez ma'lumotnoma
from pydantic import BaseModel, Field, field_validator
class Kurs(BaseModel):
nom: str = Field(min_length=2, max_length=50)
narx: float = Field(ge=0)
til: str = "uz"
teglar: list[str] = []
@field_validator("nom")
@classmethod
def nom_katta(cls, v: str) -> str:
return v.strip()
# FastAPI'da:
@app.post("/kurslar", response_model=KursJavob)
def yarat(kurs: Kurs): # kurs — so'rov tanasi
return kursMetodlar
model_dump() → dict
model_dump_json() → JSON satr
model_validate(d) → dict'dan model
model_validate_json(s)→ JSON satr'dan model4. Batafsil misollar
Misollarda Pydantic va FastAPI
TestClientbilan sinaladi.
Misol 1 — Model asoslari va validatsiya
"""BaseModel; majburiy va ixtiyoriy maydon; tur aylantirish; ValidationError; Field cheklovlari."""
import warnings
warnings.filterwarnings("ignore")
from pydantic import BaseModel, Field, ValidationError
class Kurs(BaseModel):
nom: str = Field(min_length=2, max_length=50)
narx: float = Field(ge=0)
til: str = "uz"
darslar: list[str] = []
def main() -> None:
print("=== 1. To'g'ri model ===")
k = Kurs(nom="Python", narx=100, darslar=["kirish", "asoslar"])
print(f" nom={k.nom}, narx={k.narx}, til={k.til}")
print(f" darslar={k.darslar}")
print("\n=== 2. Tur aylantirish ===")
k2 = Kurs(nom="Go", narx="120") # narx satr → float
print(f" narx='120' → {k2.narx} ({type(k2.narx).__name__})")
print("\n=== 3. Standart qiymatlar ===")
print(f" til (berilmagan) → {k2.til}, darslar → {k2.darslar}")
print("\n=== 4. ⚠️ Validatsiya xatolari ===")
try:
Kurs(nom="P", narx=-5) # nom qisqa, narx manfiy
except ValidationError as e:
print(f" xatolar soni: {len(e.errors())}")
for err in e.errors():
print(f" {err['loc'][0]}: {err['type']}")
print(" ⭐ model — ma'lumot sxemasi; Pydantic tekshiradi va aylantiradi")
if __name__ == "__main__":
main()Natijaning muhim qismi:
=== 1. To'g'ri model ===
nom=Python, narx=100.0, til=uz
darslar=['kirish', 'asoslar']
=== 2. Tur aylantirish ===
narx='120' → 120.0 (float)
=== 3. Standart qiymatlar ===
til (berilmagan) → uz, darslar → []
=== 4. ⚠️ Validatsiya xatolari ===
xatolar soni: 2
nom: string_too_short
narx: greater_than_equal
⭐ model — ma'lumot sxemasi; Pydantic tekshiradi va aylantiradiNima ko'rsatdi: 2.1, 2.2, 2.4-bo'limlar.
Misol 2 — So'rov tanasi (request body) FastAPI'da
"""Pydantic model = so'rov tanasi; POST bilan JSON qabul qilish; 422 validatsiya; javob."""
import warnings
warnings.filterwarnings("ignore")
from pydantic import BaseModel, Field
from fastapi import FastAPI
from fastapi.testclient import TestClient
app = FastAPI()
class Kurs(BaseModel):
nom: str = Field(min_length=2)
narx: float = Field(ge=0)
til: str = "uz"
@app.post("/kurslar")
def yarat(kurs: Kurs):
return {"yaratildi": kurs.nom, "narx": kurs.narx, "til": kurs.til}
def main() -> None:
client = TestClient(app)
print("=== 1. To'g'ri so'rov tanasi ===")
javob = client.post("/kurslar", json={"nom": "Python", "narx": 100})
print(f" status {javob.status_code} → {javob.json()}")
print("\n=== 2. Barcha maydonlar ===")
javob = client.post("/kurslar", json={"nom": "Go", "narx": 120, "til": "en"})
print(f" → {javob.json()}")
print("\n=== 3. ⚠️ Majburiy maydon yo'q ===")
javob = client.post("/kurslar", json={"nom": "Rust"}) # narx yo'q
print(f" narx yo'q → status {javob.status_code}")
print("\n=== 4. ⚠️ Noto'g'ri qiymat ===")
javob = client.post("/kurslar", json={"nom": "X", "narx": -5})
xato = javob.json()["detail"]
print(f" status {javob.status_code}, xatolar: {[e['loc'][-1] for e in xato]}")
print(" ⭐ model parametri = so'rov tanasi; FastAPI o'qiydi, tekshiradi, 422")
if __name__ == "__main__":
main()Natijaning muhim qismi:
=== 1. To'g'ri so'rov tanasi ===
status 200 → {'yaratildi': 'Python', 'narx': 100.0, 'til': 'uz'}
=== 2. Barcha maydonlar ===
→ {'yaratildi': 'Go', 'narx': 120.0, 'til': 'en'}
=== 3. ⚠️ Majburiy maydon yo'q ===
narx yo'q → status 422
=== 4. ⚠️ Noto'g'ri qiymat ===
status 422, xatolar: ['nom', 'narx']
⭐ model parametri = so'rov tanasi; FastAPI o'qiydi, tekshiradi, 422Nima ko'rsatdi: 2.3, 2.4-bo'limlar.
Misol 3 — Validatorlar va ichma-ich modellar
"""field_validator (maxsus qoida); ichma-ich model; ro'yxat maydoni; chuqur validatsiya."""
import warnings
warnings.filterwarnings("ignore")
from pydantic import BaseModel, field_validator, ValidationError
class Muallif(BaseModel):
ism: str
email: str
@field_validator("email")
@classmethod
def email_tekshir(cls, v: str) -> str:
if "@" not in v:
raise ValueError("email @ belgisini o'z ichiga olsin")
return v.lower()
class Kurs(BaseModel):
nom: str
muallif: Muallif # ichma-ich model
teglar: list[str] = []
@field_validator("nom")
@classmethod
def nom_tozala(cls, v: str) -> str:
return v.strip()
def main() -> None:
print("=== 1. Ichma-ich model ===")
k = Kurs(
nom=" Python ",
muallif={"ism": "Ali", "email": "ALI@Mail.uz"},
teglar=["python", "backend"],
)
print(f" nom (tozalangan): '{k.nom}'")
print(f" muallif: {k.muallif.ism}, {k.muallif.email}")
print(f" teglar: {k.teglar}")
print("\n=== 2. Validator ishga tushdi ===")
print(f" email kichik harfga: {k.muallif.email}")
print("\n=== 3. ⚠️ Ichma-ich validatsiya xatosi ===")
try:
Kurs(nom="Go", muallif={"ism": "Vali", "email": "notogri"})
except ValidationError as e:
err = e.errors()[0]
print(f" loc={err['loc']}, msg={err['msg']}")
print("\n=== 4. Chuqur seriyalizatsiya ===")
print(f" model_dump: {k.model_dump()}")
print(" ⭐ validator — maxsus qoida; ichma-ich model — chuqur validatsiya")
if __name__ == "__main__":
main()Natijaning muhim qismi:
=== 1. Ichma-ich model ===
nom (tozalangan): 'Python'
muallif: Ali, ali@mail.uz
teglar: ['python', 'backend']
=== 2. Validator ishga tushdi ===
email kichik harfga: ali@mail.uz
=== 3. ⚠️ Ichma-ich validatsiya xatosi ===
loc=('muallif', 'email'), msg=Value error, email @ belgisini o'z ichiga olsin
=== 4. Chuqur seriyalizatsiya ===
model_dump: {'nom': 'Python', 'muallif': {'ism': 'Ali', 'email': 'ali@mail.uz'}, 'teglar': ['python', 'backend']}
⭐ validator — maxsus qoida; ichma-ich model — chuqur validatsiyaNima ko'rsatdi: 2.5, 2.6, 2.8-bo'limlar.
Misol 4 — Amaliy: kirish/chiqish modellari va response_model
Real API kirish (yaratish) va chiqish (javob) uchun alohida modellar ishlatadi: kirishda parol keladi, javobda parol ko'rinmasligi kerak. response_model bilan javobni filtrlaymiz — bu xavfsizlik va aniq shartnoma.
"""kirish/chiqish modellarini ajratish; response_model bilan filtr (maxfiy maydonni yashirish); id qo'shish; ro'yxat javobi."""
import warnings
warnings.filterwarnings("ignore")
from pydantic import BaseModel, Field
from fastapi import FastAPI
from fastapi.testclient import TestClient
app = FastAPI(title="Wisar Kurslar API")
class KursYaratish(BaseModel):
nom: str = Field(min_length=2)
narx: float = Field(ge=0)
maxfiy_kod: str # ichki, javobda yo'q
class KursJavob(BaseModel):
id: int
nom: str
narx: float # maxfiy_kod YO'Q
BAZA: list[dict] = []
@app.post("/kurslar", response_model=KursJavob, status_code=201)
def yarat(kurs: KursYaratish):
yozuv = {"id": len(BAZA) + 1, "nom": kurs.nom, "narx": kurs.narx, "maxfiy_kod": kurs.maxfiy_kod}
BAZA.append(yozuv)
return yozuv # response_model maxfiy_kod'ni olib tashlaydi
@app.get("/kurslar", response_model=list[KursJavob])
def royxat():
return BAZA
def main() -> None:
client = TestClient(app)
print("=== 1. Yaratish (201) ===")
javob = client.post("/kurslar", json={"nom": "Python", "narx": 100, "maxfiy_kod": "sir123"})
print(f" status {javob.status_code} → {javob.json()}")
print("\n=== 2. ⭐ Maxfiy maydon yashiringan ===")
print(f" 'maxfiy_kod' javobda: {'maxfiy_kod' in javob.json()}")
print("\n=== 3. Yana yaratish ===")
client.post("/kurslar", json={"nom": "Go", "narx": 120, "maxfiy_kod": "sir456"})
print(" 2-kurs qo'shildi")
print("\n=== 4. Ro'yxat (filtrlangan) ===")
javob = client.get("/kurslar")
print(f" jami: {len(javob.json())}")
for k in javob.json():
print(f" id={k['id']}, nom={k['nom']}, maydonlar={sorted(k.keys())}")
print(" ⭐ response_model — javobni filtrlaydi va hujjatlaydi")
if __name__ == "__main__":
main()Natijaning muhim qismi:
=== 1. Yaratish (201) ===
status 201 → {'id': 1, 'nom': 'Python', 'narx': 100.0}
=== 2. ⭐ Maxfiy maydon yashiringan ===
'maxfiy_kod' javobda: False
=== 3. Yana yaratish ===
2-kurs qo'shildi
=== 4. Ro'yxat (filtrlangan) ===
jami: 2
id=1, nom=Python, maydonlar=['id', 'narx', 'nom']
id=2, nom=Go, maydonlar=['id', 'narx', 'nom']
⭐ response_model — javobni filtrlaydi va hujjatlaydiNima ko'rsatdi: 2.7, 2.8-bo'limlar.
5. To'g'ri va noto'g'ri tushunishlar
| Noto'g'ri fikr | To'g'risi |
|---|---|
| "Tanani qo'lda tekshirish" | Pydantic model tekshiradi |
| "Model parametri — so'rov parametri" | Model — so'rov tanasi (body) |
| "Bir model kirish va chiqish uchun" | Ajratish yaxshiroq (parol) |
"dict() ishlatiladi" |
v2'da model_dump() |
"Validator — faqat Field" |
Murakkab — field_validator |
| "Ichma-ich JSON tekshirilmaydi" | Ichma-ich model tekshiradi |
"response_model keraksiz" |
Javobni filtrlaydi va hujjatlaydi |
| "Pydantic sekin" | v2 Rust'da, tez |
6. Keng tarqalgan xatolar va yechimlari
1. Tanani qo'lda o'qish
data = await request.json()
if "nom" not in data: ... # ❌ qo'lda
def yarat(kurs: Kurs): ... # ✅ model2. Eski dict() metodi
kurs.dict() # ❌ v1
kurs.model_dump() # ✅ v23. Kirish va chiqish bir model
class Kurs(BaseModel):
parol: str # ❌ javobda ko'rinadi
# ✅ KursYaratish (parol) + KursJavob (parolsiz)4. Validatorda return unutish
@field_validator("nom")
def tozala(cls, v):
v.strip() # ❌ qaytarmadi
return v.strip() # ✅5. response_modelsiz maxfiy ma'lumot
@app.post("/kurslar") # ⚠️ butun obyekt qaytadi
@app.post("/kurslar", response_model=KursJavob) # ✅6. Majburiy maydonga = None bermaslik
til: str | None # ❌ majburiy (None berish shart)
til: str | None = None # ✅ ixtiyoriy7. Model ichida mutable standart
teglar: list = [] # ✅ Pydantic'da xavfsiz (dataclass'dan farq)7. Integratsiya — bu bilim qayerda kerak bo'ladi
- 20.4-dars (o'tilgan): parametrlar (yo'l, so'rov) — Pydantic tana bilan to'ldiradi
- 13-qism (o'tilgan): tip belgilari,
Annotated - 16.2-dars (o'tilgan): JSON — Pydantic JSON'ni model bilan bog'laydi
- 20.6-dars: so'rov va javob — chuqurroq
- 20.9-dars: CRUD — modellar amaliyotda
8. Eng yaxshi amaliyotlar
So'rov tanasi uchun Pydantic model — qo'lda tekshirmang.
Fieldbilan validatsiya (ge,min_length),field_validatormurakkab qoida uchun.Kirish va chiqish modellarini ajrating (parol javobda ko'rinmasin).
response_modelbilan javobni filtrlang va hujjatlang.v2 metodlarini ishlating:
model_dump,model_validate.Ichma-ich modellar bilan murakkab JSON'ni tuzilishlang.
Validatorda qiymatni
returnqiling.Ixtiyoriy maydonga standart bering (
= None).
9. Amaliy topshiriq
Vazifa 1: Bashorat qiling
1. # BaseModel nima?
2. # def yarat(kurs: Kurs) — kurs qayerdan?
3. # Field(ge=0) nima?
4. # majburiy maydon yo'q bo'lsa API status?
5. # model_dump() nima qaytaradi?
6. # field_validator qachon kerak?
7. # response_model nima uchun?
8. # narx="120" (satr), narx: float → ?
9. # ichma-ich model tekshiriladimi?
10. # kirish/chiqish modelini nega ajratamiz?
11. # v2'da dict() o'rniga?
12. # til: str | None majburiymi?Javoblar
- Pydantic asosiy klass (model)
- So'rov tanasidan (JSON body)
- Son >= 0 validatsiya
- 422
- dict (model → dict)
Fieldyeta olmagan murakkab qoidada- Javobni filtrlaydi va hujjatlaydi
120.0(float'ga aylanadi)- Ha (chuqur validatsiya)
- Maxfiy maydon (parol) javobda ko'rinmasligi uchun
model_dump()- Ha (
= Noneberilmagan — majburiy)
Vazifa 2: Xatolarni tuzating
1. data = await request.json()
if "nom" not in data: ... # qo'lda
2. kurs.dict() # v1
3. class Kurs(BaseModel):
parol: str # javobda ko'rinadi
4. @field_validator("nom")
def tozala(cls, v):
v.strip() # return yo'q
5. til: str | None # majburiy bo'lib qoldiJavoblar
1. def yarat(kurs: Kurs): ... # model
2. kurs.model_dump() # v2
3. class KursJavob(BaseModel): # parolsiz alohida model
nom: str
4. @field_validator("nom")
@classmethod
def tozala(cls, v):
return v.strip() # qaytar
5. til: str | None = None # ixtiyoriyVazifa 3: Ro'yxatdan o'tish modeli
Registratsiya API:
Foydalanuvchimodeli: ism, email (validator), yosh (ge=0, le=150), parol (min_length=8)FoydalanuvchiJavob(parolsiz)- POST endpoint
response_modelbilan TestClientbilan to'g'ri va noto'g'ri test
Vazifa 4: Ichma-ich modellar
Buyurtma API:
Mahsulot(nom, narx),Manzil(shahar, ko'cha),Buyurtma(mahsulotlar ro'yxati, manzil)- Chuqur validatsiya
- Jami narxni hisoblaydigan validator yoki metod
- Test
Vazifa 5: Maxsus validatorlar
Turli validatorli model:
- Telefon raqami (
+998bilan boshlansin) - Parol (katta harf, raqam bo'lsin)
- Sana (kelajakda bo'lmasin)
- Har biri uchun test
Vazifa 6: To'liq CRUD modellari
Kurs uchun model to'plami:
KursYaratish(kirish),KursYangilash(barcha maydon ixtiyoriy),KursJavob(chiqish, id bilan)- Nima uchun uch xil model kerak
model_dump(exclude_unset=True)yangilashda- Test
Vazifa 7: O'ylash
Pydantic model bir vaqtda uch vazifani bajaradi: validatsiya (ma'lumot to'g'rimi), aylantirish (satr → son), va hujjat (sxema o'zi sxema). Bu "yagona haqiqat manbai" (single source of truth) tamoyili — ma'lumot shakli bir joyda e'lon qilinadi, hamma narsa undan kelib chiqadi. Bu tamoyilning afzalligi nima, va uni buzganda (masalan, validatsiya bir joyda, hujjat boshqa joyda) qanday muammolar kelib chiqadi?
Javob
Qisqa javob: "Yagona haqiqat manbai" — ma'lumotning shakli/qoidasi bir joyda e'lon qilinadi, va validatsiya, aylantirish, hujjat, tur belgilari — hammasi shu bir manbadan kelib chiqadi. Afzalligi: izchillik (hamma joy bir xil), saqlash osonligi (o'zgartirish bir joyda), xatosizlik (takror yo'q, farqlanish yo'q). Buzilsa (validatsiya kodda, hujjat qo'lda yozilgan) — ular farqlana boshlaydi: kod yosh <= 150 tekshiradi, hujjatda <= 200 yozilgan — foydalanuvchi chalkashadi, xato kelib chiqadi.
1. Pydantic uch vazifani birlashtiradi
| Vazifa | Qanday |
|---|---|
| Validatsiya | Field(ge=0), field_validator |
| Aylantirish | Tip belgisiga qarab (satr → int) |
| Hujjat | Model o'zi OpenAPI sxema |
2. Yagona haqiqat manbai afzalligi
| Afzallik | Tafsilot |
|---|---|
| Izchillik | Validatsiya = hujjat = kod |
| Saqlash | O'zgartirish bir joyda |
| Xatosiz | Takror yo'q |
| Ishonch | Hujjat har doim to'g'ri |
3. Buzilganda muammolar
| Buzilish | Muammo |
|---|---|
| Validatsiya kodda, hujjat qo'lda | Farqlanadi, chalkashlik |
| Kirish tekshiradi, DB tekshirmaydi | Nomuvofiq ma'lumot |
| Tur bir joyda, tekshiruv boshqada | Sinxrondan chiqadi |
4. Boshqa joyda yagona manba
| Soha | Yagona manba |
|---|---|
| Ma'lumot shakli | Pydantic model |
| Ma'lumotlar bazasi | Migratsiya/sxema |
| Konfiguratsiya | Bitta config fayl |
| Tiplar | TypeScript/mypy |
5. Muhandislik saboqlari
- Ma'lumot shaklini bir joyda e'lon qil
- Validatsiya, hujjat, tur — bir manbadan
- Takror — farqlanishning manbai
- Pydantic = yagona haqiqat manbai (model)
6. Xulosa
- Pydantic model — validatsiya + aylantirish + hujjat
- Yagona manba — izchillik, saqlash, xatosizlik
- Buzilsa — farqlanisha, chalkashlik
- Bir joyda e'lon qil, hammasi undan kelib chiqsin
Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.
Xulosa
Bu darsda Pydantic modellarini — ma'lumot shaklini e'lon qilish, validatsiya va seriyalizatsiyani o'rgandik.
Eng muhim uch fikr:
Pydantic model — ma'lumot sxemasi.
BaseModeldan meros olgan klass maydonlarni tip belgilari bilan e'lon qiladi (nom: str,narx: float = Field(ge=0)). Model yaratilganda Pydantic darrov tekshiradi va aylantiradi: to'g'ri ma'lumot — obyekt, noto'g'ri —ValidationError. FastAPI'da modelni parametr qilsa, u so'rov tanasi (JSON body) bo'ladi — FastAPI JSON'ni o'qiydi, tekshiradi, xato bo'lsa422, aks holda tayyor validatsiyalangan obyekt beradi.Validatsiya va javob modeli.
Fieldmaydon cheklovlarini beradi (min_length,ge,le),field_validatormurakkab qoida (email formati, murakkab shart) uchun. Ichma-ich modellar chuqur JSON'ni tekshiradi.response_modeljavobni filtrlaydi va hujjatlaydi — kirish (KursYaratish, parol bilan) va chiqish (KursJavob, parolsiz) modellarini ajratish maxfiy ma'lumotni himoya qiladi.Seriyalizatsiya va yagona manba. Pydantic v2 metodlari:
model_dump(dict),model_dump_json(JSON satr),model_validate(dict/JSON'dan model). Model bir vaqtda validatsiya + aylantirish + hujjat ni birlashtiradi — bu "yagona haqiqat manbai": ma'lumot shakli bir joyda e'lon qilinib, validatsiya, tur va hujjat undan kelib chiqadi. Bu izchillik, saqlash osonligi va xatosizlikni ta'minlaydi.
Keyingi darsda so'rov va javob ni chuqurroq o'rganamiz: status kodlar, sarlavhalar (headers), cookie, javob turlari va so'rov ma'lumotini to'liq boshqarish.
Izohlar · 0
Izoh yozish uchun kiring.