मैं समझता हूं कि वे दोनों अनिवार्य रूप से एक ही चीज हैं, लेकिन शैली के संदर्भ में, जो एक खाली सूची या तानाशाही बनाने के लिए उपयोग करने के लिए बेहतर (अधिक पायथोनिक) है?
मैं समझता हूं कि वे दोनों अनिवार्य रूप से एक ही चीज हैं, लेकिन शैली के संदर्भ में, जो एक खाली सूची या तानाशाही बनाने के लिए उपयोग करने के लिए बेहतर (अधिक पायथोनिक) है?
जवाबों:
गति के संदर्भ में, यह खाली सूची / डिट्स के लिए कोई प्रतियोगिता नहीं है:
>>> from timeit import timeit
>>> timeit("[]")
0.040084982867934334
>>> timeit("list()")
0.17704233359267718
>>> timeit("{}")
0.033620194745424214
>>> timeit("dict()")
0.1821558326547077और गैर-खाली के लिए:
>>> timeit("[1,2,3]")
0.24316302770330367
>>> timeit("list((1,2,3))")
0.44744206316727286
>>> timeit("list(foo)", setup="foo=(1,2,3)")
0.446036018543964
>>> timeit("{'a':1, 'b':2, 'c':3}")
0.20868602015059423
>>> timeit("dict(a=1, b=2, c=3)")
0.47635635255323905
>>> timeit("dict(bar)", setup="bar=[('a', 1), ('b', 2), ('c', 3)]")
0.9028228448029267इसके अलावा, ब्रैकेट नोटेशन का उपयोग करने से आप सूची और शब्दकोश समझ का उपयोग कर सकते हैं, जो पर्याप्त कारण हो सकता है।
timeit()फ़ंक्शन एक निर्दिष्ट संख्या में पुनरावृत्तियों को निष्पादित करने के लिए कुल समय की रिपोर्ट करता है, जो 1000000डिफ़ॉल्ट रूप से है। तो ऊपर दिए गए उदाहरण एक लाख बार कोड स्निपेट को चलाने के लिए सेकंड की संख्या हैं। उदाहरण के लिए timeit('dict()', number=1) // -> 4.0531158447265625e-06(एक पुनरावृत्ति) जबकि timeit('dict()') // -> 0.12412905693054199(एक लाख पुनरावृत्तियों)
मेरी राय में []और {}खाली सूची / dicts बनाने के लिए सबसे अधिक पायथोनिक और पठनीय तरीके हैं।
set()हालांकि, उदाहरण के लिए सावधान रहें :
this_set = {5}
some_other_set = {}भ्रामक हो सकता है। पहला एक तत्व के साथ एक सेट बनाता है, दूसरा एक खाली ताना बनाता है, एक सेट नहीं ।
{}हमेशा एक खाली ताना बनाता है। {1,2,3}2.7+ में एक सेट बनाता है, लेकिन 2.6पुराने संस्करणों में एक वाक्यविन्यास त्रुटि है ।
some_epic_setजो एक खाली dictवस्तु की ओर इशारा कर रहा है ... यह एक खाली सेट नहीं है। एक खाली सेट के लिए आपको उपयोग करने की आवश्यकता है set()।
{5}एक तत्व के साथ एक सेट बनाता है, 5और {}एक खाली ताना है।
{*()}एक रिक्त बनाने के लिए उपयोग कर सकते हैं set। मैं इसे वन-आई बंदर ऑपरेटर कहता हूं। :-)
जैसा कि इसके बाइटकोड से छोटा होता है , तानाशाह का शब्द थोड़ा छोटा हो सकता है:
In [1]: import dis
In [2]: a = lambda: {}
In [3]: b = lambda: dict()
In [4]: dis.dis(a)
1 0 BUILD_MAP 0
3 RETURN_VALUE
In [5]: dis.dis(b)
1 0 LOAD_GLOBAL 0 (dict)
3 CALL_FUNCTION 0
6 RETURN_VALUEवही listबनाम पर लागू होता है[]
CALL_FUNCTIONलेता है कम से कम ज्यादा समय के रूप में के रूप में BUILD_MAP(समारोह अनिवार्य रूप से बुलाया जा रहा है BUILD_MAP), और LOAD_GLOBALले जाता है सिर्फ अतिरिक्त भूमि के ऊपर है।
IMHO, अपने पायथन का उपयोग करके list()और dict()सी। ऊग की तरह दिखता है।
[] और सूची () के बीच अंतर के मामले में, एक ऐसी गड़बड़ी है कि मैंने किसी और को इंगित नहीं किया है। यदि आप सूची के सदस्य के रूप में एक शब्दकोश का उपयोग करते हैं, तो दोनों पूरी तरह से अलग परिणाम देंगे:
In [1]: foo_dict = {"1":"foo", "2":"bar"}
In [2]: [foo_dict]
Out [2]: [{'1': 'foo', '2': 'bar'}]
In [3]: list(foo_dict)
Out [3]: ['1', '2'] [foo_dict]का उपयोग करके के रूप में एक ही परिणाम प्राप्त कर सकते हैं list((foo_dict,))। list()विधि के रूप में यह केवल पैरामीटर और दोहराता यह सूची तत्वों को जोड़ने के खत्म हो गया एक iterable लेता है। ऐसा करने से एक समान नुकसान होगा list(some_list)जो सूची को समतल कर देगा।
सूची () और [] अलग तरीके से काम करें:
>>> def a(p=None):
... print(id(p))
...
>>> for r in range(3):
... a([])
...
139969725291904
139969725291904
139969725291904
>>> for r in range(3):
... a(list())
...
139969725367296
139969725367552
139969725367616सूची () हमेशा ढेर में नई वस्तु बनाते हैं, लेकिन [] कई कारणों से मेमोरी सेल का पुन: उपयोग कर सकते हैं।
नीचे दिए गए उदाहरण के रूप में [] और सूची () के बीच व्यवहार में एक अंतर है। यदि हम चाहते हैं कि सूची की संख्या का उपयोग किया जाए, तो हमें एक मैप ऑब्जेक्ट मिलेगा! हालांकि यह कैसे समझा जाए, इस पर कोई यकीन नहीं है।
sth = [(1,2), (3,4),(5,6)]
sth2 = map(lambda x: x[1], sth)
print(sth2) # print returns object <map object at 0x000001AB34C1D9B0>
sth2 = [map(lambda x: x[1], sth)]
print(sth2) # print returns object <map object at 0x000001AB34C1D9B0>
type(sth2) # list
type(sth2[0]) # map
sth2 = list(map(lambda x: x[1], sth))
print(sth2) #[2, 4, 6]
type(sth2) # list
type(sth2[0]) # intएक बॉक्स ब्रैकेट जोड़ी एक सूची ऑब्जेक्ट या एक इंडेक्स सबस्क्रिप्ट, my_List [x] को दर्शाती है।
एक घुंघराले ब्रेस जोड़ी एक शब्दकोश वस्तु को दर्शाता है।
a_list = ['पर', 'बंद', 1, 2]
a_dict = {on: 1, बंद: 2}
यह मुख्य रूप से ज्यादातर समय पसंद का मामला है। यह वरीयता की बात है।
नोट करें कि यदि आपके पास उदाहरण के लिए संख्यात्मक कुंजियाँ हैं, तो आप ऐसा नहीं कर सकते:
mydict = dict(1="foo", 2="bar")आप को करना पड़ेगा:
mydict = {"1":"foo", "2":"bar"}mydict = {1:"foo", 2:"bar"}(कुंजियों के लिए उद्धरण के बिना) करने की आवश्यकता है।
list(i for i in range(10) if i % 2)