嵌套模型与递归结构
使用 Pydantic 高效处理深层嵌套的 JSON 结构和递归数据模型。
嵌套模型与递归结构 是 CoddyKit 上的免费 FastAPI Backend Development Bootcamp 课时。 这是第 3 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 FastAPI Backend Development Bootcamp 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 FastAPI Backend Development Bootcamp 课程共包含 4 节课。
本课时的部分内容尚未翻译，以英文显示。
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.
常见问题解答
「嵌套模型与递归结构」课时是免费的吗？
是的 — 「嵌套模型与递归结构」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 FastAPI Backend Development Bootcamp 课程的其余内容，请升级到 CoddyKit PRO。 FastAPI Backend Development Bootcamp 课程共包含 4 节课。
「嵌套模型与递归结构」这节课中我会学到什么？
使用 Pydantic 高效处理深层嵌套的 JSON 结构和递归数据模型。 你通过在浏览器中直接运行的动手代码来练习 FastAPI Backend Development Bootcamp，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 FastAPI Backend Development Bootcamp 需要有经验吗？
无需任何先前经验。CoddyKit 上的 FastAPI Backend Development Bootcamp 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 4 节。
「嵌套模型与递归结构」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 FastAPI Backend Development Bootcamp 课中编写并运行代码吗？
能。每节 FastAPI Backend Development Bootcamp 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。