Model Bersarang dan Struktur Rekursif
Kendalikan struktur JSON bersarang mendalam dan model data rekursif dengan berkesan menggunakan Pydantic.
Model Bersarang dan Struktur Rekursif ialah pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Kem Intensif Pembangunan Bahagian Belakang FastAPI merangkumi sejumlah 4 pelajaran.
Memahami Model Pydantic Bersarang
Dalam aplikasi dunia sebenar, data jarang berbentuk rata. Data biasanya mempunyai struktur hierarki, iaitu sesetengah titik data merupakan koleksi titik data yang lain.
Model bersarang dalam Pydantic membolehkan anda mentakrifkan struktur data kompleks dengan memasukkan satu BaseModel ke dalam model yang lain. Ini membantu anda membina skema data yang kukuh dan tersusun.
Mentakrifkan Model Bersarang Pertama Anda
Mari cipta model Address dan kemudian gunakannya sebagai medan dalam model User. Perhatikan cara address: Address menghubungkan kedua-duanya.
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!Mencipta Contoh Model Pydantic Bersarang
Sekarang, mari cipta satu tika model User kita. Pydantic mengesahkan data Address bersarang secara automatik untuk memastikan semua medan yang diperlukan wujud dan mempunyai jenis yang betul.
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}")Senarai Model Pydantic Bersarang
Anda juga boleh mempunyai medan yang berupa senarai model Pydantic lain. Ini lazim bagi perkara seperti seorang pengguna yang mempunyai banyak item atau sesuatu produk yang mempunyai beberapa ciri.
Kami menggunakan List daripada modul typing untuk tujuan ini.
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})")Membuka Potensi Model Pydantic Rekursif
Kadangkala, struktur data lebih kompleks: struktur tersebut merujuk kepada dirinya sendiri. Ini dipanggil model rekursif.
- Bayangkan bahagian komen yang balasannya juga merupakan komen.
- Carta organisasi yang pekerjanya boleh mempunyai pengurus yang juga merupakan pekerja.
- Sistem fail yang foldernya mengandungi folder lain.
Pydantic boleh mengendalikan struktur yang merujuk kepada dirinya sendiri ini dengan baik.
Cabaran Jenis yang Merujuk kepada Dirinya Sendiri
Apabila model perlu merujuk kepada dirinya sendiri, Python berdepan masalah "ayam dan telur": bagaimanakah anda mentakrifkan jenis yang belum ditakrifkan sepenuhnya?
Pydantic menyelesaikan masalah ini menggunakan rujukan ke hadapan. Dalam Pydantic v2 (dan selalunya dalam v1 menggunakan literal rentetan), anda hanya perlu menggunakan nama model sebagai rentetan untuk petunjuk jenis.
Memodelkan Carta Organisasi dengan Rekursi
Mari kita cipta model Employee yang membolehkan seorang pekerja mempunyai manager (yang juga merupakan Employee) dan senarai subordinates (juga Employee).
Perhatikan penggunaan 'Employee' sebagai rentetan untuk petunjuk jenis bagi membolehkan rekursi.
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!Membina Struktur Data Rekursif
Beginilah cara anda boleh mencipta tika model Employee untuk membina hierarki organisasi yang kecil. Pydantic mengendalikan pengesahan bagi setiap lapisan bersarang atau rekursif.
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}")Pengesahan dalam Model Rekursif
Sama seperti model bersarang, enjin pengesahan Pydantic berfungsi dengan lancar pada struktur rekursif. Enjin ini memastikan setiap peringkat hierarki mematuhi model yang ditakrifkan, serta mengesan ralat jenis atau medan yang tiada.
Hal ini menjadikan pengendalian data kompleks yang merujuk kepada dirinya sendiri lebih selamat dan mudah diurus.
Semakan Model Bersarang dan Rekursif
Mari semak pemahaman anda tentang ciri pemodelan data Pydantic yang berkuasa.
Ulang Kaji: Menguasai Struktur Data Kompleks
Anda telah mempelajari cara mengendalikan data kompleks dengan Pydantic!
- Model bersarang membolehkan anda menggabungkan struktur data kompleks daripada struktur yang lebih ringkas, dengan pengesahan automatik pada setiap peringkat.
- Model rekursif membolehkan anda mentakrifkan data yang merujuk kepada dirinya sendiri, sesuai untuk hierarki seperti carta organisasi atau rangkaian komen.
- Penggunaan rujukan hadapan oleh Pydantic (selalunya literal rentetan) memudahkan pentakrifan jenis rekursif.
Teknik ini merupakan asas untuk membina API yang kukuh dan jelas, yang berinteraksi dengan data berstruktur.
Pelajari Kem Intensif Pembangunan Bahagian Belakang FastAPI dengan tutor kecerdasan buatan — percuma
Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.
- Kursus
- 21
- Pelajaran
- 84
Soalan Lazim
Adakah pelajaran “Model Bersarang dan Struktur Rekursif” percuma?
Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI, termasuk “Model Bersarang dan Struktur Rekursif”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Kem Intensif Pembangunan Bahagian Belakang FastAPI merangkumi sejumlah 4 pelajaran.
Apakah yang akan saya pelajari dalam “Model Bersarang dan Struktur Rekursif”?
Kendalikan struktur JSON bersarang mendalam dan model data rekursif dengan berkesan menggunakan Pydantic. Anda berlatih Kem Intensif Pembangunan Bahagian Belakang FastAPI menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.
Adakah saya memerlukan pengalaman untuk memulakan Kem Intensif Pembangunan Bahagian Belakang FastAPI?
Tiada pengalaman terdahulu diperlukan. Pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.
Berapa lamakah pelajaran “Model Bersarang dan Struktur Rekursif” diambil?
Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.
Bolehkah saya menulis dan menjalankan kod dalam pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI ini?
Ya. Setiap pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.
Semua pelajaran dalam kursus ini
- Pengesahan Medan dan Pengesah Pydantic
- Jenis Data Tersuai dan Tetapan
- Model Bersarang dan Struktur Rekursif
- Penyirian dengan model_dump dan Alias