Python 利用Pydantic模块提升开发效率

最新推荐文章于 2024-06-21 15:22:24 发布
最新推荐文章于 2024-06-21 15:22:24 发布
阅读量2.7k 收藏 31
点赞数 48
分类专栏： python 高阶编程 第三方库探索 文章标签： python 网络 服务器 fastapi 类型注解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54217348/article/details/136589020
版权

文章目录

Pydantic 核心概念

Pydantic 是一个数据验证和设置管理库，它的核心概念是数据模型（Model）和验证（Validation）；

数据模型是通过 Python 类型提示来定义的类，这些类在实例化时会自动使用Python类型注解进行数据验证；确保传入的数据类型符合预期，并且可以自动转换数据类型（比如从字符串到整数）。

Pydantic主要用于数据解析、数据校验以及设置管理（如环境变量的读取和验证）。

pydantic 核心功能

  1. 数据验证：Pydantic 可以确保输入数据符合预定义的模型要求。例如，如果定义了一个模型，其中某个字段是整数类型，并且必须大于零，Pydantic 会在接收到这个字段的数据时进行验证，确保数据满足这些条件。如果数据不满足要求，Pydantic 会引发一个错误。
  2. 数据转换：Pydantic 可以自动将输入数据转换为模型所需的数据类型。例如，如果模型中的一个字段被定义为整数类型，但用户输入了一个字符串形式的数字，Pydantic 会自动将这个字符串转换为整数。
  3. 数据序列化：Pydantic 可以将模型实例转换为字典、JSON 或其他格式的数据，这对于 API 开发、数据存储和传输等场景非常有用。
  4. 依赖注入：Pydantic 支持依赖注入，这意味着你可以在模型定义中指定某些字段的值依赖于其他字段的值。这在处理复杂的数据模型时非常有用。
  5. 类型提示：由于 Pydantic 基于 Python 的类型提示系统，因此它可以与 Python 的类型检查工具（如 mypy、typing）一起使用，以提高代码的可读性和可维护性。
  6. 错误处理：提供清晰、结构化的错误消息，帮助开发者快速定位和修复问题；
  7. 设置管理：从配置文件、环境变量等来源加载和验证设置；

BaseModel 模型

BaseModel 是 Pydantic 库中的一个核心类，用于定义数据模型。

通过继承 BaseModel，可以创建具有数据验证、类型检查、序列化和反序列化等功能的模型。

名称描述
dict()返回模型的字典表示
json()返回模型的JSON字符串表示
copy()返回模型的浅拷贝
parse_obj()类方法，用于将已有的字典转换为模型实例
parse_raw()类方法，用于将JSON或其他格式的字符串转换为模型实例
parse_file()类方法，用于将JSON或其他格式的文件内容转换为模型实例
from_orm()类方法，用于从兼容ORM对象创建模型实例。这允许Pydantic模型与ORM模型（如SQLAlchemy）无缝协作，通过将ORM模型实例传递给此方法来创建Pydantic模型实例。
schema()类方法，返回模型的JSON Schema表示
schema_json()类方法，返回模型的JSON Schema的JSON字符串表示
construct()类方法，用于创建模型实例，不执行验证
fields一个字典，包含模型的所有字段信息。这可以用于反射或程序化地检查模型定义的字段。
config一个内嵌的类，用于配置模型的行为，如是否允许任意字段、JSON序列化时的行为等。通过在模型定义中创建一个Config子类来自定义这些设置。

Field 类

Field 类是 Pydantic 中的一个辅助类，用于在定义模型字段时提供更细致的控制和额外的配置。

它允许开发者对字段的验证、转换、描述等行为进行更精确的定制。

用途

Field 类的主要用途是增强 Pydantic 模型字段的灵活性和可配置性。

通过 Field，你可以：

  • 指定字段的默认值
  • 定制字段的验证规则
  • 定义字段的描述信息
  • 控制字段的转换行为

参数和含义

Field 类接受多个参数，用于定义字段的不同属性。

以下是 Field 的一些主要参数及其含义：

  • alias: 字段的别名，用于在序列化和反序列化时映射不同的名称。
  • default: 字段的默认值。
  • description: 字段的描述信息，通常用于文档生成。
  • ge: 字段的最小值，用于数值类型，表示“大于等于”。
  • gt: 字段的最小值，用于数值类型，表示“大于”。
  • le: 字段的最大值，用于数值类型，表示“小于等于”。
  • lt: 字段的最大值，用于数值类型，表示“小于”。
  • max_length: 字段的最大长度，用于字符串和集合类型。
  • min_length: 字段的最小长度，用于字符串和集合类型。
  • multiple_of: 字段必须是该值的倍数，用于数值类型。
  • title: 字段的标题，通常用于文档生成。
  • max_items: 字段的最大项目数，用于列表和元组类型。
  • min_items: 字段的最小项目数，用于列表和元组类型。
  • exclude: 用于指定在序列化时排除该字段。
  • description_key: 在从字典创建模型实例时，用于查找描述信息的键。
  • allow_mutation: 允许在实例创建后修改该字段的值。

Config 类

pydantic 的 Config 类是用于配置 pydantic 模型行为的辅助类。

通过在模型内部定义 Config 类，你可以指定一系列的设置来影响模型的序列化、反序列化、验证等过程。

以下是一些 Config 类中常见的属性及其含义：

属性取值类型默认值含义
allow_mutationboolFalse如果设置为 True，则允许在模型实例化后修改其属性。这通常是不建议的
arbitrary_types_allowedboolFalse如果设置为 True，则允许在模型中使用任意类型（即不是 typing 模块中定义的类型）。这通常是不推荐的；
extrastrforbid控制如何处理模型中未定义的额外字段，forbid禁止额外的字段、allow允许额外的字段，但不会包括在序列化或反序列化中；merge允许额外的字段，并且在序列化或反序列化时会包括它们；
validate_assignmentboolTrue如果设置为 True，则当为模型属性赋值时进行验证。这通常用于确保模型的状态始终有效。
validate_allboolTrue如果设置为 True，则对模型中的所有字段进行验证，即使某些字段没有被明确设置。
json_encodersDict[Type, Callable]{}用于指定自定义的 JSON 解码器。键是字符串，表示 JSON 中的键名或类型标识，值是用于将这些值解码为 Python 对象的函数。
env_prefixstr‘’用于从环境变量中加载配置的前缀。例如，如果设置为 'APP_'，那么 APP_NAME 环境变量将被用于加载 name 字段的值
env_filestrNone指定一个环境变量文件的路径，该文件包含以点分隔的键值对，用于加载配置
env_file_encodingstr‘utf-8’指定环境变量文件的编码格式
alias_generatorCallable[[str], str]None用于生成字段的别名。这可以用于在序列化或反序列化时更改字段名。
use_enum_valuesboolTrue如果设置为 True，则使用枚举值进行序列化和反序列化，而不是枚举成员的名称
from_attributesboolFalse从类的属性中自动创建模型字段
orm_modeboolFalse指定是否启用ORM模式，用于与ORM库（如SQLAlchemy）集成

基础类型验证

UserModel 是一个基于 Pydantic 的数据模型，有两个字段：name（字符串类型）和 age（整数类型）；

当尝试用非整数类型的值（如字符串 “thirty”）初始化 age 字段时，Pydantic 会抛出 ValidationError。

from pydantic import BaseModel, ValidationError
from datetime import date


class StudentModel(BaseModel):
    sid: int    # 学生学号，必填字段（无默认值的时候为必填字段）
    name: str   # 学生姓名
    age: int    # 学生年龄
    gender: str = "男"   # 学生性别，有默认值，选填字段
    clz: str = "S95001"  # 学生所属班级
    city: str       # 学生所属城市
    phone: str      # 学生手机号码
    birthday: date  # 学生生日


# 创建一条符合StudentModel模型的学生数据
# sid字段定义为int类型，但允许传递可转为int的str类型数据，如"1001"
# sbirthday字段定义为date类型，但允许传递可以转为date的str类型数据，如"1999-11-20"
student_info1 = {
    "sid": 1001,
    "name": "张三",
    "age": 18,
    "city": "上海",
    "phone": "10086",
    "birthday": "1999-11-20",
}

student1 = StudentModel(**student_info1)
print(type(student1), student1)  # <class '__main__.StudentModel'> no=1001 name='张三' gender=True birthday=datetime.date(1999, 11, 20) clsz='S95001'

print(student1.sid)     # 1001
print(student1.name)    # 张三
print(student1.age)     # 18
print(student1.gender)  # 男
print(student1.clz)     # S95001
print(student1.city)    # 上海
print(student1.phone)   # 10086
print(student1.birthday)# 1999-11-20

print(student1.dict())  # {'sid': 1001, 'name': '张三', 'age': 18, 'gender': '男', 'clz': 'S95001', 'city': '上海', 'phone': '10086', 'birthday': datetime.date(1999, 11, 20)}
print(student1.json())  # {"sid":1001,"name":"张三","age":18,"gender":"男","clz":"S95001","city":"上海","phone":"10086","birthday":"1999-11-20"}

# 创建一条不符合StudentModel模型的学生数据
# age字段传递非int类型且无法转换为int的数据
student_info2 = {
    "sid": "1002",
    "name": "李四",
    "age": "thirty",
    "city": "北京",
    "phone": "10086",
    "birthday": "1998-07-21"
}
try:
    student2 = StudentModel(**student_info2)
except ValidationError as e:
    print(e.json())  # 异常信息支持转换为json格式

# 这里会抛出错误，因为 age 不是 int 类型，错误信息如下：
# [
#     {
#         "type": "int_parsing",
#         "loc": ["sage"],
#         "msg": "Input should be a valid integer, unable to parse string as an integer", "input": "thirty",
#         "url": "https://errors.pydantic.dev/2.6/v/int_parsing"
#     }
# ]

必填字段验证

from datetime import date
from typing import Optional
from pydantic import BaseModel, Field, ValidationError


class StudentModel(BaseModel):
    sid: int    # 学生学号，必填字段（无默认值的时候为必填字段）
    name: str   # 学生姓名
    age: int    # 学生年龄
    gender: str = "男"   # 学生性别，有默认值，选填字段
    clz: str = "S95001"  # 学生所属班级
    # 利用typing模块进行类型注解，仅是提示作用，没有强制，可以为None，但必须传递
    city: Optional[str]  # 学生所属城市
    # 利用Field辅助类进行类型注解和验证，默认为None，可以不传递
    phone: str = Field(None, description="手机号码")    # 学生手机号码
    birthday: date  # 学生生日


# 创建一条符合StudentModel模型的学生数据
student1 = StudentModel(
    sid=1001,
    name="张三",
    age=18,
    city="上海",
    phone="10086",
    birthday="1999-11-20"
)
print(type(student1), student1) # <class '__main__.StudentModel'> sid=1001 name='张三' age=18 gender='男' clz='S95001' city='上海' phone='10086' birthday=datetime.date(1999, 11, 20)


# 不传递phone字段
student2 = StudentModel(
    sid=1001,
    name="张三",
    age=18,
    city="北京",
    birthday="1999-11-20"
)
print(type(student2), student2)  # <class '__main__.StudentModel'> sid=1001 name='张三' age=18 gender='男' clz='S95001' city='北京' phone=None birthday=datetime.date(1999, 11, 20)


# 不传递city字段
try:
    student3 = StudentModel(
        sid=1001,
        name="张三",
        age=18,
        birthday="1999-11-20"
    )
except ValidationError as e:
    # 将错误信息去除首位符号，转换为字典类型，方便取出错误信息
    error_msg = eval(e.json()[1:-1])
    print("发送错误的字段：", error_msg["loc"]) # 发送错误的字段： ['city']

长度验证

from datetime import date
from typing import Optional
from pydantic import BaseModel, Field, ValidationError


class StudentModel(BaseModel):
    sid: int    # 学生学号，必填字段（无默认值的时候为必填字段）
    name: str = Field(..., min_length=2, max_length=10, description="学生姓名(字符不可小于2或大于10)")
    age: int    # 学生年龄
    gender: str = "男"   # 学生性别，有默认值，选填字段
    clz: str = "S95001"  # 学生所属班级
    city: Optional[str]  # 学生所属城市
    phone: str = Field(None, min_length=11, max_length=11, description="手机号码(字符仅可为11)")
    birthday: date  # 学生生日


# 创建一条符合StudentModel模型的学生数据
student1 = StudentModel(
    sid=1001,
    name="张三",
    age=18,
    city="上海",
    phone="13500001234",
    birthday="1999-11-20"
)
print(type(student1), student1) # <class '__main__.StudentModel'> sid=1001 name='张三' age=18 gender='男' clz='S95001' city='上海' phone='13500001234' birthday=datetime.date(1999, 11, 20)


# name字段长度小于2
try:
    student2 = StudentModel(
        sid=1001,
        name="张",
        age=18,
        city="上海",
        phone="13500001234",
        birthday="1999-11-20"
    )
except ValidationError as e:
    # 将错误信息去除首位符号，转换为字典类型，方便取出错误信息
    error_msg = eval(e.json()[1:-1])
    print("发送错误的字段：", error_msg["loc"]) # 发送错误的字段： ['name']


# phone字段长度非11
try:
    student3 = StudentModel(
        sid=1001,
        name="张三",
        age=18,
        city="上海",
        phone="10086",
        birthday="1999-11-20"
    )
except ValidationError as e:
    # 将错误信息去除首位符号，转换为字典类型，方便取出错误信息
    error_msg = eval(e.json()[1:-1])
    print("发送错误的字段：", error_msg["loc"]) # 发送错误的字段： ['phone']

大小验证

from datetime import date
from typing import Optional
from pydantic import BaseModel, Field, ValidationError


class StudentModel(BaseModel):
    sid: int = Field(..., gt=1000, lt=9999, description="学生学号(不可小于1000或大于9999)")
    name: str = Field(..., min_length=2, max_length=10, description="学生姓名(字符不可小于2或大于10)")
    age: int = Field(..., gt=0, lt=100, description="学生年龄(不可小于0或大于100)")
    gender: str = "男"   # 学生性别，有默认值，选填字段
    clz: str = "S95001"  # 学生所属班级
    city: Optional[str]  # 学生所属城市
    phone: str = Field(None, min_length=11, max_length=11, description="手机号码(字符仅可为11)")
    birthday: date  # 学生生日


# 创建一条符合StudentModel模型的学生数据
student1 = StudentModel(
    sid=1001,
    name="张三",
    age=18,
    city="上海",
    phone="13500001234",
    birthday="1999-11-20"
)
print(type(student1), student1) # <class '__main__.StudentModel'> sid=1001 name='张三' age=18 gender='男' clz='S95001' city='上海' phone='13500001234' birthday=datetime.date(1999, 11, 20)


# sid字段小于1000
try:
    student2 = StudentModel(
        sid=50,
        name="张三",
        age=18,
        city="上海",
        phone="13500001234",
        birthday="1999-11-20"
    )
except ValidationError as e:
    # 将错误信息去除首位符号，转换为字典类型，方便取出错误信息
    error_msg = eval(e.json()[1:-1])
    print("发送错误的字段：", error_msg["loc"]) # 发送错误的字段： ['sid']


# age字段大于100
try:
    student3 = StudentModel(
        sid=1001,
        name="张三",
        age=101,
        city="上海",
        phone="13500001234",
        birthday="1999-11-20"
    )
except ValidationError as e:
    # 将错误信息去除首位符号，转换为字典类型，方便取出错误信息
    error_msg = eval(e.json()[1:-1])
    print("发送错误的字段：", error_msg["loc"]) # 发送错误的字段： ['age']

枚举值验证

from datetime import date
from typing import Optional
from pydantic import BaseModel, Field, ValidationError
from enum import Enum


class Gender(Enum):
    MALE = '男'
    FEMALE = '女'


class StudentModel(BaseModel):
    sid: int = Field(..., gt=1000, lt=9999, description="学生学号(不可小于1000或大于9999)")
    name: str = Field(..., min_length=2, max_length=10, description="学生姓名(字符不可小于2或大于10)")
    age: int = Field(..., gt=0, lt=100, description="学生年龄(不可小于0或大于100)")
    gender: Gender = Field(default="男", description="学生性别(仅可为男或女)")
    clz: str = "S95001"  # 学生所属班级
    city: Optional[str]  # 学生所属城市
    phone: str = Field(None, min_length=11, max_length=11, description="手机号码(字符仅可为11)")
    birthday: date  # 学生生日


# 创建一条符合StudentModel模型的学生数据
student1 = StudentModel(
    sid=1001,
    name="张三",
    age=18,
    gender="男",
    city="上海",
    phone="13500001234",
    birthday="1999-11-20"
)
print(type(student1), student1) # <class '__main__.StudentModel'> sid=1001 name='张三' age=18 gender='男' clz='S95001' city='上海' phone='13500001234' birthday=datetime.date(1999, 11, 20)


# gender字段非男或女
try:
    student2 = StudentModel(
        sid=1001,
        name="张三",
        age=18,
        gender="不男不女",
        city="上海",
        phone="13500001234",
        birthday="1999-11-20"
    )
except ValidationError as e:
    # 将错误信息去除首位符号，转换为字典类型，方便取出错误信息
    error_msg = eval(e.json()[1:-1])
    print("发送错误的字段：", error_msg["loc"]) # 发送错误的字段： ['gender']

容器验证

from datetime import date
from typing import Optional, List
from pydantic import BaseModel, Field, ValidationError
from enum import Enum


class Gender(Enum):
    MALE = '男'
    FEMALE = '女'


class StudentModel(BaseModel):
    sid: int = Field(..., gt=1000, lt=9999, description="学生学号(不可小于1000或大于9999)")
    name: str = Field(..., min_length=2, max_length=10, description="学生姓名(字符不可小于2或大于10)")
    age: int = Field(..., gt=0, lt=100, description="学生年龄(不可小于0或大于100)")
    gender: Gender = Field(default="男", description="学生性别(仅可为男或女)")
    clz: str = "S95001"  # 学生所属班级
    city: Optional[str]  # 学生所属城市
    phone: str = Field(None, min_length=11, max_length=11, description="手机号码(字符仅可为11)")
    birthday: date  # 学生生日
    hobby: List[str] = Field(default=None, min_items=1, max_items=3, description="学生爱好（可以为None或不可小于1或大于3个爱好）")


# 创建一条符合StudentModel模型的学生数据
# 不传递hobby字段
student1 = StudentModel(
    sid=1001,
    name="张三",
    age=18,
    gender="男",
    city="上海",
    phone="13500001234",
    birthday="1999-11-20",
)
print(type(student1), student1) # <class '__main__.StudentModel'> sid=1001 name='张三' age=18 gender='男' clz='S95001' city='上海' phone='13500001234' birthday=datetime.date(1999, 11, 20)


# 创建一条符合StudentModel模型的学生数据
# 传递hobby字段，参数项为1个
student2 = StudentModel(
    sid=1001,
    name="张三",
    age=18,
    gender="男",
    city="上海",
    phone="13500001234",
    birthday="1999-11-20",
    hobby=["篮球"]
)
print(type(student2), student2) # <class '__main__.StudentModel'> sid=1001 name='张三' age=18 gender=<Gender.MALE: '男'> clz='S95001' city='上海' phone='13500001234' birthday=datetime.date(1999, 11, 20) hobby=['篮球']


# 传递hobby字段，参数项为大于3个
try:
    student3 = StudentModel(
        sid=1001,
        name="张三",
        age=18,
        city="上海",
        phone="13500001234",
        birthday="1999-11-20",
        hobby=["篮球", "电竞", "直播", "户外", "汽车", "美食"]
    )
except ValidationError as e:
    # 将错误信息去除首位符号，转换为字典类型，方便取出错误信息
    error_msg = eval(e.json()[1:-1])
    print("发送错误的字段：", error_msg["loc"]) # 发送错误的字段： ['hobby']

自定义验证器

from datetime import date
from typing import Optional, List
from pydantic import BaseModel, Field, ValidationError, validator
from enum import Enum


class Gender(Enum):
    MALE = '男'
    FEMALE = '女'


class StudentModel(BaseModel):
    sid: int = Field(..., gt=1000, lt=9999, description="学生学号(不可小于1000或大于9999)")
    name: str = Field(..., min_length=2, max_length=10, description="学生姓名(字符不可小于2或大于10)")
    age: int = Field(..., gt=0, lt=100, description="学生年龄(不可小于0或大于100)")
    gender: Gender = Field(default="男", description="学生性别(仅可为男或女)")
    clz: str = "S95001"  # 学生所属班级
    city: Optional[str]  # 学生所属城市
    phone: str = Field(None, min_length=11, max_length=11, description="手机号码(字符仅可为11)")
    birthday: date  # 学生生日
    hobby: List[str] = Field(default=None, min_items=1, max_items=3,
                             description="学生爱好（可以为None或不可小于1或大于3个爱好）")

    @validator('clz')
    def check_clz_startswith(cls, v):
        if not v.startswith("S950"):
            raise ValueError('班级编号必须以S950开头')
        return v

    @validator("hobby")
    def check_hobby_items(cls, hobby, values):
        if values["gender"] == Gender.MALE and hobby[0] != "篮球":
            raise ValueError("本班级男同学的第一爱好必须是篮球哦")
        return hobby


# 创建一条符合StudentModel模型的学生数据
student1 = StudentModel(
    sid=1001,
    name="张三",
    age=18,
    city="上海",
    phone="13500001234",
    birthday="1999-11-20",
)
print(type(student1), student1)  # <class '__main__.StudentModel'> sid=1001 name='张三' age=18 gender='男' clz='S95001' city='上海' phone='13500001234' birthday=datetime.date(1999, 11, 20) hobby=None


# clz字段，不以S950开头
try:
    student2 = StudentModel(
        sid=1001,
        name="张三",
        age=18,
        clz="10086",
        city="上海",
        phone="13500001234",
        birthday="1999-11-20",
    )
except ValidationError as e:
    # 将错误信息去除首位符号，转换为字典类型，方便取出错误信息
    error_msg = eval(e.json()[1:-1])
    print("发送错误的字段：", error_msg["loc"]) # 发送错误的字段： ['hobby']


# gender为男的同学，hobby中不传递篮球或篮球不在第一元素
try:
    student3 = StudentModel(
        sid=1001,
        name="张三",
        age=18,
        gender="男",
        city="上海",
        phone="13500001234",
        birthday="1999-11-20",
        hobby=["电竞", "直播", "户外"]
    )
except ValidationError as e:
    # 将错误信息去除首位符号，转换为字典类型，方便取出错误信息
    error_msg = eval(e.json()[1:-1])
    print("发送错误的字段：", error_msg["loc"]) # 发送错误的字段： ['hobby']

嵌套模型

from typing import List
from pydantic import BaseModel


class Student(BaseModel):
    num: str
    name: str


class Teacher(BaseModel):
    num: str
    name: str
    domain: str


class Clazz(BaseModel):
    num: str
    maximum: int


class School(BaseModel):
    clazz: List[Clazz]
    student: List[Student]
    teacher: List[Teacher]


student1 = Student(num="S1001", name="张三")
student2 = Student(num="S1002", name="李四")
student3 = Student(num="S1003", name="王五")

teacher1 = Teacher(num="T1001", name="赵德柱", domain="数学")
teacher2 = Teacher(num="T1001", name="王铁锤", domain="语文")
teacher3 = Teacher(num="T1001", name="吴鱼子", domain="英语")

clazz1 = Clazz(num="C1001", maximum=30)
clazz2 = Clazz(num="C1001", maximum=40)

school = School(
    clazz=[clazz1, clazz2],
    student=[student1, student2, student3],
    teacher=[teacher1, teacher2, teacher3]
)
print(type(school), school)  # <class '__main__.School'> clazz=[Clazz(num='C1001', maximum=30), Clazz(num='C1001', maximum=40)] student=[Student(num='S1001', name='张三'), Student(num='S1002', name='李四'), Student(num='S1003', name='王五')] teacher=[Teacher(num='T1001', name='赵德柱', domain='数学'), Teacher(num='T1001', name='王铁锤', domain='语文'), Teacher(num='T1001', name='吴鱼子', domain='英语')]

print(school.dict())  # {'clazz': [{'num': 'C1001', 'maximum': 30}, {'num': 'C1001', 'maximum': 40}], 'student': [{'num': 'S1001', 'name': '张三'}, {'num': 'S1002', 'name': '李四'}, {'num': 'S1003', 'name': '王五'}], 'teacher': [{'num': 'T1001', 'name': '赵德柱', 'domain': '数学'}, {'num': 'T1001', 'name': '王铁锤', 'domain': '语文'}, {'num': 'T1001', 'name': '吴鱼子', 'domain': '英语'}]}

print(school.json())  # {"clazz":[{"num":"C1001","maximum":30},{"num":"C1001","maximum":40}],"student":[{"num":"S1001","name":"张三"},{"num":"S1002","name":"李四"},{"num":"S1003","name":"王五"}],"teacher":[{"num":"T1001","name":"赵德柱","domain":"数学"},{"num":"T1001","name":"王铁锤","domain":"语文"},{"num":"T1001","name":"吴鱼子","domain":"英语"}]}

JSON 数据导入

from pathlib import Path
from datetime import date
from typing import Optional, List
from pydantic import BaseModel, Field, ValidationError, validator
from enum import Enum


class Gender(Enum):
    MALE = '男'
    FEMALE = '女'


class StudentModel(BaseModel):
    sid: int = Field(..., gt=1000, lt=9999, description="学生学号(不可小于1000或大于9999)")
    name: str = Field(..., min_length=2, max_length=10, description="学生姓名(字符不可小于2或大于10)")
    age: int = Field(..., gt=0, lt=100, description="学生年龄(不可小于0或大于100)")
    gender: Gender = Field(default="男", description="学生性别(仅可为男或女)")
    clz: str = "S95001"  # 学生所属班级
    city: Optional[str]  # 学生所属城市
    phone: str = Field(None, min_length=11, max_length=11, description="手机号码(字符仅可为11)")
    birthday: date  # 学生生日
    hobby: List[str] = Field(default=None, min_items=1, max_items=3,
                             description="学生爱好（可以为None或不可小于1或大于3个爱好）")

    @validator('clz')
    def check_clz_startswith(cls, v):
        if not v.startswith("S950"):
            raise ValueError('班级编号必须以S950开头')
        return v

    @validator("hobby")
    def check_hobby_items(cls, hobby, values):
        if values["gender"] == Gender.MALE and hobby[0] != "篮球":
            raise ValueError("本班级男同学的第一爱好必须是篮球哦")
        return hobby


# 创建一条符合StudentModel模型的学生数据
student1 = StudentModel(
    sid=1001,
    name="张三",
    age=18,
    city="上海",
    phone="13500001234",
    birthday="1999-11-20",
)
print(type(student1), student1)  # <class '__main__.StudentModel'> sid=1001 name='张三' age=18 gender='男' clz='S95001' city='上海' phone='13500001234' birthday=datetime.date(1999, 11, 20) hobby=None

# 从指定路径下的json文件中读取内容，通过BaseModel模型的parse_file函数进行解析
path = Path("./example.json")
# example.json文件数据如下：
# {
#   "sid": 1101,
#   "name": "弗兰加圣香克斯",
#   "age": 35,
#   "gender": "男",
#   "clz": "S95001",
#   "city": "北海",
#   "phone": "13500001234",
#   "birthday": "1985-11-20",
#   "hobby": [
#     "篮球",
#     "美食",
#     "户外"
#   ]
# }

file_data = StudentModel.parse_file(path)
print(file_data.name)      # 弗兰加圣香克斯
print(file_data.dict())    # {'sid': 1101, 'name': '弗兰加圣香克斯', 'age': 35, 'gender': <Gender.MALE: '男'>, 'clz': 'S95001', 'city': '北海', 'phone': '13500001234', 'birthday': datetime.date(1985, 11, 20), 'hobby': ['篮球', '美食', '户外']}
print(file_data.json())    # {"sid":1101,"name":"弗兰加圣香克斯","age":35,"gender":"男","clz":"S95001","city":"北海","phone":"13500001234","birthday":"1985-11-20","hobby":["篮球","美食","户外"]}

ORM 数据导入

from typing import List

from sqlalchemy import Column, Integer, String
from sqlalchemy.dialects.postgresql import ARRAY
from sqlalchemy.ext.declarative import declarative_base
from pydantic import BaseModel, constr

Base = declarative_base()

# 创建一张表（ORM模型）
class CompanyOrm(Base):
    __tablename__ = 'companies'
    id = Column(Integer, primary_key=True, nullable=False)
    public_key = Column(String(20), index=True, nullable=False, unique=True)
    name = Column(String(63), unique=True)
    domains = Column(ARRAY(String(255)))


# 创建一个pydantic的BaseModel模型
class CompanyModel(BaseModel):
    id: int
    public_key: constr(max_length=20)
    name: constr(max_length=63)
    domains: List[constr(max_length=255)]

    class Config:
        orm_mode = True
        from_attributes = True


# 实例化一个数据库表（ORM模型）对象
co_orm = CompanyOrm(
    id=123,
    public_key='foobar',
    name='Testing',
    domains=['example.com', 'foobar.com'],
)
print(type(co_orm), co_orm) # <class '__main__.CompanyOrm'> <__main__.CompanyOrm object at 0x7fbfd848f580>


# 使用BaseModel类调用from_orm函数，将CompanyOrm模型解析成CompanyModel模型
company_orm = CompanyModel.from_orm(co_orm)
print(type(company_orm), company_orm)   # <class '__main__.CompanyModel'> id=123 public_key='foobar' name='Testing' domains=['example.com', 'foobar.com']

print(company_orm.dict())   # {'id': 123, 'public_key': 'foobar', 'name': 'Testing', 'domains': ['example.com', 'foobar.com']}
print(company_orm.json())   # {"id":123,"public_key":"foobar","name":"Testing","domains":["example.com","foobar.com"]}

总结

pydantic 模块的核心是 BaseModel 类；
它让我们能够轻松定义数据模型，并在数据转换、验证和序列化过程中获得强大的功能。
通过类型注解，我们可以为模型字段指定数据类型，并确保输入数据满足这些要求。
如果数据不符合预期，pydantic 会引发错误，帮助我们及时发现并处理问题。
此外，pydantic 还提供了依赖注入、文档生成等高级功能，进一步丰富了数据模型的应用场景。
无论是API开发、数据存储，还是其他数据处理任务，pydantic 都能帮助我们提高代码质量、减少错误，并提升开发效率。

需要休息的KK.
关注
  • 48
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Py之pydantic：pydantic的简介、安装、使用方法之详细攻略
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
02-21 3349
​ Py之pydantic：pydantic的简介、安装、使用方法之详细攻略 目录 pydantic的简介 pydantic的安装 pydantic的使用方法 pydantic的简介 pydantic是使用Python类型提示进行数据验证。快速且可扩展，Pydantic与您的检查器/IDE/思维相容。使用纯净、规范的Python 3.8+定义数据的格式；使用Pydantic进行验证。 pydantic_settings使用Pydantic进行设置管理，这是Pydantic的BaseSetti
python库pydantic简易教程
weixin_43936332的博客
07-09 7055
pydantic 库是 python 中用于数据接口定义检查与设置管理的库。pydantic 在运行时强制执行类型提示，并在数据无效时提供友好的错误。1.与 IDE/linter 完美搭配，不需要学习新的模式，只是使用类型注解定义类的实例2.多用途，BaseSettings 既可以验证请求数据，也可以从环境变量中读取系统设置快速3.可以验证复杂结构4.可扩展，可以使用validator装饰器装饰的模型上的方法来扩展验证。
Pydantic 全面指南：从入门到高级应用
最新发布
全世界的博客
06-21 2858
Pydantic 是一个用于数据验证和设置管理的 Python 库。它通过 Python 类型注解来定义数据模型，并提供了强大的数据验证功能。Pydantic 的主要目标是确保数据在输入和输出时的一致性和有效性。它广泛应用于各种 Python 项目中，特别是在需要处理复杂数据结构和确保数据完整性的场景中。数据验证：确保输入数据符合预定义的类型和结构。序列化：将复杂的数据结构转换为 Python 数据类型，便于处理和传输。错误处理：提供详细的错误信息，帮助开发者快速定位和修复问题。配置管理。
pydantic学习与使用-1.pydantic简介与基础入门
qq_27371025的博客
02-25 8285
前言 版本文档：v1.9.0 使用 python 类型注释的数据验证和设置管理。 pydantic在运行时强制执行类型提示，并在数据无效时提供用户友好的错误。 定义数据应该如何在纯粹的、规范的 python 中；并使用 pydantic 对其进行验证。 pydantic 简介 pydantic 主要是一个解析库，而不是验证库。 验证是达到目的的一种手段：建立一个符合所提供的类型和约束的模型。 换句话说，pydantic 保证输出模型的类型和约束，而不是输入数据。 这听起来像是一个深奥的区别，但事实并非如此。
Python学习之-Pydantic详解
Summer的博客
04-08 3497
Pydantic 是一个 Python 库，用于数据解析和验证。它主要基于 Python 类型提示来实现数据的校验和设定限制条件。在 Pydantic 中，BaseModel 是一个核心基类，用于创建数据模型。Pydantic 的主要优势在于其结合了灵活性和强大的数据处理能力，同时简化了常规的数据校验任务，让开发人员更专注于业务逻辑的实现。它通常用于快速开发中，特别是在构建API、数据交互和设置管理场景中发挥重要作用。
Python笔记：Pydantic库简介
热门推荐
codename_cys的博客
07-29 3万+
pydantic库简介 1. pydantic库是什么 2. pydantic库用法考察 1. 基本使用方法 1. schema基本定义方法 2. 基本的schema实例化方法 3. pydantic基本数据类型 2. 高级数据结构考察 1. enum数据类型 2. 可选数据类型 3. 数据默认值的设置 4. 允许多种数据类型 5. 异名数据传递方法 3. 多级schema定义样例 4. 数据检查方法考察 1. validator用法考察 2. Config方法考察 3. 参考..
FastAPI 开发中数据校验利器 Pydantic 介绍与集成使用
宇宙之一粟的技术漂泊之旅
05-18 1599
前言当我们在处理一些数据来自系统外部的时候，可能来自 API、终端用户输入或者其他途径，Web 开发中有句话叫做：永远不要相信用户的输入。所以，我们可能需要检查、校验这些数据，将这些数据格式化、标准化，以至于这些数据满足我们真实程序的数据输入，保证项目的正确执行。Pydantic 介绍Pydantic 是一个 Python...
Python库 | django_pydantic_settings-0.3.0-py3-none-any.whl
02-16
`django_pydantic_settings` 提供了一种优雅的方式来管理和验证Django项目的配置，通过结合Pydantic的强类型验证和Django的灵活性，提升了项目的整体质量和开发效率。无论是小型项目还是大型复杂项目，它都能成为...
Web开发-员工信息自主审核-Python源码示例.zip
12-13
在本示例中，我们关注的是使用Python进行Web开发，特别是构建一个员工信息自主审核的系统。这个系统可能被用于企业内部，允许员工查看、更新和验证他们的个人信息，提高数据准确性，减少人力资源部门的工作负担。...
PyPI 官网下载 | pydantic-1.7.2-cp39-cp39-win_amd64.whl
02-08
《PyPI与Pydantic库详解》 PyPI（Python Package Index）是Python社区的官方软件包仓库，它为Python开发者提供了一个...通过使用whl文件，开发者可以快速便捷地在本地环境中安装并使用Pydantic，进一步提升开发效率。
PyPI 官网下载 | stac_pydantic-1.2.4-py3-none-any.whl
02-09
使用Python库可以显著提高开发效率，减少重复工作，并确保遵循最佳实践。 **whl 文件格式** wheel（whl）文件是Python的二进制分发格式，它是一种预编译的Python包，包含已编译的Python扩展、纯Python模块的归档...
Python库 | gitlab-auto-mr-0.2.3.post1.tar.gz
03-07
综上所述，`gitlab-auto-mr-0.2.3.post1.tar.gz`是一个Python库，旨在简化和自动化GitLab的Merge Request过程，通过与GitLab API的交互，提供诸如创建、管理MR以及与CI/CD流程集成等功能，从而提升团队的开发效率和...
软件测试|Pydantic详细介绍与基础入门
Tester_muller的博客
09-15 730
Pydantic 是一个强大的 Python 库，用于数据验证和解析，特别是用于处理 JSON 数据。它的主要目标是使数据验证和解析变得简单、直观和可维护。本文将介绍 Pydantic 的基础知识，包括如何定义模型、验证数据以及处理错误。Pydantic 是一个用于数据验证和解析的库，它让我们能够定义数据模型并根据这些模型验证输入数据。它的一个重要特性是自动转换输入数据为强类型的 Python 对象，并提供了清晰的错误信息，以便我们可以轻松地处理验证失败的情况。
pydantic学习与使用-12.使用 Field 定制字段
qq_27371025的博客
03-06 6112
前言 Field 可用于提供有关字段和验证的额外信息，如设置必填项和可选，设置最大值和最小值，字符串长度等限制 Field模块 关于 Field 字段参数说明 Field(None) 是可选字段，不传的时候值默认为None Field(…) 是设置必填项字段 title 自定义标题，如果没有默认就是字段属性的值 description 定义字段描述内容 from pydantic import BaseModel, Field class Item(BaseModel): name: str
Python——pydantic库
pumpkin84514的博客
04-05 778
Pydantic 是一个用于 Python 的数据验证库，特别适用于构建 RESTful API 服务，尤其是结合 FastAPI 和 Starlette 框架时。它利用 Python 的类型注解系统，可以高效且准确地验证和清理传入应用程序的数据。Pydantic 提供了强类型模式验证，能够确保数据结构一致性和安全性。
数据验证新技术：Python详细解析Pydantic
Rocky006的博客
01-22 1411
数据验证和处理是编程中的常见任务之一。在 Python 中，有许多库可用于数据验证和处理，其中一个流行的选择是 Pydantic。Pydantic 是一个强大的库，用于定义数据模型、验证输入数据、进行数据转换和生成文档。本文将介绍 Pydantic 的基本概念、用法和示例，帮助大家更好地理解如何使用它来管理数据。
Pydantic，数据类型确认和解析神器
weixin_39915649的博客
12-14 1250
Pydantic：简化Python中的数据验证和解析。
python中pydantic库
既然选择远方，便只顾风雨兼程！
09-27 2503
不知道大家是否非常羡慕C语言等在进行函数传参时，可以指定数据类型来传参呢？我之前有一篇讲过使用typing来指定数据类型，但是其仅仅是能指定数据类型，只能做一个提醒的作用，那么我们如何来结合typing模块，来写一个可以像Java等语言的指定参数类型呢？这里我推荐pydantic库。首先，在学这个库之前，我们需要去回顾一下typing然后，我们来解释一下我们即将要学的库：其使用 Python 类型注释的数据验证和设置管理。pydantic在运行时强制执行类型提示，并在数据无效时提供用户友好的错误。
pydantic strict
11-24
在Pydantic中，可以使用`strict`参数来控制模型是否应该强制执行类型限制。如果启用了`strict`模式，则模型将拒绝任何不符合类型限制的值。否则，将尝试将值转换为指定的类型。默认情况下，`strict`模式是禁用的。 以下是一个启用`strict`模式的示例： ```python from pydantic import BaseModel class MyModel(BaseModel): id: int name: str class Config: strict = True model = MyModel(id=1, name='John') print(model.dict()) # Output: {'id': 1, 'name': 'John'} model = MyModel(id='1', name='John') Raises a ValueError because the id is not an integer ``` 在上面的示例中，`strict`模式被启用，因此如果我们尝试将一个字符串传递给`id`字段，Pydantic将引发一个`ValueError`异常。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

需要休息的KK.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值