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

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]
    """

2

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]
      """
  

  0
• đố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]
        """
    

    5

  • 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 nhận phải trả lại 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]
      """
  

  7,

  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 câu lệ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]
      """
  

  10]

Cảnh báo

Nếu bạn sử dụng các câu lệ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]
    """

10, hãy nhớ rằng việc chạy Python với cờ tối ưu hó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]
    """

12 sẽ vô hiệu hóa các câu lệ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]
    """

10 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,

    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]
        """
    

    14 có quyền truy cập 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]
        """
    

    15 [và

    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]
        """
    

    16], như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]
        """
    

    15 không có quyền truy cập 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]
        """
    

    14. 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 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]
        """
    

    10

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]
    """

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]
    """

1

[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 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]
      """
  

  11
• đối số từ khó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]
      """
  

  12 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 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]
      """
  

  13 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 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]
      """
  

  14,

  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]
      """
  

  15,

  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]
      """
  

  16, 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 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]
    """

17¶

Nếu sử dụng trình xác thực với lớp con tham chiếu trường loạ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]
    """

14 trên lớp cha, thì việc sử dụ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]
    """

13 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 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]
    """

1

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

[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]
    """

5

[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 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]
    """

12, 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]
    """

41 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]
    """

42, đ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]
    """

43 đã đượ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]
    """

44 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]
    """

45 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]
    """

2

[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]
    """

46 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]
    """

4

[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]
    """

47, 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]
    """

48 [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]
    """

47 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]
    """

48] 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]
    """

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

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

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

Xác thực dữ liệu trong Python là gì?

Trình xác thực đầu vào là gì?