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




list (15)

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

इस भेद का उपयोग कोड को अधिक स्पष्ट और समझ में आता है।

एक उदाहरण एक पुस्तक में संदर्भ स्थानों के लिए पृष्ठ और रेखा संख्या के जोड़े होंगे, उदाहरण के लिए:

my_location = (42, 11)  # page number, line number

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

ऐसी स्थितियां हो सकती हैं जहां आप मौजूदा स्थान tuple के भीतर आइटम बदलना चाहते हैं, उदाहरण के लिए जब किसी पृष्ठ की रेखाओं के माध्यम से पुनरावृत्ति होती है। लेकिन अपरिवर्तनीयता आपको प्रत्येक नए मूल्य के लिए एक नया स्थान टुपल बनाने के लिए मजबूर करती है। यह इसके चेहरे पर असुविधाजनक लगता है, लेकिन इस तरह के अपरिवर्तनीय डेटा का उपयोग मूल्य प्रकारों और कार्यात्मक प्रोग्रामिंग तकनीकों का आधारशिला है, जिसमें पर्याप्त फायदे हो सकते हैं।

इस मुद्दे पर कुछ दिलचस्प लेख हैं, उदाहरण के लिए "पायथन टुपल्स न सिर्फ कॉन्स्टेंट लिस्ट हैं" या " पायथन में टुपल्स बनाम सूचियों को समझना" । आधिकारिक पायथन दस्तावेज में यह भी उल्लेख किया गया है ( "टुपल्स अपरिवर्तनीय हैं, और आमतौर पर एक विषम अनुक्रम होते हैं ..." )।

एक सामान्य रूप से टाइप की गई भाषा में जैसे हास्केल में टुपल में मानों में आम तौर पर अलग-अलग प्रकार होते हैं और ट्यूपल की लंबाई तय की जानी चाहिए। एक सूची में मूल्यों का एक ही प्रकार होता है और लंबाई तय नहीं होती है। तो अंतर बहुत स्पष्ट है।

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

https://code.i-harness.com

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

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


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

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

Tuples के लिए लाभ:

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

यदि आप पैदल चलने के लिए गए थे, तो आप किसी भी समय (x, y) tuple में अपने निर्देशांक को नोट कर सकते हैं।

यदि आप अपनी यात्रा रिकॉर्ड करना चाहते हैं, तो आप सूची में हर कुछ सेकंड में अपना स्थान जोड़ सकते हैं।

लेकिन आप इसे दूसरी तरफ नहीं कर सका।


यह उल्लेख किया गया है कि अंतर काफी हद तक अर्थपूर्ण है: लोग विभिन्न जानकारी का प्रतिनिधित्व करने के लिए एक tuple और सूची की उम्मीद है। लेकिन यह एक दिशानिर्देश से आगे चला जाता है; कुछ पुस्तकालय वास्तव में उनके द्वारा पारित किए गए कार्यों के आधार पर अलग-अलग व्यवहार करते हैं। उदाहरण के लिए NumPy लो ( एक और पोस्ट से कॉपी जहां मैं और उदाहरण के लिए पूछना):

>>> import numpy as np
>>> a = np.arange(9).reshape(3,3)
>>> a
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> idx = (1,1)
>>> a[idx]
4
>>> idx = [1,1]
>>> a[idx]
array([[3, 4, 5],
       [3, 4, 5]])

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


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

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] देता है (पठनीय नहीं)

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


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


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

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

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


सूची उत्परिवर्तनीय हैं और tuples अपरिवर्तनीय हैं। बस इस उदाहरण पर विचार करें।

a = ["1", "2", "ra", "sa"]    #list
b = ("1", "2", "ra", "sa")    #tuple

अब सूची और tuple के सूचकांक मूल्यों को बदलें।

a[2] = 1000
print a     #output : ['1', '2', 1000, 'sa']
b[2] = 1000
print b     #output : TypeError: 'tuple' object does not support item assignment.

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


सूची उत्परिवर्तनीय हैं; tuples नहीं हैं।

docs.python.org/2/tutorial/datastructures.html

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


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

  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
    

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

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

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


5.3 पर प्रलेखन से एक दिशा उद्धरण टुपल्स और अनुक्रम :

हालांकि tuples सूचियों के समान प्रतीत हो सकता है, वे अक्सर विभिन्न परिस्थितियों में और विभिन्न उद्देश्यों के लिए उपयोग किया जाता है। टुपल्स अपरिवर्तनीय होते हैं, और आम तौर पर उन तत्वों का एक विषम अनुक्रम होता है जिन्हें अनपॅकिंग (बाद में इस खंड में देखें) या अनुक्रमण (या यहां तक ​​कि नामांकित के मामले में विशेषता द्वारा) के माध्यम से उपयोग किया जाता है। सूचियां उत्परिवर्तनीय होती हैं , और उनके तत्व आमतौर पर सजातीय होते हैं और सूची में पुनरावृत्त होते हैं।


पीईपी 484 - टाइप संकेत कहते हैं कि एक tuple के तत्वों के प्रकार व्यक्तिगत रूप से टाइप किए जा सकते हैं; ताकि आप Tuple[str, int, float] कह Tuple[str, int, float] ; लेकिन List टाइपिंग क्लास के साथ एक list केवल एक प्रकार का पैरामीटर ले सकती है: List[str] , जो संकेत देती है कि 2 का अंतर वास्तव में यह है कि पूर्व विषम है, जबकि बाद में आंतरिक रूप से सजातीय है।

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


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

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





tuples