Pydantic은 Python 표준 라이브러리의 다양한 일반 유형을 지원합니다. 더 엄격한 처리가 필요한 경우 허용되는 값을 제한해야 하는 경우(예: 양의 int 요구)를 포함하여 엄격한 유형을 참조하세요.
부울¶
표준 bool 필드는 값이 다음 중 하나가 아닌 경우 ValidationError 발생시킵니다.
- 유효한 부울(예:
True또는False) - 정수
0또는1, - 소문자로 변환하면 다음 중 하나가 되는
str'0', 'off', 'f', 'false', 'n', 'no', '1', 'on', 't', 'true', 'y', 'yes' str로 디코딩될 때 이전 규칙에 따라 유효한bytes
!!! note 보다 엄격한 부울 논리(예: True 및 False 만 허용하는 필드)를 원하는 경우 StrictBool 사용할 수 있습니다.
다음은 이러한 동작 중 일부를 보여주는 스크립트입니다.
from pydantic import BaseModel, ValidationError
class BooleanModel(BaseModel):
bool_value: bool
print(BooleanModel(bool_value=False))
#> bool_value=False
print(BooleanModel(bool_value='False'))
#> bool_value=False
print(BooleanModel(bool_value=1))
#> bool_value=True
try:
BooleanModel(bool_value=[])
except ValidationError as e:
print(str(e))
"""
1 validation error for BooleanModel
bool_value
Input should be a valid boolean [type=bool_type, input_value=[], input_type=list]
"""
날짜/시간 유형¶
Pydantic은 다음 날짜/시간 유형을 지원합니다:
datetime.datetime¶
-
datetime필드는 다음 유형의 값을 허용합니다.datetime; 기존datetime객체int또는float; Unix 시간으로 가정합니다. 즉, 1970년 1월 1일 이후의 초(if >=-2e10및 <=2e10) 또는 밀리초( <-2e10또는 >2e10)입니다.str; 다음 형식이 허용됩니다.YYYY-MM-DD[T]HH:MM[:SS[.ffffff]][Z or [±]HH[:]MM]YYYY-MM-DD완화 모드에서는 허용되지만 엄격 모드에서는 허용되지 않습니다.int또는float형식의 문자열(Unix 시간으로 가정)
datetime.date인스턴스는 완화 모드에서는 허용되지만 엄격 모드에서는 허용되지 않습니다.
from datetime import datetime
from pydantic import BaseModel
class Event(BaseModel): dt: datetime = None
event = Event(dt='2032-04-23T10:20:30.400+02:30')
print(event.model_dump()) """ {'dt': datetime.datetime(2032, 4, 23, 10, 20, 30, 400000, tzinfo=TzInfo(+02:30))} """
datetime.date¶
-
date필드는 다음 유형의 값을 허용합니다.date; 기존date객체int또는float; 위의datetime에 대해 설명한 것과 동일하게 처리됩니다.str; 다음 형식이 허용됩니다.YYYY-MM-DDint또는float형식의 문자열(Unix 시간으로 가정)
from datetime import date
from pydantic import BaseModel
class Birthday(BaseModel): d: date = None
my_birthday = Birthday(d=1679616000.0)
print(my_birthday.model_dump())
>¶
datetime.time¶
-
time필드는 다음 유형의 값을 허용합니다.time; 기존time객체str; 다음 형식이 허용됩니다.HH:MM[:SS[.ffffff]][Z or [±]HH[:]MM]
from datetime import time
from pydantic import BaseModel
class Meeting(BaseModel): t: time = None
m = Meeting(t=time(4, 8, 16))
print(m.model_dump())
>¶
datetime.timedelta¶
-
timedelta필드는 다음 유형의 값을 허용합니다.timedelta; 기존timedelta객체int또는float; 초로 추정str; 다음 형식이 허용됩니다.[-][DD]D[,][HH:MM:]SS[.ffffff]- 예:
'1d,01:02:03.000004'또는'1D01:02:03.000004'또는'01:02:03'
- 예:
[±]P[DD]DT[HH]H[MM]M[SS]S(시간델타에 대한 ISO 8601 형식)
from datetime import timedelta
from pydantic import BaseModel
class Model(BaseModel): td: timedelta = None
m = Model(td='P3DT12H30M5S')
print(m.model_dump())
>¶
숫자 유형¶
Pydantic은 Python 표준 라이브러리에서 다음 숫자 유형을 지원합니다.
int¶
- Pydantic은
int(v)사용하여 유형을int로 강제 변환합니다. 데이터 변환 중 정보 손실에 대한 자세한 내용은 데이터 변환을 참조하세요.
float¶
- Pydantic은
float(v)사용하여 값을 float로 강제 변환합니다.
enum.IntEnum¶
- 유효성 검사: Pydantic은 값이 유효한
IntEnum인스턴스인지 확인합니다. enum.IntEnum의 하위 클래스에 대한 유효성 검사: 값이 정수 열거형의 유효한 멤버인지 확인합니다. 자세한 내용은 열거형 및 선택 항목을 참조하세요.
decimal.Decimal¶
- 유효성 검사: Pydantic은 값을 문자열로 변환하려고 시도한 다음 문자열을
Decimal(v)에 전달합니다. -
직렬화: Pydantic은
Decimal유형을 문자열로 직렬화합니다. 원하는 경우 사용자 지정 직렬 변환기를 사용하여 이 동작을 재정의할 수 있습니다. 예를 들어:from decimal import Decimal
from typing_extensions import Annotated
from pydantic import BaseModel, PlainSerializer
class Model(BaseModel): x: Decimal y: Annotated[ Decimal, PlainSerializer( lambda x: float(x), return_type=float, when_used='json' ), ]
my_model = Model(x=Decimal('1.1'), y=Decimal('2.1'))
print(my_model.model_dump()) # (1)!
>¶
print(my_model.model_dump(mode='json')) # (2)!
>¶
print(my_model.model_dump_json()) # (3)!
>¶
-
model_dump를 사용하면x와y모두Decimal유형의 인스턴스로 유지됩니다. mode='json'과 함께model_dump를 사용하면xstring으로 직렬화되고y적용된 사용자 정의 직렬 변환기로 인해float로 직렬화됩니다.model_dump_json을 사용하면xstring으로 직렬화되고,y적용된 사용자 정의 직렬 변환기로 인해float로 직렬화됩니다.
Enum¶
Pydantic은 Python의 표준 enum 클래스를 사용하여 선택 사항을 정의합니다.
enum.Enum 값이 유효한 Enum 인스턴스인지 확인합니다. enum.Enum 의 하위 클래스는 값이 열거형의 유효한 멤버인지 확인합니다.
from enum import Enum, IntEnum
from pydantic import BaseModel, ValidationError
class FruitEnum(str, Enum):
pear = 'pear'
banana = 'banana'
class ToolEnum(IntEnum):
spanner = 1
wrench = 2
class CookingModel(BaseModel):
fruit: FruitEnum = FruitEnum.pear
tool: ToolEnum = ToolEnum.spanner
print(CookingModel())
#> fruit=<FruitEnum.pear: 'pear'> tool=<ToolEnum.spanner: 1>
print(CookingModel(tool=2, fruit='banana'))
#> fruit=<FruitEnum.banana: 'banana'> tool=<ToolEnum.wrench: 2>
try:
CookingModel(fruit='other')
except ValidationError as e:
print(e)
"""
1 validation error for CookingModel
fruit
Input should be 'pear' or 'banana' [type=enum, input_value='other', input_type=str]
"""
리스트와 튜플¶
list¶
list, tuple, set, frozenset, deque 또는 생성기와 list에 대한 캐스트를 허용합니다. 일반 매개변수가 제공되면 목록의 모든 항목에 적절한 유효성 검사가 적용됩니다.
typing.List¶
위의 list 과 동일하게 처리됩니다.
from typing import List, Optional
from pydantic import BaseModel
class Model(BaseModel):
simple_list: Optional[list] = None
list_of_ints: Optional[List[int]] = None
print(Model(simple_list=['1', '2', '3']).simple_list)
#> ['1', '2', '3']
print(Model(list_of_ints=['1', '2', '3']).list_of_ints)
#> [1, 2, 3]
tuple¶
list, tuple, set, frozenset, deque 또는 생성기와 tuple로의 캐스트를 허용합니다. 일반 매개변수가 제공되면 튜플의 각 항목에 적절한 유효성 검사가 적용됩니다.
typing.Tuple¶
위의 tuple 과 동일하게 처리됩니다.
from typing import Optional, Tuple
from pydantic import BaseModel
class Model(BaseModel):
simple_tuple: Optional[tuple] = None
tuple_of_different_types: Optional[Tuple[int, float, bool]] = None
print(Model(simple_tuple=[1, 2, 3, 4]).simple_tuple)
#> (1, 2, 3, 4)
print(Model(tuple_of_different_types=[3, 2, 1]).tuple_of_different_types)
#> (3, 2.0, True)
typing.NamedTuple¶
typing.NamedTuple의 하위 클래스는 tuple 과 유사하지만 지정된 namedtuple 클래스의 인스턴스를 만듭니다.
collections.namedtuple의 하위 클래스는 typing.NamedTuple의 하위 클래스와 유사하지만 필드 유형이 지정되지 않으므로 모든 필드는 Any 유형을 갖는 것으로 처리됩니다.
from typing import NamedTuple
from pydantic import BaseModel, ValidationError
class Point(NamedTuple):
x: int
y: int
class Model(BaseModel):
p: Point
try:
Model(p=('1.3', '2'))
except ValidationError as e:
print(e)
"""
1 validation error for Model
p.0
Input should be a valid integer, unable to parse string as an integer [type=int_parsing, input_value='1.3', input_type=str]
"""
데크¶
deque¶
list, tuple, set, frozenset, deque 또는 생성기와 deque에 대한 캐스트를 허용합니다. 일반 매개변수가 제공되면 deque 의 각 항목에 적절한 유효성 검사가 적용됩니다.
[typing.Deque 데크 ][`typing.Deque` 데크 ]¶
위의 deque 와 동일하게 처리됩니다.
from typing import Deque, Optional
from pydantic import BaseModel
class Model(BaseModel):
deque: Optional[Deque[int]] = None
print(Model(deque=[1, 2, 3]).deque)
#> deque([1, 2, 3])
세트¶
set¶
list, tuple, set, frozenset, deque 또는 생성기와 set에 대한 캐스트를 허용합니다. 일반 매개변수가 제공되면 세트의 모든 항목에 적절한 유효성 검사가 적용됩니다.
typing.Set¶
위에서 set 것과 동일하게 처리됩니다.
from typing import Optional, Set
from pydantic import BaseModel
class Model(BaseModel):
simple_set: Optional[set] = None
set_of_ints: Optional[Set[int]] = None
print(Model(simple_set={'1', '2', '3'}).simple_set)
#> {'1', '2', '3'}
print(Model(simple_set=['1', '2', '3']).simple_set)
#> {'1', '2', '3'}
print(Model(set_of_ints=['1', '2', '3']).set_of_ints)
#> {1, 2, 3}
frozenset¶
list, tuple, set, frozenset, deque 또는 생성기와 frozenset에 대한 캐스트를 허용합니다. 일반 매개변수가 제공되면 고정 세트의 모든 항목에 적절한 유효성 검사가 적용됩니다.
typing.FrozenSet¶
위의 frozenset 과 동일하게 처리됩니다.
from typing import FrozenSet, Optional
from pydantic import BaseModel
class Model(BaseModel):
simple_frozenset: Optional[frozenset] = None
frozenset_of_ints: Optional[FrozenSet[int]] = None
m1 = Model(simple_frozenset=['1', '2', '3'])
print(type(m1.simple_frozenset))
#> <class 'frozenset'>
print(sorted(m1.simple_frozenset))
#> ['1', '2', '3']
m2 = Model(frozenset_of_ints=['1', '2', '3'])
print(type(m2.frozenset_of_ints))
#> <class 'frozenset'>
print(sorted(m2.frozenset_of_ints))
#> [1, 2, 3]
기타 반복 가능 항목¶
typing.Sequence¶
이는 제공된 값이 Sequence ABC의 요구 사항을 충족해야 하고 컨테이너의 값을 적극적으로 검증하는 것이 바람직할 때 사용하기 위한 것입니다. 컨테이너 값에 대해 유효성 검사를 수행해야 하는 경우 유효성 검사로 인해 값이 대체될 수 있으므로 컨테이너 유형이 유지되지 않을 수 있습니다. 우리는 검증된 값이 유효한 typing.Sequence임을 보장하지만 제공된 것과 다른 유형을 가질 수 있습니다(일반적으로 list 이 됩니다).
typing.Iterable¶
이는 제공된 값이 소비되어서는 안 되는 반복 가능일 수 있는 경우에 사용하기 위한 것입니다. 구문 분석 및 검증에 대한 자세한 내용은 아래의 무한 생성기를 참조하세요. typing.Sequence와 유사하게 검증된 결과가 유효한 typing.Iterable임을 보장하지만 제공된 것과 다른 유형을 가질 수 있습니다. 특히, list 과 같은 비생성자 유형이 제공되더라도 typing.Iterable 유형 필드의 유효성 검증 후 값은 생성기가 됩니다.
다음은 typing.Sequence를 사용한 간단한 예입니다.
from typing import Sequence
from pydantic import BaseModel
class Model(BaseModel):
sequence_of_ints: Sequence[int] = None
print(Model(sequence_of_ints=[1, 2, 3, 4]).sequence_of_ints)
#> [1, 2, 3, 4]
print(Model(sequence_of_ints=(1, 2, 3, 4)).sequence_of_ints)
#> (1, 2, 3, 4)
무한 발전기¶
유효성을 검사하려는 생성기가 있는 경우에도 위에서 설명한 대로 Sequence 사용할 수 있습니다. 이 경우 생성기는 모델에 목록으로 사용 및 저장되며 해당 값은 Sequence 의 유형 매개변수(예: Sequence[int] 의 int )에 대해 유효성이 검사됩니다.
그러나 너무 많이 사용하고 싶지 않은 생성기가 있는 경우(예: 무한 생성기 또는 원격 데이터 로더) Iterable 유형의 필드를 사용할 수 있습니다.
from typing import Iterable
from pydantic import BaseModel
class Model(BaseModel):
infinite: Iterable[int]
def infinite_ints():
i = 0
while True:
yield i
i += 1
m = Model(infinite=infinite_ints())
print(m)
"""
infinite=ValidatorIterator(index=0, schema=Some(Int(IntValidator { strict: false })))
"""
for i in m.infinite:
print(i)
#> 0
#> 1
#> 2
#> 3
#> 4
#> 5
#> 6
#> 7
#> 8
#> 9
#> 10
if i == 10:
break
!!! warning 초기 검증 중에 Iterable 필드는 제공된 인수가 반복 가능한지 간단한 확인만 수행합니다. 소비되는 것을 방지하기 위해 산출된 값에 대한 검증이 적극적으로 수행되지 않습니다.
산출된 값은 적극적으로 검증되지는 않지만 산출될 때 여전히 검증되며 적절한 경우 산출 시간에 ValidationError 를 발생시킵니다.
from typing import Iterable
from pydantic import BaseModel, ValidationError
class Model(BaseModel):
int_iterator: Iterable[int]
def my_iterator():
yield 13
yield '27'
yield 'a'
m = Model(int_iterator=my_iterator())
print(next(m.int_iterator))
#> 13
print(next(m.int_iterator))
#> 27
try:
next(m.int_iterator)
except ValidationError as e:
print(e)
"""
1 validation error for ValidatorIterator
2
Input should be a valid integer, unable to parse string as an integer [type=int_parsing, input_value='a', input_type=str]
"""
매핑 유형¶
dict¶
dict(v) 는 사전 변환을 시도하는 데 사용됩니다. 하위 유형 제약 조건은 아래의 typing.Dict를 참조하세요.
from pydantic import BaseModel, ValidationError
class Model(BaseModel):
x: dict
m = Model(x={'foo': 1})
print(m.model_dump())
#> {'x': {'foo': 1}}
try:
Model(x='test')
except ValidationError as e:
print(e)
"""
1 validation error for Model
x
Input should be a valid dictionary [type=dict_type, input_value='test', input_type=str]
"""
typing.Dict¶
from typing import Dict
from pydantic import BaseModel, ValidationError
class Model(BaseModel):
x: Dict[str, int]
m = Model(x={'foo': 1})
print(m.model_dump())
#> {'x': {'foo': 1}}
try:
Model(x={'foo': '1'})
except ValidationError as e:
print(e)
"""
1 validation error for Model
x
Input should be a valid dictionary [type=dict_type, input_value='test', input_type=str]
"""
TypedDict¶
!!! note 이는 Python 3.8부터 Python 표준 라이브러리의 새로운 기능입니다. 3.12 이전의 typing.TypedDict 제한으로 인해 Typing-extensions 패키지는 Python <3.12에 필요합니다. typing 대신 typing_extensions 에서 TypedDict 가져와야 하며, 그렇지 않으면 빌드 시간 오류가 발생합니다.
TypedDict는 모든 인스턴스가 특정 키 세트를 가질 것으로 예상하는 사전 유형을 선언합니다. 여기서 각 키는 일관된 유형의 값과 연결됩니다.
dict 와 동일하지만 키에 주석이 추가되므로 Pydantic이 사전의 유효성을 검사합니다.
from typing_extensions import TypedDict
from pydantic import TypeAdapter, ValidationError
class User(TypedDict):
name: str
id: int
ta = TypeAdapter(User)
print(ta.validate_python({'name': 'foo', 'id': 1}))
#> {'name': 'foo', 'id': 1}
try:
ta.validate_python({'name': 'foo'})
except ValidationError as e:
print(e)
"""
1 validation error for typed-dict
id
Field required [type=missing, input_value={'name': 'foo'}, input_type=dict]
"""
__pydantic_config__ 정의하여 TypedDict에서 상속된 모델을 변경할 수 있습니다. 자세한 내용은 ConfigDict API 참조를 참조하세요.
from typing import Optional
from typing_extensions import TypedDict
from pydantic import ConfigDict, TypeAdapter, ValidationError
# `total=False` means keys are non-required
class UserIdentity(TypedDict, total=False):
name: Optional[str]
surname: str
class User(TypedDict):
__pydantic_config__ = ConfigDict(extra='forbid')
identity: UserIdentity
age: int
ta = TypeAdapter(User)
print(
ta.validate_python(
{'identity': {'name': 'Smith', 'surname': 'John'}, 'age': 37}
)
)
#> {'identity': {'name': 'Smith', 'surname': 'John'}, 'age': 37}
print(
ta.validate_python(
{'identity': {'name': None, 'surname': 'John'}, 'age': 37}
)
)
#> {'identity': {'name': None, 'surname': 'John'}, 'age': 37}
print(ta.validate_python({'identity': {}, 'age': 37}))
#> {'identity': {}, 'age': 37}
try:
ta.validate_python(
{'identity': {'name': ['Smith'], 'surname': 'John'}, 'age': 24}
)
except ValidationError as e:
print(e)
"""
1 validation error for typed-dict
identity.name
Input should be a valid string [type=string_type, input_value=['Smith'], input_type=list]
"""
try:
ta.validate_python(
{
'identity': {'name': 'Smith', 'surname': 'John'},
'age': '37',
'email': 'john.smith@me.com',
}
)
except ValidationError as e:
print(e)
"""
1 validation error for typed-dict
email
Extra inputs are not permitted [type=extra_forbidden, input_value='john.smith@me.com', input_type=str]
"""
호출 가능¶
구문 분석 및 유효성 검사에 대한 자세한 내용은 아래를 참조하세요.
필드는 Callable 유형일 수도 있습니다.
from typing import Callable
from pydantic import BaseModel
class Foo(BaseModel):
callback: Callable[[int], int]
m = Foo(callback=lambda x: x)
print(m)
#> callback=<function <lambda> at 0x0123456789ab>
!!! 경고 호출 가능 필드는 인수가 호출 가능하다는 간단한 확인만 수행합니다. 인수, 해당 유형 또는 반환 유형에 대한 유효성 검사가 수행되지 않습니다.
IP 주소 유형¶
ipaddress.IPv4Address: 값을IPv4Address(v)에 전달하여 유효성 검사에 유형 자체를 사용합니다.ipaddress.IPv4Interface: 값을IPv4Address(v)에 전달하여 유효성 검사에 유형 자체를 사용합니다.ipaddress.IPv4Network: 값을IPv4Network(v)에 전달하여 유효성 검사에 유형 자체를 사용합니다.ipaddress.IPv6Address: 값을IPv6Address(v)에 전달하여 유효성 검사에 유형 자체를 사용합니다.ipaddress.IPv6Interface: 값을IPv6Interface(v)에 전달하여 유효성 검사에 유형 자체를 사용합니다.ipaddress.IPv6Network: 값을IPv6Network(v)에 전달하여 유효성 검사에 유형 자체를 사용합니다.
다른 사용자 정의 IP 주소 유형은 네트워크 유형을 참조하세요.
UUID¶
UUID의 경우 Pydantic은 값을 UUID(v) 에 전달하여 유효성 검사를 위해 유형 자체를 사용하려고 합니다. bytes 및 bytearray 에 대한 UUID(bytes=v) 대체가 있습니다.
UUID 버전을 제한하려는 경우 다음 유형을 확인할 수 있습니다.
노동 조합¶
Pydantic은 통합 검증을 광범위하게 지원하며, typing.Union과 Python 3.10의 파이프 구문( A | B )이 모두 지원됩니다. 개념 문서의 Unions 섹션에서 자세한 내용을 읽어보세요.
Type 및 TypeVar¶
type¶
Pydantic은 필드가 T 의 하위 클래스인 클래스(인스턴스 아님)만 허용하도록 지정하기 위해 type[T] 사용을 지원합니다.
typing.Type¶
위의 type 과 동일하게 처리됩니다.
from typing import Type
from pydantic import BaseModel, ValidationError
class Foo:
pass
class Bar(Foo):
pass
class Other:
pass
class SimpleModel(BaseModel):
just_subclasses: Type[Foo]
SimpleModel(just_subclasses=Foo)
SimpleModel(just_subclasses=Bar)
try:
SimpleModel(just_subclasses=Other)
except ValidationError as e:
print(e)
"""
1 validation error for SimpleModel
just_subclasses
Input should be a subclass of Foo [type=is_subclass_of, input_value=<class '__main__.Other'>, input_type=type]
"""
Type 사용하여 모든 클래스가 허용되도록 지정할 수도 있습니다.
from typing import Type
from pydantic import BaseModel, ValidationError
class Foo:
pass
class LenientSimpleModel(BaseModel):
any_class_goes: Type
LenientSimpleModel(any_class_goes=int)
LenientSimpleModel(any_class_goes=Foo)
try:
LenientSimpleModel(any_class_goes=Foo())
except ValidationError as e:
print(e)
"""
1 validation error for LenientSimpleModel
any_class_goes
Input should be a type [type=is_type, input_value=<__main__.Foo object at 0x0123456789ab>, input_type=Foo]
"""
typing.TypeVar¶
TypeVar는 제한 없음, 제한 또는 제한 있음으로 지원됩니다.
from typing import TypeVar
from pydantic import BaseModel
Foobar = TypeVar('Foobar')
BoundFloat = TypeVar('BoundFloat', bound=float)
IntStr = TypeVar('IntStr', int, str)
class Model(BaseModel):
a: Foobar # equivalent of ": Any"
b: BoundFloat # equivalent of ": float"
c: IntStr # equivalent of ": Union[int, str]"
print(Model(a=[1], b=4.2, c='x'))
#> a=[1] b=4.2 c='x'
# a may be None
print(Model(a=None, b=1, c=1))
#> a=None b=1.0 c=1
없음 유형¶
None, type(None) 또는 Literal[None] 은 입력 사양 에 따라 모두 동일합니다. None 값만 허용합니다.
문자열¶
str : 문자열은 있는 그대로 허용됩니다. bytes 및 bytearray v.decode() 사용하여 변환됩니다. str s inheriting from Enum은 v.value`를 are converted using . 다른 모든 유형은 오류를 발생시킵니다.
!!! "문자열은 시퀀스가 아닙니다" 경고
While instances of `str` are technically valid instances of the `Sequence[str]` protocol from a type-checker's point of
view, this is frequently not intended as is a common source of bugs.
As a result, Pydantic raises a `ValidationError` if you attempt to pass a `str` or `bytes` instance into a field of type
`Sequence[str]` or `Sequence[bytes]`:
from typing import Optional, Sequence
from pydantic import BaseModel, ValidationError
class Model(BaseModel):
sequence_of_strs: Optional[Sequence[str]] = None
sequence_of_bytes: Optional[Sequence[bytes]] = None
print(Model(sequence_of_strs=['a', 'bc']).sequence_of_strs)
#> ['a', 'bc']
print(Model(sequence_of_strs=('a', 'bc')).sequence_of_strs)
#> ('a', 'bc')
print(Model(sequence_of_bytes=[b'a', b'bc']).sequence_of_bytes)
#> [b'a', b'bc']
print(Model(sequence_of_bytes=(b'a', b'bc')).sequence_of_bytes)
#> (b'a', b'bc')
try:
Model(sequence_of_strs='abc')
except ValidationError as e:
print(e)
"""
1 validation error for Model
sequence_of_strs
'str' instances are not allowed as a Sequence value [type=sequence_str, input_value='abc', input_type=str]
"""
try:
Model(sequence_of_bytes=b'abc')
except ValidationError as e:
print(e)
"""
1 validation error for Model
sequence_of_bytes
'bytes' instances are not allowed as a Sequence value [type=sequence_str, input_value=b'abc', input_type=bytes]
"""
바이트¶
bytes는 있는 그대로 허용됩니다. bytearray 는 bytes(v) 사용하여 변환됩니다. str v.encode() 사용하여 변환됩니다. int , float 및 Decimal str(v).encode() 사용하여 강제됩니다. 자세한 내용은 바이트 크기를 참조하세요.
typing.Literal¶
Pydantic은 필드가 특정 리터럴 값만 허용하도록 지정하는 간단한 방법으로 typing.Literal 사용을 지원합니다.
from typing import Literal
from pydantic import BaseModel, ValidationError
class Pie(BaseModel):
flavor: Literal['apple', 'pumpkin']
Pie(flavor='apple')
Pie(flavor='pumpkin')
try:
Pie(flavor='cherry')
except ValidationError as e:
print(str(e))
"""
1 validation error for Pie
flavor
Input should be 'apple' or 'pumpkin' [type=literal_error, input_value='cherry', input_type=str]
"""
이 필드 유형의 한 가지 이점은 사용자 정의 유효성 검사기를 선언할 필요 없이 하나 이상의 특정 값과 동일한지 확인하는 데 사용할 수 있다는 것입니다.
from typing import ClassVar, List, Literal, Union
from pydantic import BaseModel, ValidationError
class Cake(BaseModel):
kind: Literal['cake']
required_utensils: ClassVar[List[str]] = ['fork', 'knife']
class IceCream(BaseModel):
kind: Literal['icecream']
required_utensils: ClassVar[List[str]] = ['spoon']
class Meal(BaseModel):
dessert: Union[Cake, IceCream]
print(type(Meal(dessert={'kind': 'cake'}).dessert).__name__)
#> Cake
print(type(Meal(dessert={'kind': 'icecream'}).dessert).__name__)
#> IceCream
try:
Meal(dessert={'kind': 'pie'})
except ValidationError as e:
print(str(e))
"""
2 validation errors for Meal
dessert.Cake.kind
Input should be 'cake' [type=literal_error, input_value='pie', input_type=str]
dessert.IceCream.kind
Input should be 'icecream' [type=literal_error, input_value='pie', input_type=str]
"""
주석이 달린 Union 에서 적절한 순서를 사용하면 이를 사용하여 특이성이 감소하는 유형을 구문 분석할 수 있습니다.
from typing import Literal, Optional, Union
from pydantic import BaseModel
class Dessert(BaseModel):
kind: str
class Pie(Dessert):
kind: Literal['pie']
flavor: Optional[str]
class ApplePie(Pie):
flavor: Literal['apple']
class PumpkinPie(Pie):
flavor: Literal['pumpkin']
class Meal(BaseModel):
dessert: Union[ApplePie, PumpkinPie, Pie, Dessert]
print(type(Meal(dessert={'kind': 'pie', 'flavor': 'apple'}).dessert).__name__)
#> ApplePie
print(type(Meal(dessert={'kind': 'pie', 'flavor': 'pumpkin'}).dessert).__name__)
#> PumpkinPie
print(type(Meal(dessert={'kind': 'pie'}).dessert).__name__)
#> Dessert
print(type(Meal(dessert={'kind': 'cake'}).dessert).__name__)
#> Dessert
typing.Any¶
None 포함한 모든 값을 허용합니다.
typing.Annotated¶
PEP-593 에 따라 임의의 메타데이터로 다른 유형을 래핑할 수 있습니다. Annotated 힌트에는 Field 함수 에 대한 단일 호출이 포함될 수 있지만 그렇지 않으면 추가 메타데이터가 무시되고 루트 유형이 사용됩니다.
typing.Pattern¶
정규식 패턴을 생성하기 위해 입력 값이 re.compile(v) 에 전달됩니다.
pathlib.Path¶
간단히 Path(v) 에 값을 전달하여 유효성 검사를 위해 유형 자체를 사용합니다.
本文总阅读量次