मैं एक कुंजी के लिए एकाधिक कुंजी के साथ एक शब्दकोश कैसे बना सकता हूं?

Question

मेरे पास एक शब्दकोश के बारे में एक प्रश्न है जिसे मैं बनाना चाहता हूं।

dictionary = {('a', 'b'): 1, ('c', 'd'): 2} 
assert dictionary['a'] == 1 
assert dictionary['b'] == 1 

कोई भी विचार: मेरा लक्ष्य है, एक एकल मूल्य के लिए कई कुंजी नीचे की तरह है?

Answer 1

आपका कोड सिर्फ काम करता है:

In [1]: mydict ={('a','b'):1,('c','d'):2} 

In [2]: mydict 
Out[2]: {('a', 'b'): 1, ('c', 'd'): 2} 

In [3]: mydict['a', 'b'] 
Out[3]: 1 

In [4]: mydict[('a', 'b')] 
Out[4]: 1 

ध्यान दें कि उपरोक्त कोड अजगर 2.7.8 का उपयोग कर मार डाला गया था।

Answer 2

मुझे लगता है कि आप इस मतलब है:

class Value: 
    def __init__(self, v=None): 
     self.v = v 

v1 = Value(1) 
v2 = Value(2) 

d = {'a': v1, 'b': v1, 'c': v2, 'd': v2} 
d['a'].v += 1 

d['b'].v == 2 # True 

• पायथन के तार और संख्या अपरिवर्तनीय वस्तुओं रहे हैं,
• इसलिए, यदि आप को एक जैसा मान है कि "बात करने के लिए d['a'] और d['b'] चाहते अद्यतन "जैसा कि यह बदलता है, मान को उत्परिवर्तनीय ऑब्जेक्ट (ऊपर की तरह उपयोगकर्ता परिभाषित वर्ग, या dict,देखें, set)।
• फिर, जब आप d['a'] पर वस्तु को संशोधित, क्योंकि एक ही वस्तु के लिए वे दोनों बिंदु एक ही समय में d['b'] बदल जाता है।

Answer 3

आपका उदाहरण एकाधिक कुंजी बनाता है: fromkeys का उपयोग करते हुए मूल्य जोड़े। यदि आप यह नहीं चाहते हैं, तो आप एक कुंजी का उपयोग कर सकते हैं और कुंजी के लिए उपनाम बना सकते हैं। उदाहरण के लिए यदि आप एक रजिस्टर मानचित्र का उपयोग कर रहे हैं, तो आपकी कुंजी रजिस्टर पता हो सकती है और उपनाम रजिस्टर नाम हो सकता है। इस तरह आप सही रजिस्टर पर पढ़ने/लिखने के संचालन कर सकते हैं।

>>> mydict = {} 
>>> mydict[(1,2)] = [30, 20] 
>>> alias1 = (1,2) 
>>> print mydict[alias1] 
[30, 20] 
>>> mydict[(1,3)] = [30, 30] 
>>> print mydict 
{(1, 2): [30, 20], (1, 3): [30, 30]} 
>>> alias1 in mydict 
True 

Answer 4

आप अक्सर आप एक वर्ग आधारित दृष्टिकोण लेने के लिए चाहते हैं @ करने के लिए कुछ इसी तरह इस में Latty के जवाब अतः 2d-dictionary-with-many-keys-that-will-return-the-same-value सवाल इस शब्दकोश में जोड़ने से जा करने के लिए जा रहे हैं।

हालांकि, यदि आपके पास एक स्थिर शब्दकोश है, और आपको केवल एकाधिक कुंजी द्वारा मूल्यों की आवश्यकता है तो आप केवल दो शब्दकोशों का उपयोग करने का एक बहुत ही सरल मार्ग जा सकते हैं। एक उर्फ ​​कुंजी संघ स्टोर करने के लिए और एक अपने वास्तविक डाटा स्टोर करने की:

def add(key, id, value=None) 
    if id in dict: 
     if key in alias: 
      # Do nothing 
      pass 
     else: 
      alias[key] = id 
    else: 
     dict[id] = value 
     alias[key] = id 

add('e', 'id2') 
add('f', 'id3', 3) 

जबकि:

alias = { 
    'a': 'id1', 
    'b': 'id1', 
    'c': 'id2', 
    'd': 'id2' 
} 

dict = { 
    'id1': 1, 
    'id2': 2 
} 

dict[alias['a']] 

तुम दोनों शब्दकोशों प्रयोग करने के लिए इस तरह एक समारोह लिख सकता है आप शब्दकोश में जोड़ने के लिए की जरूरत है यह काम करता है, मुझे लगता है कि आखिरकार यदि आप इस लेखन की तरह कुछ करना चाहते हैं तो आपकी खुद की डेटा संरचना शायद जाने का तरीका है, हालांकि यह एक समान संरचना का उपयोग कर सकती है।

Answer 5

यह आसान है। पहली बात यह है कि आपको पाइथन दुभाषिया के डिजाइन को समझना है। यह मूल रूप से सभी चरों के लिए स्मृति आवंटित नहीं करता है यदि किसी भी दो या अधिक चर के समान मूल्य है तो यह उस मान पर नक्शा लगाता है।जब मैं एक नया वेरिएबल ई बना सकते हैं और एक मूल्य (स्टोर

के कोड उदाहरण के लिए चलते हैं,

In [6]: a = 10 

In [7]: id(a) 
Out[7]: 10914656 

In [8]: b = 10 

In [9]: id(b) 
Out[9]: 10914656 

In [10]: c = 11 

In [11]: id(c) 
Out[11]: 10914688 

In [12]: d = 21 

In [13]: id(d) 
Out[13]: 10915008 

In [14]: e = 11 

In [15]: id(e) 
Out[15]: 10914688 

In [16]: e = 21 

In [17]: id(e) 
Out[17]: 10915008 

In [18]: e is d 
Out[18]: True 
In [19]: e = 30 

In [20]: id(e) 
Out[20]: 10915296 

ऊपर उत्पादन, चर ए और बी के शेयरों में एक ही स्मृति, ग और घ से अलग मेमोरी है 11) जो वैरिएबल सी में पहले से मौजूद है, इसलिए यह उस मेमोरी लोकेशन में मैप किया गया है और जब मैं वैरिएबल ई से 21 में मौजूद मान को बदलता हूं तो एक नई मेमोरी नहीं बनाता है जो पहले से ही वेरिएबल डी में मौजूद है, इसलिए अब चर और ई एक ही स्मृति स्थान साझा करें। अंत में, मैं वैरिएबल ई से 30 में मान बदलता हूं जो किसी भी अन्य चर में संग्रहीत नहीं होता है, इसलिए यह ई के लिए एक नई मेमोरी बनाता है।

इसलिए कोई भी वैरिएबल जो समान मान वाला है वह स्मृति साझा करता है।

Not for list and dictionary objects

चलिए आपके प्रश्न पर आते हैं।

जब एकाधिक कुंजियों का एक ही मूल्य होता है तो सभी समान स्मृति साझा करते हैं, इसलिए आप जिस चीज की अपेक्षा करते हैं वह पहले से ही पाइथन में है।

आप बस इस

In [49]: dictionary = { 
    ...:  'k1':1, 
    ...:  'k2':1, 
    ...:  'k3':2, 
    ...:  'k4':2} 
    ...:  
    ...:  

In [50]: id(dictionary['k1']) 
Out[50]: 10914368 

In [51]: id(dictionary['k2']) 
Out[51]: 10914368 

In [52]: id(dictionary['k3']) 
Out[52]: 10914400 

In [53]: id(dictionary['k4']) 
Out[53]: 10914400 

ऊपर उत्पादन से की तरह उपयोग कर सकते हैं, कुंजी k1 और k2 एक ही पते से मैप मूल्य एक स्मृति में केवल एक बार संग्रहीत है जो कई प्रमुख एकल मान शब्दकोश है जिसका मतलब है यह वही चीज है जो आप चाहते हैं। : पी