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

Chain of Responsibility Pattern in Python

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

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

Chain of Responsibility Pattern क्या है?

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

किसी रिक्वेस्ट को उसके साइज़ या टाइप के हिसाब से कई लोगों या नियमों में से किसी एक को संभालना पड़ सकता है: छोटे ख़र्च टीम लीड, बड़े ख़र्च मैनेजर। अगर भेजने वाले code में ही हार्ड-कोड कर दिया जाए कि कौन क्या संभालेगा, तो नियम बदलना मुश्किल हो जाता है।

ऐसे समझें

Chain of Responsibility दफ़्तर में ऊपर जाते हुए ख़र्च के बिल जैसा है। Team lead 100 तक का बिल पास कर देता है। उससे बड़ा बिल manager के पास जाता है, जो 1000 तक पास करता है। कर्मचारी बिल सिर्फ़ lead को देता है, उसे यह जानने की ज़रूरत नहीं कि आख़िर में कौन पास करेगा।

ख़र्च के बिल से code तक
Approver("Lead", 100, ...)🧑 Team lead: 100 तक पास करता है
if amount <= self.limit:✅ क्या यह मेरी सीमा के अंदर है?
self.next.approve(amount)⬆️ नहीं: अगले व्यक्ति को दे दीजिए
"Manager approved 500"🧑‍💼 Manager पास कर देता है
हर handler या तो रिक्वेस्ट संभालता है या आगे भेज देता है।
एक वाक्य में

Chain of Responsibility पैटर्न एक रिक्वेस्ट को हैंडलर्स की चेन में तब तक आगे भेजता है जब तक कोई उसे संभाल न ले, ताकि भेजने वाले को यह जानने की ज़रूरत न हो कि कौन सा handler जवाब देगा।

मुख्य बातें

  1. हर Approver के पास एक limit और एक ऑप्शनल next approver है।
  2. अगर रकम self.limit के अंदर है, तो approve उसे संभाल लेता है।
  3. वरना यह self.next.approve(amount) कॉल करके रिक्वेस्ट आगे भेजता है।
  4. 500 Lead की 100 की लिमिट से ज़्यादा है, इसलिए Manager उसे मंज़ूर करता है। 1000 से ऊपर नतीजा "Declined" होगा।

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

  • बढ़ती लिमिट वाले अप्रूवल वर्कफ़्लो।
  • सपोर्ट एस्केलेशन और रिक्वेस्ट रूटिंग।
  • वेब फ़्रेमवर्क में मिडलवेयर, जहाँ हर परत रिक्वेस्ट संभाल सकती है या आगे भेज सकती है।

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

  • हमेशा ठीक एक ही handler लागू होता है: सीधा लुकअप आसान है।
  • ऐसी रिक्वेस्ट जिसे हर स्टेप को संभालना है: वह पाइपलाइन है, चेन नहीं।

उदाहरण कोड

कोड चलाएँ →
main.py
class Approver:
    # Chain of Responsibility: offer a request to handlers in order.
    def __init__(self, name, limit, next_approver=None):
        self.name, self.limit, self.next = name, limit, next_approver

    def approve(self, amount):
        # Handle locally or pass the request along the chain.
        if amount <= self.limit:
            return f"{self.name} approved {amount}"
        if self.next:
            return self.next.approve(amount)
        return "Declined"


chain = Approver("Lead", 100, Approver("Manager", 1000))
print(chain.approve(500))
इस उदाहरण के लिए Run बटन बनाएँ

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

Manager approved 500

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

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

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

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

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

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

आम गलतियाँ

चेन का अंत भूल जाना

जाँच के बिना आख़िरी handler None.approve कॉल करता है और क्रैश हो जाता है।

समस्या
return self.next.approve(amount)
सुधार
if self.next:
    return self.next.approve(amount)
return "Declined"

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

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