पायथन में वर्ग कोष्ठक और कोष्ठक द्वारा संलग्न सूचियों के बीच अंतर क्या है?

Question

>>> x=[1,2]
>>> x[1]
2
>>> x=(1,2)
>>> x[1]
2

क्या वे दोनों वैध हैं? क्या किसी कारण से पसंद किया जाता है?

Comments

बस FYI करें: वहाँ के बीच एक अधिक गहरा अंतर है (i for i in ...)और [i for i in ...]।

— रिक पोगी

@RikPoggi गहरा अंतर क्या है? क्या आप कृपया विस्तार से बता सकते हैं?

— क़ज़वेक्स

पहला एक जनरेटर अभिव्यक्ति है और दूसरा एक सूची बोध है । आप यहाँ कुछ जानकारी पा सकते हैं: सूची समझ पर आधिकारिक ट्यूटोरियल , पीईपी 289 । और यहां कुछ ओएस प्रश्नों में: जेनरेटर एक्सप्रेशंस बनाम लिस्ट कॉम्प्रिहेंशन , जनरेटर-कॉम्प्रिहेंशन ।

— रिक पोगी

Answer 1

वर्ग कोष्ठक सूचियाँ हैं जबकि कोष्ठक टुपल्स हैं ।

एक सूची परिवर्तनशील है, जिसका अर्थ है कि आप इसकी सामग्री बदल सकते हैं:

>>> x = [1,2]
>>> x.append(3)
>>> x
[1, 2, 3]

जबकि टुपल्स नहीं हैं:

>>> x = (1,2)
>>> x
(1, 2)
>>> x.append(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'append'

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

>>> x = (1,2)
>>> y = [1,2]
>>> z = {}
>>> z[x] = 3
>>> z
{(1, 2): 3}
>>> z[y] = 4
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

---

ध्यान दें, जैसा कि कई लोगों ने बताया है, आप एक साथ ट्यूपल्स जोड़ सकते हैं। उदाहरण के लिए:

>>> x = (1,2)
>>> x += (3,)
>>> x
(1, 2, 3)

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

>>> x = (1,2)
>>> y = x
>>> x += (3,)
>>> x
(1, 2, 3)
>>> y
(1, 2)

जबकि, यदि आप एक सूची के साथ एक ही उदाहरण का निर्माण करने के लिए, yभी अद्यतन किया जाएगा:

>>> x = [1, 2]
>>> y = x
>>> x += [3]
>>> x
[1, 2, 3]
>>> y
[1, 2, 3]

Comments

मतभेदों को सूचीबद्ध करने के लिए अच्छे अभी तक सरल उदाहरण हैं। धन्यवाद!

— डॉ। एसेन

Answer 2

एक दिलचस्प अंतर:

lst=[1]
print lst          // prints [1]
print type(lst)    // prints <type 'list'>

notATuple=(1)
print notATuple        // prints 1
print type(notATuple)  // prints <type 'int'>
                                         ^^ instead of tuple(expected)

एक अल्पविराम को एक टपल में शामिल किया जाना चाहिए, भले ही इसमें केवल एक मूल्य हो। के (1,)बजाय उदाहरण के लिए (1)।

Comments

धन्यवाद। यह वही है जिसे मैं देख रहा था। मेरे द्वारा देखे गए कोड में (list1 + list2 + list3) सूची थी और इसने एक सूची दी, न कि टपल।

— हकीत

Answer 3

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

In [1]: x = (1, 2)

In [2]: x[0] = 3
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)

/home/user/<ipython console> in <module>()

TypeError: 'tuple' object does not support item assignment

Answer 4

एक और तरीका है कि कोष्ठक और कोष्ठक भिन्न हैं, वर्ग कोष्ठक एक सूची बोध का वर्णन कर सकते हैं, जैसे [x for x in y]

जबकि संबंधित अभिभावकीय वाक्यविन्यास एक टापल जनरेटर को निर्दिष्ट करता है :(x for x in y)

आप का उपयोग कर एक स्पष्ट समझ प्राप्त कर सकते हैं: tuple(x for x in y)

देखें: पायथन में कोई तुच्छ समझ क्यों नहीं है?

Answer 5

पहला एक सूची है, दूसरा टपल है। सूचियाँ परस्पर हैं, टुपल्स नहीं हैं।

ट्यूटोरियल के डेटा स्ट्रक्चर्स सेक्शन और डॉक्यूमेंट के सीक्वेंस टाइप सेक्शन पर एक नज़र डालें ।

Answer 6

कोमा द्वारा अलग की गई वस्तुएं हैं (और )वे हैं tuple, जो संलग्न हैं [और एस हैं।]list

Comments

कोई सूची नहीं है जो "गोल" कोष्ठक द्वारा संलग्न हैं, वे टुपल्स हैं! लेकिन आपको शायद सही बात से मतलब है। :P

— गैंडारो

(और) द्वारा संलग्न सूचियाँ tuples हैं .. मैं उलझन में हूँ, क्या वे सूचियाँ या tuples हैं?

— जूलियोमालेग्रिया

@ julio.alegria मुझे लगता है कि लिखने के लिए @FlopCoder का क्या मतलब था " आइटमों को संलग्न किया गया है (और )वे हैं tuple, जो संलग्न हैं [और एस हैं।" ]list

— फफूंद