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

Flyweight Pattern in Python

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

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

Flyweight Pattern क्या है?

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

एक टेक्स्ट एडिटर दस लाख character दिखा सकता है, एक गेम हज़ारों पेड़ बना सकता है। जब ज़्यादातर डेटा एक जैसा हो, तो हर एक के लिए पूरा object बनाना मेमोरी बर्बाद करता है। Flyweight साझा हिस्से को शेयर करता है।

ऐसे समझें

Flyweight पोस्टर के लिए स्टैम्प सेट जैसा है। हर बार A आने पर नया A तराशने के बजाय आप A का एक ही स्टैम्प रखते हैं और जहाँ ज़रूरत हो, वहाँ दबा देते हैं। सिर्फ़ जगह बदलती है, स्टैम्प वही रहता है।

स्टैम्प सेट से code तक
Glyph(character)🔠 हर अक्षर के लिए एक स्टैम्प
_cache🗃️ पहले से बने स्टैम्प का डिब्बा
setdefault(character, ...)🔍 स्टैम्प हो तो दोबारा इस्तेमाल कीजिए, न हो तो बनाइए
first is second✅ दोनों A एक ही स्टैम्प इस्तेमाल करते हैं: True
जो हिस्सा दोहराता है उसे शेयर कीजिए। जो अलग है, वह इस्तेमाल के समय दो।
एक वाक्य में

Flyweight पैटर्न में एक जैसे डेटा के लिए हर जगह एक ही object शेयर किया जाता है। बदलने वाला डेटा, जैसे जगह, साझा object के बाहर रखा जाता है।

मुख्य बातें

  1. Glyph सिर्फ़ साझा डेटा रखता है: character।
  2. _cache class-लेवल की dictionary है जो हर character के लिए एक glyph रखती है।
  3. self._cache.setdefault(character, Glyph(character)) रखा हुआ glyph लौटाता है या नया रख देता है।
  4. "A" के लिए दोनों कॉल एक ही object लौटाती हैं, इसलिए first is second True है।

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

  • बहुत बड़ी संख्या में मिलते-जुलते object: डॉक्यूमेंट के character, गेम की टाइल या पेड़।
  • जब object का ज़्यादातर डेटा दोहराता हो, तब मेमोरी कम करना।
  • ऐसी इम्यूटेबल वैल्यू cache करना जिन्हें प्रोग्राम के कई हिस्से इस्तेमाल करते हैं।

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

  • कम object: cache बिना असली बचत के उलझन बढ़ाता है।
  • साझा object जिन्हें कॉल करने वाले बदलते हैं: एक बदलाव हर इस्तेमाल पर असर डालेगा।

उदाहरण कोड

कोड चलाएँ →
main.py
class Glyph:
    # Flyweight: share repeated intrinsic state between many uses.
    def __init__(self, character): self.character = character


class GlyphFactory:
    _cache = {}

    def get(self, character):
        # Reuse immutable intrinsic state.
        return self._cache.setdefault(character, Glyph(character))


factory = GlyphFactory()
first = factory.get("A")
second = factory.get("A")
print(first is second)
print(first.character)
इस उदाहरण के लिए Run बटन बनाएँ

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

True
A

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

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

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

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

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

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

आम गलतियाँ

साझा object में अलग डेटा रखना

अगर हर glyph अपनी जगह रखे, तो शेयर करने से जगहें गड़बड़ा जाएँगी।

समस्या
glyph = factory.get("A")
glyph.x = 10  # changes every A
सुधार
glyph = factory.get("A")
draw(glyph, x=10, y=20)

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

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