快捷導(dǎo)航

Python中的Pydantic序列化詳解

更新時間：2023年10月08日 09:55:52 作者：__如風__

這篇文章主要介紹了Python中的Pydantic序列化詳解,Pydantic 是 Python 中一個高性能的數(shù)據(jù)驗證和序列化庫,它提供了一個簡單而強大的方式來定義結(jié)構(gòu)化的數(shù)據(jù),并在應(yīng)用程序的各個層次中使用這些數(shù)據(jù),需要的朋友可以參考下

Pydantic系列之序列化

model_dump

model_dump將對象轉(zhuǎn)化為字典對象，之后便可以調(diào)用Python標準庫序列化為json字符串，會序列化嵌套對象。

也可以使用dict(model)將對象轉(zhuǎn)化為字典，但嵌套對象不會被轉(zhuǎn)化為字典。

自定義序列化

@field_serializer

裝飾在實例方法或者靜態(tài)方法，被裝飾方法可以是以下四種。

(self, value: Any, info: FieldSerializationInfo)
(self, value: Any, nxt: SerializerFunctionWrapHandler, info: FieldSerializationInfo)
(value: Any, info: SerializationInfo)
(value: Any, nxt: SerializerFunctionWrapHandler, info: SerializationInfo)

默認為PlainSerializer，不走pydantic的序列化邏輯，此時的方法簽名只能是1或3，

nxt參數(shù)為pydantic序列化鏈

mode='wrap’支持上述四個方法簽名，可完成前置處理，pydantic序列化邏輯，載返回之前再處理的邏輯。

from datetime import datetime, timedelta, timezone
from pydantic import BaseModel, ConfigDict, field_serializer
from pydantic_core.core_schema import FieldSerializationInfo, SerializerFunctionWrapHandler
class WithCustomEncoders(BaseModel):
    model_config = ConfigDict(ser_json_timedelta='iso8601')
    dt: datetime
    diff: timedelta
    diff2: timedelta
    @field_serializer('dt')
    def serialize_dt(self, dt: datetime, _info: FieldSerializationInfo):
        print(_info)
        return dt.timestamp()
    # 下面的裝飾器先執(zhí)行
    @field_serializer('diff')
    def ssse(self, diff: timedelta, info: FieldSerializationInfo):
        print(info)
        return diff.total_seconds()
    @field_serializer('diff2', mode='wrap')
    @staticmethod
    def diff2_ser(diff2: timedelta, nxt: SerializerFunctionWrapHandler, info: FieldSerializationInfo):
        value = nxt(diff2)
        return value + 'postprocess'
m = WithCustomEncoders(
    dt=datetime(2032, 6, 1, tzinfo=timezone.utc), diff=timedelta(minutes=2),
    diff2=timedelta(minutes=1)
)
print(m.model_dump_json())
# {"dt":1969660800.0,"diff":120.0,"diff2":"PT60Spostprocess"}

@model_serializer

(self, info: FieldSerializationInfo)，mode=‘plain’
(self, nxt: SerializerFunctionWrapHandler, info: FieldSerializationInfo)，mode=‘plain’

from typing import Dict, Any
from pydantic import BaseModel, model_serializer
from pydantic_core.core_schema import SerializerFunctionWrapHandler, SerializationInfo
class Model(BaseModel):
    x: str
    @model_serializer
    def ser_model(self, info: SerializationInfo):
        print(info)
        return {'x': f'xxxxxx {self.x}'}
    @model_serializer(mode='wrap')
    def ser_model_wrap(self, nxt: SerializerFunctionWrapHandler, info: SerializationInfo) -> Dict[str, Any]:
        print(info)
        return {'x': f'serialized {nxt(self)}'}
print(Model(x='test value').model_dump_json())
# {"x":"serialized {'x': 'test value'}"}

PlainSerializer和WrapSerializer

from typing import Any
from typing_extensions import Annotated
from pydantic import BaseModel, SerializerFunctionWrapHandler
from pydantic.functional_serializers import WrapSerializer, PlainSerializer
def ser_wrap(v: Any, nxt: SerializerFunctionWrapHandler) -> str:
    return f'{nxt(v + 1):,}'
FancyInt = Annotated[int, WrapSerializer(ser_wrap, when_used='json')]
DoubleInt = Annotated[int, PlainSerializer(lambda x: x * 2)]
class MyModel(BaseModel):
    x: FancyInt
    y: DoubleInt
print(MyModel(x=1234, y=2).model_dump())
# {'x': 1234, 'y': 4}
print(MyModel(x=1234, y=2).model_dump(mode='json'))
# {'x': '1,235', 'y': 4}

如何指定某個類型的序列化行為

在 pydantic v1 版本，configdict有個json_encoders參數(shù)，可以配置指定類型的序列化行為。在 pydantic v2 版本，不推薦json_encoders參數(shù)，可使用如下方式

def serialize_datetime(value: datetime.datetime, __: SerializerFunctionWrapHandler, _: SerializationInfo):
    return value.strftime('%Y-%m-%d %H:%M:%S')
LocalDateTime = Annotated[datetime.datetime, WrapSerializer(serialize_datetime, when_used='json')]

按照聲明類型序列化，而不是實際類型

當某個屬性的聲明類型是可序列化類型時，如 BaseModel ， dataclass ， TypedDict 等，按照聲明類型序列化，而不是實際類型。如果想改變這種行為，可以使用 SerializeAsAny 。

from pydantic import BaseModel, SerializeAsAny
class User(BaseModel):
    name: str
class UserLogin(User):
    password: str
class OuterModel(BaseModel):
    # 聲明為User類型，按照User類序列化，只有name字段
    user: User
    user1: SerializeAsAny[User] = UserLogin(name='serialize as any', password='hunter')
# 實際類型為UserLogin
user = UserLogin(name='pydantic', password='hunter2')
m = OuterModel(user=user)
print(m)
# user=UserLogin(name='pydantic', password='hunter2') user1=UserLogin(name='serialize as any', password='hunter')
print(m.model_dump())
# {'user': {'name': 'pydantic'}, 'user1': {'name': 'serialize as any', 'password': 'hunter'}}

pickle

# TODO need to get pickling to work
import pickle
from pydantic import BaseModel
class FooBarModel(BaseModel):
    a: str
    b: int
m = FooBarModel(a='hello', b=123)
print(m)
#> a='hello' b=123
data = pickle.dumps(m)
print(data[:20])
#> b'\x80\x04\x95\x95\x00\x00\x00\x00\x00\x00\x00\x8c\x08__main_'
m2 = pickle.loads(data)
print(m2)
#> a='hello' b=123

靈活的exclude和include

exclude，include支持集合，字典
支持集合指定位置序列化或不序列化， exclude = {'items' :{0: True, -1: False} ， include = {'items': {'__all__':{'id':False}}}

from pydantic import BaseModel, SecretStr
class User(BaseModel):
    id: int
    username: str
    password: SecretStr
class Transaction(BaseModel):
    id: str
    user: User
    value: int
t = Transaction(
    id='1234567890',
    user=User(id=42, username='JohnDoe', password='hashedpassword'),
    value=9876543210,
)
# using a set:
print(t.model_dump(exclude={'user', 'value'}))
#> {'id': '1234567890'}
# using a dict:
print(t.model_dump(exclude={'user': {'username', 'password'}, 'value': True}))
#> {'id': '1234567890', 'user': {'id': 42}}
print(t.model_dump(include={'id': True, 'user': {'id'}}))
#> {'id': '1234567890', 'user': {'id': 42}}

到此這篇關(guān)于Python中的Pydantic序列化詳解的文章就介紹到這了,更多相關(guān)Pydantic序列化內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: