FastAPI बैकएंड डेवलपमेंट बूटकैंप · पाठ

नेस्टेड मॉडल और पुनरावर्ती संरचनाएँ

Pydantic की सहायता से गहराई से नेस्टेड JSON संरचनाओं और पुनरावर्ती डेटा मॉडल को प्रभावी ढंग से संभालें।

पाठ 3, कुल 4 में से11 चरण

नेस्टेड मॉडल और पुनरावर्ती संरचनाएँ, CoddyKit पर FastAPI बैकएंड डेवलपमेंट बूटकैंप का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह FastAPI बैकएंड डेवलपमेंट बूटकैंप सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। FastAPI बैकएंड डेवलपमेंट बूटकैंप पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

नेस्टेड Pydantic मॉडलों को समझना

वास्तविक अनुप्रयोगों में डेटा शायद ही कभी समतल होता है। इसकी संरचना अक्सर पदानुक्रमित होती है, अर्थात कुछ डेटा बिंदु अन्य डेटा बिंदुओं के संग्रह होते हैं।

Pydantic में नेस्टेड मॉडल आपको एक BaseModel को दूसरे के भीतर रखकर जटिल डेटा संरचनाएँ परिभाषित करने देते हैं। इससे आप मजबूत और सुव्यवस्थित डेटा स्कीमा बना सकते हैं।

अपना पहला नेस्टेड मॉडल परिभाषित करना

आइए एक Address मॉडल बनाएँ और फिर उसे User मॉडल के भीतर एक फ़ील्ड के रूप में उपयोग करें। ध्यान दें कि address: Address दोनों को कैसे जोड़ता है।

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!

नेस्टेड Pydantic मॉडल का इंस्टैंस बनाना

अब आइए अपने User मॉडल का एक इंस्टैंस बनाएँ। Pydantic नेस्टेड Address डेटा का स्वतः सत्यापन करता है और सुनिश्चित करता है कि सभी आवश्यक फ़ील्ड मौजूद हों तथा उनके प्रकार सही हों।

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}")

नेस्टेड Pydantic मॉडलों की सूचियाँ

आप ऐसे फ़ील्ड भी रख सकते हैं जो अन्य Pydantic मॉडलों की सूचियाँ हों। यह तब सामान्य है जब किसी उपयोगकर्ता के पास कई आइटम हों या किसी उत्पाद में कई विशेषताएँ हों।

इसके लिए हम typing मॉड्यूल से List का उपयोग करते हैं।

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})")

पुनरावर्ती Pydantic मॉडलों की शक्ति

कभी-कभी डेटा संरचनाएँ और भी जटिल होती हैं: वे स्वयं का संदर्भ देती हैं। इसे पुनरावर्ती मॉडल कहते हैं।

  • ऐसे टिप्पणी अनुभाग की कल्पना करें जहाँ उत्तर भी टिप्पणियाँ हों।
  • ऐसा संगठनात्मक चार्ट जहाँ कर्मचारियों के प्रबंधक भी कर्मचारी हों।
  • ऐसी फ़ाइल प्रणाली जहाँ फ़ोल्डरों के भीतर अन्य फ़ोल्डर हों।

Pydantic इन स्वयं-संदर्भित संरचनाओं को आसानी से संभाल सकता है।

स्वयं-संदर्भित प्रकारों की चुनौती

जब किसी मॉडल को स्वयं का संदर्भ देना हो, तो Python के सामने "मुर्गी और अंडे" जैसी समस्या आती है: ऐसे प्रकार को कैसे परिभाषित करें जो अभी पूरी तरह परिभाषित ही नहीं हुआ है?

Pydantic इसे अग्रिम संदर्भों की सहायता से हल करता है। Pydantic v2 में (और अक्सर v1 में स्ट्रिंग लिटरल के साथ) आप प्रकार संकेत के लिए मॉडल के नाम को स्ट्रिंग के रूप में सीधे उपयोग कर सकते हैं।

पुनरावर्तन से संगठनात्मक चार्ट बनाना

आइए एक Employee मॉडल बनाएँ, जिसमें किसी कर्मचारी का manager (जो स्वयं भी Employee है) और subordinates की एक सूची (जो Employee के ही इंस्टैंस हैं) हो सकती है।

ध्यान दें कि पुनरावर्तन सक्षम करने के लिए प्रकार संकेत में 'Employee' को स्ट्रिंग के रूप में उपयोग किया गया है।

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!

पुनरावर्ती डेटा संरचना बनाना

यहाँ बताया गया है कि एक छोटी संगठनात्मक पदानुक्रम बनाने के लिए Employee मॉडल का इंस्टैंस कैसे बनाया जा सकता है। Pydantic प्रत्येक नेस्टेड या पुनरावर्ती स्तर का सत्यापन संभालता है।

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}")

पुनरावर्ती मॉडलों में सत्यापन

नेस्टेड मॉडलों की तरह ही, Pydantic का सत्यापन इंजन पुनरावर्ती संरचनाओं के साथ भी सहजता से काम करता है। यह सुनिश्चित करता है कि पदानुक्रम का प्रत्येक स्तर परिभाषित मॉडल के अनुरूप हो और प्रकार संबंधी त्रुटियों या गायब फ़ील्ड का पता लगा सके।

इससे जटिल, स्वयं-संदर्भित डेटा को संभालना अधिक सुरक्षित और आसान हो जाता है।

नेस्टेड और पुनरावर्ती मॉडल की जाँच

आइए Pydantic की शक्तिशाली डेटा मॉडलिंग सुविधाओं की आपकी समझ जाँचें।

पुनरावलोकन: जटिल डेटा संरचनाओं में निपुणता

आपने Pydantic के साथ जटिल डेटा को संभालना सीख लिया है!

  • नेस्टेड मॉडल आपको सरल संरचनाओं से जटिल डेटा संरचनाएँ बनाने देते हैं और हर स्तर पर स्वचालित सत्यापन करते हैं।
  • पुनरावर्ती मॉडल आपको स्वयं को संदर्भित करने वाले डेटा को परिभाषित करने देते हैं, जो संगठनात्मक चार्ट या टिप्पणी-श्रृंखलाओं जैसी पदानुक्रमित संरचनाओं के लिए बहुत उपयोगी हैं।
  • Pydantic में फ़ॉरवर्ड संदर्भों (अक्सर स्ट्रिंग लिटरल) का उपयोग पुनरावर्ती प्रकारों को आसानी से परिभाषित करना संभव बनाता है।

संरचित डेटा के साथ काम करने वाले मज़बूत और स्पष्ट API बनाने के लिए ये तकनीकें मूलभूत हैं।

शुरुआत निःशुल्क

एआई शिक्षक के साथ FastAPI बैकएंड डेवलपमेंट बूटकैंप सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम
21
पाठ
84

अक्सर पूछे जाने वाले प्रश्न

क्या “नेस्टेड मॉडल और पुनरावर्ती संरचनाएँ” पाठ निःशुल्क है?

हाँ — FastAPI बैकएंड डेवलपमेंट बूटकैंप अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “नेस्टेड मॉडल और पुनरावर्ती संरचनाएँ” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। FastAPI बैकएंड डेवलपमेंट बूटकैंप पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“नेस्टेड मॉडल और पुनरावर्ती संरचनाएँ” में मैं क्या सीखूँगा?

Pydantic की सहायता से गहराई से नेस्टेड JSON संरचनाओं और पुनरावर्ती डेटा मॉडल को प्रभावी ढंग से संभालें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ FastAPI बैकएंड डेवलपमेंट बूटकैंप का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या FastAPI बैकएंड डेवलपमेंट बूटकैंप शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर FastAPI बैकएंड डेवलपमेंट बूटकैंप शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।

“नेस्टेड मॉडल और पुनरावर्ती संरचनाएँ” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस FastAPI बैकएंड डेवलपमेंट बूटकैंप पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर FastAPI बैकएंड डेवलपमेंट बूटकैंप पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

  1. Pydantic फ़ील्ड सत्यापन और वैलिडेटर
  2. कस्टम डेटा प्रकार और सेटिंग्स
  3. नेस्टेड मॉडल और पुनरावर्ती संरचनाएँ
  4. model_dump और उपनामों के साथ सीरियलाइज़ेशन
← FastAPI बैकएंड डेवलपमेंट बूटकैंप पर वापस जाएँ