Modelos anidados y estructuras recursivas
Gestione eficazmente estructuras JSON profundamente anidadas y modelos de datos recursivos con Pydantic.
Modelos anidados y estructuras recursivas es una lección gratuita de FastAPI Backend Development Bootcamp en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de FastAPI Backend Development Bootcamp, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de FastAPI Backend Development Bootcamp incluye 4 lecciones en total.
Partes de esta lección aún no han sido traducidas y se muestran en inglés.
Understanding Nested Pydantic Models
In real-world applications, data is rarely flat. It often has a hierarchical structure, meaning some data points are collections of other data points.
Nested models in Pydantic allow you to define complex data structures by embedding one BaseModel within another. This helps you build robust and well-organized data schemas.
Defining Your First Nested Model
Let's create an Address model and then use it as a field within a User model. Notice how address: Address links the two.
from pydantic import BaseModel
class Address(BaseModel):
street: str
city: str
zip_code: str
class User(BaseModel):
name: str
email: str
address: Address
# We'll see it in action next!Instantiating Nested Pydantic Models
Now, let's create an instance of our User model. Pydantic automatically validates the nested Address data, ensuring all required fields are present and correctly typed.
from pydantic import BaseModel
class Address(BaseModel):
street: str
city: str
zip_code: str
class User(BaseModel):
name: str
email: str
address: Address
if __name__ == "__main__":
user_data = {
"name": "Alice Wonderland",
"email": "alice@example.com",
"address": {
"street": "123 Rabbit Hole",
"city": "Wonderland",
"zip_code": "90210"
}
}
user = User(**user_data)
print(f"User: {user.name}")
print(f"Lives in: {user.address.city}")
# Pydantic will validate nested data:
try:
User(name="Bob", email="b@example.com", address={"street": "Main"})
except Exception as e:
print(f"\nValidation Error (expected): {e}")Lists of Nested Pydantic Models
You can also have fields that are lists of other Pydantic models. This is common for things like a user having multiple items, or a product having several features.
We use List from the typing module for this.
from typing import List
from pydantic import BaseModel
class Skill(BaseModel):
name: str
level: int # e.g., 1-5
class Developer(BaseModel):
name: str
skills: List[Skill]
if __name__ == "__main__":
dev_data = {
"name": "Grace Hopper",
"skills": [
{"name": "Python", "level": 5},
{"name": "SQL", "level": 4},
{"name": "Algorithms", "level": 3}
]
}
developer = Developer(**dev_data)
print(f"Developer: {developer.name}")
print("Skills:")
for skill in developer.skills:
print(f"- {skill.name} (Level: {skill.level})")Unlocking Recursive Pydantic Models
Sometimes, data structures are even more complex: they refer to themselves. This is called a recursive model.
- Think of a comment section where replies are also comments.
- An organizational chart where employees can have managers who are also employees.
- A file system where folders contain other folders.
Pydantic can handle these self-referencing structures elegantly.
The Challenge of Self-Referencing Types
When a model needs to refer to itself, Python faces a "chicken-and-egg" problem: how can you define a type that isn't fully defined yet?
Pydantic solves this using forward references. In Pydantic v2 (and often in v1 with string literals), you can simply use the model's name as a string for the type hint.
Modeling an Org Chart with Recursion
Let's create an Employee model where an employee can have a manager (who is also an Employee) and a list of subordinates (also Employees).
Notice the use of 'Employee' as a string for the type hint to enable the recursion.
from typing import List, Optional
from pydantic import BaseModel
class Employee(BaseModel):
name: str
title: str
# 'Employee' is a forward reference to itself
manager: Optional['Employee'] = None
subordinates: List['Employee'] = []
# We'll build an org chart in the next scene!Building a Recursive Data Structure
Here's how you can instantiate the Employee model to build a small organizational hierarchy. Pydantic handles the validation of each nested/recursive layer.
from typing import List, Optional
from pydantic import BaseModel
class Employee(BaseModel):
name: str
title: str
manager: Optional['Employee'] = None
subordinates: List['Employee'] = []
if __name__ == "__main__":
# Create employees
ceo = Employee(name="Mr. Boss", title="CEO")
manager_a = Employee(name="Ms. Lead", title="Manager A", manager=ceo)
dev_1 = Employee(name="Dev One", title="Developer", manager=manager_a)
dev_2 = Employee(name="Dev Two", title="Developer", manager=manager_a)
# Link subordinates (Pydantic can also do this from structured data dicts)
manager_a.subordinates.extend([dev_1, dev_2])
ceo.subordinates.append(manager_a)
print(f"Org Chart: {ceo.name} ({ceo.title})")
for sub in ceo.subordinates:
print(f" - {sub.name} ({sub.title})")
for dev in sub.subordinates:
print(f" - {dev.name} ({dev.title})")
# You can also parse a dictionary directly:
org_data = {
"name": "Top CEO", "title": "CEO",
"subordinates": [
{
"name": "Mid Manager", "title": "Manager",
"subordinates": [
{"name": "Junior Dev", "title": "Developer"}
]
}
]
}
full_org = Employee(**org_data)
print(f"\nParsed Org: {full_org.name} -> {full_org.subordinates[0].name} -> {full_org.subordinates[0].subordinates[0].name}")Validation in Recursive Models
Just like with nested models, Pydantic's validation engine works seamlessly with recursive structures. It ensures that every level of the hierarchy conforms to the defined model, catching type errors or missing fields.
This makes handling complex, self-referencing data much safer and easier to manage.
Nested & Recursive Model Check
Let's check your understanding of Pydantic's powerful data modeling features.
Recap: Mastering Complex Data Structures
You've learned how to handle complex data with Pydantic!
- Nested models allow you to compose complex data structures from simpler ones, with automatic validation at every level.
- Recursive models enable you to define self-referencing data, perfect for hierarchies like organizational charts or comment threads.
- Pydantic's use of forward references (often string literals) makes defining recursive types straightforward.
These techniques are fundamental for building robust and clear APIs that interact with structured data.
Preguntas frecuentes
¿La lección «Modelos anidados y estructuras recursivas» es gratis?
Sí — el texto completo de «Modelos anidados y estructuras recursivas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de FastAPI Backend Development Bootcamp, actualiza a CoddyKit PRO. El curso de FastAPI Backend Development Bootcamp incluye 4 lecciones en total.
¿Qué aprenderé en «Modelos anidados y estructuras recursivas»?
Gestione eficazmente estructuras JSON profundamente anidadas y modelos de datos recursivos con Pydantic. Practicas FastAPI Backend Development Bootcamp con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar FastAPI Backend Development Bootcamp?
No se requiere experiencia previa. FastAPI Backend Development Bootcamp en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «Modelos anidados y estructuras recursivas»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de FastAPI Backend Development Bootcamp?
Sí. Cada lección de FastAPI Backend Development Bootcamp incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Validación de campos y validadores de Pydantic
- Tipos de datos y configuración personalizados
- Modelos anidados y estructuras recursivas
- Serialización con model_dump y aliases