पहले से ही उत्तर दिया गया है, लेकिन चूंकि कई लोगों ने शब्दकोश को उलटने का उल्लेख किया है, यहां बताया गया है कि आप इसे एक पंक्ति में कैसे करते हैं (1: 1 मानचित्रण) और कुछ विभिन्न पूर्ण डेटा:
अजगर 2.6:
reversedict = dict([(value, key) for key, value in mydict.iteritems()])
2.7+:
reversedict = {value:key for key, value in mydict.iteritems()}
अगर आपको लगता है कि यह 1: 1 नहीं है, तो आप अभी भी एक युगल लाइनों के साथ एक उचित रिवर्स मैपिंग बना सकते हैं:
reversedict = defaultdict(list)
[reversedict[value].append(key) for key, value in mydict.iteritems()]
यह कितना धीमा है: एक साधारण खोज की तुलना में धीमा, लेकिन लगभग उतना नहीं जितना आप सोचते हैं - 'सीधे' 100000 प्रविष्टि डिक्शनरी पर, एक 'तेज' खोज (यानी एक मूल्य की तलाश में जो कुंजी में जल्दी होनी चाहिए) पूरे शब्दकोश को उलटने की तुलना में लगभग 10x तेज था, और 'धीमी' खोज (अंत की ओर) लगभग 4-5x तेज थी। तो लगभग 10 लुकअप के बाद, यह खुद के लिए भुगतान किया जाता है।
दूसरा संस्करण (प्रति आइटम की सूची के साथ) लगभग 2.5x सरल संस्करण के रूप में लंबे समय तक ले जाता है।
largedict = dict((x,x) for x in range(100000))
# Should be slow, has to search 90000 entries before it finds it
In [26]: %timeit largedict.keys()[largedict.values().index(90000)]
100 loops, best of 3: 4.81 ms per loop
# Should be fast, has to only search 9 entries to find it.
In [27]: %timeit largedict.keys()[largedict.values().index(9)]
100 loops, best of 3: 2.94 ms per loop
# How about using iterkeys() instead of keys()?
# These are faster, because you don't have to create the entire keys array.
# You DO have to create the entire values array - more on that later.
In [31]: %timeit islice(largedict.iterkeys(), largedict.values().index(90000))
100 loops, best of 3: 3.38 ms per loop
In [32]: %timeit islice(largedict.iterkeys(), largedict.values().index(9))
1000 loops, best of 3: 1.48 ms per loop
In [24]: %timeit reversedict = dict([(value, key) for key, value in largedict.iteritems()])
10 loops, best of 3: 22.9 ms per loop
In [23]: %%timeit
....: reversedict = defaultdict(list)
....: [reversedict[value].append(key) for key, value in largedict.iteritems()]
....:
10 loops, best of 3: 53.6 ms per loop
इफिल्टर के साथ कुछ दिलचस्प परिणाम भी मिले। सैद्धांतिक रूप से, इफिल्टर तेज होना चाहिए, इसमें हम itervalues () का उपयोग कर सकते हैं और संभवतः पूरे मान सूची के माध्यम से बनाना / जाना नहीं है। व्यवहार में, परिणाम थे ... विषम ...
In [72]: %%timeit
....: myf = ifilter(lambda x: x[1] == 90000, largedict.iteritems())
....: myf.next()[0]
....:
100 loops, best of 3: 15.1 ms per loop
In [73]: %%timeit
....: myf = ifilter(lambda x: x[1] == 9, largedict.iteritems())
....: myf.next()[0]
....:
100000 loops, best of 3: 2.36 us per loop
इसलिए, छोटे ऑफसेट्स के लिए, यह किसी भी पिछले संस्करण की तुलना में नाटकीय रूप से तेज था (2.36 * u * S बनाम पिछले मामलों के लिए न्यूनतम 1.48 * m * S)। हालाँकि, सूची के अंत के पास बड़े ऑफ़सेट्स के लिए, यह नाटकीय रूप से धीमा था (15.1ms बनाम वही 1.48mS)। कम अंत में छोटी बचत उच्च अंत, इम्हो में लागत के लायक नहीं है।