पायथन: (1,2,3) और [1,2,3] के बीच क्या अंतर है, और मुझे प्रत्येक का उपयोग कब करना चाहिए?

कई स्थानों पर, (1,2,3) और [1,2,3] का उपयोग एक दूसरे के लिए किया जा सकता है।

मुझे एक या दूसरे का उपयोग कब करना चाहिए, और क्यों?

0
जोड़ा संपादित
विचारों: 1

13 उत्तर

सूची [1,2,3] गतिशील और लचीली है लेकिन वह लचीलापन एक गति लागत पर आता है।

ट्यूपल (1,2,3) तय किया जाता है (अपरिवर्तनीय) और इसलिए तेज़।

0
जोड़ा
जिसके लिए परिचालन तेजी से बढ़ रहे हैं? अनुक्रमण?
जोड़ा लेखक rafak, स्रोत

समग्र डेटा-प्रकार बनाने के लिए टुपल्स एक त्वरित \ लचीला तरीका है। सूचियां, अच्छी तरह से, वस्तुओं की सूचियों के लिए कंटेनर हैं।

उदाहरण के लिए, आप कक्षा में छात्र विवरण की एक सूची स्टोर करने के लिए एक सूची का उपयोग करेंगे।

उस सूची में प्रत्येक छात्र का विवरण 3-टुपल हो सकता है जिसमें उनका रोल नंबर, नाम और परीक्षण स्कोर शामिल हो।

`[(1,'Mark',86),(2,'John',34)...]`

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

0
जोड़ा
सूक्ष्म चेतावनी के साथ कि एक ट्यूपल में केवल अन्य अपरिवर्तनीय होना चाहिए जिसे हेशेबल माना जा सकता है, उदाहरण: ([], 3) हैशबल नहीं है; ("हाय", 3) हैशबल है; (([], 3), 3) हैशबल नहीं है; (((), 3), 3) हैशबल है।
जोड़ा लेखक Jegschemesch, स्रोत

यदि आप एक समाधान ढूंढ सकते हैं जो टुपल्स के साथ काम करता है, तो उनका उपयोग करें, क्योंकि यह अपरिवर्तनीयता को मजबूर करता है जो आपको एक अधिक कार्यात्मक पथ से नीचे चलाता है। आप लगभग कार्यात्मक / अपरिवर्तनीय पथ नीचे जाने पर कभी पछतावा नहीं करते हैं।

0
जोड़ा

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

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

0
जोड़ा

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

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

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

0
जोड़ा

पायथन FAQ से :

सूचियां और tuples, जबकि कई मामलों में समान, आमतौर पर मूल रूप से विभिन्न तरीकों से उपयोग किया जाता है। टपल्स को पास्कल रिकॉर्ड या सी structs के समान होने के रूप में सोचा जा सकता है; वे संबंधित डेटा के छोटे संग्रह हैं जो विभिन्न प्रकार के हो सकते हैं जिन्हें समूह के रूप में संचालित किया जाता है। उदाहरण के लिए, एक कार्टेसियन समन्वय उचित रूप से दो या तीन संख्याओं के टुपल के रूप में दर्शाया जाता है।

     

दूसरी ओर, सूचियां अन्य भाषाओं में सरणी की तरह हैं। वे अलग-अलग वस्तुओं को पकड़ते हैं जिनमें से सभी एक ही प्रकार के होते हैं और जो एक-एक-एक पर संचालित होते हैं।

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

0
जोड़ा

(1,2,3) is a tuple and [1,2,3] is a list. You either of the two represent sequences of numbers but note that tuples are immutable and list are mutable Python objects.

0
जोड़ा

एक कंसोल खोलें और पायथन चलाएं। इसे इस्तेमाल करे:

  >>> list = [1, 2, 3]     
  >>> dir(list)
    ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delsli
    ce__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getit
    em__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__',
     '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__r
    educe__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__'
    , '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 
'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

As you may see the last on the last line list have the following methods: 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'

अब टुपल के लिए कोशिश करें:

>>> tuple = (1, 2, 3)
>>> dir(tuple)
    ['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__
    format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__get
    slice__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__
    lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__'
    , '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']

सूची विधियों से केवल 'गिनती' और 'अनुक्रमणिका' यहां दिखाई देती है।

ऐसा इसलिए है क्योंकि tuples अपरिवर्तनीय हैं और वे किसी भी संशोधन का समर्थन नहीं करते हैं। इसके बजाय वे आंतरिक कार्यान्वयन में सरल और तेज़ हैं।

0
जोड़ा

(1,2,3) is a tuple while [1,2,3] is a list. A tuple is an immutable object while a list is mutable.

0
जोड़ा

[1,2,3] is a list.

(1,2,3) is a tuple and immutable.

0
जोड़ा

Tuples की धारणा अत्यधिक अभिव्यक्तिपूर्ण हैं:

  • Pragmatically, they are great for packing and unpacking values (x,y=coord).

  • In combination with dictionaries (hash tables), they allow forms of mapping that would otherwise require many levels of association. For example, consider marking that (x,y) has been found.

    // PHP
    if (!isset($found[$x])) {
        $found[$x] = Array();
        $found[$x][$y] = true;
    } else if (!isset($found[$x][$y])) {
        $found[$x][$y] = true;
    }
    
    # Python
    found[(x,y)] = True # parens added for clarity
    
  • Lists should be used with the expectation of operations on its contents (hence the various mentions of immutability). One will want to pop, push, splice, slice, search, insert before, insert after, etc with a list.

  • Tuples should be a low-level representation of an object, where simple comparisons are made, or operations such as extracting the n'th element or n elements in a predictable fashion, such as the coordinates example given earlier.

  • Lastly, lists are not hashable, so the type of mapping done with dictionaries (hash tables in Perl, associative arrays in PHP) must be done with tuples.

    Here's a simple example of tuples and dictionaries, together at last:

    """
    couple is a tuple of two people
    doesLike is a dictionary mapping couples to True or False
    """
    couple = "john", "jane"
    doesLike = dict()
    doesLike[couple] = True
    doesLike["jane", "john"] = False # unrequited love :'(
    
0
जोड़ा
  • एक टुपल शब्दकोश में एक कुंजी का प्रतिनिधित्व कर सकता है, क्योंकि यह है अपरिवर्तनीय।
  • सूचियों का उपयोग करें यदि आपके पास डेटा का संग्रह है जो नहीं करता है यादृच्छिक अभिगम की आवश्यकता है।
0
जोड़ा

(1,2,3) और [1,2,3] दुर्लभ परिस्थितियों में एक दूसरे के लिए इस्तेमाल किया जा सकता है।

तो (1,2,3) एक ट्यूपल है और अपरिवर्तनीय है। किसी भी बदलाव को आप ऑब्जेक्ट को ओवरराइट करने की आवश्यकता है।

[1,2,3] एक सूची है और तत्वों को जोड़ा और हटाया जा सकता है।

सूची में टुपल की तुलना में अधिक सुविधाएं हैं।

0
जोड़ा