პითონის Pydantic ბიბლიოთეკა მონაცემთა ვალიდაციისთვის

შესავალი 🌟

როდესაც თქვენი Python აპლიკაცია გარედან იღებს მონაცემებს (API მოთხოვნიდან, JSON ფაილიდან, webhook-იდან, AI მოდელისგან...), არ უნდა ჩათვალოთ, რომ ეს მონაცემები ყოველთვის სწორია. სწორედ მონაცემების ვალიდაციის ხელსაწყოა Pydantic-ი, რომლის გამოყენებასაც ამ სტატიაში ისწავლით.

Pydantic Python-ის ეკოსისტემაში

Pydantic ყველგანაა:

• FastAPI იყენებს Pydantic-ს მოთხოვნის/პასუხის ვალიდაციისთვის.
• Django Ninja იყენებს Pydantic-ს API სქემებისთვის.
• SQLModel აერთიანებს Pydantic-ს SQLAlchemy-სთან.
• თანამედროვე Python ფრეიმვორკების უმეტესობა კულისებში (under the hood) ეყრდნობა Pydantic-ს.

Pydantic-ის სწავლა ნიშნავს სანდო, ტიპების მიმართ უსაფრთხო (type-safe) Python კოდის წერას.

გსურთ Python-ის პროფესიონალურ დონეზე შესწავლა? 🚀

Type Hints და Pydantic მხოლოდ მცირე ნაწილია იმ უზარმაზარი შესაძლებლობებისა, რასაც Python გვთავაზობს. თუ გსურთ, რომ დაწეროთ სუფთა, უსაფრთხო კოდი, შექმნათ მასშტაბური ვებ-აპლიკაციები ან დაეუფლოთ ხელოვნურ ინტელექტს, ScaleUp Academy დაგეხმარებათ:

• 👉 Python & AI ინჟინერიის კურსი — ისწავლეთ პითონი და AI ინჟინერია ნულიდან. შექმენით ვებ-საიტები, AI აგენტები, ჩატბოტები და RAG სისტემები.
• 👉 მონაცემთა ანალიტიკის კურსი — თუ გიყვართ რიცხვები და ლამაზი გრაფიკები; და გსურთ დაეხმაროთ ბიზნესებს მონაცემებზე დაყრდნობილი გადაწყვეტილებების მიღებაში, ეს კურსი იდეალური სტარტია.

გადადგით პირველი ნაბიჯი ტექნოლოგიურ კარიერაში დღესვე! შეარჩიეთ თქვენთვის საინტერესო კურსი ScaleUp.ge-ზე.

პრობლემა Python-თან დაკავშირებით ⚠️

Python დინამიურად ტიპიზირებულია. ეს ნიშნავს, რომ შეგიძლიათ გააკეთოთ შემდეგი:

username = "alex"
username = 42
username = {"name": "alex"}

არანაირი შეცდომა. Python-ს ეს არ ადარდებს; და ეს მოქნილობა შესანიშნავია სწრაფი სკრიპტებისთვის. მაგრამ ის ნამდვილ კოშმარად შეიძლება იქცეს, როდესაც რეალურ აპლიკაციებს ქმნით, განსაკუთრებით კი გარე მონაცემებთან მუშაობისას.

როდესაც საქმე ცუდად მიდის 💥

წარმოიდგინეთ, რომ ქმნით API-ს, რომელიც იღებს პროდუქტის მონაცემებს:

def create_product(data):
    product_id = data["id"]
    name = data["name"]
    price = data["price"]

    # მოგვიანებით თქვენს კოდში...
    total = price * 10  # რა მოხდება, თუ ფასი არის "expensive"?

თქვენი API გარე სამყაროდან იღებს JSON-ს. თქვენ ელოდებით:

{"id": 15, "name": "Keyboard", "price": 89.99}

მაგრამ API გიგზავნით:

{"id": 15, "name": null, "price": "expensive"}

თქვენი კოდი წყვეტს მუშაობას (crashes).

რეალური სამყაროს გავლენა 🌍

ნებისმიერ აპლიკაციაში, თქვენ მუდმივად მუშაობთ შემდეგთან:

• API-ის პასუხები - გარე სერვისები აბრუნებენ იმას, რაც სურთ.
• მომხმარებლის მიერ შეყვანილი მონაცემები - არასოდეს ენდოთ მომხმარებლის მონაცემებს.
• კონფიგურაცია - გარემოს ცვლადები ყოველთვის ტექსტურია.
• მონაცემთა ბაზის ჩანაწერები - მონაცემები შეიძლება აკლდეს ან არასწორი ფორმატის იყოს.

ვალიდაციის გარეშე, ხარვეზები ფროდაქშენამდე იმალება. Pydantic-ის დახმარებით, ისინი მყისიერად ვლინდება.

რას აკეთებს Pydantic 🛠️

Pydantic ახდენს მონაცემების ვალიდაციას გაშვების დროში. თქვენ განსაზღვრავთ, როგორ უნდა გამოიყურებოდეს თქვენი მონაცემები, და Pydantic უზრუნველყოფს მათ შესაბამისობას:

from pydantic import BaseModel

class Product(BaseModel):
    id: int
    name: str
    price: float

# ვალიდური მონაცემები - კარგად მუშაობს
product = Product(
    id=15,
    name="Keyboard",
    price=89.99,
)

# არავალიდური მონაცემები - მყისიერად ჩერდება ნათელი შეცდომით
product = Product(
    id=15,
    name=None,
    price="expensive",
)

როდესაც ვალიდაცია ვერ სრულდება, იღებთ შეცდომის ნათელ შეტყობინებას, რომელიც ზუსტად გეტყვით, რა მოხდა არასწორად:

2 validation errors for Product
name
  Input should be a valid string
price
  Input should be a valid number

პრობლემა დაჭერილია საწყისშივე.

ინსტალაცია 💻

დააინსტალირეთ Pydantic თქვენს პროექტში pip-ის ან uv-ის გამოყენებით:

pip install pydantic

ან:

uv add pydantic

რატომ უნდა ისწავლოთ Pydantic 💡

Python-ის საფუძვლების შემდეგ, Pydantic არის ერთ-ერთი ყველაზე მნიშვნელოვანი ბიბლიოთეკა, რომელიც უნდა ისწავლოთ. განსაკუთრებით აგენტური კოდირების (agentic coding) ეპოქაში.

• უფრო სანდო აპლიკაციები: მკაცრი Pydantic მოდელები იჭერენ ხარვეზებს, სანამ ისინი ფროდაქშენამდე მიაღწევენ. თქვენ განსაზღვრავთ, როგორ გამოიყურება ვალიდური მონაცემები, და Pydantic უზრუნველყოფს მის შესრულებას გაშვების დროში.
• AI აგენტებს უკეთ ესმით თქვენი კოდი: როდესაც განსაზღვრავთ Pydantic-ის ნათელ მოდელებს, AI კოდირების ასისტენტებს შეუძლიათ გაიგონ თქვენი მონაცემთა სტრუქტურები. მოდელები მოქმედებენ როგორც დამცავი ბარიერები (guardrails), რომლებიც მიმართულებას აძლევენ როგორც ადამიანებს, ასევე AI-ს.
• აუცილებელია აგენტური სისტემებისთვის: ქმნით AI აგენტებს, რომლებიც იძახებენ ხელსაწყოებს (tools), ამუშავებენ მონაცემებს ან ურთიერთქმედებენ API-ებთან? თქვენ გჭირდებათ სტრუქტურირებული შედეგი (structured output). Pydantic მოდელები განსაზღვრავენ, თუ რა უნდა დააბრუნოს AI-მ, რაც აგენტის პასუხებს ხდის პროგნოზირებადს და ტიპების მიმართ უსაფრთხოს.
• მას ყველგან შეხვდებით: თუ გაინტერესებთ Python-ის გამოყენება AI-სთვის, მუდმივად წააწყდებით Pydantic-ს. FastAPI, LangChain, OpenAI SDKs და AI ფრეიმვორკების უმეტესობა კულისებში Pydantic-ს იყენებს.

გაიგეთ მეტი 📖

• Pydantic-ის ოფიციალური დოკუმენტაცია
• Pydantic GitHub-ზე

ტიპების მითითებები (Type Hints) 🏷️

საძირკველი, რომელზეც Pydantic არის აშენებული.

რა არის ტიპების მითითებები?

ტიპების მითითებები ეუბნება Python-ს (და სხვა დეველოპერებს), თუ რა ტიპის მონაცემებს უნდა შეიცავდეს ცვლადი:

product_name: str = "Keyboard"
quantity: int = 5
price: float = 49.99
in_stock: bool = True

აქ : str, : int, : float და : bool არის ტიპების მითითებები.

Python მათ არ აკონტროლებს ⚠️

აი, მთავარი რამ: გაშვების დროში (runtime) Python აიგნორებს ტიპების მითითებებს. ისინი მხოლოდ დოკუმენტაციაა:

quantity: int = "five"  # Python ამის საშუალებას იძლევა

არანაირი შეცდომა. Python ამ კოდს პრეტენზიების გარეშე უშვებს. მაშინ რატომ უნდა გამოვიყენოთ ისინი?

ტიპების მითითებების უპირატესობები 💡

ტიპების მითითებები გაძლევთ სამ მთავარ უპირატესობას:

• დოკუმენტაცია - კოდი თავისთავად გასაგები ხდება.
• IDE-ის მხარდაჭერა - ავტო-შევსება (Autocomplete), შეცდომების აღმოჩენა, რეფაქტორინგი.
• ვალიდაციის ინსტრუმენტები - Pydantic, mypy და სხვები იყენებენ მათ.

ტიპების მითითებების გარეშე:

def create_product(name, price, quantity):
    # რა ტიპის უნდა იყოს ესენი?
    pass

ტიპების მითითებებით:

def create_product(name: str, price: float, quantity: int) -> dict:
    # ყველაფერი ნათელია
    pass

საბაზისო ტიპები 🧱

ოთხი ტიპი, რომლებსაც მუდმივად გამოიყენებთ:

# სტრიქონები (Strings) - ტექსტი
title: str = "Python Course"
description: str = "Learn Python from scratch"

# მთელი რიცხვები (Integers)
quantity: int = 10
student_id: int = 2048

# ათწილადები (Floats)
price: float = 149.99
discount: float = 15.5

# ლოგიკური ტიპები (Booleans) - true ან false
is_published: bool = True
has_discount: bool = False

კონტეინერის ტიპები 📦

მონაცემთა კოლექციებისთვის, თქვენ უთითებთ, თუ რა არის მათ შიგნით:

# სტრიქონების სია
categories: list[str] = ["Python", "Django", "AI"]

# მთელი რიცხვების სია
scores: list[int] = [85, 92, 78, 96]

# ლექსიკონი ტექსტური გასაღებებით (keys) და მთელი რიცხვითი მნიშვნელობებით (values)
inventory: dict[str, int] = {
    "keyboard": 12,
    "mouse": 25,
}

# ლექსიკონი ტექსტური გასაღებებით და ტექსტური მნიშვნელობებით
profile: dict[str, str] = {
    "name": "Nika",
    "country": "Georgia",
}

Python 3.9+-დან გამოიყენეთ პატარა ასოებით დაწერილი ჩაშენებული ტიპები (list, dict, set, tuple). ძველი კოდი იყენებს დიდი ასოებით დაწერილ იმპორტებს typing მოდულიდან (List, Dict). ისინი ეკვივალენტურია, მაგრამ ახლა პატარა ასოებით ჩაწერაა რეკომენდებული.

არასავალდებულო (Optional) მნიშვნელობები ❓

ხანდახან მნიშვნელობა შეიძლება არ არსებობდეს. გამოიყენეთ Optional ან | სინტაქსი:

from typing import Optional

# ეს ორი ერთი და იგივეს ნიშნავს
description: Optional[str] = None
description: str | None = None

გამოიყენეთ Optional, როდესაც მნიშვნელობა შეიძლება იყოს None:

# პროდუქტს შეიძლება არ ჰქონდეს აღწერა
description: str | None = None
description: str | None = "Wireless mechanical keyboard"

# ფასდაკლების კოდი არასავალდებულოა
discount_code: str | None = None
discount_code: str | None = "SAVE20"

ლიტერალური ტიპები (Literal types) 🎯

როდესაც მნიშვნელობა კონკრეტული ვარიანტებიდან ერთ-ერთი უნდა იყოს:

from typing import Literal

plan: Literal["free", "basic", "premium"] = "free"

# მხოლოდ ეს სამი მნიშვნელობაა ვალიდური
plan = "free"      # OK
plan = "premium"   # OK
plan = "enterprise"  # ტიპების შემმოწმებლები (Type checkers) ამაზე გაფრთხილებას გამოიტანენ

რეალური სამყაროს მაგალითი:

from typing import Literal

payment_status: Literal["pending", "paid", "failed"] = "pending"
user_role: Literal["student", "teacher", "admin"] = "student"
course_level: Literal["beginner", "intermediate", "advanced"] = "beginner"

ფუნქციის ტიპების მითითებები ⚙️

ტიპების მითითებები მუშაობს ფუნქციის პარამეტრებსა და დასაბრუნებელ მნიშვნელობებზე (return values):

def format_currency(amount: float, currency: str = "USD") -> str:
    return f"{currency} {amount:.2f}"

def calculate_average(scores: list[float]) -> float:
    return sum(scores) / len(scores)

def find_product(product_id: int) -> dict | None:
    # აბრუნებს პროდუქტს, თუ იპოვა, ან None-ს, თუ ვერ იპოვა
    pass

ფრჩხილების შემდეგ არსებული -> str მიუთითებს დასაბრუნებელი მნიშვნელობის ტიპზე.

ტიპების მითითებების გავრცელებული პატერნები 🧩

აი პატერნები, რომლებსაც მუდმივად შეხვდებით Python კოდში:

from typing import Optional, Literal

# სავალდებულო სტრიქონი
title: str

# არასავალდებულო სტრიქონი (შეიძლება იყოს None)
subtitle: str | None = None

# სტრიქონი ნაგულისხმევი მნიშვნელობით
language: str = "English"

# ელემენტების სია
courses: list[str] = []

# ლექსიკონი
attributes: dict[str, str] = {}

# კონკრეტული დაშვებული მნიშვნელობები
level: Literal["beginner", "intermediate", "advanced"] = "beginner"

ტიპების მითითებები არ ახდენს ვალიდაციას 🛑

დაიმახსოვრეთ: Python აიგნორებს ტიპების მითითებებს. ეს კოდი უშეცდომოდ ეშვება:

quantity: int = "five"
prices: list[float] = "not a list"

ტიპების მითითებები მხოლოდ მინიშნებებია. ისინი არაფერს ითხოვენ მკაცრად. სწორედ აქ შემოდის Pydantic. Pydantic კითხულობს თქვენი ტიპების მითითებებს და რეალურად ახდენს მონაცემების ვალიდაციას მათზე დაყრდნობით.

გაიგეთ მეტი 📖

• Python typing ოფიციალური დოკუმენტაცია
• Type hints ცნობარი (cheat sheet)

თქვენი პირველი მოდელი 🚀

შექმენით ვალიდირებული მონაცემთა სტრუქტურები BaseModel-ის გამოყენებით.

რა არის მოდელი?

Pydantic მოდელი არის კლასი, რომელიც განსაზღვრავს თქვენი მონაცემების სტრუქტურას. ის აკონკრეტებს, თუ რა ველები არსებობს და რა ტიპის უნდა იყოს ისინი:

from pydantic import BaseModel

class Product(BaseModel):
    name: str
    price: float
    quantity: int

ეს მოდელი ამბობს: "პროდუქტს (Product) აქვს სახელი (string), ფასი (float) და რაოდენობა (integer)."

Dataclass-ები Pydantic-ის წინააღმდეგ ⚔️

Python-ს აქვს ჩაშენებული dataclass-ები მონაცემთა სტრუქტურების განსასაზღვრად:

from dataclasses import dataclass

@dataclass
class Product:
    name: str
    price: float
    quantity: int

product = Product(
    name="Keyboard",
    price=99.99,
    quantity="many",
)

print(product.quantity)  # "many" - არანაირი ვალიდაცია!

@dataclass დეკორატორი აგენერირებს __init__ მეთოდს თქვენი ტიპების მითითებებიდან. მის გარეშე მიიღებთ შეცდომას TypeError: Product() takes no arguments, რადგან ჩვეულებრივი კლასი ანოტაციებით არ იღებს კონსტრუქტორის არგუმენტებს.

Dataclass-ები გაძლევთ სუფთა სინტაქსს მონაცემთა კონტეინერებისთვის, მაგრამ ისინი არ აკეთებენ ვალიდაციას. ტიპების მითითებები მხოლოდ დოკუმენტაციაა.

Pydantic მოდელები მსგავსად გამოიყურება, მაგრამ რეალურად აიძულებენ ტიპების დაცვას:

from pydantic import BaseModel

class Product(BaseModel):
    name: str
    price: float
    quantity: int

product = Product(
    name="Keyboard",
    price=99.99,
    quantity="many",
)
# ValidationError: Input should be a valid integer

პროექტების უმეტესობისთვის, უბრალოდ გამოიყენეთ Pydantic. თქვენ იღებთ ვალიდაციას, სერიალიზაციას და JSON Schema-ს გენერაციას მინიმალური დანახარჯებით. Pydantic v2 იმდენად სწრაფია, რომ წარმადობაში (performance) სხვაობას იშვიათად აქვს მნიშვნელობა.

ეგზემპლარების (instances) შექმნა 🏗️

შექმენით მოდელის ეგზემპლარი მისთვის მონაცემების გადაწოდებით:

from pydantic import BaseModel

class Product(BaseModel):
    name: str
    price: float
    quantity: int

# პროდუქტის შექმნა
product = Product(
    name="Mechanical Keyboard",
    price=129.99,
    quantity=5,
)

print(product.name)      # Mechanical Keyboard
print(product.price)     # 129.99
print(product.quantity)  # 5

Pydantic ამოწმებს მონაცემებს ეგზემპლარის შექმნისას. არავალიდური მონაცემები მყისიერად იწვევს შეცდომას.

ვალიდაცია მოქმედებაში 🛑

სცადეთ არავალიდური მონაცემების გადაცემა:

from pydantic import BaseModel

class Product(BaseModel):
    name: str
    price: float
    quantity: int

# ეს გამოიწვევს ვალიდაციის შეცდომას
product = Product(
    name="Mechanical Keyboard",
    price=129.99,
    quantity="five",
)

მიიღებთ ნათელ შეცდომას:

ValidationError: 1 validation error for Product
quantity
  Input should be a valid integer, unable to parse string as an integer

შეცდომა ზუსტად გეუბნებათ, თუ რა და სად წავიდა არასწორად.

ტიპების ავტომატური გარდაქმნა (coercion) 🔄

Pydantic ჭკვიანურად უდგება ტიპების კონვერტაციას. ის ავტომატურად გარდაქმნის თავსებად ტიპებს:

from pydantic import BaseModel

class Product(BaseModel):
    name: str
    price: float

# სტრიქონი "49.99" ხდება float 49.99
product = Product(
    name="USB Microphone",
    price="49.99",
)

print(product.price)        # 49.99
print(type(product.price))  # <class 'float'>

ეს სასარგებლოა ფორმის მონაცემებთან ან API პასუხებთან მუშაობისას, სადაც რიცხვები ტექსტის სახით მოდის.

სავალდებულო და არასავალდებულო ველები 📌

ველები ნაგულისხმევი მნიშვნელობების გარეშე სავალდებულოა:

from pydantic import BaseModel

class Product(BaseModel):
    name: str                # სავალდებულო
    price: float             # სავალდებულო
    description: str | None = None  # არასავალდებულო

# მუშაობს - აღწერა არასავალდებულოა
product = Product(
    name="Webcam",
    price=79.99,
)

print(product.description)  # None

# ასევე მუშაობს - მიწოდებულია აღწერა
product = Product(
    name="Webcam",
    price=79.99,
    description="Full HD webcam",
)

print(product.description)  # Full HD webcam

ნაგულისხმევი მნიშვნელობები ⚙️

დააყენეთ ნაგულისხმევი მნიშვნელობები იმ ველებისთვის, რომლებსაც, როგორც წესი, აქვთ საერთო მნიშვნელობა:

from pydantic import BaseModel

class ServerConfig(BaseModel):
    host: str
    port: int = 8000
    debug: bool = False
    workers: int = 4

# სავალდებულოა მხოლოდ host
config = ServerConfig(host="localhost")

print(config.port)     # 8000
print(config.debug)    # False
print(config.workers)  # 4

ლექსიკონად (dictionary) გარდაქმნა 📖

გამოიყენეთ model_dump(), რათა მოდელი ლექსიკონად გარდაქმნათ:

from pydantic import BaseModel

class Product(BaseModel):
    name: str
    price: float
    quantity: int

product = Product(
    name="Monitor",
    price=299.99,
    quantity=2,
)

# ლექსიკონად გარდაქმნა
product_dict = product.model_dump()

print(product_dict)
# {'name': 'Monitor', 'price': 299.99, 'quantity': 2}

ეს სასარგებლოა, როდესაც გჭირდებათ მონაცემების გაგზავნა API-სთვის, მონაცემთა ბაზაში შენახვა ან JSON-ად სერიალიზაცია.

JSON-ად გარდაქმნა 🌐

გამოიყენეთ model_dump_json() JSON სტრიქონის მისაღებად:

from pydantic import BaseModel

class Product(BaseModel):
    name: str
    price: float
    quantity: int

product = Product(
    name="Monitor",
    price=299.99,
    quantity=2,
)

# JSON სტრიქონად გარდაქმნა
json_string = product.model_dump_json()

print(json_string)
# {"name":"Monitor","price":299.99,"quantity":2}

ლექსიკონიდან შექმნა 🧩

ლექსიკონიდან მოდელის შექმნის ორი გზა არსებობს:

from pydantic import BaseModel

class Product(BaseModel):
    name: str
    price: float
    quantity: int

# მონაცემები API პასუხიდან
data = {
    "name": "Monitor",
    "price": 299.99,
    "quantity": 2,
}

# ვარიანტი 1: ლექსიკონის ანფაქინგი (unpacking)
product = Product(**data)

# ვარიანტი 2: model_validate-ის გამოყენება (ცხადი, მეტი პარამეტრით)
product = Product.model_validate(data)

ორივე ახდენს მონაცემების ვალიდაციას. მარტივი შემთხვევებისთვის გამოიყენეთ **data. გამოიყენეთ model_validate(), როდესაც გჭირდებათ ისეთი პარამეტრები, როგორიცაა strict=True.

ეს არის პატერნი, რომელსაც ყველაზე ხშირად გამოიყენებთ: მონაცემების მიღება ლექსიკონის სახით (API-დან, მონაცემთა ბაზიდან ან ფაილიდან) და მისი ვალიდაცია მოდელში.

მოდელები როგორც ტიპების მითითებები 🎯

Pydantic მოდელები მუშაობენ როგორც ტიპების მითითებები თქვენს ფუნქციებში. ეს გაძლევთ IDE-ის ავტო-შევსებასა და ტიპების შემოწმებას:

from pydantic import BaseModel

class Product(BaseModel):
    name: str
    price: float

def show_product(product: Product) -> str:
    return f"{product.name}: ${product.price}"

def load_product(data: dict) -> Product:
    return Product.model_validate(data)

# IDE-მ იცის რომ 'product' არის Product, ავტო-შევსება მუშაობს
product = load_product({
    "name": "Headphones",
    "price": 79.99,
})

message = show_product(product)
print(message)  # Headphones: $79.99

ეს ხდის თქვენს კოდს თვით-დოკუმენტირებადს (self-documenting). როდესაც ხედავთ product: Product ფუნქციის სიგნატურაში, ზუსტად იცით, რა მონაცემები უნდა გადააწოდოთ მას.

რეალური სამყაროს მაგალითი 📊

აი, მოდელი API-ის პასუხების დასამუშავებლად:

from pydantic import BaseModel

class StockResponse(BaseModel):
    symbol: str
    company: str
    price: float
    change_percent: float

# API პასუხის სიმულაცია
api_data = {
    "symbol": "AAPL",
    "company": "Apple",
    "price": 228.45,
    "change_percent": 1.72,
}

# ვალიდაცია და პარსინგი
stock = StockResponse.model_validate(api_data)

print(f"{stock.company} ({stock.symbol})")
print(f"Price: ${stock.price}")
print(f"Change: {stock.change_percent}%")

გავრცელებული შეცდომები ⚠️

ტიპების მითითებების დავიწყება:

# არასწორია - არ არის ტიპების მითითებები
class Product(BaseModel):
    name
    price

# სწორია - ყოველთვის მიუთითეთ ტიპები
class Product(BaseModel):
    name: str
    price: float

ცვალებადი (Mutable) ნაგულისხმევი მნიშვნელობები:

ჩვეულებრივ Python კლასებში, = [] საშიშია, რადგან ყველა ეგზემპლარი იზიარებს ერთსა და იმავე სიას. Pydantic ამას სწორად უმკლავდება და თითოეული ეგზემპლარისთვის ქმნის ახალ სიას:

from pydantic import BaseModel

class User(BaseModel):
    tags: list[str] = []  # Pydantic-ში უსაფრთხოა - თითოეული ეგზემპლარი იღებს თავის სიას

user1 = User()
user2 = User()

user1.tags.append("django")

print(user2.tags)  # [] - არ იცვლება

ასევე შეგიძლიათ გამოიყენოთ Field(default_factory=list), თუ გირჩევნიათ იყოთ უფრო ცხადი, მაგრამ Pydantic-ში ეს სავალდებულო არ არის.

მკაცრი (Strict) რეჟიმი:

სტანდარტულად, Pydantic გარდაქმნის თავსებად ტიპებს, მაგალითად "25"-ს 25-ად. თუ გსურთ ამის გამორთვა და ზუსტი ტიპების მოთხოვნა, გამოიყენეთ მკაცრი რეჟიმი:

from pydantic import BaseModel, ConfigDict

class StrictProduct(BaseModel):
    model_config = ConfigDict(strict=True)
    name: str
    quantity: int

# ეს ვერ შესრულდება - გარდაქმნა დაშვებული არ არის
product = StrictProduct(
    name="Keyboard",
    quantity="5",
)
# ValidationError: Input should be a valid integer

model_config არის სპეციალური ატრიბუტის სახელი, რომელსაც Pydantic ეძებს. ConfigDict ინახავს მოდელის კონფიგურაციის პარამეტრებს. უმეტეს შემთხვევაში, default რეჟიმი არის ის, რაც გჭირდებათ.

გაიგეთ მეტი 📖

• Models დოკუმენტაცია (Pydantic)

შემდეგი ნაბიჯი: დაეუფლეთ Python-ს პროფესიონალურ დონეზე 🚀

Pydantic-ისა და Type Hints-ის გაგება საუკეთესო საფუძველია სუფთა და უსაფრთხო კოდის საწერად. თუმცა, თუ გსურთ ეს ცოდნა რეალურ, მასშტაბურ პროექტებში გამოიყენოთ, ScaleUp Academy-ის პრაქტიკული კურსები ზუსტად თქვენთვისაა შექმნილი:

• 👉 Python & AI ინჟინერიის სრული კურსი: ააგეთ რეალური ვებ-აპლიკაციები, დაეუფლეთ API-ების შექმნას Django-ს გამოყენებით. შექმენით AI აგენტები და ჩატბოტები.
• 👉 SQL-ის კურსი - მონაცემთა ბაზები: ისწავლეთ, როგორ შეინახოთ, დაამუშავოთ და მართოთ თქვენი აპლიკაციის მონაცემები ყველაზე მოთხოვნად ბაზებთან (PostgreSQL) მუშაობით.

გადადით ScaleUp.ge-ს მთავარ გვერდზე და შეარჩიეთ სასურველი კურსი!