Serializacja za pomocą model_dump i aliasów
Kontroluj konwersję modeli Pydantic do danych i z danych za pomocą model_dump, aliasów pól, pól obliczanych i opcji serializacji, aby tworzyć przejrzyste payloady API.
Serializacja za pomocą model_dump i aliasów to bezpłatna lekcja FastAPI Backend Development Bootcamp na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej FastAPI Backend Development Bootcamp, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs FastAPI Backend Development Bootcamp zawiera 4 lekcji w sumie.
Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.
Serialization vs Validation
Pydantic does two jobs: validation (untrusted input becomes a typed model) and serialization (a model becomes a dict or JSON to send out). This lesson focuses on controlling the output side precisely.
model_dump Basics
In Pydantic v2, model_dump() turns a model into a dict and model_dump_json() into a JSON string.
from pydantic import BaseModel
class User(BaseModel):
name: str
age: int
u = User(name='Ada', age=36)
print(u.model_dump())
print(u.model_dump_json())Including and Excluding Fields
Trim the output with include or exclude to hide internal or sensitive fields from a payload.
u.model_dump(exclude={'age'})
u.model_dump(include={'name'})Dropping Defaults and None
Use exclude_none=True or exclude_defaults=True to produce leaner payloads that omit empty values.
class Profile(BaseModel):
name: str
bio: str | None = None
Profile(name='Ada').model_dump(exclude_none=True)Field Aliases
External APIs often use names like userName while Python prefers user_name. An alias maps between them.
from pydantic import BaseModel, Field
class User(BaseModel):
user_name: str = Field(alias='userName')Serializing by Alias
By default model_dump uses the Python field names. Pass by_alias=True to output the alias names instead.
u = User(userName='ada')
print(u.model_dump())
print(u.model_dump(by_alias=True))populate_by_name
Set model_config = ConfigDict(populate_by_name=True) to accept either the field name or the alias when parsing input, giving you flexibility on both ends.
from pydantic import ConfigDict
class User(BaseModel):
model_config = ConfigDict(populate_by_name=True)
user_name: str = Field(alias='userName')Computed Fields
Expose derived values in the output with @computed_field. They appear in model_dump but are not part of the input.
from pydantic import computed_field
class Person(BaseModel):
first: str
last: str
@computed_field
@property
def full(self) -> str:
return self.first + ' ' + self.lastCustom Field Serializers
Use @field_serializer to control how a specific field is rendered, for example formatting a datetime or masking a secret.
from pydantic import field_serializer
class Account(BaseModel):
card: str
@field_serializer('card')
def mask(self, v: str) -> str:
return '****' + v[-4:]Alias Mapping in Plain Python
The by_alias transform is just key renaming. Here is the concept without Pydantic.
data = {'user_name': 'ada', 'user_age': 36}
alias = {'user_name': 'userName', 'user_age': 'userAge'}
out = {alias[k]: v for k, v in data.items()}
print(out)FastAPI Response Integration
FastAPI serializes return values through your response_model. Set response_model_by_alias and exclusion flags on the route to shape the JSON your API emits.
@app.get('/user', response_model=User, response_model_by_alias=True)
async def get_user():
return User(user_name='ada')Quick Check
Your model has user_name: str = Field(alias='userName'). What does model_dump(by_alias=True) produce for the key?
Recap
You mastered Pydantic serialization:
model_dump/model_dump_jsonwith include, exclude, and exclude_none.- Aliases plus
by_aliasandpopulate_by_name. - Computed fields and custom field serializers.
- Wiring it into FastAPI response models.
Często zadawane pytania
Czy lekcja „Serializacja za pomocą model_dump i aliasów” jest bezpłatna?
Tak — pełny tekst „Serializacja za pomocą model_dump i aliasów” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu FastAPI Backend Development Bootcamp, przejdź na CoddyKit PRO. Kurs FastAPI Backend Development Bootcamp zawiera 4 lekcji w sumie.
Co nauczysz się w „Serializacja za pomocą model_dump i aliasów”?
Kontroluj konwersję modeli Pydantic do danych i z danych za pomocą model_dump, aliasów pól, pól obliczanych i opcji serializacji, aby tworzyć przejrzyste payloady API. Ćwiczysz FastAPI Backend Development Bootcamp z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć FastAPI Backend Development Bootcamp?
Nie wymagamy żadnego doświadczenia. FastAPI Backend Development Bootcamp w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.
Ile czasu zajmuje lekcja „Serializacja za pomocą model_dump i aliasów”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji FastAPI Backend Development Bootcamp?
Tak. Każda lekcja FastAPI Backend Development Bootcamp zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Walidacja pól Pydantic i walidatory
- Niestandardowe typy danych i ustawienia
- Modele zagnieżdżone i struktury rekurencyjne
- Serializacja za pomocą model_dump i aliasów