Python डिज़ाइन पैटर्न

Composite Pattern in Python

Composite Pattern in Python को संपादित और ऑनलाइन चलाए जा सकने वाले व्यावहारिक उदाहरण से सीखें।

  • उन्नत
  • 2 मिनट में पढ़ें
  • 1 चलाने योग्य उदाहरण

Composite Pattern क्या है?

समस्या क्या है

फ़ोल्डर में फ़ाइलें भी होती हैं और दूसरे फ़ोल्डर भी। मेन्यू में आइटम और सबमेन्यू होते हैं, और एक expression में नंबर और छोटे expression। जिस code को बार-बार जाँचना पड़े कि यह अकेला आइटम है या ग्रुप, वह उलझ जाता है। Composite से दोनों एक ही कॉल का जवाब दे पाते हैं।

ऐसे समझें

Composite पैटर्न किसी पार्सल का कुल वज़न पूछने जैसा है। एक अकेली चीज़ अपना वज़न जानती है। एक डिब्बा अपने अंदर की हर चीज़ से पूछता है, छोटे डिब्बों से भी, और जवाब जोड़ देता है। आप बाहर वाले डिब्बे से वही सवाल पूछते हैं जो किसी अकेली चीज़ से पूछते।

डिब्बे में डिब्बे से code तक
Number(1)📦 एक अकेली चीज़: अपना वज़न जानती है
Sum(...)🗃️ चीज़ों और छोटे डिब्बों वाला डिब्बा
sum(child.total() for child in self.children)➕ डिब्बा हर चाइल्ड से पूछकर जोड़ता है
expression.total()⚖️ पूरे पार्सल के लिए एक सवाल: 6
लीफ़ और ग्रुप एक ही कॉल का जवाब देते हैं।
एक वाक्य में

Composite पैटर्न में अकेला object और objects का ग्रुप, दोनों एक ही interface देते हैं। इसलिए पूरे tree को एक ही object की तरह इस्तेमाल किया जा सकता है।

मुख्य बातें

  1. Number.total() अपनी वैल्यू लौटाता है: यह एक लीफ़ है।
  2. Sum.total() हर चाइल्ड पर total() कॉल करता है और नतीजे जोड़ता है।
  3. Sum का चाइल्ड एक और Sum हो सकता है, जिससे स्ट्रक्चर tree बन जाता है।
  4. expression.total() 6 लौटाता है, और कॉल करने वाले को यह जाँचना नहीं पड़ता कि हर हिस्सा किस तरह का object है।

इसका उपयोग कब करें?

  • tree स्ट्रक्चर: फ़ोल्डर और फ़ाइलें, मेन्यू और सबमेन्यू, ऑर्गनाइज़ेशन चार्ट।
  • nested हिस्सों से बने expression और डॉक्यूमेंट।
  • पूरी हायरार्की पर एक ऑपरेशन लागू करना।

कब ज़रूरत नहीं

  • बिना नेस्टिंग वाले फ़्लैट collection: साधारण list काफ़ी है।
  • लीफ़ और ग्रुप को बहुत अलग ऑपरेशन चाहिए: उन पर एक interface थोपने से अटपटे method जुड़ जाते हैं।

उदाहरण कोड

कोड चलाएँ →
main.py
class Number:
    # Composite: leaves and containers expose the same operation.
    def __init__(self, value): self.value = value
    def total(self): return self.value


class Sum:
    def __init__(self, *children): self.children = children

    def total(self):
        # Treat leaves and nested groups uniformly.
        return sum(child.total() for child in self.children)


expression = Sum(Number(1), Sum(Number(2), Number(3)))
print(expression.total())
इस उदाहरण के लिए Run बटन बनाएँ

अपेक्षित आउटपुट

6

यह कैसे काम करता है

यह उदाहरण Composite Pattern in Python दिखाता है। कोड समझने के लिए इनपुट मान बदलें।

मान बदलें और Python इंस्टॉल किए बिना CodeUtility ऑनलाइन Python कंपाइलर में प्रोग्राम चलाएँ।

अभ्यास के कार्य

बड़े dataset पर जाने से पहले input बदलें और edge cases की जाँच करें।

  1. Pattern की संरचना बनाए रखते हुए उदाहरण का domain बदलें।
  2. Pattern की तुलना सरल implementation से करें और उनके trade-off समझाएँ।
  3. नई implementation जोड़ने से पहले प्रत्येक participant के लिए test लिखें।
Python IDE में चलाएँ →

आम गलतियाँ

साझा method के बजाय टाइप जाँचना

नया node टाइप जुड़ने पर isinstance जाँचिए टूट जाती हैं।

समस्या
if isinstance(child, Number):
    total += child.value
सुधार
total += child.total()

यह पाठ पूरा कर लिया?

अपनी प्रगति ट्रैक करने के लिए इसे सीखा हुआ मार्क करें।

अगला: Observer Pattern in Python →

चैलेंज से अभ्यास करें

इस पाठ में सीखी बात से एक असली समस्या हल करें। हर चैलेंज ब्राउज़र में चलता है, तुरंत टेस्ट और AI रिव्यू के साथ।

सभी चैलेंज