Pydantic高级特性 - 元素码农

发布时间: 2025-03-29 16:14

↑

# Pydantic高级特性

## 自定义验证器

### 1. 字段验证器
```python
from pydantic import BaseModel, validator, Field

class Product(BaseModel):
    name: str = Field(..., min_length=1)
    price: float = Field(..., gt=0)
    quantity: int = Field(..., ge=0)
    
    @validator('name')
    def name_must_be_valid(cls, v):
        if v.strip() == '':
            raise ValueError('名称不能为空白')
        return v.strip()
    
    @validator('price')
    def price_must_be_reasonable(cls, v):
        if v > 1000000:
            raise ValueError('价格不能超过100万')
        return round(v, 2)
```

### 2. 依赖验证器
```python
from pydantic import BaseModel, validator
from typing import List

class Order(BaseModel):
    items: List[str]
    total: float
    discount: float = 0.0
    final_price: float
    
    @validator('discount')
    def discount_must_be_valid(cls, v):
        if not 0 <= v <= 1:
            raise ValueError('折扣必须在0到1之间')
        return v
    
    @validator('final_price', always=True)
    def calculate_final_price(cls, v, values):
        if 'total' not in values or 'discount' not in values:
            raise ValueError('需要total和discount来计算final_price')
        return values['total'] * (1 - values['discount'])
```

## 复杂类型处理

### 1. 自定义类型
```python
from pydantic import BaseModel, constr
from datetime import datetime
from typing import NewType, List

# 自定义类型
PhoneNumber = NewType('PhoneNumber', str)
PositiveInt = NewType('PositiveInt', int)

class Contact(BaseModel):
    name: constr(min_length=2, max_length=50)
    phone: PhoneNumber
    age: PositiveInt
    tags: List[str] = []
    
    @validator('phone')
    def validate_phone(cls, v):
        if not v.startswith('+') or not v[1:].isdigit():
            raise ValueError('无效的电话号码格式')
        return v
```

### 2. 泛型模型
```python
from typing import TypeVar, Generic, List
from pydantic import BaseModel, Field
from pydantic.generics import GenericModel

T = TypeVar('T')

class Response(GenericModel, Generic[T]):
    code: int = Field(200, description='状态码')
    message: str = '成功'
    data: T

class User(BaseModel):
    id: int
    name: str

# 使用泛型模型
user_response = Response[User](data=User(id=1, name='张三'))
list_response = Response[List[User]](data=[User(id=1, name='张三')])
```

## 序列化与反序列化

### 1. 自定义序列化
```python
from pydantic import BaseModel
from datetime import datetime
from typing import Any

class Event(BaseModel):
    id: int
    title: str
    timestamp: datetime
    
    class Config:
        json_encoders = {
            datetime: lambda v: v.strftime('%Y-%m-%d %H:%M:%S')
        }
    
    def json(self, **kwargs):
        # 自定义JSON序列化
        json_data = super().json(**kwargs)
        return json_data
```

### 2. 模型导出配置
```python
from pydantic import BaseModel
from typing import Optional

class UserProfile(BaseModel):
    id: int
    username: str
    email: str
    _password: str
    internal_id: str
    
    class Config:
        # 字段别名
        fields = {
            'internal_id': 'user_id'
        }
        # 排除私有字段
        exclude = {'_password'}
        # 允许从ORM对象创建
        orm_mode = True
```

## 高级配置选项

### 1. 模型配置
```python
from pydantic import BaseModel, Field
from typing import Optional

class AdvancedConfig(BaseModel):
    name: str
    value: Optional[str] = None
    
    class Config:
        # 允许填充额外字段
        extra = 'allow'
        # 验证所有赋值
        validate_assignment = True
        # 允许种群变异
        validate_all = True
        # 使用枚举值
        use_enum_values = True
        # 允许自定义验证器修改值
        validate_default = True
```

### 2. 动态模型生成
```python
from pydantic import create_model, Field

def create_dynamic_model(fields):
    # 动态创建模型
    field_definitions = {
        name: (type_, Field(...)) 
        for name, type_ in fields.items()
    }
    return create_model('DynamicModel', **field_definitions)

# 使用示例
fields = {
    'name': str,
    'age': int,
    'is_active': bool
}
DynamicUser = create_dynamic_model(fields)
```

## 最佳实践

### 1. 性能优化
```python
from pydantic import BaseModel, validator
from typing import Dict, Any

class OptimizedModel(BaseModel):
    # 使用__slots__优化内存使用
    __slots__ = ['__dict__', '__fields_set__']
    
    data: Dict[str, Any]
    
    class Config:
        # 禁用额外验证以提高性能
        extra = 'ignore'
        # 验证默认值
        validate_default = False
```

### 2. 错误处理
```python
from pydantic import BaseModel, ValidationError
from typing import List, Optional

class ErrorHandler(BaseModel):
    name: str
    items: List[str]
    metadata: Optional[dict] = None
    
    @classmethod
    def safe_parse(cls, data: dict):
        try:
            return cls(**data)
        except ValidationError as e:
            # 自定义错误处理
            errors = e.errors()
            return {
                'success': False,
                'errors': [{
                    'field': error['loc'][0],
                    'message': error['msg']
                } for error in errors]
            }
```

### 3. 集成测试
```python
from pydantic import BaseModel
import pytest

class TestModel(BaseModel):
    name: str
    age: int

def test_model_validation():
    # 正确的数据
    valid_data = {'name': '张三', 'age': 25}
    model = TestModel(**valid_data)
    assert model.name == '张三'
    assert model.age == 25
    
    # 错误的数据
    with pytest.raises(ValidationError):
        TestModel(name='李四', age='invalid')
```