[python] सूचियों और tuples के बीच क्या अंतर है?


Answers

सूची और ट्यूपल के बीच अंतर

  1. शाब्दिक

    someTuple = (1,2)
    someList  = [1,2] 
    
  2. आकार

    a = tuple(range(1000))
    b = list(range(1000))
    
    a.__sizeof__() # 8024
    b.__sizeof__() # 9088
    

    एक ट्यूपल ऑपरेशन के छोटे आकार के कारण, यह थोड़ा तेज़ हो जाता है, लेकिन जब तक आपके पास बड़ी संख्या में तत्व नहीं होते हैं तब तक इसका उल्लेख नहीं किया जाता है।

  3. अनुमत परिचालन

    b    = [1,2]   
    b[0] = 3       # [3, 2]
    
    a    = (1,2)
    a[0] = 3       # Error
    

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

    a     = (1,2)
    b     = [1,2]  
    
    id(a)          # 140230916716520
    id(b)          # 748527696
    
    a   += (3,)    # (1, 2, 3)
    b   += [3]     # [1, 2, 3]
    
    id(a)          # 140230916878160
    id(b)          # 748527696
    
  4. प्रयोग

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

    a    = (1,2)
    b    = [1,2] 
    
    c = {a: 1}     # OK
    c = {b: 1}     # Error
    
Question

क्या फर्क पड़ता है?

Tuples / सूचियों के फायदे / नुकसान क्या हैं?




मुख्य अंतर यह है कि tuples अपरिवर्तनीय हैं। इसका अर्थ यह है कि जब आप इसे बनाते हैं तो आप मानों को टुपल में नहीं बदल सकते हैं।

तो यदि आपको मूल्यों को बदलने की आवश्यकता होगी तो सूची का उपयोग करें।

Tuples के लिए लाभ:

  1. थोड़ा प्रदर्शन सुधार।
  2. चूंकि एक ट्यूपल अपरिवर्तनीय है, इसे एक शब्दकोश में एक कुंजी के रूप में उपयोग किया जा सकता है।
  3. यदि आप इसे नहीं बदल सकते हैं और न ही कोई और कह सकता है, जो आपको कहना है कि आपको किसी भी एपीआई फ़ंक्शन इत्यादि के बारे में चिंता करने की आवश्यकता नहीं है। बिना पूछे अपने टुपल को बदलना।



सूची उत्परिवर्तनीय है और tuples अपरिवर्तनीय है। जब आप किसी आइटम को जोड़ने का प्रयास कर रहे हों तो परिवर्तनीय और अपरिवर्तनीय के बीच मुख्य अंतर स्मृति उपयोग होता है।

जब आप एक चर बनाते हैं, तो कुछ निश्चित स्मृति चर को आवंटित की जाती है। यदि यह एक सूची है, तो वास्तव में उपयोग की तुलना में अधिक स्मृति असाइन की जाती है। उदाहरण के लिए यदि वर्तमान मेमोरी असाइनमेंट 100 बाइट्स है, जब आप 101 वें बाइट जोड़ना चाहते हैं, तो शायद एक और 100 बाइट असाइन किए जाएंगे (इस मामले में कुल 200 बाइट्स में)।

हालांकि, अगर आप जानते हैं कि आप अक्सर नए तत्व नहीं जोड़ते हैं, तो आपको टुपल्स का उपयोग करना चाहिए। टुपल्स आवश्यक मेमोरी का बिल्कुल आकार निर्दिष्ट करता है, और इसलिए स्मृति को बचाता है, खासकर जब आप स्मृति के बड़े ब्लॉक का उपयोग करते हैं।




सूची लूपिंग के लिए हैं, tuples संरचनाओं के लिए हैं अर्थात् "%s %s" %tuple

सूचियां आम तौर पर सजातीय होती हैं, आमतौर पर ट्यूपल्स विषम होते हैं।

सूची चर लंबाई के लिए हैं, tuples निश्चित लंबाई के लिए हैं।




सूची के मूल्य किसी भी समय बदला जा सकता है लेकिन tuples के मूल्यों को बदला नहीं जा सकता है।

फायदे और नुकसान उपयोग पर निर्भर करता है। यदि आपके पास ऐसा डेटा है जिसे आप कभी नहीं बदलना चाहते हैं तो आपको ट्यूपल का उपयोग करना होगा, अन्यथा सूची सबसे अच्छा विकल्प है।




यह पायथन सूची का एक उदाहरण है:

my_list = [0,1,2,3,4]
top_rock_list = ["Bohemian Rhapsody","Kashmir","Sweet Emotion", "Fortunate Son"]

यह पायथन टुपल का एक उदाहरण है:

my_tuple = (a,b,c,d,e)
celebrity_tuple = ("John", "Wayne", 90210, "Actor", "Male", "Dead")

पायथन सूचियां और tuples समान हैं कि वे दोनों मूल्यों के संग्रह का आदेश दिया जाता है। उथले अंतर के अलावा सूचियों को ब्रैकेट्स "[..., ...]" और ब्रांड्स का उपयोग करके ब्रांड्स "(..., ...)" का उपयोग करके बनाया गया है, मूल तकनीकी "पाइथन सिंटैक्स में हार्ड कोडित" उनके बीच अंतर यह है कि एक विशेष ट्यूपल के तत्व अपरिवर्तनीय होते हैं जबकि सूचियां उत्परिवर्तनीय होती हैं (... इसलिए केवल टुपल्स हैंशबल हैं और शब्दकोश / हैश कुंजी के रूप में उपयोग किया जा सकता है!)। इससे मतभेदों में वृद्धि होती है कि वे कैसे उपयोग कर सकते हैं या नहीं कर सकते हैं (वाक्यविन्यास द्वारा प्राथमिकता को लागू किया गया है) और अंतर यह है कि लोग उन्हें कैसे उपयोग करना चुनते हैं ('सर्वोत्तम प्रथाओं' के रूप में प्रोत्साहित किया जाता है, यह एक स्मार्ट प्रोग्रामर करता है)। मुख्य रूप से भिन्नता में एक पोस्टरियोरी होती है जब सूचियों का उपयोग किया जाता है जब सूचियों का उपयोग किया जाता है जब लोग तत्वों के क्रम में क्या अर्थ देते हैं।

Tuples के लिए, 'आदेश' जानकारी रखने के लिए सिर्फ एक विशिष्ट 'संरचना' से ज्यादा कुछ नहीं दर्शाता है। पहले फ़ील्ड में कौन से मान पाए जाते हैं, आसानी से दूसरे फ़ील्ड में स्विच किए जा सकते हैं क्योंकि प्रत्येक दो अलग-अलग आयामों या तराजू में मान प्रदान करता है। वे विभिन्न प्रकार के प्रश्नों के उत्तर प्रदान करते हैं और आम तौर पर फॉर्म के होते हैं: किसी दिए गए ऑब्जेक्ट / विषय के लिए, इसकी विशेषताएं क्या हैं? वस्तु / विषय निरंतर रहता है, गुण भिन्न होते हैं।

सूचियों के लिए, 'ऑर्डर' अनुक्रम या दिशात्मकता को दर्शाता है। दूसरा तत्व पहले तत्व के बाद आना चाहिए क्योंकि यह किसी विशेष और सामान्य पैमाने या आयाम के आधार पर दूसरी जगह पर स्थित है। तत्वों को पूरी तरह से लिया जाता है और अधिकतर एक विशेष रूप से फ़ॉर्म के एक प्रश्न के उत्तर प्रदान करते हैं, किसी दिए गए गुण के लिए, इन वस्तुओं / विषयों की तुलना कैसे की जाती है? विशेषता स्थिर रहता है, वस्तु / विषय अलग है।

लोकप्रिय संस्कृति और प्रोग्रामर में लोगों के अनगिनत उदाहरण हैं जो इन मतभेदों के अनुरूप नहीं हैं और अनगिनत लोग हैं जो अपने मुख्य पाठ्यक्रम के लिए सलाद कांटा का उपयोग कर सकते हैं। दिन के अंत में, यह ठीक है और दोनों आमतौर पर काम पूरा कर सकते हैं।

कुछ बेहतर विवरण सारांशित करने के लिए

समानता:

  1. डुप्लिकेट - दोनों tuples और सूचियों डुप्लीकेट के लिए अनुमति देते हैं
  2. इंडेक्सिंग, चयन, और स्लाइसिंग - ब्रैकेट्स के भीतर पूर्णांक मानों का उपयोग करके टुपल्स और सूचियों दोनों इंडेक्स। इसलिए, यदि आप किसी दिए गए सूची या टुपल के पहले 3 मान चाहते हैं, तो वाक्यविन्यास समान होगा:

    >>> my_list[0:3]
    [0,1,2]
    >>> my_tuple[0:3]
    [a,b,c]
    
  3. तुलना और छंटाई - दो tuples या दो सूचियों दोनों की तुलना उनके पहले तत्व से की जाती है, और यदि कोई टाई है, तो दूसरे तत्व द्वारा, और इसी तरह। पिछले तत्वों के बाद एक अंतर दिखाने के बाद बाद के तत्वों पर कोई और ध्यान नहीं दिया जाता है।

    >>> [0,2,0,0,0,0]>[0,0,0,0,0,500]
    True
    >>> (0,2,0,0,0,0)>(0,0,0,0,0,500)
    True
    

मतभेद: - परिभाषा के अनुसार, प्राथमिकता

  1. सिंटेक्स - सूचियों का उपयोग [], tuples उपयोग ()

  2. उत्परिवर्तन - किसी दिए गए सूची में तत्व उत्परिवर्तनीय हैं, दिए गए टुपल में तत्व उत्परिवर्तनीय नहीं हैं।

    # Lists are mutable:
    >>> top_rock_list
    ['Bohemian Rhapsody', 'Kashmir', 'Sweet Emotion', 'Fortunate Son']
    >>> top_rock_list[1]
    'Kashmir'
    >>> top_rock_list[1] = "Stairway to Heaven"
    >>> top_rock_list
    ['Bohemian Rhapsody', 'Stairway to Heaven', 'Sweet Emotion', 'Fortunate Son']
    
    # Tuples are NOT mutable:       
    >>> celebrity_tuple
    ('John', 'Wayne', 90210, 'Actor', 'Male', 'Dead')
    >>> celebrity_tuple[5]
    'Dead'
    >>> celebrity_tuple[5]="Alive"
    Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    TypeError: 'tuple' object does not support item assignment
    
  3. हैशटेबल्स (शब्दकोश) - हैशटेबल्स (शब्दकोश) के रूप में इसकी चाबियाँ हैंशबल हैं और इसलिए अपरिवर्तनीय हैं, केवल टुपल्स शब्दकोश कुंजी के रूप में कार्य कर सकते हैं, सूचियों में नहीं।

    #Lists CAN'T act as keys for hashtables(dictionaries)
    >>> my_dict = {[a,b,c]:"some value"}
    Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    TypeError: unhashable type: 'list'
    
    #Tuples CAN act as keys for hashtables(dictionaries)
    >>> my_dict = {("John","Wayne"): 90210}
    >>> my_dict
    {('John', 'Wayne'): 90210}
    

मतभेद - उपयोग में एक पोस्टरियोरी

  1. होमो बनाम तत्वों की विषमता - आम तौर पर सूची वस्तुएं homogenous हैं और tuple वस्तुओं विषम हैं। यही है, सूचियों का उपयोग उसी प्रकार की वस्तुओं / विषयों (जैसे सभी राष्ट्रपति पद के उम्मीदवारों, या सभी गाने, या सभी धावकों) के लिए किया जाता है, जबकि यद्यपि इसे मजबूर नहीं किया जाता है), जबकि ट्यूपल्स विषम वस्तुओं के लिए अधिक होते हैं।

  2. लूपिंग बनाम संरचनाएं - हालांकि दोनों लूपिंग (my_list में x के लिए ...) के लिए अनुमति देते हैं, लेकिन यह केवल सूची के लिए इसे करने के लिए वास्तव में समझ में आता है। ट्यूपल्स जानकारी की संरचना और प्रस्तुत करने के लिए अधिक उपयुक्त हैं (% s में% s% s% s है और वर्तमान में% s% ("जॉन", "वेन", 90210, "अभिनेता", "मृत"))




सबसे पहले, वे दोनों पाइथन में गैर-स्केलर ऑब्जेक्ट्स (जिसे कंपाउंड ऑब्जेक्ट्स भी कहते हैं) हैं।

  • ट्यूपल्स, तत्वों के अनुक्रम का क्रमिक क्रम (जिसमें कोई ऑब्जेक्ट समस्या नहीं हो सकती है)
    • अपरिवर्तनीय (ट्यूपल, int, float, str)
    • + का उपयोग कर Concatenation (बिल्कुल नया नया tuple बनाया जाएगा)
    • इंडेक्सिंग
    • टुकड़ा करने की क्रिया
    • सिंगलटन (3,) # -> (3) बजाय (3) # -> 3
  • सूची (अन्य भाषाओं में ऐरे), मूल्यों का क्रम अनुक्रमित किया गया
    • परिवर्तनशील
    • सिंगलटन [3]
    • क्लोनिंग new_array = origin_array[:]
    • सूची समझ [x**2 for x in range(1,7)] आपको [1,4,9,16,25,36] देता है (पठनीय नहीं)

सूची का उपयोग करने से एलियासिंग बग भी हो सकता है (एक ही ऑब्जेक्ट को इंगित करने वाले दो अलग-अलग पथ)।




Related