एकाधिक अनुक्रमणिका के साथ एक शब्दकोश को लागू करने के लिए डेटा संरचना?

Question

मैं एक डेटा संरचना की तलाश में हूं जो दो अलग-अलग इंडेक्स के तहत समान मूल्य रखता है, जहां मैं या तो एक द्वारा डेटा तक पहुंच सकता हूं।

उदाहरण:

x = mysticalDataStructure() 
x.add(1,'karl', dog) 
x.add(2,'lisa', cat) 

$ x[1].age 
2 
$ x['karl'].age 
2 
$ x[1].age = 4 
$ x['karl'].age 
4 

क्या prerolled है, या क्या है सबसे अच्छा तरीका रोल करने मेरे अपने (मैं एक सूचकांक (संख्या 1 की वृद्धि के साथ एन 0 से जा रहा) के द्वारा उपलब्ध है, और के माध्यम से एक स्ट्रिंग)।

collections.ordereddict स्थिति के माध्यम से तेज़ यादृच्छिक पहुंच प्रतीत नहीं होता है, जहां तक ​​मुझे लगता है कि मैं इसे केवल तब तक चल सकता हूं जब तक कि मैं तत्व i तक पहुंच नहीं पाता (मैं सही क्रम में सम्मिलित कर सकता हूं)।

Answer 1

class MultiKeyDict(object): 

    def __init__(self, **kwargs): 
     self._keys = {} 
     self._data = {} 
     for k, v in kwargs.iteritems(): 
      self[k] = v 

    def __getitem__(self, key): 
     try: 
      return self._data[key] 
     except KeyError: 
      return self._data[self._keys[key]] 

    def __setitem__(self, key, val): 
     try: 
      self._data[self._keys[key]] = val 
     except KeyError: 
      if isinstance(key, tuple): 
       if not key: 
        raise ValueError(u'Empty tuple cannot be used as a key') 
       key, other_keys = key[0], key[1:] 
      else: 
       other_keys = [] 
      self._data[key] = val 
      for k in other_keys: 
       self._keys[k] = key 

    def add_keys(self, to_key, new_keys): 
     if to_key not in self._data: 
      to_key = self._keys[to_key] 
     for key in new_keys: 
      self._keys[key] = to_key 


    @classmethod 
    def from_dict(cls, dic): 
     result = cls() 
     for key, val in dic.items(): 
      result[key] = val 
     return result 

उपयोग:

>>> d = MultiKeyDict(a=1, b=2) 
>>> d['c', 'd'] = 3 # two keys for one value 
>>> print d['c'], d['d'] 
3 3 
>>> d['c'] = 4 
>>> print d['d'] 
4 
>>> d.add_keys('d', ('e',)) 
>>> d['e'] 
4 
>>> d2 = MultiKeyDict.from_dict({ ('a', 'b'): 1 }) 
>>> d2['a'] = 2 
>>> d2['b'] 
2 

Answer 2

बस तीन नक्शे का उपयोग करें।

maps = [dict(), dict(), dict()] 

def insert(rec): 
    maps[0][rec[0]] = rec 
    maps[1][rec[1]] = rec 
    maps[2][rec[2]] = rec 

रिक ऑब्जेक्ट के प्रमुख विशेषताओं में परिवर्तन के लिए पुन: सम्मिलन की आवश्यकता होगी। किसी अन्य मानचित्र की तरह, जब आप किसी ऑब्जेक्ट की कुंजी बदलते हैं।

नक्शे बस कुंजी के नक्शे -> वस्तु, सब के बाद। वे वास्तव में वस्तु की प्रतियों को संग्रहित नहीं करते हैं (यह केवल कचरा नहीं है)। तो एक नक्शा एक सूचकांक है, और कुछ नहीं। यदि आप तीन इंडेक्स चाहते हैं, तो तीन मानचित्रों का उपयोग करें। उन्हें प्रबंधित करने के लिए कुछ गोंद कोड फ़ंक्शन लिखें।

index = dict() 

def insert(rec): 
    index[rec[0]] = rec 
    index[rec[1]] = rec 
    index[rec[2]] = rec 

तो आप या तो यह तक पहुंच सकते हैं:

ट्रेवर से उल्लेख किया है, तो आप भी एक साझा शब्दकोश का उपयोग कर सकते हैं।

हालांकि कुंजी टकराव से सावधान!

Answer 3

वहाँ एक विशेष कारण है कि आप सिर्फ एक शब्दकोश का उपयोग नहीं कर सकता है:

x = {} 
x[1] = x['karl'] = dog 
x[2] = x['lisa'] = cat 

तो फिर तुम यह या तो द्वारा पहुँच सकते हैं।

तुम सच में अपने आप को दोहराने के लिए नहीं करना चाहते हैं आप ऐसा करते हैं:

class MysticalDataStructure(dict): 
    def add(self, key1, key2, value): 
     return self[key1] = self[key2] = value 

x = MysticalDataStructure() 
x.add(1, 'karl', dog) 
x.add(2, 'lisa', cat)