Какие знаешь сериализаторы?

Сериализаторы в Python

Сериализаторы преобразуют объекты Python в текстовый/бинарный формат и обратно. Вот основные сериализаторы для production разработки.

JSON - встроенный модуль

import json
from datetime import datetime

# Сериализация (объект -> JSON строка)
data = {"name": "John", "age": 30, "active": True}
json_string = json.dumps(data)
print(json_string)  # {"name": "John", "age": 30, "active": true}

# Десериализация (JSON -> объект)
parsed = json.loads(json_string)
print(parsed)  # {"name": "John", "age": 30, "active": True}

# Работа с файлами
with open("data.json", "w") as f:
    json.dump(data, f)

with open("data.json", "r") as f:
    data = json.load(f)

# Кастомный encoder для необычных типов
class CustomEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.isoformat()
        return super().default(obj)

data = {"created_at": datetime.now()}
json_string = json.dumps(data, cls=CustomEncoder)

Pickle - бинарная сериализация

import pickle

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

user = User("Alice", 25)

# Сериализация в bytes
pickled = pickle.dumps(user)
print(pickled)  # b"\x80\x04\x95..."

# Десериализация
restored_user = pickle.loads(pickled)
print(restored_user.name)  # "Alice"

# Работа с файлами
with open("user.pkl", "wb") as f:
    pickle.dump(user, f)

with open("user.pkl", "rb") as f:
    user = pickle.load(f)

# ВАЖНО: pickle может выполнять произвольный код!
# Никогда не распаковывай pickle от ненадёжных источников!

Pydantic - валидация и сериализация

from pydantic import BaseModel, Field, validator
from typing import Optional

class User(BaseModel):
    name: str
    email: str
    age: int = Field(..., ge=0, le=150)
    is_active: bool = True
    
    @validator("email")
    def email_must_be_valid(cls, v):
        if "@" not in v:
            raise ValueError("Invalid email")
        return v

# Создание из словаря
user = User(name="John", email="john@example.com", age=30)

# Сериализация в dict
user_dict = user.dict()
print(user_dict)

# Сериализация в JSON
user_json = user.json()
print(user_json)

# Десериализация из словаря
data = {"name": "Alice", "email": "alice@example.com", "age": 25}
user = User(**data)

MessagePack - компактный бинарный формат

import msgpack

data = {
    "name": "John",
    "age": 30,
    "skills": ["Python", "JavaScript"],
    "active": True
}

# Сериализация
packed = msgpack.packb(data)
print(packed)  # b"\x84\xa4name..."

# Десериализация
unpacked = msgpack.unpackb(packed, raw=False)
print(unpacked)

# MessagePack обычно компактнее JSON на 30-40%
import json
json_size = len(json.dumps(data).encode())
msgpack_size = len(packed)
print(f"JSON: {json_size}, MessagePack: {msgpack_size}")

Protocol Buffers - от Google

# Установка: pip install protobuf

# user.proto (определение схемы)
# syntax = "proto3";
# message User {
#   string name = 1;
#   int32 age = 2;
#   string email = 3;
# }

# Компиляция: protoc --python_out=. user.proto

from user_pb2 import User

# Создание объекта
user = User()
user.name = "John"
user.age = 30
user.email = "john@example.com"

# Сериализация
serialized = user.SerializeToString()
print(serialized)  # b"\n\x04John\x10\x1e..."

# Десериализация
user2 = User()
user2.ParseFromString(serialized)
print(user2.name)  # "John"

PyYAML - человекочитаемый формат

import yaml

data = {
    "name": "John",
    "age": 30,
    "address": {"city": "New York", "zip": "10001"},
    "hobbies": ["reading", "coding"]
}

# Сериализация в YAML
yaml_string = yaml.dump(data)
print(yaml_string)
# name: John
# age: 30
# address:
#   city: New York
# hobbies:
# - reading
# - coding

# Десериализация
parsed = yaml.safe_load(yaml_string)
print(parsed)

# Работа с файлами
with open("config.yaml", "w") as f:
    yaml.dump(data, f)

Marshmallow - маршаллизация данных

from marshmallow import Schema, fields, validate

class UserSchema(Schema):
    name = fields.Str(required=True)
    email = fields.Email(required=True)
    age = fields.Int(validate=validate.Range(min=0, max=150))

schema = UserSchema()

# Сериализация (dump) - dict
data = {"name": "John", "email": "john@example.com", "age": 30}
result = schema.dump(data)
print(result)

# Десериализация (load) - с валидацией
raw_data = {"name": "Alice", "email": "alice@example.com", "age": 25}
result = schema.load(raw_data)
print(result)

# Ошибки валидации
bad_data = {"name": "Bob", "email": "invalid", "age": 200}
result = schema.load(bad_data)  # ValidationError

FastAPI с Pydantic (лучшая практика)

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
from datetime import datetime
from typing import List

app = FastAPI()

class UserCreate(BaseModel):
    name: str = Field(..., min_length=1, max_length=100)
    email: str
    age: int = Field(..., ge=0, le=150)

class UserResponse(UserCreate):
    id: int
    created_at: datetime

users_db = [{"id": 1, "name": "John", "email": "john@example.com", "age": 30, "created_at": datetime.now()}]

@app.get("/users/", response_model=List[UserResponse])
async def get_users():
    return users_db

@app.post("/users/", response_model=UserResponse)
async def create_user(user: UserCreate):
    # FastAPI автоматически валидирует и сериализует
    new_user = {"id": len(users_db) + 1, **user.dict(), "created_at": datetime.now()}
    users_db.append(new_user)
    return new_user

@app.get("/users/{user_id}", response_model=UserResponse)
async def get_user(user_id: int):
    user = next((u for u in users_db if u["id"] == user_id), None)
    if not user:
        raise HTTPException(status_code=404, detail="User not found")
    return user

Сравнение сериализаторов

Рекомендации

• REST API: JSON + Pydantic (встроенная валидация)
• Конфигурационные файлы: YAML
• Микросервисы: MessagePack или Protocol Buffers
• Внутреннее кэширование: Pickle (осторожно с безопасностью)
• Производительность: MessagePack, Protocol Buffers или Pickle
• Человеческая читаемость: JSON или YAML