Pydantic: Hướng dẫn với các ví dụ thực tế

Pydantic là gì?

Bạn gần như đang chơi trò may rủi với dữ liệu khi xây dựng ứng dụng tương tác với thế giới bên ngoài. Người dùng có thể gửi số điện thoại dưới dạng chuỗi thay vì số nguyên, một API có thể trả về giá trị null nơi bạn mong đợi là số, hoặc một tệp cấu hình có lỗi chính tả làm ứng dụng đổ vỡ lúc 3 giờ sáng.

Các cách tiếp cận Python truyền thống cho vấn đề này nhanh chóng trở nên cồng kềnh. Bạn kết thúc bằng việc viết mã xác thực như sau:

def create_user(data):
   # Cơn ác mộng xác thực thủ công
   if not isinstance(data.get('age'), int):
       raise ValueError("Age must be an integer")
   if data['age'] < 0 or data['age'] > 150:
       raise ValueError("Age must be between 0 and 150")
   if not isinstance(data.get('email'), str) or '@' not in data['email']:
       raise ValueError("Invalid email format")
   if not isinstance(data.get('is_active'), bool):
       raise ValueError("is_active must be a boolean")
  
   # Cuối cùng mới tạo user...
   return User(data['age'], data['email'], data['is_active'])Được hỗ trợ bởi

Nhân lên cho mọi cấu trúc dữ liệu trong ứng dụng, bạn sẽ dành nhiều thời gian viết mã xác thực hơn là xử lý logic nghiệp vụ.

Pydantic giải quyết điều này bằng cách kết hợp ba khái niệm mạnh mẽ: gợi ý kiểu, xác thực khi chạy và tuần tự hóa tự động. Thay vì kiểm tra thủ công, bạn định nghĩa cấu trúc dữ liệu một lần bằng cú pháp chú thích kiểu của Python, và Pydantic tự động xử lý toàn bộ phần xác thực:

from pydantic import BaseModel, EmailStr
from typing import Optional

class User(BaseModel):
   age: int
   email: EmailStr
   is_active: bool = True
   nickname: Optional[str] = None

# Pydantic tự động xác thực và chuyển đổi dữ liệu
user_data = {
   "age": "25",  # Chuỗi được chuyển thành int
   "email": "[email protected]",
   "is_active": "true"  # Chuỗi được chuyển thành bool
}

user = User(**user_data)
print(user.age)  # 25 (kiểu int)
print(user.model_dump())  # Kết quả dict sạchĐược hỗ trợ bởi

Các tính năng của Pydantic

Cách tiếp cận của Pydantic mang lại nhiều lợi ích. Hiệu năng là ưu điểm đầu tiên bạn sẽ nhận thấy — lõi xác thực của Pydantic được viết bằng Rust, giúp nó nhanh hơn so với mã xác thực viết tay bằng Python trong hầu hết trường hợp. Ứng dụng của bạn có thể xử lý hàng nghìn yêu cầu mà phần xác thực không trở thành nút thắt cổ chai.

Pydantic cũng dễ dàng tích hợp với các framework hiện đại. FastAPI, một trong những framework web phát triển nhanh nhất của Python, dùng các model Pydantic để tự động tạo tài liệu API, xác thực body yêu cầu và tuần tự hóa phản hồi. Khi bạn định nghĩa một model Pydantic, bạn có ngay tính năng sinh schema OpenAPI miễn phí:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class UserCreate(BaseModel):
   name: str
   email: EmailStr
   age: int

@app.post("/users/")
async def create_user(user: UserCreate):
   # FastAPI tự động xác thực request body
   # và tạo tài liệu API từ model Pydantic của bạn
   return {"message": f"Created user {user.name}"}Được hỗ trợ bởi

Việc sinh JSON schema diễn ra tự động với mọi model Pydantic. Điều này có nghĩa là cấu trúc dữ liệu của bạn tự ghi tài liệu, và bạn có thể tạo thư viện client, quy tắc xác thực cho ứng dụng frontend hoặc schema cơ sở dữ liệu từ cùng một nguồn sự thật.

Pydantic vs. Dataclasses vs. Marshmallow

Vậy khi nào nên chọn Pydantic thay vì các lựa chọn khác? Nếu bạn đang so sánh Pydantic với dataclasses, quyết định phụ thuộc vào nhu cầu xác thực. @dataclass của Python hoàn hảo cho các bộ chứa dữ liệu đơn giản nơi bạn tin tưởng đầu vào, còn Pydantic vượt trội khi bạn cần xác thực, tuần tự hóa và tích hợp với framework web:

from dataclasses import dataclass
from pydantic import BaseModel

# Dataclass: nhanh, đơn giản, không xác thực
@dataclass
class UserDataclass:
   name: str
   age: int

# Pydantic: xác thực, tuần tự hóa, tích hợp framework
class UserPydantic(BaseModel):
   name: str
   age: intĐược hỗ trợ bởi

Khi so sánh Pydantic với Marshmallow, cách tiếp cận gợi ý kiểu của Pydantic tự nhiên hơn với lập trình viên Python, trong khi Marshmallow dùng các lớp schema. Pydantic cũng mang lại hiệu năng tốt hơn và tích hợp dễ dàng hơn với các framework async hiện đại.

Pydantic hoạt động tốt nhất khi bạn xây dựng API, xử lý dữ liệu bên ngoài, quản lý cấu hình, hoặc bất kỳ tình huống nào mà lỗi xác thực dữ liệu cần được phát hiện sớm thay vì gây ra lỗi khó hiểu sau này. Nó chuyển các lỗi khi chạy thành thông báo xác thực rõ ràng, có thể hành động, giúp cả nhà phát triển và người dùng hiểu điều gì đã sai.

Bắt đầu với Pydantic

Hãy đi vào cách sử dụng Pydantic trong dự án của bạn, từ cài đặt đến tạo model dữ liệu đầu tiên.

Cài đặt và thiết lập

Thiết lập Pydantic khá đơn giản, nhưng một vài lỗi phổ biến có thể làm khó người mới. Tôi sẽ hướng dẫn bạn quy trình cài đặt đúng và giúp bạn tránh những sai lầm gây tốn công gỡ lỗi.

Đầu tiên, tạo môi trường ảo để cô lập phụ thuộc của dự án. Điều này ngăn xung đột phiên bản có thể gây lỗi import khó hiểu về sau:

# Tạo và kích hoạt môi trường ảo (dùng cho zsh và bash)
python -m venv pydantic_env
source pydantic_env/bin/activate  # Trên macOS/Linux
# pydantic_env\Scripts\activate  # Trên WindowsĐược hỗ trợ bởi

Giờ hãy cài đặt Pydantic với lệnh sau:

pip install pydanticĐược hỗ trợ bởi

Để có chức năng xác thực email, thứ bạn rất có thể cần trong ứng dụng thực tế (và trong hướng dẫn này), hãy cài đặt gói mở rộng email:

pip install "pydantic[email]"Được hỗ trợ bởi

Dấu ngoặc kép quanh pydantic[email] rất quan trọng trong hầu hết terminal. Nếu thiếu, bạn có thể gặp lỗi "no matches found".

Lưu ý: Nếu bạn gặp ModuleNotFoundError: No module named 'pydantic', hãy kiểm tra các vấn đề sau:

1. Sai môi trường Python: Đảm bảo môi trường ảo đã được kích hoạt
2. Nhiều phiên bản Python: Xác nhận bạn đang dùng đúng phiên bản Python đã cài Pydantic
3. Cấu hình IDE: Trình soạn thảo có thể đang dùng trình thông dịch Python khác

Cảnh báo đặt tên quan trọng: Không bao giờ đặt tên tệp Python của bạn là pydantic.py. Điều này tạo ra vòng lặp import làm hỏng mã với thông báo lỗi khó hiểu. Python sẽ cố import tệp của bạn thay vì thư viện Pydantic thực sự.

Model Pydantic đầu tiên của bạn

Hãy xây dựng một model người dùng đơn giản để thấy Pydantic hoạt động thế nào. Thay vì bắt đầu bằng ví dụ trừu tượng, ta sẽ giải quyết một vấn đề thực: xác thực dữ liệu đăng ký người dùng từ biểu mẫu web.

from pydantic import BaseModel, EmailStr
from typing import Optional
from datetime import datetime

class User(BaseModel):
   name: str
   email: EmailStr
   age: int
   is_active: bool = True
   created_at: datetime = None

# Test với dữ liệu sạch
clean_data = {
   "name": "Alice Johnson",
   "email": "[email protected]",
   "age": 28
}

user = User(**clean_data)
print(f"User created: {user.name}, Age: {user.age}")
print(f"Model output: {user.model_dump()}")Được hỗ trợ bởi

Kết quả:

User created: Alice Johnson, Age: 28
Model output: {'name': 'Alice Johnson', 'email': '[email protected]', 'age': 28, 'is_active': True, 'created_at': None}Được hỗ trợ bởi

Hãy phân tích những gì đang diễn ra trong định nghĩa model này:

• Tạo model Pydantic: Lớp User của bạn kế thừa từ BaseModel, mang lại toàn bộ khả năng xác thực và tuần tự hóa của Pydantic. Kế thừa này biến một lớp Python thông thường thành công cụ xác thực dữ liệu.
• Định nghĩa trường: Mỗi dòng trong lớp định nghĩa một trường với kiểu mong đợi. Cú pháp name: str cho Pydantic biết name phải là chuỗi, age: int nghĩa là tuổi phải là số nguyên, v.v.
• Giải thích EmailStr: EmailStr là kiểu đặc biệt của Pydantic tự động xác thực địa chỉ email. Nó đến từ gói pydantic[email] bạn đã cài và dùng biểu thức chính quy để đảm bảo định dạng email hợp lệ. Nếu ai đó truyền "not-an-email", Pydantic sẽ ném lỗi xác thực.
• Giá trị mặc định: Các trường như is_active: bool = True có giá trị mặc định. Nếu bạn không cung cấp khi tạo user, Pydantic sẽ dùng mặc định. = None với created_at khiến trường này tùy chọn.
• Khởi tạo model: Khi bạn gọi User(**clean_data), toán tử ** bung từ điển và truyền từng cặp khóa-giá trị dưới dạng đối số từ khóa cho hàm tạo model.

Giờ hãy xem tính năng chuyển đổi kiểu tự động của Pydantic hoạt động ra sao:

# Dữ liệu lộn xộn nhưng vẫn hoạt động
messy_data = {
   "name": "Bob Smith",
   "email": "[email protected]",
   "age": "35",  # Chuỗi thay vì int
   "is_active": "true"  # Chuỗi thay vì bool
}

user = User(**messy_data)
print(f"Age type: {type(user.age)}")  # <class 'int'>
print(f"Is active type: {type(user.is_active)}")  # <class 'bool'>Được hỗ trợ bởi

Giờ hãy xem tính năng chuyển đổi kiểu tự động của Pydantic hoạt động ra sao:

# Dữ liệu lộn xộn nhưng vẫn hoạt động
messy_data = {
   "name": "Bob Smith",
   "email": "[email protected]",
   "age": "35",  # Chuỗi thay vì int
   "is_active": "true"  # Chuỗi thay vì bool
}

user = User(**messy_data)
print(f"Age type: {type(user.age)}")  # <class 'int'>
print(f"Is active type: {type(user.is_active)}")  # <class 'bool'>Được hỗ trợ bởi

Kết quả:

Age type: <class 'int'>

Is active type: <class 'bool'>Được hỗ trợ bởi

Như bạn thấy, các trường age và is_inactive được tự động chuyển về định dạng đúng thông qua xác thực.

Khi xác thực thất bại, Pydantic cung cấp thông báo lỗi rõ ràng:

from pydantic import ValidationError

try:
   invalid_user = User(
       name="",  # Chuỗi rỗng
       email="not-an-email",  # Email không hợp lệ
       age=-5  # Tuổi âm
   )
except ValidationError as e:
   print(e)Được hỗ trợ bởi

Kết quả:

   # Chỉ ra chính xác trường nào sai và vì sao
1 validation error for User
email
 value is not a valid email address: An email address must have an @-sign. [type=value_error, input_value='not-an-email', input_type=str]Được hỗ trợ bởi

BaseModel vs. data classes

Hiểu khi nào dùng BaseModel của Pydantic so với @dataclass của Python sẽ giúp bạn chọn đúng công cụ cho từng tình huống.

Dataclass của Python phù hợp cho các bộ chứa dữ liệu đơn giản nơi bạn kiểm soát đầu vào:

from dataclasses import dataclass

@dataclass
class ProductDataclass:
   name: str
   price: float
   in_stock: bool

# Nhanh, đơn giản, nhưng không xác thực
product = ProductDataclass("Laptop", 999.99, True)

# Dòng này cũng chạy, dù kiểu sai:
broken_product = ProductDataclass(123, "expensive", "maybe")Được hỗ trợ bởi

Model Pydantic bổ sung xác thực, tuần tự hóa và tích hợp với framework:

from pydantic import BaseModel, Field

class ProductPydantic(BaseModel):
   name: str = Field(min_length=1)
   price: float = Field(gt=0)  # Phải lớn hơn 0
   in_stock: bool

# Xác thực tự động ngăn dữ liệu xấu
try:
   product = ProductPydantic(name="", price=-10, in_stock="maybe")
except ValidationError as e:
   print("Validation caught the errors!")

# Dữ liệu hợp lệ chạy mượt
good_product = ProductPydantic(
   name="Laptop",
   price="999.99",  # Chuỗi chuyển thành float
   in_stock=True
)Được hỗ trợ bởi

Khi nào chọn mỗi cách:

• Dùng dataclasses cho cấu trúc dữ liệu nội bộ, đối tượng cấu hình, hoặc khi hiệu năng là tối quan trọng và bạn tin tưởng nguồn dữ liệu
• Dùng Pydantic cho endpoint API, đầu vào người dùng, phân tích dữ liệu bên ngoài hoặc khi bạn cần tuần tự hóa JSON

Pydantic có thêm một chút chi phí so với dataclasses, nhưng chi phí này thường không đáng kể so với số lỗi nó ngăn chặn và thời gian phát triển nó tiết kiệm. Với ứng dụng web, tích hợp tự động với các framework như FastAPI khiến Pydantic là lựa chọn rõ ràng.

Các tính năng xác thực và tuần tự hóa càng trở nên giá trị khi ứng dụng của bạn lớn dần. Bắt đầu với các model Pydantic giúp bạn có nền tảng vững chắc có thể mở rộng theo nhu cầu.

Xây dựng mô hình dữ liệu với Pydantic

Giờ bạn đã nắm cơ bản, hãy giải quyết những thách thức khi xây dựng ứng dụng sẵn sàng cho môi trường sản xuất.

Xác thực trường và ràng buộc

Xem xét một API danh mục sản phẩm nơi dữ liệu giá đến từ nhiều nhà cung cấp với tiêu chuẩn định dạng khác nhau. Có nơi gửi giá dưới dạng chuỗi, nơi khác là số thực, và đôi khi ai đó gửi giá âm làm sập hệ thống thanh toán của bạn.

Hàm Field() của Pydantic biến gợi ý kiểu cơ bản thành các quy tắc xác thực tinh vi bảo vệ ứng dụng của bạn:

from pydantic import BaseModel, Field
from decimal import Decimal
from typing import Optional

class Product(BaseModel):
   name: str = Field(min_length=1, max_length=100)
   price: Decimal = Field(gt=0, le=10000)  # Lớn hơn 0, nhỏ hơn hoặc bằng 10.000
   description: Optional[str] = Field(None, max_length=500)
   category: str = Field(..., pattern=r'^[A-Za-z\s]+$')  # Chỉ chữ và khoảng trắng
   stock_quantity: int = Field(ge=0)  # Lớn hơn hoặc bằng 0
   is_available: bool = True

# Cái này hoạt động - mọi ràng buộc đều thỏa
valid_product = Product(
   name="Wireless Headphones",
   price="199.99",  # Chuỗi chuyển thành Decimal
   description="High-quality wireless headphones",
   category="Electronics",
   stock_quantity=50
)

# Cái này thất bại với thông báo lỗi rõ ràng
try:
   invalid_product = Product(
       name="",  # Quá ngắn
       price=-50,  # Giá âm
       category="Electronics123",  # Chứa số
       stock_quantity=-5  # Tồn kho âm
   )
except ValidationError as e:
   print(f"Validation errors: {len(e.errors())} issues found")Được hỗ trợ bởi

Mỗi tham số của Field() có mục đích riêng: min_length và max_length ngăn vi phạm schema cơ sở dữ liệu, gt và le tạo ranh giới logic nghiệp vụ, và pattern xác thực dữ liệu định dạng bằng regex. Cú pháp Field(...) với dấu ba chấm đánh dấu trường bắt buộc, còn Field(None, ...) tạo trường tùy chọn nhưng vẫn có quy tắc xác thực.

Ép kiểu so với xác thực nghiêm ngặt

Theo mặc định, Pydantic sẽ chuyển đổi các kiểu tương thích thay vì từ chối ngay. Sự linh hoạt này phù hợp với đầu vào người dùng, nhưng một số bối cảnh đòi hỏi khớp kiểu chính xác:

from pydantic import BaseModel, Field, ValidationError

# Mặc định: ép kiểu linh hoạt
class FlexibleOrder(BaseModel):
   order_id: int
   total_amount: float
   is_paid: bool

# Các trường hợp này đều hoạt động nhờ chuyển đổi tự động
flexible_order = FlexibleOrder(
   order_id="12345",  # Chuỗi sang int
   total_amount="99.99",  # Chuỗi sang float
   is_paid="true"  # Chuỗi sang bool
)

# Xác thực nghiêm ngặt khi cần độ chính xác
class StrictOrder(BaseModel):
   model_config = {"str_strip_whitespace": True, "validate_assignment": True}
  
   order_id: int = Field(strict=True)
   total_amount: float = Field(strict=True)
   is_paid: bool = Field(strict=True)Được hỗ trợ bởi

Từ điển model_config điều khiển hành vi xác thực trên toàn bộ model. Tùy chọn str_strip_whitespace tự động làm sạch khoảng trắng ở đầu/cuối chuỗi, còn validate_assignment đảm bảo các thay đổi trường sau khi tạo model vẫn kích hoạt xác thực. Các trường riêng lẻ có thể ghi đè cài đặt này bằng Field(strict=True) cho các tình huống cần khớp kiểu tuyệt đối, như tính toán tài chính hoặc dữ liệu khoa học.

Model lồng nhau và dữ liệu phức tạp

Ứng dụng thực tế xử lý các cấu trúc dữ liệu phức tạp, liên kết với nhau. Một đơn hàng thương mại điện tử chứa thông tin khách hàng, địa chỉ giao hàng và nhiều mặt hàng sản phẩm ,  mỗi cái đều cần xác thực riêng:

from typing import List
from datetime import datetime

class Address(BaseModel):
   street: str = Field(min_length=5)
   city: str = Field(min_length=2)
   postal_code: str = Field(pattern=r'^\d{5}(-\d{4})?$')
   country: str = "USA"

class Customer(BaseModel):
   name: str = Field(min_length=1)
   email: EmailStr
   shipping_address: Address
   billing_address: Optional[Address] = None

class OrderItem(BaseModel):
   product_id: int = Field(gt=0)
   quantity: int = Field(gt=0, le=100)
   unit_price: Decimal = Field(gt=0)

class Order(BaseModel):
   order_id: str = Field(pattern=r'^ORD-\d{6}$')
   customer: Customer
   items: List[OrderItem] = Field(min_items=1)
   order_date: datetime = Field(default_factory=datetime.now)

# Xác thực dữ liệu lồng nhau phức tạp
order_data = {
   "order_id": "ORD-123456",
   "customer": {
       "name": "John Doe",
       "email": "[email protected]",
       "shipping_address": {
           "street": "123 Main Street",
           "city": "Anytown",
           "postal_code": "12345"
       }
   },
   "items": [
       {"product_id": 1, "quantity": 2, "unit_price": "29.99"},
       {"product_id": 2, "quantity": 1, "unit_price": "149.99"}
   ]
}

order = Order(**order_data)
print(f"Order validated with {len(order.items)} items")Được hỗ trợ bởi

Pydantic xác thực đệ quy các cấu trúc lồng nhau — trường Customer trở thành một đối tượng Customer hoàn chỉnh, và đối tượng này tự xác thực trường Address của nó. Cú pháp List[OrderItem] xác thực từng phần tử danh sách như một OrderItem, trong khi Field(min_items=1) ngăn các đơn hàng trống lọt vào hệ thống kho. Việc dùng default_factory=datetime.now tạo timestamp riêng cho mỗi thể hiện đơn hàng.

Trường tùy chọn và xử lý None

Các thao tác khác nhau cần yêu cầu dữ liệu khác nhau. Tạo người dùng đòi hỏi thông tin đầy đủ, còn cập nhật thì nên chấp nhận thay đổi một phần:

from typing import Optional

class UserCreate(BaseModel):
   name: str = Field(min_length=1)
   email: EmailStr
   age: int = Field(ge=13, le=120)
   phone: Optional[str] = Field(None, pattern=r'^\+?1?\d{9,15}$')

class UserUpdate(BaseModel):
   name: Optional[str] = Field(None, min_length=1)
   email: Optional[EmailStr] = None
   age: Optional[int] = Field(None, ge=13, le=120)
   phone: Optional[str] = Field(None, pattern=r'^\+?1?\d{9,15}$')

# Yêu cầu PATCH với dữ liệu một phần
update_data = {"name": "Jane Smith", "age": 30}
user_update = UserUpdate(**update_data)

# Chỉ tuần tự hóa các trường được cung cấp
patch_data = user_update.model_dump(exclude_none=True)
print(f"Fields to update: {list(patch_data.keys())}")Được hỗ trợ bởi

Tuần tự hóa chuyển đối tượng Pydantic trở lại thành từ điển hoặc chuỗi JSON để lưu trữ hoặc truyền tải. Phương thức model_dump() xử lý việc chuyển đổi này, với exclude_none=True loại bỏ các trường không được cung cấp. Mẫu này rất phù hợp cho yêu cầu PATCH, nơi client chỉ gửi các trường muốn thay đổi, tránh ghi đè dữ liệu ngoài ý muốn trong cơ sở dữ liệu.

Nền tảng này chuẩn bị cho thử thách tiếp theo: triển khai logic xác thực tùy chỉnh phản ánh các quy tắc nghiệp vụ đặc thù của ứng dụng.

Xác thực tùy chỉnh và tích hợp thực tế

Xây dựng ứng dụng sản xuất đồng nghĩa với việc xử lý dữ liệu không khớp với các mẫu kiểm tra kiểu tiêu chuẩn.

Hãy xét biểu mẫu đăng ký người dùng nơi yêu cầu mật khẩu thay đổi theo gói thuê bao, hoặc một API nhận dữ liệu địa chỉ từ nhiều quốc gia với định dạng mã bưu điện khác nhau. Những tình huống này cần logic xác thực tùy chỉnh phản ánh quy tắc nghiệp vụ cụ thể của bạn, đồng thời tích hợp trơn tru với framework web và hệ thống cấu hình.

Phần này sẽ chỉ cho bạn cách triển khai các mẫu xác thực tùy chỉnh thực tiễn, tích hợp model Pydantic với FastAPI để tự động tạo tài liệu API, và quản lý cài đặt ứng dụng thông qua biến môi trường bằng tệp .env — cách mà hầu hết ứng dụng sản xuất dựa vào.

Field validator và xác thực cấp model

Khi logic nghiệp vụ quyết định tính hợp lệ của dữ liệu, decorator @field_validator của Pydantic biến các hàm xác thực của bạn thành một phần của chính model. Hãy xét hệ thống đăng ký nơi các bậc thuê bao khác nhau có yêu cầu mật khẩu khác nhau:

from pydantic import BaseModel, field_validator, Field
import re

class UserRegistration(BaseModel):
   username: str = Field(min_length=3)
   email: EmailStr
   password: str
   subscription_tier: str = Field(pattern=r'^(free|pro|enterprise)$')
  
   @field_validator('password')
   @classmethod
   def validate_password_complexity(cls, password, info):
       tier = info.data.get('subscription_tier', 'free')
      
       if len(password) < 8:
           raise ValueError('Password must be at least 8 characters')
          
       if tier == 'enterprise' and not re.search(r'[A-Z]', password):
           raise ValueError('Enterprise accounts require uppercase letters')
          
       return passwordĐược hỗ trợ bởi

Decorator @field_validator cho phép bạn truy cập giá trị các trường khác qua tham số info.data, cho phép thiết lập quy tắc xác thực phụ thuộc nhiều trường. Validator chạy sau khi kiểm tra kiểu cơ bản, nên bạn có thể an tâm giả định subscription_tier thuộc một trong các giá trị cho phép.

Với xác thực bao trùm nhiều trường, decorator @model_validator chạy sau khi tất cả trường riêng lẻ đã được xác thực:

from datetime import datetime
from pydantic import model_validator

class EventRegistration(BaseModel):
   start_date: datetime
   end_date: datetime
   max_attendees: int = Field(gt=0)
   current_attendees: int = Field(ge=0)
  
   @model_validator(mode='after')
   def validate_event_constraints(self):
       if self.end_date <= self.start_date:
           raise ValueError('Event end date must be after start date')
          
       if self.current_attendees > self.max_attendees:
           raise ValueError('Current attendees cannot exceed maximum')
          
       return selfĐược hỗ trợ bởi

Tham số mode='after' đảm bảo validator nhận một thể hiện model đã được tạo đầy đủ, rất phù hợp cho logic nghiệp vụ cần truy cập tất cả trường đã xác thực. Validator phải trả về self để biểu thị xác thực thành công.

Tích hợp FastAPI

Sự tích hợp của FastAPI với Pydantic tạo ra xác thực yêu cầu và tài liệu API tự động. Mẫu chính là tạo các model riêng cho từng thao tác, giúp bạn kiểm soát dữ liệu chảy theo mỗi hướng:

from fastapi import FastAPI
from typing import Optional
from datetime import datetime

app = FastAPI()

class UserCreate(BaseModel):
   username: str = Field(min_length=3)
   email: EmailStr
   password: str = Field(min_length=8)

class UserResponse(BaseModel):
   id: int
   username: str
   email: EmailStr
   created_at: datetime
  
@app.post("/users/", response_model=UserResponse)
async def create_user(user: UserCreate):
   # FastAPI tự động xác thực request body
   new_user = {
       "id": 1,
       "username": user.username,
       "email": user.email,
       "created_at": datetime.now()
   }
   return UserResponse(**new_user)Được hỗ trợ bởi

Sự tách biệt giữa model đầu vào và đầu ra mang lại nhiều lợi ích. Model đầu vào có thể bao gồm quy tắc xác thực và các trường bắt buộc, trong khi model đầu ra kiểm soát chính xác dữ liệu nào được gửi tới client. FastAPI tự động sinh tài liệu OpenAPI từ các model Pydantic của bạn, tạo ra tài liệu API tương tác để nhà phát triển thử nghiệm endpoint.

Với thao tác cập nhật, bạn có thể tạo model mà mọi trường đều tùy chọn:

class UserUpdate(BaseModel):
   username: Optional[str] = Field(None, min_length=3)
   email: Optional[EmailStr] = None

@app.patch("/users/{user_id}")
async def update_user(user_id: int, user_update: UserUpdate):
   # Chỉ cập nhật các trường được cung cấp
   update_data = user_update.model_dump(exclude_unset=True)
   # Logic cập nhật cơ sở dữ liệu của bạn tại đây
   return {"message": f"Updated user {user_id}"}Được hỗ trợ bởi

Tham số exclude_unset=True trong các thao tác PATCH đảm bảo bạn chỉ cập nhật trường được cung cấp rõ ràng, tránh ghi đè ngoài ý muốn. Mẫu này rất phù hợp cho REST API nơi client gửi cập nhật một phần.

Quản lý cấu hình với biến môi trường

Ứng dụng sản xuất cần quản lý cấu hình an toàn, thân thiện triển khai. BaseSettings của Pydantic kết hợp với tệp .env cung cấp cấu hình an toàn kiểu (type-safe) hoạt động xuyên suốt môi trường phát triển, staging và sản xuất.

Trước tiên, tạo tệp .env trong thư mục gốc dự án:

# .env file
DATABASE_URL=postgresql://user:password@localhost:5432/myapp
SECRET_KEY=your-secret-key-here
DEBUG=false
ALLOWED_HOSTS=localhost,127.0.0.1,yourdomain.comĐược hỗ trợ bởi

Sau đó định nghĩa model cài đặt của bạn:

from pydantic import BaseSettings, Field
from typing import List

class AppSettings(BaseSettings):
   database_url: str = Field(description="Database connection URL")
   secret_key: str = Field(description="Secret key for JWT tokens")
   debug: bool = Field(default=False)
   allowed_hosts: List[str] = Field(default=["localhost"])
  
   class Config:
       env_file = ".env"
       case_sensitive = False

# Load settings automatically from environment and .env file
settings = AppSettings()Được hỗ trợ bởi

Lớp BaseSettings tự động đọc từ biến môi trường, tệp .env và đối số dòng lệnh. Biến môi trường được ưu tiên hơn giá trị trong tệp .env, giúp dễ dàng ghi đè cài đặt theo từng môi trường triển khai. Cài đặt case_sensitive = False cho phép đặt tên biến môi trường linh hoạt.

Với ứng dụng phức tạp, bạn có thể tổ chức cài đặt thành các nhóm logic:

class DatabaseSettings(BaseSettings):
   url: str = Field(env="DATABASE_URL")
   max_connections: int = Field(default=5, env="DB_MAX_CONNECTIONS")

class AppSettings(BaseSettings):
   secret_key: str
   debug: bool = False
   database: DatabaseSettings = DatabaseSettings()
  
   class Config:
       env_file = ".env"

settings = AppSettings()
# Truy cập cấu hình lồng nhau
db_url = settings.database.urlĐược hỗ trợ bởi

Cách tiếp cận lồng nhau này giữ các cài đặt liên quan ở cùng nhau đồng thời duy trì ranh giới rõ ràng giữa các thành phần ứng dụng khác nhau. Mỗi nhóm cài đặt có thể có tiền tố biến môi trường và quy tắc xác thực riêng.

Cách dùng tệp .env hoạt động với các nền tảng triển khai như Heroku, AWS và Docker, nơi biến môi trường là tiêu chuẩn cấu hình ứng dụng. Ứng dụng của bạn có tính an toàn kiểu và xác thực trong khi vẫn tuân theo các mẫu cấu hình cloud-native mà đội vận hành mong đợi.

Những mẫu này tạo nền tảng để xây dựng ứng dụng dễ bảo trì, xử lý được độ phức tạp thực tế. Hệ thống xác thực của Pydantic thích ứng với yêu cầu cụ thể của bạn, đồng thời cung cấp thông báo lỗi rõ ràng và tài liệu tự động giúp cả đội hiểu các cấu trúc dữ liệu mà ứng dụng mong đợi.

Kết luận

Giờ bạn đã thấy Pydantic có thể giúp bạn tránh công việc tẻ nhạt là tự viết mã xác thực như thế nào. Thay vì làm rối hàm với các kiểm tra isinstance() và xử lý lỗi thủ công, bạn định nghĩa cấu trúc dữ liệu một lần và để Pydantic lo phần còn lại.

Hãy đọc phần Câu hỏi thường gặp (FAQs) bên dưới cho các thắc mắc cụ thể về Pydantic. Với tài liệu toàn diện và các mẫu nâng cao, đây là vài tài nguyên bạn có thể dùng:

• Tài liệu chính thức:
• Tài liệu Pydantic — Tham chiếu đầy đủ kèm ví dụ và thực hành tốt
• Hướng dẫn nâng cấp Pydantic — Đọc bắt buộc khi nâng cấp giữa các phiên bản
• Tài liệu FastAPI — Tìm hiểu cách Pydantic hỗ trợ tạo tài liệu API tự động
• Tài nguyên học tập từ DataCamp:
• Model Validation in Python — Đào sâu kỹ thuật xác thực với scikit-learn
• Introduction to FastAPI — Xây dựng API sản xuất với tích hợp Pydantic
• Introduction to APIs in Python — Làm việc với API bên ngoài và xác thực dữ liệu JSON
• Intermediate Python — Nắm vững nền tảng Python bổ trợ cho việc dùng Pydantic
• Object-Oriented Programming in Python — Xây nền tảng để hiểu model Pydantic