python - कहत - विश्व मानचित्र के निर्माणकर्ता




पाइथन में एक शब्दकोश में दो सूचियों को मानचित्र करें (8)

कल्पना कीजिए कि आपके पास है:

keys = ('name', 'age', 'food')
values = ('Monty', 42, 'spam')

निम्नलिखित शब्दकोश का उत्पादन करने का सबसे आसान तरीका क्या है?

dict = {'name' : 'Monty', 'age' : 42, 'food' : 'spam'}

अधिकांश कलाकार - पायथन 2.7 और 3, श्रोताओं की समझ:

ताना कन्स्ट्रक्टर का उपयोग करने में एक संभावित सुधार एक धक्का समझ के मूल वाक्यविन्यास का उपयोग करना है (सूची समझ नहीं, क्योंकि अन्य ने गलती से इसे रखा है):

new_dict = {k: v for k, v in zip(keys, values)}

पायथन 2 में, zip एक अनावश्यक सूची बनाने से बचने के लिए एक सूची देता है, इसके बजाय izip उपयोग करें (ज़िप के लिए उपनाम जब आप पाइथन 3 पर जाते हैं तो कोड परिवर्तन को कम कर सकते हैं)।

from itertools import izip as zip

तो यह अभी भी है:

new_dict = {k: v for k, v in zip(keys, values)}

पायथन 2, <= 2.6 के लिए आदर्श

izip से itertools पायथन 3 में zip बन जाता है। izip पायथन 2 के लिए ज़िप से बेहतर है (क्योंकि यह अनावश्यक सूची निर्माण से बचाता है), और 2.6 या उससे नीचे के लिए आदर्श:

from itertools import izip
new_dict = dict(izip(keys, values))

पायथन 3

पायथन 3 में, zip एक ही फ़ंक्शन बन जाता है जो itertools मॉड्यूल में था, इसलिए यह बस है:

new_dict = dict(zip(keys, values))

यद्यपि एक समझ की समझ अधिक प्रदर्शनकारी होगी (इस उत्तर के अंत में प्रदर्शन समीक्षा देखें)।

सभी मामलों के परिणाम:

सभी मामलों में:

>>> new_dict
{'age': 42, 'name': 'Monty', 'food': 'spam'}

स्पष्टीकरण:

यदि हम dict पर सहायता देखते हैं तो हम देखते हैं कि यह विभिन्न प्रकार के तर्क लेता है:

>>> help(dict)

class dict(object)
 |  dict() -> new empty dictionary
 |  dict(mapping) -> new dictionary initialized from a mapping object's
 |      (key, value) pairs
 |  dict(iterable) -> new dictionary initialized as if via:
 |      d = {}
 |      for k, v in iterable:
 |          d[k] = v
 |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
 |      in the keyword argument list.  For example:  dict(one=1, two=2)

अनावश्यक डेटा संरचनाओं को टालने से बचने के दौरान इष्टतम दृष्टिकोण एक पुनरावर्तनीय उपयोग करना है। पायथन 2 में, ज़िप एक अनावश्यक सूची बनाता है:

>>> zip(keys, values)
[('name', 'Monty'), ('age', 42), ('food', 'spam')]

पायथन 3 में, बराबर होगा:

>>> list(zip(keys, values))
[('name', 'Monty'), ('age', 42), ('food', 'spam')]

और पायथन 3 की zip केवल एक पुनरावृत्त वस्तु बनाता है:

>>> zip(keys, values)
<zip object at 0x7f0e2ad029c8>

चूंकि हम अनावश्यक डेटा संरचनाओं से बचना चाहते हैं, इसलिए हम आमतौर पर पाइथन 2 के zip से बचना चाहते हैं (क्योंकि यह एक अनावश्यक सूची बनाता है)।

कम प्रदर्शन विकल्प:

यह एक जनरेटर अभिव्यक्ति है जो कि कन्स्ट्रक्टर को पास किया जा रहा है:

generator_expression = ((k, v) for k, v in zip(keys, values))
dict(generator_expression)

या समकक्ष:

dict((k, v) for k, v in zip(keys, values))

और यह एक सूची समझने वाला है जो कि कन्स्ट्रक्टर को पारित किया जा रहा है:

dict([(k, v) for k, v in zip(keys, values)])

पहले दो मामलों में, गैर-ऑपरेटिव (इस प्रकार अनावश्यक) गणना की एक अतिरिक्त परत ज़िप पर अचूक रखी जाती है, और सूची समझ के मामले में, एक अतिरिक्त सूची अनावश्यक रूप से बनाई जाती है। मैं उम्मीद करता हूं कि वे सभी कम प्रदर्शन करने वाले हों, और निश्चित रूप से अधिक नहीं।

प्रदर्शन मूल्यांकन:

64 बिट पायथन 3.4.3 में, उबंटू 14.04 पर, सबसे तेज़ से धीमे से आदेश दिया गया:

>>> min(timeit.repeat(lambda: {k: v for k, v in zip(keys, values)}))
0.7836067057214677
>>> min(timeit.repeat(lambda: dict(zip(keys, values))))
1.0321204089559615
>>> min(timeit.repeat(lambda: {keys[i]: values[i] for i in range(len(keys))}))
1.0714934510178864
>>> min(timeit.repeat(lambda: dict([(k, v) for k, v in zip(keys, values)])))
1.6110592018812895
>>> min(timeit.repeat(lambda: dict((k, v) for k, v in zip(keys, values))))
1.7361853648908436

कल्पना कीजिए कि आपके पास है:

keys = ('name', 'age', 'food')
values = ('Monty', 42, 'spam')

निम्नलिखित शब्दकोश का उत्पादन करने का सबसे आसान तरीका क्या है?

a_dict = {'name' : 'Monty', 'age' : 42, 'food' : 'spam'}

यह कोड काम करता है, लेकिन मुझे इस पर गर्व नहीं है:

a_dict = {}
junk = map(lambda k, v: a_dict.update({k: v}), keys, values)

आप नीचे दिए गए कोड का उपयोग कर सकते हैं:

dict(zip(['name', 'age', 'food'], ['Monty', 42, 'spam']))

लेकिन सुनिश्चित करें कि सूचियों की लंबाई समान होगी। अगर लंबाई समान नहीं है। तो ज़िप कार्य लंबे समय तक चालू हो जाता है।


इस कदर:

>>> keys = ['a', 'b', 'c']
>>> values = [1, 2, 3]
>>> dictionary = dict(zip(keys, values))
>>> print(dictionary)
{'a': 1, 'b': 2, 'c': 3}

वोला :-) जोड़ीदार dict और zip फ़ंक्शन बेहद उपयोगी हैं: https://docs.python.org/3/library/functions.html#func-dict


इसे इस्तेमाल करे:

>>> import itertools
>>> keys = ('name', 'age', 'food')
>>> values = ('Monty', 42, 'spam')
>>> adict = dict(itertools.izip(keys,values))
>>> adict
{'food': 'spam', 'age': 42, 'name': 'Monty'}

पायथन 2 में, यह zip की तुलना में स्मृति खपत में भी अधिक किफायती है।


ज़िप समारोह के बिना विधि

l1 = {1,2,3,4,5}
l2 = {'a','b','c','d','e'}
d1 = {}
for l1_ in l1:
    for l2_ in l2:
        d1[l1_] = l2_
        l2.remove(l2_)
        break  

print (d1)


{1: 'd', 2: 'b', 3: 'e', 4: 'a', 5: 'c'}

पायथन 3.x के साथ, dict समझ के लिए चला जाता है

keys = ('name', 'age', 'food')
values = ('Monty', 42, 'spam')

dic = {k:v for k,v in zip(keys, values)}

print(dic)

यहां श्रोताओं की समझ पर अधिक, एक उदाहरण है:

>>> print {i : chr(65+i) for i in range(4)}
    {0 : 'A', 1 : 'B', 2 : 'C', 3 : 'D'}

शब्दकोश समझने का एक और प्राकृतिक तरीका है

keys = ('name', 'age', 'food')
values = ('Monty', 42, 'spam')    
dict = {keys[i]: values[i] for i in range(len(keys))}

>>> keys = ('name', 'age', 'food')
>>> values = ('Monty', 42, 'spam')
>>> dict(zip(keys, values))
{'food': 'spam', 'age': 42, 'name': 'Monty'}




dictionary