क्या फर्क पड़ता है?
टुपल्स / सूचियों के क्या फायदे / नुकसान हैं?
list
। ; डी
क्या फर्क पड़ता है?
टुपल्स / सूचियों के क्या फायदे / नुकसान हैं?
list
। ; डी
जवाबों:
ट्यूपल्स अपरिवर्तनीय होने के अलावा एक अर्थ भेद भी है जो उनके उपयोग को निर्देशित करना चाहिए। ट्यूप्स विषम डेटा संरचनाएं हैं (यानी, उनकी प्रविष्टियों के अलग-अलग अर्थ हैं), जबकि सूचियां एकरूप अनुक्रम हैं। ट्यूपल्स में संरचना है, सूचियों का क्रम है।
इस अंतर का उपयोग करना कोड को अधिक स्पष्ट और समझने योग्य बनाता है।
एक उदाहरण एक पुस्तक में संदर्भ स्थानों के लिए पेज और लाइन नंबर के जोड़े होंगे, जैसे:
my_location = (42, 11) # page number, line number
आप स्थानों पर नोटों को संग्रहीत करने के लिए शब्दकोश में एक कुंजी के रूप में इसका उपयोग कर सकते हैं। दूसरी ओर एक सूची का उपयोग कई स्थानों को संग्रहीत करने के लिए किया जा सकता है। स्वाभाविक रूप से कोई सूची से स्थानों को जोड़ना या हटाना चाह सकता है, इसलिए यह समझ में आता है कि सूचियाँ परस्पर हैं। दूसरी ओर किसी मौजूदा स्थान से आइटम जोड़ने या हटाने का कोई मतलब नहीं है - इसलिए ट्यूप्स अपरिवर्तनीय हैं।
ऐसी स्थितियाँ हो सकती हैं जहाँ आप किसी मौजूदा स्थान के भीतर आइटम बदलना चाहते हैं, उदाहरण के लिए जब पृष्ठ की पंक्तियों के माध्यम से पुनरावृत्ति हो। लेकिन tuple अपरिवर्तनीयता आपको प्रत्येक नए मान के लिए एक नया स्थान बनाने के लिए बाध्य करती है। यह इसके चेहरे पर असुविधाजनक लगता है, लेकिन इस तरह के अपरिवर्तनीय डेटा का उपयोग करना मूल्य प्रकार और कार्यात्मक प्रोग्रामिंग तकनीकों की आधारशिला है, जिसमें पर्याप्त लाभ हो सकते हैं।
इस मुद्दे पर कुछ दिलचस्प लेख हैं, उदाहरण के लिए "पायथन टुपल्स नॉट जस्ट कॉन्स्टेंट लिस्ट" या "पायथन में सूचियों बनाम ट्यूपल्स को समझना" । आधिकारिक पायथन प्रलेखन में भी इसका उल्लेख है
"ट्यूपल्स अपरिवर्तनीय हैं, और आमतौर पर एक विषम अनुक्रम होता है ..."।
हास्केल की तरह एक वैधानिक रूप से टाइप की गई भाषा में आमतौर पर अलग-अलग प्रकार के होते हैं और टपल की लंबाई निश्चित होनी चाहिए। एक सूची में सभी मान समान हैं और लंबाई तय नहीं है। तो अंतर बहुत स्पष्ट है।
अंत में पाइथन में नेकटुपल है, जो समझ में आता है क्योंकि एक टुपल पहले से ही संरचना के लिए माना जाता है। यह इस विचार को रेखांकित करता है कि ट्यूपल कक्षाओं और उदाहरणों के लिए एक हल्के वजन वाले विकल्प हैं।
collections.namedtuple
कि बेहतर कहा जाएगा collections.record
। इससे ग्राहक के रिकॉर्ड में नाम, पते की अदला-बदली करने का कोई मतलब नहीं होगा; वास्तव में, ऐसा करना आम तौर पर एक त्रुटि होगी, जिसे टपल की अपरिहार्यता आपको कमिट करने से रोकती है।
What would you do with such a list?
, मैं हमेशा कंपकंपी करता हूं जब पीपीएल एक तर्क के रूप में कल्पना की कमी का उपयोग करता है। मिश्रित प्रकार की सूचियों का उपयोग करना कुछ पदानुक्रमित डेटा संरचनाओं के लिए महान काम करता है, जहां प्रत्येक सूची बाल-सूचियों और मूल्य-तत्वों से बनी होती है।
सूची और टपल के बीच अंतर
शाब्दिक
someTuple = (1,2)
someList = [1,2]
आकार
a = tuple(range(1000))
b = list(range(1000))
a.__sizeof__() # 8024
b.__sizeof__() # 9088
ट्यूपल ऑपरेशन के छोटे आकार के कारण, यह थोड़ा तेज हो जाता है, लेकिन तब तक इसका उल्लेख नहीं किया जाता है जब तक कि आपके पास भारी संख्या में तत्व न हों।
संचालन की अनुमति दी
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
प्रयोग
एक सूची के रूप में परिवर्तनशील है, यह एक शब्दकोश में एक कुंजी के रूप में इस्तेमाल नहीं किया जा सकता है, जबकि एक tuple का उपयोग किया जा सकता है।
a = (1,2)
b = [1,2]
c = {a: 1} # OK
c = {b: 1} # Error
3. Permitted operation
में टपल मामले को पहले दिखाया गया है। मैं जानता हूं कि सफलता को दिखाना सामान्य है, फिर त्रुटि, लेकिन वह कुछ क्षणों के लिए मेरे सिर के साथ खिलवाड़ है।
one_item_list = [a]
, लेकिन one_tuple = (a,)
संबंधित टपल है। वैरिएबल नाम के बाद अल्पविराम पर ध्यान दें। लेकिन यह भी ध्यान रखें two_tuple = (a, b)
। इसने मुझे एक से अधिक बार (अभी भी पायथन 3 में) दूर फेंक दिया।
tuple(sorted(the_unsorted_tuple))
यदि आप टहलने के लिए जाते हैं, तो आप अपने निर्देशांक को (x,y)
टूप्ले में किसी भी समय नोट कर सकते हैं ।
यदि आप अपनी यात्रा को रिकॉर्ड करना चाहते हैं, तो आप हर कुछ सेकंड में अपना स्थान सूची में जोड़ सकते हैं।
लेकिन आप इसे दूसरी तरह से नहीं कर सकते थे।
मुख्य अंतर यह है कि ट्यूपल्स अपरिवर्तनीय हैं। इसका मतलब है कि आपने इसे बनाते ही मानों को टूपल में नहीं बदल सकते।
इसलिए यदि आप मानों को बदलने की आवश्यकता के लिए सूची का उपयोग करते हैं।
टुपल्स के लाभ:
frozenset
या विभिन्न तृतीय-पक्ष जमे हुए तानाशाह / पेड़ / आदि। प्रकार, लेकिन उनमें से कोई भी आपको परस्पर तत्वों को जोड़ने की अनुमति नहीं देता है। (और निश्चित रूप से एक ट्यूबल केवल हैशनेबल है अगर उसके सभी तत्व हैं, जो सामान्य ईएएफपी तरीके से संभालता है, तो d[1, [2]]
यह ऊपर उठाएगा TypeError: unhashable type: 'list'
।)
सूचियाँ परस्पर हैं; ट्यूपल नहीं हैं।
से docs.python.org/2/tutorial/datastructures.html
ट्यूपल्स अपरिवर्तनीय हैं, और आमतौर पर इसमें विषम तत्वों का अनुक्रम होता है, जिन्हें अनपैकिंग (इस सेक्शन में बाद में देखें) या इंडेक्सिंग (या यहां तक कि नेमटुपल्स के मामले में विशेषता द्वारा) तक पहुँचा जाता है। सूचियाँ उत्परिवर्तनीय हैं, और उनके तत्व आमतौर पर सजातीय होते हैं और सूची से अधिक पुनरावृति करके इसे एक्सेस किया जाता है।
यह उल्लेख किया गया है कि अंतर काफी हद तक शब्दार्थ है: लोग अलग-अलग सूचनाओं का प्रतिनिधित्व करने के लिए एक टपल और सूची की अपेक्षा करते हैं। लेकिन यह एक दिशानिर्देश से आगे बढ़ता है; कुछ पुस्तकालय वास्तव में अलग-अलग व्यवहार करते हैं जो वे पारित किए जाते हैं। उदाहरण के लिए 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]])
बिंदु यह है, जबकि NumPy मानक पुस्तकालय का हिस्सा नहीं हो सकता है, यह एक प्रमुख पायथन पुस्तकालय है, और NumPy सूचियों और टुपल्स के भीतर पूरी तरह से अलग चीजें हैं।
type(a_list) != type(a_tuple)
, लाइब्रेरी कोड ब्रांचिंग पर आधारित कोई भी टुकड़ा type(x)
अलग तरह से व्यवहार करेगा
'%d %d' % [2, 3]
एक है TypeError
, क्योंकि आप पहले एक सूची को पास करने की कोशिश %d
कर रहे हैं और आप दूसरे को कोई मूल्य नहीं दे रहे हैं %d
। (हालांकि, इसके प्रति भी कई उदाहरण हैं, जैसे max
…)
सूचियाँ लूपिंग के लिए हैं, ट्यूपल संरचना के लिए हैं "%s %s" %tuple
।
सूचियाँ आमतौर पर सजातीय होती हैं, ट्यूपल्स आमतौर पर विषम होते हैं।
सूचियाँ परिवर्तनशील लंबाई के लिए हैं, टुपल्स निश्चित लंबाई के लिए हैं।
यह पायथन सूचियों का एक उदाहरण है:
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")
पायथन की सूची और टुपल्स समान हैं कि वे दोनों मूल्यों के संग्रह का आदेश दिए गए हैं। कोष्ठक "[..., ...]" और कोष्ठक का उपयोग कर टुपल्स "(..., ...)" का उपयोग करके बनाए गए उथले अंतर के अलावा, कोर तकनीकी "पायथन सिंटैक्स में कोडित हार्ड" तकनीकी अंतर उनके बीच अंतर है। यह है कि एक विशेष टपल के तत्व अपरिवर्तनीय हैं, जबकि सूचियाँ परस्पर हैं (... इसलिए केवल टुपल्स हैशेबल हैं और इसका उपयोग शब्दकोश / हैश कीज़ के रूप में किया जा सकता है!)। यह उन अंतरों को जन्म देता है, जिनका वे उपयोग कर सकते हैं या नहीं कर सकते हैं (वाक्यविन्यास द्वारा एक प्राथमिकता को लागू किया जाता है) और लोग कैसे उनका उपयोग करने के लिए चुनते हैं ('सर्वोत्तम प्रथाओं' के रूप में प्रोत्साहित किया जाता है, एक पश्चाताप, यही स्मार्ट प्रोग्रामर करते हैं)। लोग तत्वों के क्रम को देते हैं।
टुपल्स के लिए, 'ऑर्डर' सूचना रखने के लिए सिर्फ एक विशिष्ट 'संरचना' से ज्यादा कुछ नहीं दर्शाता है। पहले फ़ील्ड में कौन से मान पाए जाते हैं उन्हें आसानी से दूसरे फ़ील्ड में स्विच किया जा सकता है क्योंकि प्रत्येक दो अलग-अलग आयामों या पैमानों पर मान प्रदान करता है। वे विभिन्न प्रकार के प्रश्नों के उत्तर प्रदान करते हैं और आम तौर पर फॉर्म के होते हैं: किसी दिए गए ऑब्जेक्ट / विषय के लिए, इसकी विशेषताएँ क्या हैं? वस्तु / विषय स्थिर रहता है, विशेषताएँ भिन्न होती हैं।
सूचियों के लिए, 'ऑर्डर' एक अनुक्रम या एक दिशात्मकता को दर्शाता है। दूसरा तत्व MUST पहले तत्व के बाद आता है क्योंकि यह एक विशेष और सामान्य पैमाने या आयाम के आधार पर 2 वें स्थान पर स्थित है। तत्वों को एक पूरे के रूप में लिया जाता है और ज्यादातर किसी एक प्रश्न के उत्तर दिए जाते हैं, जो आमतौर पर किसी दिए गए विशेषता के लिए होते हैं, इन वस्तुओं / विषयों की तुलना कैसे करते हैं? विशेषता स्थिर रहती है, वस्तु / विषय अलग होता है।
लोकप्रिय संस्कृति और प्रोग्रामर में लोगों के अनगिनत उदाहरण हैं जो इन मतभेदों के अनुरूप नहीं हैं और ऐसे कई लोग हैं जो अपने मुख्य पाठ्यक्रम के लिए सलाद कांटा का उपयोग कर सकते हैं। दिन के अंत में, यह ठीक है और दोनों आमतौर पर काम कर सकते हैं।
कुछ बारीक विवरणों को संक्षेप में प्रस्तुत करना
समानता:
अनुक्रमण, चयन और स्लाइसिंग - दोनों कोष्ठक में पाए जाने वाले पूर्णांक मानों का उपयोग करते हुए अनुक्रमणिका दोनों को सूचीबद्ध करता है। इसलिए, यदि आप दी गई सूची या टपल के पहले 3 मान चाहते हैं, तो सिंटैक्स समान होगा:
>>> my_list[0:3]
[0,1,2]
>>> my_tuple[0:3]
[a,b,c]
तुलना और छंटनी - दो टुपल्स या दो सूचियों की तुलना उनके पहले तत्व से की जाती है, और यदि एक टाई है, तो दूसरे तत्व द्वारा, और इसी तरह। पहले के तत्वों में अंतर दिखाई देने के बाद बाद के तत्वों पर कोई ध्यान नहीं दिया जाता है।
>>> [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
अंतर: - एक प्राथमिकता, परिभाषा द्वारा
सिंटैक्स - सूचियों का उपयोग [], टुपल्स का उपयोग ()
म्यूटेबिलिटी - किसी दिए गए सूची में तत्व उत्परिवर्तनीय हैं, किसी दिए गए टपल में तत्व उत्परिवर्तनीय नहीं हैं।
# 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
हैशटेबल्स (शब्दकोश) - जैसा कि हैशटेबल्स (शब्दकोशों) के लिए आवश्यक है कि इसकी कुंजियाँ हैंज़ेबल हैं और इसलिए अपरिवर्तनीय हैं, केवल ट्यूपल्स ही शब्दकोश कीज़ के रूप में कार्य कर सकते हैं, सूचियाँ नहीं।
#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}
अंतर - उपयोग में एक पश्चगामी,
होमो बनाम तत्वों की विषमता - आम तौर पर सूची की वस्तुएं समरूप और तुच्छ वस्तुएं विषम होती हैं। यही है, सूचियों का उपयोग उसी प्रकार की वस्तुओं / विषयों के लिए किया जाता है (जैसे सभी राष्ट्रपति उम्मीदवार, या सभी गाने, या सभी धावक) जबकि यह इसके द्वारा मजबूर नहीं किया जाता है), जबकि टुपल्स विषम वस्तुओं के लिए अधिक होते हैं।
लूपिंग बनाम संरचनाएं - हालांकि दोनों लूपिंग के लिए अनुमति देते हैं (my_list ... में x के लिए), यह केवल एक सूची के लिए ऐसा करने के लिए वास्तव में समझ में आता है। Tuples संरचित और प्रस्तुत करने की जानकारी के लिए अधिक उपयुक्त हैं (% s% s% s में निवास करने वाला% s है और वर्तमान में% s% ("जॉन", "वेन", 90210, "अभिनेता", "मृत"))
ट्यूपल्स और सूचियाँ दोनों पायथन में समान रूप से समान अनुक्रम प्रकार हैं।
शाब्दिक वाक्य रचना
हम एक नई सूची प्राप्त करने के लिए tuples और वर्ग कोष्ठक के निर्माण के लिए कोष्ठक ( ) का उपयोग करते हैं
[ ]
। इसके अलावा, हम आवश्यक संरचना प्राप्त करने के लिए उपयुक्त प्रकार के कॉल का उपयोग कर सकते हैं - टपल या सूची।
someTuple = (4,6)
someList = [2,6]
अस्थिरता
ट्यूप्स अपरिवर्तनीय हैं, जबकि सूचियाँ परस्पर हैं। यह बिंदु निम्नलिखित लोगों के लिए आधार है।
स्मृति उपयोग
परिवर्तनशीलता के कारण, आपको सूचियों के लिए अधिक मेमोरी और टुपल्स के लिए कम मेमोरी की आवश्यकता होती है।
विस्तार
आप टुपल्स और सूचियों दोनों में एक नया तत्व जोड़ सकते हैं, केवल इस अंतर के साथ कि ट्यूपल की आईडी बदल जाएगी (यानी, हमारे पास एक नई वस्तु होगी)।
हैशिंग
टुपल्स धोने योग्य हैं और सूचियां नहीं हैं। इसका मतलब है कि आप एक शब्दकोश में एक कुंजी के रूप में एक टपल का उपयोग कर सकते हैं। सूची का उपयोग शब्दकोश में एक कुंजी के रूप में नहीं किया जा सकता है, जबकि एक टपल का उपयोग किया जा सकता है
tup = (1,2)
list_ = [1,2]
c = {tup : 1} # ok
c = {list_ : 1} # error
शब्दार्थ
यह बिंदु सर्वोत्तम अभ्यास के बारे में अधिक है। आपको टुपल्स को विषम डेटा संरचनाओं के रूप में उपयोग करना चाहिए, जबकि सूचियां समरूप अनुक्रम हैं।
सूचियों को सजातीय अनुक्रम माना जाता है, जबकि ट्यूप विषम डेटा संरचनाएं हैं।
जैसा कि लोग पहले ही यहां जवाब दे चुके tuples
हैं जबकि वह अपरिवर्तनीय हैlists
परिवर्तनशील होते हैं, लेकिन tuples का उपयोग करने का एक महत्वपूर्ण पहलू हमें याद रखना चाहिए जो है
यदि tuple
इसमें एक list
या dictionary
इसके अंदर समाहित है , तो इन्हें बदला भी जा सकता हैtuple
ही वह अपरिवर्तनीय हो।
उदाहरण के लिए, मान लें कि हमारे पास एक ट्यूपल है जिसमें एक सूची और एक शब्दकोश है
my_tuple = (10,20,30,[40,50],{ 'a' : 10})
हम सूची की सामग्री को बदल सकते हैं
my_tuple[3][0] = 400
my_tuple[3][1] = 500
जो नया टपल जैसा दिखता है
(10, 20, 30, [400, 500], {'a': 10})
हम भी tuple के अंदर शब्दकोश को बदल सकते हैं
my_tuple[4]['a'] = 500
जो समग्र टपल जैसा दिखाई देगा
(10, 20, 30, [400, 500], {'a': 500})
ऐसा इसलिए होता है list
औरdictionary
वस्तुओं रहे हैं और इन वस्तुओं को नहीं बदलते हैं, लेकिन सामग्री इसके इशारा करने के लिए।
तो tuple
बिना किसी अपवाद के अपरिवर्तनीय रहता है
पीईपी 484 - प्रकार संकेत का कहना है कि एक के तत्वों के प्रकार tuple
अलग-अलग टाइप किया जा सकता है; ताकि आप कह सकें Tuple[str, int, float]
; लेकिन एक list
, List
टाइपिंग क्लास केवल एक ही प्रकार का पैरामीटर ले सकता है:List[str]
जो संकेत देता है कि 2 का अंतर वास्तव में है कि पूर्व विषम है, जबकि बाद वाला आंतरिक रूप से सजातीय है।
इसके अलावा, मानक पुस्तकालय ज्यादातर ऐसे मानक कार्यों से वापसी मूल्य के रूप में टपल का उपयोग करता है जहां सी वापस आ जाएगा struct
।
जैसा कि लोगों ने पहले ही मतभेदों का उल्लेख किया है कि मैं टुपल्स के बारे में क्यों लिखूंगा।
टुपल्स को क्यों पसंद किया जाता है?
छोटे tuples के लिए आवंटन अनुकूलन
स्मृति विखंडन को कम करने और आवंटन को गति देने के लिए, पायथन पुराने ट्यूपल्स का पुन: उपयोग करता है। यदि टपल की आवश्यकता नहीं है और इसे हटाने के बजाय 20 से कम आइटम हैं, तो स्थायी रूप से पायथन इसे एक मुफ्त सूची में ले जाता है।
एक निशुल्क सूची को 20 समूहों में विभाजित किया गया है, जहां प्रत्येक समूह 0 और 20 के बीच की लंबाई के tuples की सूची का प्रतिनिधित्व करता है। प्रत्येक समूह 2 000 tuples तक स्टोर कर सकता है। पहले (शून्य) समूह में केवल 1 तत्व होता है और एक खाली ट्यूपल का प्रतिनिधित्व करता है।
>>> a = (1,2,3)
>>> id(a)
4427578104
>>> del a
>>> b = (1,2,4)
>>> id(b)
4427578104
ऊपर के उदाहरण में हम देख सकते हैं कि a और b में एक ही id है। ऐसा इसलिए है क्योंकि हमने तुरंत नष्ट हो चुके टपल पर कब्जा कर लिया था जो कि मुफ्त सूची में था।
सूचियों के लिए आवंटन अनुकूलन
चूंकि सूचियों को संशोधित किया जा सकता है, पायथन ट्यूपल्स में समान अनुकूलन का उपयोग नहीं करता है। हालाँकि, पायथन सूचियों की भी एक निःशुल्क सूची है, लेकिन इसका उपयोग केवल खाली वस्तुओं के लिए किया जाता है। यदि कोई खाली सूची जीसी द्वारा हटा दी जाती है या एकत्र की जाती है, तो इसे बाद में पुन: उपयोग किया जा सकता है।
>>> a = []
>>> id(a)
4465566792
>>> del a
>>> b = []
>>> id(b)
4465566792
स्रोत: https://rushter.com/blog/python-lists-and-tuples/
ट्यूपल्स सूचियों की तुलना में कुशल क्यों हैं? -> https://stackoverflow.com/a/22140115
5.3 पर प्रलेखन से एक दिशा उद्धरण । टुपल्स और अनुक्रम :
हालांकि टुपल्स सूचियों के समान प्रतीत हो सकते हैं, वे अक्सर विभिन्न स्थितियों में और विभिन्न उद्देश्यों के लिए उपयोग किए जाते हैं। Tuples हैं अपरिवर्तनीय है, और आम तौर पर एक को शामिल विषम अनुक्रम तत्वों के माध्यम से पहुंचा जा सकता है कि के खोल (इस भाग में बाद में देखें) या अनुक्रमण (या यहां तक namedtuples के मामले में विशेषता के आधार पर)। सूचियाँ उत्परिवर्तनीय हैं , और उनके तत्व आमतौर पर सजातीय होते हैं और सूची से अधिक पुनरावृति करके इसे एक्सेस किया जाता है ।
सबसे पहले, वे दोनों पायथन में गैर-स्केलर ऑब्जेक्ट (एक यौगिक ऑब्जेक्ट के रूप में भी जाना जाता है) हैं।
+
(एकदम नया टपल बनाया जाएगा)(3,) # -> (3)
बजाय सिंगलटन(3) # -> 3
[3]
new_array = origin_array[:]
[x**2 for x in range(1,7)]
आपको देता है
[1,4,9,16,25,36]
(पठनीय नहीं)सूची का उपयोग करने से एक एलियासिंग बग (एक ही वस्तु को इंगित करने वाले दो अलग-अलग पथ) हो सकता है।
सूचियाँ उत्परिवर्तनीय हैं और टुपल्स अपरिवर्तनीय हैं। इस उदाहरण पर विचार करें।
a = ["1", "2", "ra", "sa"] #list
b = ("1", "2", "ra", "sa") #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.
इसलिए साबित हुआ कि निम्न कोड टपल के साथ अमान्य है, क्योंकि हमने एक टपल को अपडेट करने का प्रयास किया, जिसकी अनुमति नहीं है।
सूची परिवर्तनशील है और टुपल्स अपरिवर्तनीय है। जब आप किसी आइटम को जोड़ने की कोशिश कर रहे हैं, तो परिवर्तनशील और अपरिवर्तनीय के बीच मुख्य अंतर मेमोरी उपयोग है।
जब आप एक वैरिएबल बनाते हैं, तो कुछ निश्चित मेमोरी को वैरिएबल को सौंपा जाता है। यदि यह एक सूची है, तो वास्तव में उपयोग किए जाने से अधिक मेमोरी असाइन की जाती है। उदाहरण के लिए यदि वर्तमान मेमोरी असाइनमेंट 100 बाइट्स है, जब आप 101 वें बाइट को जोड़ना चाहते हैं, तो हो सकता है कि एक और 100 बाइट्स असाइन किया जाएगा (इस मामले में कुल 200 बाइट्स)।
हालांकि, यदि आप जानते हैं कि आप अक्सर नए तत्व नहीं जोड़ रहे हैं, तो आपको ट्यूपल्स का उपयोग करना चाहिए। Tuples आवश्यक मेमोरी के आकार को असाइन करता है, और इसलिए मेमोरी को बचाता है, खासकर जब आप मेमोरी के बड़े ब्लॉक का उपयोग करते हैं।