python - सूची (] से तेज [] क्यों है?

चूंकि list एक स्ट्रिंग को एक सूची ऑब्जेक्ट में बदलने के लिए एक function है, जबकि [] का उपयोग बल्ले से एक सूची बनाने के लिए किया जाता है। इसे आज़माएं (आपको अधिक समझ हो सकता है):

x = "wham bam"
a = list(x)
>>> a
["w", "h", "a", "m", ...]

जबकि

y = ["wham bam"]
>>> y
["wham bam"]

आपको एक वास्तविक सूची देता है जिसमें आप जो भी डालते हैं।

list() [] से तेज [] क्यों है?

सबसे बड़ा कारण यह है कि पाइथन list() उपयोगकर्ता द्वारा परिभाषित फ़ंक्शन की तरह व्यवहार करता है, जिसका अर्थ है कि आप इसे list और कुछ अलग करने के list किसी अन्य चीज़ को अलिया करके इसे रोक सकते हैं (जैसे कि अपनी स्वयं की उप-वर्गीकृत सूची या शायद एक डेक का उपयोग करें)।

यह तुरंत [] साथ एक सूची बनाता है।

मेरी व्याख्या आपको इसके लिए अंतर्ज्ञान देना चाहती है।

व्याख्या

[] आमतौर पर शाब्दिक वाक्यविन्यास के रूप में जाना जाता है।

व्याकरण में, इसे "सूची प्रदर्शन" के रूप में जाना जाता है। दस्तावेज़ों से :

एक सूची प्रदर्शन स्क्वायर ब्रैकेट में संलग्न अभिव्यक्तियों की संभावित रूप से खाली श्रृंखला है:

list_display ::=  "[" [starred_list | comprehension] "]"

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

संक्षेप में, इसका मतलब है कि टाइप list की एक अंतर्निहित वस्तु बनाई गई है।

इस पर कोई बाधा नहीं है - जिसका अर्थ है कि पाइथन इसे जितनी जल्दी हो सके कर सकता है।

दूसरी तरफ, बिल्टिन सूची कन्स्ट्रक्टर का उपयोग करके एक बिल्टिन list बनाने से list() को अवरुद्ध किया जा सकता है।

उदाहरण के लिए, हम चाहते हैं कि हमारी सूचियों को शोर से बनाया जाए:

class List(list):
    def __init__(self, iterable=None):
        if iterable is None:
            super().__init__()
        else:
            super().__init__(iterable)
        print('List initialized.')

हम मॉड्यूल स्तर के वैश्विक दायरे पर नाम list को रोक सकते हैं, और फिर जब हम एक list बनाते हैं, तो हम वास्तव में हमारी उप-सूची सूची बनाते हैं:

>>> list = List
>>> l = list()
List initialized.
>>> type(l)
<class '__main__.List'>

इसी तरह हम इसे वैश्विक नामस्थान से हटा सकते हैं

del list

और इसे बिल्टिन नेमस्पेस में रखें:

import builtins
builtins.list = List

और अब:

>>> l0 = list()
List initialized.
>>> type(l0)
<class '__main__.List'>

और ध्यान दें कि सूची प्रदर्शन बिना किसी शर्त के एक सूची बनाता है:

>>> l1 = []
>>> type(l1)
<class 'list'>

हम शायद यह अस्थायी रूप से केवल ऐसा करते हैं, इसलिए हमारे परिवर्तनों को पूर्ववत करने दें - पहले बिल्टिन से नई List ऑब्जेक्ट को हटा दें:

>>> del builtins.list
>>> builtins.list
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: module 'builtins' has no attribute 'list'
>>> list()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'list' is not defined

ओह, नहीं, हम मूल का ट्रैक खो गए।

चिंता न करें, हम अभी भी list प्राप्त कर सकते हैं - यह एक सूची का प्रकार शाब्दिक है:

>>> builtins.list = type([])
>>> list()
[]

इसलिए...

list() [] से तेज [] क्यों है?

जैसा कि हमने देखा है - हम list को ओवरराइट कर सकते हैं - लेकिन हम शाब्दिक प्रकार के निर्माण को रोक नहीं सकते हैं। जब हम list उपयोग करते हैं तो हमें यह देखने के लिए लुकअप करना पड़ता है कि क्या कुछ भी है या नहीं।

फिर हमें जो भी कॉल करने योग्य दिखता है उसे कॉल करना होगा। व्याकरण से:

एक कॉल कॉल करने योग्य ऑब्जेक्ट (उदाहरण के लिए, एक फ़ंक्शन) को संभवतः तर्कों की खाली श्रृंखला के साथ कॉल करता है:

call                 ::=  primary "(" [argument_list [","] | comprehension] ")"

हम देख सकते हैं कि यह किसी भी नाम के लिए एक ही चीज़ करता है, केवल सूची नहीं:

>>> import dis
>>> dis.dis('list()')
  1           0 LOAD_NAME                0 (list)
              2 CALL_FUNCTION            0
              4 RETURN_VALUE
>>> dis.dis('doesnotexist()')
  1           0 LOAD_NAME                0 (doesnotexist)
              2 CALL_FUNCTION            0
              4 RETURN_VALUE

[] लिए पाइथन बाइटकोड स्तर पर कोई फ़ंक्शन कॉल नहीं है:

>>> dis.dis('[]')
  1           0 BUILD_LIST               0
              2 RETURN_VALUE

यह सीधे बाइटकोड स्तर पर किसी भी लुकअप या कॉल के बिना सूची बनाने के लिए सीधे चला जाता है।

निष्कर्ष

हमने दिखाया है कि स्कोपिंग नियमों का उपयोग करके list को उपयोगकर्ता कोड से अवरुद्ध किया जा सकता है, और वह list() कॉल करने योग्य लगती है और फिर इसे कॉल करती है।

जबकि [] एक सूची प्रदर्शन है, या एक शाब्दिक है, और इस प्रकार नाम लुकअप और फ़ंक्शन कॉल से बचाता है।