पाइथन शब्दकोश कुंजी की स्मृति के साथ जो उपयोग किया गया था?

Question

मैं एक डेटा संरचना बनाना चाहता हूं जो एक अतिरिक्त कार्यक्षमता के साथ एक शब्दकोश की तरह व्यवहार करता है जो कि किस कुंजी को "उपभोग" किया गया है, इसका ट्रैक रखना है। कृपया ध्यान दें कि मैं केवल मूल्यों को पॉप नहीं कर सकता क्योंकि उनका पुन: उपयोग किया जा रहा है।

संरचना इन तीन मामलों का समर्थन करना चाहिए, यानी जब तक पहुँचा के रूप में सेवन किया कुंजी के रूप में चिह्नित:

class DictWithMemory(dict): 

    def __init__(self, *args, **kwargs): 
     self.memory = set() 
     return super(DictWithMemory, self).__init__(*args, **kwargs) 

    def __getitem__(self, key): 
     self.memory.add(key) 
     return super(DictWithMemory, self).__getitem__(key) 

    def __contains__(self, key): 
     self.memory.add(key) 
     return super(DictWithMemory, self).__contains__(key) 

    def get(self, key, d=None): 
     self.memory.add(key) 
     return super(DictWithMemory, self).get(key, d) 

    def unused_keys(self): 
     """ 
     Returns the list of unused keys. 
     """ 
     return set(self.keys()).difference(self.memory) 

जैसा कि मैंने साथ बहुत परिचित नहीं हूँ:

if key in d: 
    ... 
d[key] 
d.get(key) 

यह मैं क्या लिखा है है dict के आंतरिक, क्या इस परिणाम को प्राप्त करने का एक बेहतर तरीका है?

Answer 1

यहां एक समाधान है जो मेटाक्लास के अंदर सबकुछ दूर करता है। मुझे यकीन है कि अगर यह वास्तव में किसी भी अधिक सुरुचिपूर्ण है नहीं कर रहा हूँ, लेकिन यह आप कैसे इस्तेमाल किया कुंजी स्टोर करने के लिए के बारे में अपना मन बदल चाहिए कैप्सूलीकरण की कुछ राशि प्रदान करता है:

class KeyRememberer(type): 

    def __new__(meta, classname, bases, classDict): 
     cls = type.__new__(meta, classname, bases, classDict) 

     # Define init that creates the set of remembered keys 
     def __init__(self, *args, **kwargs): 
      self.memory = set() 
      return super(cls, self).__init__(*args, **kwargs) 
     cls.__init__ = __init__ 

     # Decorator that stores a requested key in the cache 
     def remember(f): 
      def _(self, key, *args, **kwargs): 
       self.memory.add(key) 
       return f(self, key, *args, **kwargs) 
      return _ 

     # Apply the decorator to each of the default implementations 
     for method_name in [ '__getitem__', '__contains__', 'get' ]: 
      m = getattr(cls, method_name) 
      setattr(cls, method_name, remember(m)) 

     return cls 


class DictWithMemory(dict): 

    # A metaclass that ensures the object 
    # has a set called 'memory' as an attribute, 
    # which is updated on each call to __getitem__, 
    # __contains__, or get. 
    __metaclass__ = KeyRememberer 

    def unused_keys(self): 
     """ 
     Returns the list of unused keys. 
     """ 
     print "Used", self.memory 
     return list(set(super(DictWithMemory, 
           self).keys()).difference(self.memory))