FastAPI Backend Development Bootcamp · Pelajaran

Model Bersarang dan Struktur Rekursif

Tangani struktur JSON bertingkat dalam dan model data rekursif secara efektif dengan Pydantic.

Model Bersarang dan Struktur Rekursif adalah pelajaran FastAPI Backend Development Bootcamp gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar FastAPI Backend Development Bootcamp, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus FastAPI Backend Development Bootcamp mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Model Bersarang dan Struktur Rekursif” gratis?

Ya — teks lengkap “Model Bersarang dan Struktur Rekursif” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus FastAPI Backend Development Bootcamp, upgrade ke CoddyKit PRO. Kursus FastAPI Backend Development Bootcamp mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Model Bersarang dan Struktur Rekursif”?

Tangani struktur JSON bertingkat dalam dan model data rekursif secara efektif dengan Pydantic. Kamu berlatih FastAPI Backend Development Bootcamp dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai FastAPI Backend Development Bootcamp?

Tidak diperlukan pengalaman sebelumnya. FastAPI Backend Development Bootcamp di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Model Bersarang dan Struktur Rekursif” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran FastAPI Backend Development Bootcamp ini?

Ya. Setiap pelajaran FastAPI Backend Development Bootcamp menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke FastAPI Backend Development Bootcamp