ネストしたモデルと再帰構造
Pydanticを使って、深くネストしたJSON構造や再帰的なデータモデルを効果的に扱います。
「ネストしたモデルと再帰構造」はCoddyKit上の無料FastAPI Backend Development Bootcampレッスンです。 これはレッスン3/4です。 下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応の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.
よくある質問
「ネストしたモデルと再帰構造」レッスンは無料ですか？
はい。「ネストしたモデルと再帰構造」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、FastAPI Backend Development Bootcampコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 FastAPI Backend Development Bootcampコースには全4レッスンが含まれています。
「ネストしたモデルと再帰構造」で何を学びますか？
Pydanticを使って、深くネストしたJSON構造や再帰的なデータモデルを効果的に扱います。 ブラウザで直接実行するハンズオンコードでFastAPI Backend Development Bootcampを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。
FastAPI Backend Development Bootcampを始めるのに経験は必要ですか？
事前経験は必要ありません。CoddyKitのFastAPI Backend Development Bootcampは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。 これはレッスン3/4です。
「ネストしたモデルと再帰構造」レッスンにはどのくらい時間がかかりますか？
ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。
このFastAPI Backend Development Bootcampレッスンでコードを書いて実行できますか？
はい。すべてのFastAPI Backend Development Bootcampレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。