Python kursi20.5-dars: Pydantic modellari
Python kursi · Web backend FastAPI

20.5-dars: Pydantic modellari

17 daqiqa5/16-dars

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)
  • Field bilan validatsiya
  • Maxsus validatorlar (field_validator va model_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 TestClient bilan sinaladi.


2. Nazariya — chuqur tushuntirish

2.1. Pydantic model nima

Pydantic model — ma'lumot shaklini tip belgilari bilan e'lon qiluvchi klass:

python
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

python
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:

python
@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:

python
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:

python
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:

python
class Muallif(BaseModel):
    ism: str
    email: str

class Kurs(BaseModel):
    nom: str
    muallif: Muallif           # ichma-ich model
    teglar: list[str] = []     # ro'yxat

Ichma-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:

python
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:

python
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:

python
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
python
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

python
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 kurs

Metodlar

model_dump()          → dict
model_dump_json()     → JSON satr
model_validate(d)     → dict'dan model
model_validate_json(s)→ JSON satr'dan model

4. Batafsil misollar

Misollarda Pydantic va FastAPI TestClient bilan sinaladi.

Misol 1 — Model asoslari va validatsiya

python
"""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:

text
=== 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 aylantiradi

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

Misol 2 — So'rov tanasi (request body) FastAPI'da

python
"""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:

text
=== 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, 422

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

Misol 3 — Validatorlar va ichma-ich modellar

python
"""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:

text
=== 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 validatsiya

Nima 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.

python
"""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:

text
=== 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 hujjatlaydi

Nima 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

python
data = await request.json()
if "nom" not in data: ...              # ❌ qo'lda
def yarat(kurs: Kurs): ...             # ✅ model

2. Eski dict() metodi

python
kurs.dict()                            # ❌ v1
kurs.model_dump()                      # ✅ v2

3. Kirish va chiqish bir model

python
class Kurs(BaseModel):
    parol: str                         # ❌ javobda ko'rinadi
# ✅ KursYaratish (parol) + KursJavob (parolsiz)

4. Validatorda return unutish

python
@field_validator("nom")
def tozala(cls, v):
    v.strip()                          # ❌ qaytarmadi
    return v.strip()                   # ✅

5. response_modelsiz maxfiy ma'lumot

python
@app.post("/kurslar")                  # ⚠️ butun obyekt qaytadi
@app.post("/kurslar", response_model=KursJavob)   # ✅

6. Majburiy maydonga = None bermaslik

python
til: str | None                        # ❌ majburiy (None berish shart)
til: str | None = None                 # ✅ ixtiyoriy

7. Model ichida mutable standart

python
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

  1. So'rov tanasi uchun Pydantic model — qo'lda tekshirmang.

  2. Field bilan validatsiya (ge, min_length), field_validator murakkab qoida uchun.

  3. Kirish va chiqish modellarini ajrating (parol javobda ko'rinmasin).

  4. response_model bilan javobni filtrlang va hujjatlang.

  5. v2 metodlarini ishlating: model_dump, model_validate.

  6. Ichma-ich modellar bilan murakkab JSON'ni tuzilishlang.

  7. Validatorda qiymatni return qiling.

  8. Ixtiyoriy maydonga standart bering (= None).


9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
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
  1. Pydantic asosiy klass (model)
  2. So'rov tanasidan (JSON body)
  3. Son >= 0 validatsiya
  4. 422
  5. dict (model → dict)
  6. Field yeta olmagan murakkab qoidada
  7. Javobni filtrlaydi va hujjatlaydi
  8. 120.0 (float'ga aylanadi)
  9. Ha (chuqur validatsiya)
  10. Maxfiy maydon (parol) javobda ko'rinmasligi uchun
  11. model_dump()
  12. Ha (= None berilmagan — majburiy)

Vazifa 2: Xatolarni tuzating

python
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 qoldi
Javoblar
python
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              # ixtiyoriy

Vazifa 3: Ro'yxatdan o'tish modeli

Registratsiya API:

  1. Foydalanuvchi modeli: ism, email (validator), yosh (ge=0, le=150), parol (min_length=8)
  2. FoydalanuvchiJavob (parolsiz)
  3. POST endpoint response_model bilan
  4. TestClient bilan to'g'ri va noto'g'ri test

Vazifa 4: Ichma-ich modellar

Buyurtma API:

  1. Mahsulot (nom, narx), Manzil (shahar, ko'cha), Buyurtma (mahsulotlar ro'yxati, manzil)
  2. Chuqur validatsiya
  3. Jami narxni hisoblaydigan validator yoki metod
  4. Test

Vazifa 5: Maxsus validatorlar

Turli validatorli model:

  1. Telefon raqami (+998 bilan boshlansin)
  2. Parol (katta harf, raqam bo'lsin)
  3. Sana (kelajakda bo'lmasin)
  4. Har biri uchun test

Vazifa 6: To'liq CRUD modellari

Kurs uchun model to'plami:

  1. KursYaratish (kirish), KursYangilash (barcha maydon ixtiyoriy), KursJavob (chiqish, id bilan)
  2. Nima uchun uch xil model kerak
  3. model_dump(exclude_unset=True) yangilashda
  4. 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

  1. Ma'lumot shaklini bir joyda e'lon qil
  2. Validatsiya, hujjat, tur — bir manbadan
  3. Takror — farqlanishning manbai
  4. Pydantic = yagona haqiqat manbai (model)

6. Xulosa

  1. Pydantic model — validatsiya + aylantirish + hujjat
  2. Yagona manba — izchillik, saqlash, xatosizlik
  3. Buzilsa — farqlanisha, chalkashlik
  4. 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:

  1. 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'lsa 422, aks holda tayyor validatsiyalangan obyekt beradi.

  2. Validatsiya va javob modeli. Field maydon cheklovlarini beradi (min_length, ge, le), field_validator murakkab qoida (email formati, murakkab shart) uchun. Ichma-ich modellar chuqur JSON'ni tekshiradi. response_model javobni filtrlaydi va hujjatlaydi — kirish (KursYaratish, parol bilan) va chiqish (KursJavob, parolsiz) modellarini ajratish maxfiy ma'lumotni himoya qiladi.

  3. 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.

Web backend FastAPI · 5-dars yakunlandi

20.5-dars: Pydantic modellari

17 daqvaqt
0belgi
Keyingi dars: 20.6-dars: So'rov va javob
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0