pydantic 常见使用

字段类型基本规则：

1、定义了字段的类型，就必须要符合要求，否则报错，如果可以转换，则能转换成对应数据类型

class A(BaseModel):
    a: str

t = A(a=1)
print(t)

 

2、可以有默认值 如msg: str = '1234'

3、set类型可以传入列表，因为会转成set

4、比较特殊的数据类型: datetime,timedelta

       Any(传入任意值包括None)

      Union  允许模型属性接受不同的类型

　　

class User(BaseModel):
    id: Union[int, str, UUID]

print(User(id=1))
print(User(id='1'))
t = UUID('cf57432e-809e-4353-adbd-9d5c0d733868')
print(User(id=t))

      枚举

     

class FoolEnum(str,Enum):
    pear = 'pear'
    banana = 'banana'

class ToolEnum(IntEnum):
    spanner = 1
    wrench = 2

class User(BaseModel):
    fool: FoolEnum = FoolEnum.pear
    tool: ToolEnum = ToolEnum.spanner

print(User())
print(User(fool='banana',tool=2))

     bool

     Callable  可调用

class User(BaseModel):
    
    # 可调用字段仅执行参数是否可调用的简单检查；不执行参数、它们的类型或返回类型的验证
    callback: Callable[[int], int]

print(User(callback=lambda x:x))

  命名元组

class Foo(NamedTuple):
    x: int
    y: int

class User(BaseModel):
    just_subclasses: Foo


print(User(just_subclasses = Foo(x=1,y=2)))

类型化字典

# `total=False` means keys are non-required
class USerIdentity(TypedDict, total =False):
    name: str
    surname: str


class User(TypedDict):
    identity:USerIdentity
    age: int


class Model(BaseModel):
    u: User

    class Config:
        extra = Extra.forbid


print(Model(u={'identity':{'name':'jake','surname':'jone'},'age':18}))
print(Model(u={'identity':{},'age':18}))
print(Model(u={'identity':{'surname':'jone'},'age':18}))

   允许任意类型

class Pet:
    def __init__(self, name:str):
        self.name = name


class Model(BaseModel):
    u: Pet

    class Config:
        # arbitrary_types_allowed中的配置 来允许任意类型
        arbitrary_types_allowed = True


print(Model(u = Pet('123')))
print(Model(u = Pet('123')).u.name)

 

     Optional  可选

5、生成器的使用

def yield_demo():
    i = 0
    while True:
        yield i
        i += 1

class User(BaseModel):
    username: Iterable[int]

m = User(username=yield_demo())
for i in m.username:
    print(i)

 

6、类的嵌套(必须都继承了BaseModel)

class A(BaseModel):
    a: str

class B(BaseModel):
    b: str
    a: List[A]


a = {
    'b':1,
    'a':[A(a=1)]
}
t= B(**a)
print(t)

 

7、orm(必须有config类，且属性orm_mode=True)

调用方法 from_orm()

from  sqlalchemy import Column, Integer, String
from  sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class CompanyOrm(Base):

    __tablename__ = 'company'

    id = Column(Integer,primary_key=True,nullable=False)
    name = Column(String(64),nullable=False,unique=True)

class CompanPydantic(BaseModel):

    id: int
    name: constr(max_length=64) # 如果有限制，则可以使用constr

    class Config:
        orm_mode = True

co_orm = CompanyOrm(id=1,name='233')
t = CompanPydantic.from_orm(co_orm)
print(t)  # id=1 name='233'

 

 

 

 常用方法:

 实例.dict()

实例.json()  # dict 和json一样

schema()和schema.json() 都比json()输出更多的东西

class A(BaseModel):
    a: str

a = A(a=1)
print(a.schema())
print(a.schema_json())
'''

{'title': 'A', 'type': 'object', 'properties': {'a': {'title': 'A', 'type': 'string'}}, 'required': ['a']}
{"title": "A", "type": "object", "properties": {"a": {"title": "A", "type": "string"}}, "required": ["a"]}

'''

 

实例.copy()

类.parse_obj()

类.parse_raw()

类.parse_file(file)

class A(BaseModel):
    a: str

t = A.parse_obj({'a':1})
print(t)
print(A.parse_raw('{"a":1}'))
A.parse_file(file)

 

验证器:

1、验证某个字段符合的要求

class User(BaseModel):
    name:str

     @validator('name')
    def name_must_contains_s(cls,v):
        if 's' not in v:
            raise ValidationError('must contains s')
        return v.title()

 

2、验证列表，字典等迭代数据

class User(BaseModel):
       names: List[str]
      
      @validator('names',each_item=True)
    def each_str(cls,v):
        assert v !='123'
        return v

 

3、验证某个字段如果没有默认值，我就给你一个默认值

class User(BaseModel):
    id: int
    msg: datetime = None
   

    @validator('msg',pre=True,always=True)
    def default_msg(cls,v):
        return v or datetime.now()

 4、重复使用验证器

def normalize(name: str) -> str:
    return ' '.join((word.capitalize()) for word in name.split(' '))

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

    # validators
    _normalize_name = validator('name',allow_reuse=True)(normalize)

class Item(BaseModel):
    msg: str

    _normalize_name = validator('msg', allow_reuse=True)(normalize)

print(User(id=2,name='sss zz kk'))
print(Item(msg="kk ll oo pp"))

5、根验证器(验证所有数据)

class User(BaseModel):
    username: str
    password1: str
    password2: str

    @root_validator
    def check_all(cls,values):
        password1, password2 = values.get('password1'), values.get('password2')

        if password1 is not None and password2 is not None and password1 != password2:
            raise ValidationError('password does not match')

        return values

print(User(username='123',password1='234',password2='2345'))