Pydantic ondersteunt veel voorkomende typen uit de Python-standaardbibliotheek. Als u een striktere verwerking nodig heeft, raadpleegt u Strict Types , inclusief of u de toegestane waarden moet beperken (bijvoorbeeld om een positieve int te vereisen).

Booleaanse waarden¶

Een standaard bool genereert een ValidationError als de waarde niet een van de volgende is:

Een geldige booleaanse waarde (dat wil zeggen True of False ),
De gehele getallen 0 of 1 ,
een str die, wanneer omgezet in kleine letters, er een van is '0', 'off', 'f', 'false', 'n', 'no', '1', 'on', 't', 'true', 'y', 'yes'
een bytes die geldig is volgens de vorige regel wanneer gedecodeerd naar str

!!! note Als u striktere Booleaanse logica wilt (bijvoorbeeld een veld dat alleen True en False toestaat), kunt u StrictBool gebruiken.

Hier is een script dat enkele van deze gedragingen demonstreert:

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

Datetime-typen¶

Pydantic ondersteunt de volgende datetime- typen:

`datetime.datetime`¶

datetime velden accepteren waarden van het type:
- datetime ; een bestaand datetime object
- int of float ; aangenomen als Unix-tijd, dwz seconden (indien >= -2e10 en <= 2e10 ) of milliseconden (indien < -2e10 of > 2e10 ) sinds 1 januari 1970
- str ; de volgende formaten worden geaccepteerd:
  - YYYY-MM-DD[T]HH:MM[:SS[.ffffff]][Z or [±]HH[:]MM]
  - YYYY-MM-DD wordt geaccepteerd in de lakse modus, maar niet in de strikte modus
  - int of float als een string (aangenomen als Unix-tijd)
- datetime.date instanties worden geaccepteerd in de lakse modus, maar niet in de strikte modus
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 accepteren waarden van het type:
- date ; een bestaand date
- int of float ; wordt op dezelfde manier afgehandeld als beschreven voor datetime hierboven
- str ; de volgende formaten worden geaccepteerd:
  - YYYY-MM-DD
  - int of float als een string (aangenomen als Unix-tijd)
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 accepteren waarden van het type:
- time ; een bestaand time
- str ; de volgende formaten worden geaccepteerd:
  - 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 velden accepteren waarden van het type:
- timedelta ; een bestaand timedelta object
- int of float ; aangenomen dat dit seconden zijn
- str ; de volgende formaten worden geaccepteerd:
  - [-][DD]D[,][HH:MM:]SS[.ffffff]
    - Bijvoorbeeld: '1d,01:02:03.000004' of '1D01:02:03.000004' of '01:02:03'
  - [±]P[DD]DT[HH]H[MM]M[SS]S ( ISO 8601- formaat voor tijddelta)
from datetime import timedelta

from pydantic import BaseModel

class Model(BaseModel): td: timedelta = None

m = Model(td='P3DT12H30M5S')

print(m.model_dump())

>¶

Nummertypen¶

Pydantic ondersteunt de volgende numerieke typen uit de Python-standaardbibliotheek:

`int`¶

Pydantic gebruikt int(v) om typen tot een int te dwingen; zie Gegevensconversie voor details over het verlies van informatie tijdens gegevensconversie.

`float`¶

Pydantic gebruikt float(v) om waarden tot floats te dwingen.

`enum.IntEnum`¶

Validatie: Pydantic controleert of de waarde een geldige IntEnum instantie is.
Validatie voor subklasse van enum.IntEnum : controleert of de waarde een geldig lid is van het gehele getal enum; zie Opsommingen en keuzes voor meer details.

`decimal.Decimal`¶

Validatie: Pydantic probeert de waarde naar een string te converteren en geeft de string vervolgens door aan Decimal(v) .
Serialisatie: Pydantic serialiseert [Decimal][decimaal.Decimaal] typen als tekenreeksen. U kunt desgewenst een aangepaste serialisatiefunctie gebruiken om dit gedrag te overschrijven. Bijvoorbeeld:

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)!

>¶
Met behulp van model_dump blijven zowel x als y exemplaren van het Decimal type
Met behulp van model_dump met mode='json' wordt x geserialiseerd als een string en wordt y geserialiseerd als een float vanwege de toegepaste aangepaste serialisator.
Met behulp van model_dump_json wordt x geserialiseerd als een string en wordt y geserialiseerd als een float vanwege de toegepaste aangepaste serialisator.

`Enum`¶

Pydantic gebruikt de standaard enum klassen van Python om keuzes te definiëren.

enum.Enum controleert of de waarde een geldige Enum -instantie is. Subklasse van enum.Enum controleert of de waarde een geldig lid is van de 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]
    """

Lijsten en tupels¶

`list`¶

Staat list, tuple, set, frozenset, deque, of generatoren en casts naar een list toe. Wanneer een generieke parameter wordt opgegeven, wordt de juiste validatie toegepast op alle items in de lijst.

`typing.List`¶

Op dezelfde manier behandeld als list hierboven.

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`¶

Maakt het mogelijk list, tuple, set, frozenset, deque, of generatoren en casts naar een tuple. Wanneer generieke parameters worden opgegeven, wordt de juiste validatie toegepast op de respectieve items van de tuple

`typing.Tuple`¶

Op dezelfde manier behandeld als tuple hierboven.

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`¶

Subklassen van typing.NamedTuple zijn vergelijkbaar met tuple , maar creëren exemplaren van de gegeven namedtuple klasse.

Subklassen van collections.namedtuple zijn vergelijkbaar met de subklasse van typing.NamedTuple, maar aangezien veldtypen niet zijn gespecificeerd, worden alle velden behandeld alsof ze het type Any hebben.

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¶

[`deque`][collecties.deque]¶

Maakt list, tuple, set, frozenset, deque, of generatoren en casts naar een deque mogelijk. Wanneer generieke parameters worden opgegeven, wordt de juiste validatie toegepast op de respectieve items van de deque .

`typing.Deque`¶

Op dezelfde manier behandeld als deque hierboven.

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

Stelt in¶

`set`¶

Maakt het mogelijk list, tuple, set, frozenset, deque, of generatoren en casts naar een set. Wanneer een generieke parameter wordt opgegeven, wordt de juiste validatie toegepast op alle items van de set.

`typing.Set`¶

Op dezelfde manier behandeld als 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`¶

Maakt het mogelijk list, tuple, set, frozenset, deque, of generatoren en casts naar een frozenset. Wanneer een generieke parameter wordt opgegeven, wordt de juiste validatie toegepast op alle items van de bevroren set.

`typing.FrozenSet`¶

Op dezelfde manier behandeld als frozenset hierboven.

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]

Andere iterabelen¶

[`typing.Sequence` . Reeks ][]¶

Dit is bedoeld voor gebruik wanneer de opgegeven waarde moet voldoen aan de vereisten van de Sequence ABC, en het wenselijk is om de waarden in de container gretig te valideren. Houd er rekening mee dat wanneer validatie moet worden uitgevoerd op de waarden van de container, het type container mogelijk niet behouden blijft, aangezien validatie uiteindelijk waarden kan vervangen. We garanderen dat de gevalideerde waarde een geldige typing.Sequence zal zijn, maar deze kan een ander type hebben dan is opgegeven (doorgaans wordt het een list ).

`typing.Iterable`¶

Dit is bedoeld voor gebruik wanneer de opgegeven waarde mogelijk een iterabele waarde is die niet mag worden gebruikt. Zie Infinite Generators hieronder voor meer informatie over parseren en validatie. Net als bij typing.Sequence garanderen we dat het gevalideerde resultaat een geldig typing.Iterable zal zijn, maar het kan een ander type hebben dan werd opgegeven. In het bijzonder zal, zelfs als er een niet-generatortype zoals een list wordt opgegeven, de postvalidatiewaarde van een veld van het type typing.Iterable een generator zijn.

Hier is een eenvoudig voorbeeld met behulp van 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)

Oneindige generatoren¶

Als u een generator heeft die u wilt valideren, kunt u Sequence nog steeds gebruiken zoals hierboven beschreven. In dat geval wordt de generator gebruikt en opgeslagen in het model als een lijst en worden de waarden ervan gevalideerd aan de hand van de parameter type van de Sequence (bijvoorbeeld int in Sequence[int] ).

Als u echter een generator heeft waarvan u niet gretig gebruik wilt maken (bijvoorbeeld een oneindige generator of een externe gegevenslader), kunt u een veld van het type Iterable gebruiken:

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

!!! waarschuwing Tijdens de initiële validatie voeren Iterable velden alleen een eenvoudige controle uit of het opgegeven argument itereerbaar is. Om te voorkomen dat het wordt verbruikt, wordt er niet gretig een validatie van de opgeleverde waarden uitgevoerd.

Hoewel de opgeleverde waarden niet gretig worden gevalideerd, worden ze nog steeds gevalideerd wanneer ze worden opgeleverd, en zullen ze indien nodig een ValidationError opleveren op het moment van opleveren:

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

Typen in kaart brengen¶

`dict`¶

dict(v) wordt gebruikt om te proberen een woordenboek te converteren. zie typing.Dict hieronder voor subtypebeperkingen.

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

GetyptDict¶

!!! opmerking Dit is een nieuwe functie van de standaardbibliotheek van Python vanaf Python 3.8. Vanwege beperkingen in typing.TypedDict vóór 3.12 is het typering-extensions- pakket vereist voor Python <3.12. U moet TypedDict importeren vanuit typing_extensions in plaats van typing . Als u dat niet doet, krijgt u een buildtime-fout.

TypedDict declareert een woordenboektype dat verwacht dat al zijn instanties een bepaalde set sleutels hebben, waarbij elke sleutel is gekoppeld aan een waarde van een consistent type.

Het is hetzelfde als dict maar Pydantic zal het woordenboek valideren omdat de sleutels geannoteerd zijn.

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

U kunt __pydantic_config__ definiëren om het model te wijzigen dat is overgenomen van TypedDict. Zie de ConfigDict API-referentie voor meer details.

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

Oproepbaar¶

Zie hieronder voor meer informatie over parseren en validatie

Velden kunnen ook van het type Callable zijn:

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>

!!! waarschuwing Oproepbare velden voeren alleen een eenvoudige controle uit of het argument opvraagbaar is; er wordt geen validatie van argumenten, hun typen of het retourtype uitgevoerd.

IP-adrestypen¶

ipaddress.IPv4Address: gebruikt het type zelf voor validatie door de waarde door te geven aan IPv4Address(v) .
ipaddress.IPv4Interface: gebruikt het type zelf voor validatie door de waarde door te geven aan IPv4Address(v) .
ipaddress.IPv4Network: Gebruikt het type zelf voor validatie door de waarde door te geven aan IPv4Network(v) .
ipaddress.IPv6Address: gebruikt het type zelf voor validatie door de waarde door te geven aan IPv6Address(v) .
ipaddress.IPv6Interface: gebruikt het type zelf voor validatie door de waarde door te geven aan IPv6Interface(v) .
ipaddress.IPv6Network: gebruikt het type zelf voor validatie door de waarde door te geven aan IPv6Network(v) .

Zie Netwerktypen voor andere aangepaste IP-adrestypen.

UUID¶

Voor UUID probeert Pydantic het type zelf te gebruiken voor validatie door de waarde door te geven aan UUID(v) . Er is een terugval naar UUID(bytes=v) voor bytes en bytearray .

Als u de UUID-versie wilt beperken, kunt u de volgende typen controleren:

UUID1: vereist UUID versie 1.
UUID3: vereist UUID versie 3.
UUID4: vereist UUID versie 4.
UUID5: vereist UUID versie 5.

Unie¶

Pydantic heeft uitgebreide ondersteuning voor unie-validatie, zowel typing.Union als de pipe-syntaxis van Python 3.10 ( A | B ) worden ondersteund. Lees meer in de sectie Unions van de conceptdocumenten.

`Type` en `TypeVar`¶

`type`¶

Pydantic ondersteunt het gebruik van type[T] om te specificeren dat een veld alleen klassen (geen instanties) mag accepteren die subklassen zijn van T .

`typing.Type`¶

Hetzelfde behandeld als type hierboven.

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

U kunt Type ook gebruiken om aan te geven dat elke klasse is toegestaan.

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 wordt onbeperkt, beperkt of met een grens ondersteund.

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

Geen typen¶

None, type(None) of Literal[None] zijn allemaal gelijkwaardig volgens de typespecificatie . Staat alleen de waarde None .

Snaren¶

str : Tekenreeksen worden geaccepteerd zoals ze zijn. bytes en bytearray worden geconverteerd met behulp van v.decode() . Enums s inheriting from str are converted using v.value`. Alle andere typen veroorzaken een fout.

Strings zijn geen reeksen

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¶

bytes worden geaccepteerd zoals ze zijn. bytearray wordt geconverteerd met behulp van bytes(v) . str worden geconverteerd met behulp van v.encode() . int , float en Decimal worden afgedwongen met str(v).encode() . Zie ByteSize voor meer details.

[`typing.Literal` . Letterlijk ][]¶

Pydantic ondersteunt het gebruik van typing.Literal als een lichtgewicht manier om te specificeren dat een veld alleen specifieke letterlijke waarden mag accepteren:

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

Een voordeel van dit veldtype is dat het kan worden gebruikt om te controleren op gelijkheid met een of meer specifieke waarden zonder dat u aangepaste validators hoeft te declareren:

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

Met de juiste volgorde in een geannoteerde Union kunt u dit gebruiken om soorten afnemende specificiteit te ontleden:

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`¶

Staat elke waarde toe, inclusief None .

`typing.Annotated`¶

Maakt het mogelijk om een ander type te verpakken met willekeurige metadata, volgens PEP-593 . De Annotated hint kan een enkele aanroep naar de Field functie bevatten, maar anders worden de aanvullende metagegevens genegeerd en wordt het roottype gebruikt.

`typing.Pattern`¶

Zorgt ervoor dat de invoerwaarde wordt doorgegeven aan re.compile(v) om een reguliere expressiepatroon te creëren.

`pathlib.Path`¶

Gebruikt eenvoudigweg het type zelf voor validatie door de waarde door te geven aan Path(v) .

本文总阅读量次