programming python

Trình xác thực trong Python

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

4, n. Con chó canh gác của Hades, có nhiệm vụ canh gác lối vào; . - Ambrose Bierce, Từ điển của quỷ

Cerberus cung cấp chức năng xác thực dữ liệu mạnh mẽ nhưng đơn giản và nhẹ và được thiết kế để có thể dễ dàng mở rộng, cho phép xác thực tùy chỉnh. Nó không có phụ thuộc và được kiểm tra kỹ lưỡng từ Python 2. 7 đến 3. 8, PyPy và PyPy3

Sơ lược¶

Bạn định nghĩa một lược đồ xác thực và chuyển nó tới một thể hiện của lớp

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

>>> schema = {'name': {'type': 'string'}}
>>> v = Validator[schema]

Sau đó, bạn chỉ cần gọi

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

6 để xác thực từ điển dựa trên lược đồ. Nếu xác nhận thành công,

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

7 được trả về

>>> document = {'name': 'john doe'}
>>> v.validate[document]
True

Tài trợ Cerberus¶

Cerberus là một dự án được tài trợ hợp tác . Nếu bạn điều hành một doanh nghiệp và đang sử dụng Cerberus trong một sản phẩm tạo ra doanh thu, thì việc tài trợ cho sự phát triển của nó là điều hợp lý. nó đảm bảo dự án mà sản phẩm của bạn dựa vào luôn hoạt động tốt và được duy trì tích cực.

Người dùng cá nhân cũng được hoan nghênh thực hiện cam kết định kỳ hoặc quyên góp một lần nếu Cerberus đã giúp bạn trong công việc hoặc các dự án cá nhân của bạn. Mỗi lần đăng ký đều có tác động đáng kể đến việc biến Cerberus thành hiện thực

Xác thực tùy chỉnh và các mối quan hệ phức tạp giữa các đối tượng có thể đạt được bằng cách sử dụng trình trang trí

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

Trăn 3. 7 trở lên

from pydantic import BaseModel, ValidationError, validator


class UserModel[BaseModel]:
    name: str
    username: str
    password1: str
    password2: str

    @validator['name']
    def name_must_contain_space[cls, v]:
        if ' ' not in v:
            raise ValueError['must contain a space']
        return v.title[]

    @validator['password2']
    def passwords_match[cls, v, values, **kwargs]:
        if 'password1' in values and v != values['password1']:
            raise ValueError['passwords do not match']
        return v

    @validator['username']
    def username_alphanumeric[cls, v]:
        assert v.isalnum[], 'must be alphanumeric'
        return v


user = UserModel[
    name='samuel colvin',
    username='scolvin',
    password1='zxcvbn',
    password2='zxcvbn',
]
print[user]
#> name='Samuel Colvin' username='scolvin' password1='zxcvbn' password2='zxcvbn'

try:
    UserModel[
        name='samuel',
        username='scolvin',
        password1='zxcvbn',
        password2='zxcvbn2',
    ]
except ValidationError as e:
    print[e]
    """
    2 validation errors for UserModel
    name
      must contain a space [type=value_error]
    password2
      passwords do not match [type=value_error]
    """

[Tập lệnh này đã hoàn tất, tập lệnh sẽ chạy "nguyên trạng"]

Một vài điều cần lưu ý về trình xác thực

trình xác thực là "phương thức lớp", vì vậy giá trị đối số đầu tiên mà chúng nhận được là lớp

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

0, không phải là phiên bản của

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

đối số thứ hai luôn là giá trị trường để xác thực;

bạn cũng có thể thêm bất kỳ tập hợp con nào của các đối số sau vào chữ ký [tên phải khớp]

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

2. một lệnh chứa ánh xạ tên thành giá trị của bất kỳ trường nào đã được xác thực trước đó

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

3. cấu hình mô hình

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

4. trường đang được xác thực. Loại đối tượng là

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

6. nếu được cung cấp, điều này sẽ bao gồm các đối số ở trên không được liệt kê rõ ràng trong chữ ký

trình xác thực phải trả về giá trị được phân tích cú pháp hoặc tăng

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

8 hoặc

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

9 [có thể sử dụng ___130 câu lệnh]

Cảnh báo

Nếu bạn sử dụng các câu lệnh

>>> document = {'name': 'john doe'}
>>> v.validate[document]
True

30, hãy nhớ rằng việc chạy Python với cờ tối ưu hóa

>>> document = {'name': 'john doe'}
>>> v.validate[document]
True

32 sẽ vô hiệu hóa các câu lệnh

>>> document = {'name': 'john doe'}
>>> v.validate[document]
True

30 và trình xác thực sẽ ngừng hoạt động

nơi trình xác thực dựa vào các giá trị khác, bạn nên lưu ý rằng

Xác thực được thực hiện trong các trường thứ tự được xác định. e. g. trong ví dụ trên,

>>> document = {'name': 'john doe'}
>>> v.validate[document]
True

34 có quyền truy cập vào

>>> document = {'name': 'john doe'}
>>> v.validate[document]
True

35 [và

>>> document = {'name': 'john doe'}
>>> v.validate[document]
True

36], nhưng

>>> document = {'name': 'john doe'}
>>> v.validate[document]
True

35 không có quyền truy cập vào

>>> document = {'name': 'john doe'}
>>> v.validate[document]
True

34. Xem Thứ tự trường để biết thêm thông tin về cách các trường được sắp xếp

Nếu xác thực không thành công trên một trường khác [hoặc trường đó bị thiếu] thì nó sẽ không được đưa vào

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

2, do đó trong ví dụ này là

from pydantic import BaseModel, ValidationError, validator


class UserModel[BaseModel]:
    name: str
    username: str
    password1: str
    password2: str

    @validator['name']
    def name_must_contain_space[cls, v]:
        if ' ' not in v:
            raise ValueError['must contain a space']
        return v.title[]

    @validator['password2']
    def passwords_match[cls, v, values, **kwargs]:
        if 'password1' in values and v != values['password1']:
            raise ValueError['passwords do not match']
        return v

    @validator['username']
    def username_alphanumeric[cls, v]:
        assert v.isalnum[], 'must be alphanumeric'
        return v


user = UserModel[
    name='samuel colvin',
    username='scolvin',
    password1='zxcvbn',
    password2='zxcvbn',
]
print[user]
#> name='Samuel Colvin' username='scolvin' password1='zxcvbn' password2='zxcvbn'

try:
    UserModel[
        name='samuel',
        username='scolvin',
        password1='zxcvbn',
        password2='zxcvbn2',
    ]
except ValidationError as e:
    print[e]
    """
    2 validation errors for UserModel
    name
      must contain a space [type=value_error]
    password2
      passwords do not match [type=value_error]
    """

Trình xác nhận trước và từng mặt hàng¶

Trình xác thực có thể thực hiện một số điều phức tạp hơn

Trăn 3. 7 trở lên Python 3. 9 trở lên

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

>>> document = {'name': 'john doe'}
>>> v.validate[document]
True

[Tập lệnh này đã hoàn tất, tập lệnh sẽ chạy "nguyên trạng"]

Một vài điều nữa cần lưu ý

một trình xác thực duy nhất có thể được áp dụng cho nhiều trường bằng cách chuyển nhiều tên trường cho nó

một trình xác thực duy nhất cũng có thể được gọi trên tất cả các trường bằng cách chuyển giá trị đặc biệt

from pydantic import BaseModel, ValidationError, validator


class UserModel[BaseModel]:
    name: str
    username: str
    password1: str
    password2: str

    @validator['name']
    def name_must_contain_space[cls, v]:
        if ' ' not in v:
            raise ValueError['must contain a space']
        return v.title[]

    @validator['password2']
    def passwords_match[cls, v, values, **kwargs]:
        if 'password1' in values and v != values['password1']:
            raise ValueError['passwords do not match']
        return v

    @validator['username']
    def username_alphanumeric[cls, v]:
        assert v.isalnum[], 'must be alphanumeric'
        return v


user = UserModel[
    name='samuel colvin',
    username='scolvin',
    password1='zxcvbn',
    password2='zxcvbn',
]
print[user]
#> name='Samuel Colvin' username='scolvin' password1='zxcvbn' password2='zxcvbn'

try:
    UserModel[
        name='samuel',
        username='scolvin',
        password1='zxcvbn',
        password2='zxcvbn2',
    ]
except ValidationError as e:
    print[e]
    """
    2 validation errors for UserModel
    name
      must contain a space [type=value_error]
    password2
      passwords do not match [type=value_error]
    """

đối số từ khóa

from pydantic import BaseModel, ValidationError, validator


class UserModel[BaseModel]:
    name: str
    username: str
    password1: str
    password2: str

    @validator['name']
    def name_must_contain_space[cls, v]:
        if ' ' not in v:
            raise ValueError['must contain a space']
        return v.title[]

    @validator['password2']
    def passwords_match[cls, v, values, **kwargs]:
        if 'password1' in values and v != values['password1']:
            raise ValueError['passwords do not match']
        return v

    @validator['username']
    def username_alphanumeric[cls, v]:
        assert v.isalnum[], 'must be alphanumeric'
        return v


user = UserModel[
    name='samuel colvin',
    username='scolvin',
    password1='zxcvbn',
    password2='zxcvbn',
]
print[user]
#> name='Samuel Colvin' username='scolvin' password1='zxcvbn' password2='zxcvbn'

try:
    UserModel[
        name='samuel',
        username='scolvin',
        password1='zxcvbn',
        password2='zxcvbn2',
    ]
except ValidationError as e:
    print[e]
    """
    2 validation errors for UserModel
    name
      must contain a space [type=value_error]
    password2
      passwords do not match [type=value_error]
    """

32 sẽ khiến trình xác thực được gọi trước khi xác thực khác

vượt qua

from pydantic import BaseModel, ValidationError, validator


class UserModel[BaseModel]:
    name: str
    username: str
    password1: str
    password2: str

    @validator['name']
    def name_must_contain_space[cls, v]:
        if ' ' not in v:
            raise ValueError['must contain a space']
        return v.title[]

    @validator['password2']
    def passwords_match[cls, v, values, **kwargs]:
        if 'password1' in values and v != values['password1']:
            raise ValueError['passwords do not match']
        return v

    @validator['username']
    def username_alphanumeric[cls, v]:
        assert v.isalnum[], 'must be alphanumeric'
        return v


user = UserModel[
    name='samuel colvin',
    username='scolvin',
    password1='zxcvbn',
    password2='zxcvbn',
]
print[user]
#> name='Samuel Colvin' username='scolvin' password1='zxcvbn' password2='zxcvbn'

try:
    UserModel[
        name='samuel',
        username='scolvin',
        password1='zxcvbn',
        password2='zxcvbn2',
    ]
except ValidationError as e:
    print[e]
    """
    2 validation errors for UserModel
    name
      must contain a space [type=value_error]
    password2
      passwords do not match [type=value_error]
    """

33 sẽ dẫn đến việc trình xác thực được áp dụng cho các giá trị riêng lẻ [e. g. của

from pydantic import BaseModel, ValidationError, validator


class UserModel[BaseModel]:
    name: str
    username: str
    password1: str
    password2: str

    @validator['name']
    def name_must_contain_space[cls, v]:
        if ' ' not in v:
            raise ValueError['must contain a space']
        return v.title[]

    @validator['password2']
    def passwords_match[cls, v, values, **kwargs]:
        if 'password1' in values and v != values['password1']:
            raise ValueError['passwords do not match']
        return v

    @validator['username']
    def username_alphanumeric[cls, v]:
        assert v.isalnum[], 'must be alphanumeric'
        return v


user = UserModel[
    name='samuel colvin',
    username='scolvin',
    password1='zxcvbn',
    password2='zxcvbn',
]
print[user]
#> name='Samuel Colvin' username='scolvin' password1='zxcvbn' password2='zxcvbn'

try:
    UserModel[
        name='samuel',
        username='scolvin',
        password1='zxcvbn',
        password2='zxcvbn2',
    ]
except ValidationError as e:
    print[e]
    """
    2 validation errors for UserModel
    name
      must contain a space [type=value_error]
    password2
      passwords do not match [type=value_error]
    """

34,

from pydantic import BaseModel, ValidationError, validator


class UserModel[BaseModel]:
    name: str
    username: str
    password1: str
    password2: str

    @validator['name']
    def name_must_contain_space[cls, v]:
        if ' ' not in v:
            raise ValueError['must contain a space']
        return v.title[]

    @validator['password2']
    def passwords_match[cls, v, values, **kwargs]:
        if 'password1' in values and v != values['password1']:
            raise ValueError['passwords do not match']
        return v

    @validator['username']
    def username_alphanumeric[cls, v]:
        assert v.isalnum[], 'must be alphanumeric'
        return v


user = UserModel[
    name='samuel colvin',
    username='scolvin',
    password1='zxcvbn',
    password2='zxcvbn',
]
print[user]
#> name='Samuel Colvin' username='scolvin' password1='zxcvbn' password2='zxcvbn'

try:
    UserModel[
        name='samuel',
        username='scolvin',
        password1='zxcvbn',
        password2='zxcvbn2',
    ]
except ValidationError as e:
    print[e]
    """
    2 validation errors for UserModel
    name
      must contain a space [type=value_error]
    password2
      passwords do not match [type=value_error]
    """

35,

from pydantic import BaseModel, ValidationError, validator


class UserModel[BaseModel]:
    name: str
    username: str
    password1: str
    password2: str

    @validator['name']
    def name_must_contain_space[cls, v]:
        if ' ' not in v:
            raise ValueError['must contain a space']
        return v.title[]

    @validator['password2']
    def passwords_match[cls, v, values, **kwargs]:
        if 'password1' in values and v != values['password1']:
            raise ValueError['passwords do not match']
        return v

    @validator['username']
    def username_alphanumeric[cls, v]:
        assert v.isalnum[], 'must be alphanumeric'
        return v


user = UserModel[
    name='samuel colvin',
    username='scolvin',
    password1='zxcvbn',
    password2='zxcvbn',
]
print[user]
#> name='Samuel Colvin' username='scolvin' password1='zxcvbn' password2='zxcvbn'

try:
    UserModel[
        name='samuel',
        username='scolvin',
        password1='zxcvbn',
        password2='zxcvbn2',
    ]
except ValidationError as e:
    print[e]
    """
    2 validation errors for UserModel
    name
      must contain a space [type=value_error]
    password2
      passwords do not match [type=value_error]
    """

36, v.v. ], chứ không phải toàn bộ đối tượng

Trình xác thực phân lớp và

from pydantic import BaseModel, ValidationError, validator


class UserModel[BaseModel]:
    name: str
    username: str
    password1: str
    password2: str

    @validator['name']
    def name_must_contain_space[cls, v]:
        if ' ' not in v:
            raise ValueError['must contain a space']
        return v.title[]

    @validator['password2']
    def passwords_match[cls, v, values, **kwargs]:
        if 'password1' in values and v != values['password1']:
            raise ValueError['passwords do not match']
        return v

    @validator['username']
    def username_alphanumeric[cls, v]:
        assert v.isalnum[], 'must be alphanumeric'
        return v


user = UserModel[
    name='samuel colvin',
    username='scolvin',
    password1='zxcvbn',
    password2='zxcvbn',
]
print[user]
#> name='Samuel Colvin' username='scolvin' password1='zxcvbn' password2='zxcvbn'

try:
    UserModel[
        name='samuel',
        username='scolvin',
        password1='zxcvbn',
        password2='zxcvbn2',
    ]
except ValidationError as e:
    print[e]
    """
    2 validation errors for UserModel
    name
      must contain a space [type=value_error]
    password2
      passwords do not match [type=value_error]
    """

37¶

Nếu sử dụng trình xác thực với lớp con tham chiếu trường loại

from pydantic import BaseModel, ValidationError, validator


class UserModel[BaseModel]:
    name: str
    username: str
    password1: str
    password2: str

    @validator['name']
    def name_must_contain_space[cls, v]:
        if ' ' not in v:
            raise ValueError['must contain a space']
        return v.title[]

    @validator['password2']
    def passwords_match[cls, v, values, **kwargs]:
        if 'password1' in values and v != values['password1']:
            raise ValueError['passwords do not match']
        return v

    @validator['username']
    def username_alphanumeric[cls, v]:
        assert v.isalnum[], 'must be alphanumeric'
        return v


user = UserModel[
    name='samuel colvin',
    username='scolvin',
    password1='zxcvbn',
    password2='zxcvbn',
]
print[user]
#> name='Samuel Colvin' username='scolvin' password1='zxcvbn' password2='zxcvbn'

try:
    UserModel[
        name='samuel',
        username='scolvin',
        password1='zxcvbn',
        password2='zxcvbn2',
    ]
except ValidationError as e:
    print[e]
    """
    2 validation errors for UserModel
    name
      must contain a space [type=value_error]
    password2
      passwords do not match [type=value_error]
    """

34 trên lớp cha, thì việc sử dụng

from pydantic import BaseModel, ValidationError, validator


class UserModel[BaseModel]:
    name: str
    username: str
    password1: str
    password2: str

    @validator['name']
    def name_must_contain_space[cls, v]:
        if ' ' not in v:
            raise ValueError['must contain a space']
        return v.title[]

    @validator['password2']
    def passwords_match[cls, v, values, **kwargs]:
        if 'password1' in values and v != values['password1']:
            raise ValueError['passwords do not match']
        return v

    @validator['username']
    def username_alphanumeric[cls, v]:
        assert v.isalnum[], 'must be alphanumeric'
        return v


user = UserModel[
    name='samuel colvin',
    username='scolvin',
    password1='zxcvbn',
    password2='zxcvbn',
]
print[user]
#> name='Samuel Colvin' username='scolvin' password1='zxcvbn' password2='zxcvbn'

try:
    UserModel[
        name='samuel',
        username='scolvin',
        password1='zxcvbn',
        password2='zxcvbn2',
    ]
except ValidationError as e:
    print[e]
    """
    2 validation errors for UserModel
    name
      must contain a space [type=value_error]
    password2
      passwords do not match [type=value_error]
    """

33 sẽ khiến trình xác thực không chạy;

Trăn 3. 7 trở lên Python 3. 9 trở lên

from pydantic import BaseModel, ValidationError, validator


class UserModel[BaseModel]:
    name: str
    username: str
    password1: str
    password2: str

    @validator['name']
    def name_must_contain_space[cls, v]:
        if ' ' not in v:
            raise ValueError['must contain a space']
        return v.title[]

    @validator['password2']
    def passwords_match[cls, v, values, **kwargs]:
        if 'password1' in values and v != values['password1']:
            raise ValueError['passwords do not match']
        return v

    @validator['username']
    def username_alphanumeric[cls, v]:
        assert v.isalnum[], 'must be alphanumeric'
        return v


user = UserModel[
    name='samuel colvin',
    username='scolvin',
    password1='zxcvbn',
    password2='zxcvbn',
]
print[user]
#> name='Samuel Colvin' username='scolvin' password1='zxcvbn' password2='zxcvbn'

try:
    UserModel[
        name='samuel',
        username='scolvin',
        password1='zxcvbn',
        password2='zxcvbn2',
    ]
except ValidationError as e:
    print[e]
    """
    2 validation errors for UserModel
    name
      must contain a space [type=value_error]
    password2
      passwords do not match [type=value_error]
    """

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

[Tập lệnh này đã hoàn tất, tập lệnh sẽ chạy "nguyên trạng"]

Xác nhận luôn¶

Vì lý do hiệu suất, theo mặc định, trình xác thực không được gọi cho các trường khi giá trị không được cung cấp. Tuy nhiên, có những tình huống có thể hữu ích hoặc bắt buộc phải luôn gọi trình xác thực, e. g. để đặt giá trị mặc định động

Trăn 3. 7 trở lên

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

[Tập lệnh này đã hoàn tất, tập lệnh sẽ chạy "nguyên trạng"]

Bạn sẽ thường muốn sử dụng cái này cùng với

from pydantic import BaseModel, ValidationError, validator


class UserModel[BaseModel]:
    name: str
    username: str
    password1: str
    password2: str

    @validator['name']
    def name_must_contain_space[cls, v]:
        if ' ' not in v:
            raise ValueError['must contain a space']
        return v.title[]

    @validator['password2']
    def passwords_match[cls, v, values, **kwargs]:
        if 'password1' in values and v != values['password1']:
            raise ValueError['passwords do not match']
        return v

    @validator['username']
    def username_alphanumeric[cls, v]:
        assert v.isalnum[], 'must be alphanumeric'
        return v


user = UserModel[
    name='samuel colvin',
    username='scolvin',
    password1='zxcvbn',
    password2='zxcvbn',
]
print[user]
#> name='Samuel Colvin' username='scolvin' password1='zxcvbn' password2='zxcvbn'

try:
    UserModel[
        name='samuel',
        username='scolvin',
        password1='zxcvbn',
        password2='zxcvbn2',
    ]
except ValidationError as e:
    print[e]
    """
    2 validation errors for UserModel
    name
      must contain a space [type=value_error]
    password2
      passwords do not match [type=value_error]
    """

32, vì nếu không, với

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

61 pydantic sẽ cố xác thực giá trị mặc định của

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

62, điều này sẽ gây ra lỗi

Tái sử dụng trình xác thực¶

Đôi khi, bạn sẽ muốn sử dụng cùng một trình xác thực trên nhiều trường/mô hình [ví dụ:. g. để chuẩn hóa một số dữ liệu đầu vào]. Cách tiếp cận "ngây thơ" sẽ là viết một hàm riêng biệt, sau đó gọi nó từ nhiều trình trang trí. Rõ ràng, điều này đòi hỏi rất nhiều sự lặp lại và mã tấm nồi hơi. Để tránh điều này, tham số

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

63 đã được thêm vào

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

64 trong v1. 2 [

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

65 theo mặc định]

Trăn 3. 7 trở lên

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

[Tập lệnh này đã hoàn tất, tập lệnh sẽ chạy "nguyên trạng"]

Rõ ràng là, sự lặp lại đã giảm đi và các mô hình lại gần như mang tính khai báo.

Mẹo

Nếu bạn có nhiều trường muốn xác thực, bạn nên xác định chức năng trợ giúp mà bạn sẽ tránh phải đặt đi đặt lại

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

66 nhiều lần

Trình xác thực gốc¶

Việc xác thực cũng có thể được thực hiện trên toàn bộ dữ liệu của mô hình

Trăn 3. 7 trở lên

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

[Tập lệnh này đã hoàn tất, tập lệnh sẽ chạy "nguyên trạng"]

Giống như trình xác thực trường, trình xác thực gốc có thể có

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

67, trong trường hợp đó chúng được gọi trước khi xác thực trường xảy ra [và được cung cấp dữ liệu đầu vào thô] hoặc

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

68 [mặc định], trong trường hợp đó, chúng được gọi sau khi xác thực trường

Xác thực trường sẽ không xảy ra nếu trình xác thực gốc của

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

67 phát sinh lỗi. Như với trình xác thực trường, "đăng" [i. e.

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

68] trình xác thực gốc theo mặc định sẽ được gọi ngay cả khi trình xác thực trước không thành công; . Đối số

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

2 sẽ là một lệnh chứa các giá trị đã vượt qua xác thực trường và giá trị mặc định của trường nếu có

Kiểm tra thực địa¶

Khi tạo lớp, trình xác thực được kiểm tra để xác nhận rằng các trường mà chúng chỉ định thực sự tồn tại trên mô hình

Tuy nhiên, đôi khi điều này là không mong muốn. e. g. nếu bạn xác định trình xác thực để xác thực các trường trên các mô hình kế thừa. Trong trường hợp này, bạn nên đặt

from typing import List
from pydantic import BaseModel, ValidationError, validator


class DemoModel[BaseModel]:
    square_numbers: List[int] = []
    cube_numbers: List[int] = []

    # '*' is the same as 'cube_numbers', 'square_numbers' here:
    @validator['*', pre=True]
    def split_str[cls, v]:
        if isinstance[v, str]:
            return v.split['|']
        return v

    @validator['cube_numbers', 'square_numbers']
    def check_sum[cls, v]:
        if sum[v] > 42:
            raise ValueError['sum of numbers greater than 42']
        return v

    @validator['square_numbers', each_item=True]
    def check_squares[cls, v]:
        assert v ** 0.5 % 1 == 0, f'{v} is not a square number'
        return v

    @validator['cube_numbers', each_item=True]
    def check_cubes[cls, v]:
        # 64 ** [1 / 3] == 3.9999999999999996 [!]
        # this is not a good way of checking cubes
        assert v ** [1 / 3] % 1 == 0, f'{v} is not a cubed number'
        return v


print[DemoModel[square_numbers=[1, 4, 9]]]
#> square_numbers=[1, 4, 9] cube_numbers=[]
print[DemoModel[square_numbers='1|4|16']]
#> square_numbers=[1, 4, 16] cube_numbers=[]
print[DemoModel[square_numbers=[16], cube_numbers=[8, 27]]]
#> square_numbers=[16] cube_numbers=[8, 27]
try:
    DemoModel[square_numbers=[1, 4, 2]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    square_numbers -> 2
      2 is not a square number [type=assertion_error]
    """

try:
    DemoModel[cube_numbers=[27, 27]]
except ValidationError as e:
    print[e]
    """
    1 validation error for DemoModel
    cube_numbers
      sum of numbers greater than 42 [type=value_error]
    """

73 trên trình xác thực

Trình xác thực trong Python là gì?

Xác thực trong python ngăn người dùng bên thứ ba vô tình hoặc cố ý xử lý sai mã . Nó có thể được sử dụng để kiểm tra xem kiểu dữ liệu đầu vào có đúng hay không. Nó có thể được sử dụng để kiểm tra xem không có giá trị không hợp lệ trong đầu vào đã cho.

Làm cách nào để xác thực dữ liệu trong Python?

Yêu cầu hệ thống. .

Bước 1. Nhập mô-đun

Bước 2. Chuẩn bị tập dữ liệu

Bước 3. Xác thực khung dữ liệu

Bước 4. Xử lý các cột phù hợp

Bước 5. Kiểm tra Loại dữ liệu chuyển đổi thành cột Ngày

Bước 6. xác thực dữ liệu để kiểm tra các giá trị còn thiếu

Trình xác thực được sử dụng để làm gì?

Trình xác thực là một chương trình máy tính được sử dụng để kiểm tra tính hợp lệ hoặc tính chính xác về mặt cú pháp của một đoạn mã hoặc tài liệu . Thuật ngữ này thường được sử dụng trong ngữ cảnh xác thực các tài liệu HTML, CSS và XML như nguồn cấp dữ liệu RSS, mặc dù nó có thể được sử dụng cho bất kỳ định dạng hoặc ngôn ngữ xác định nào.

Trình xác thực mã là gì?

1. Quá trình kiểm tra xem mã có đúng không . Trong trường hợp các ứng dụng web, đó là quá trình kiểm tra xem mã có tuân thủ các tiêu chuẩn và khuyến nghị do World Wide Web Consortium [W3C] đặt ra cho web hay không.

Sơ lược¶

Tài trợ Cerberus¶

Trình xác nhận trước và từng mặt hàng¶

Xác nhận luôn¶

Tái sử dụng trình xác thực¶

Trình xác thực gốc¶

Kiểm tra thực địa¶

Trình xác thực trong Python là gì?

Làm cách nào để xác thực dữ liệu trong Python?

Trình xác thực được sử dụng để làm gì?

Trình xác thực mã là gì?

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề