चैतना का विशाल कोस्टर

एक list ऐसा संग्रह है जिसमें आइटम क्रम में रखे जाते हैं और जिसे बदला जा सकता है। ज़्यादातर संग्रहों की तरह (देखिए बिल्ट-इन tuple, dict और set), ऐरे किसी भी (या कई) डेटा टाइप का रेफरेंस रख सकते हैं, दूसरे ऐरे भी शामिल हैं। ऐरे को पूरा या आंशिक रूप से स्लाइस नोटेशन की मदद से या <list>.copy() इस्तेमाल करके कॉपी किया जा सकता है। किसी भी सीक्वेंस की तरह, lists के अंदर के एलिमेंट को बाईं ओर से 0-based index संख्या से, या दाईं ओर से -1-based index संख्या से रेफर किया जाता है।

ऐरे सामान्य और बदलने योग्य, दोनों तरह के सीक्वेंस ऑपरेशन सपोर्ट करते हैं, जैसे min(<list>)/max(<list>), <list>.index(), <list>.append() और <list>.reverse()। किसी list के अंदर के एलिमेंट पर for item in <list> रचना की मदद से इटरेशन किया जा सकता है। जब एलिमेंट का इंडेक्स और एलिमेंट की वैल्यू, दोनों चाहिए हों, तब for index, item in enumerate(<list>) इस्तेमाल किया जा सकता है।

Python ऐरे के साथ काम करने के लिए कई उपयोगी ऐरे के मेथड भी देता है। इनमें से कुछ list methods नीचे समझाए गए हैं।

ध्यान दीजिए कि जब आप किसी list पर किसी list-method की मदद से काम करते हैं, तो आप उस ऐरे ऑब्जेक्ट को बदल देते हैं जो पास किया गया था। अगर आप मूल list को बदलना नहीं चाहते, तो आपको उसका स्लाइस या <list>.copy() इस्तेमाल करके कम से कम एक shallow copy बनानी होगी।

आइटम जोड़ना

किसी मौजूदा ऐरे के अंत में, यानी "दाईं ओर", एक आइटम जोड़ने के लिए <list>.append(<item>) का इस्तेमाल कीजिए:

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

>>> numbers
[1, 2, 3, 9]

आइटम को अंत में जोड़ने के बजाय, <list>.insert() आपको ऐरे में किसी खास इंडेक्स पर आइटम जोड़ने का मौका देता है। यह 2 पैरामीटर लेता है:

1. वह <index> जहाँ आप आइटम जोड़ना चाहते हैं।
2. वह <item> जो जोड़ा जाना है।

ध्यान दीजिए: अगर दिया गया index 0 है, तो आइटम list के शुरू में ("बाईं ओर") जोड़ दिया जाएगा। अगर दिया गया index list के आखिरी index से बड़ा है, तो आइटम आखिरी जगह पर जोड़ा जाएगा, यानी <list>.append(<item>) इस्तेमाल करने जैसा ही।

>>> numbers = [1, 2, 3]
>>> numbers.insert(0, -2)

>>> numbers
[-2, 1, 2, 3]

>>> numbers.insert(1, 0)

>>> numbers
[-2, 0, 1, 2, 3]

<list>.extend(<item>) का इस्तेमाल किसी मौजूदा ऐरे को किसी दूसरे इटरेबल (जैसे set, tuple, str या list) के एलिमेंट के साथ जोड़ने के लिए किया जा सकता है। उस इटरेबल को अनपैक किया जाता है और उसके एलिमेंट क्रम से जोड़ दिए जाते हैं (ऐसी स्थिति में <list>.append(<item>) इस्तेमाल करने से पूरा इटरेबल एक ही आइटम की तरह जुड़ जाता।)।

>>> numbers = [1, 2, 3]
>>> other_numbers = [5, 6, 7]

>>> numbers.extend(other_numbers)

>>> numbers
[1, 2, 3, 5, 6, 7]

>>> numbers.extend([8, 9])

>>> numbers
[1, 2, 3, 5, 6, 7, 8, 9]

>>> numbers.append([8,9])

>>> numbers
[1, 2, 3, 5, 6, 7, 8, 9, [8, 9]]

आइटम हटाना

ऐरे से कोई आइटम हटाने के लिए <list>.remove(<item>) इस्तेमाल कीजिए और हटाए जाने वाले आइटम को आर्गुमेंट की तरह पास कीजिए। अगर आइटम list में मौजूद न हो, तो <list>.remove(<item>) एक ValueError उठाता है।

>>> numbers = [1, 2, 3]
>>> numbers.remove(2)

>>> numbers
[1, 3]

# Trying to remove a value that is not in the list throws a ValueError
>>> numbers.remove(0)
ValueError: list.remove(x): x not in list

दूसरा तरीका यह है कि <list>.pop(<index>) मेथड किसी एलिमेंट को हटाता भी है और उसे इस्तेमाल के लिए return भी करता है।

<list>.pop(<index>) एक वैकल्पिक पैरामीटर लेता है: उस आइटम का index जिसे हटाया और लौटाया जाना है। अगर (वैकल्पिक) index आर्गुमेंट नहीं दिया गया हो, तो list का आखिरी एलिमेंट हटा दिया जाएगा और लौटा दिया जाएगा। अगर दिया गया index आखिरी आइटम के index से बड़ा हो, तो एक IndexError उठाया जाता है।

>>> numbers = [1, 2, 3]

>>> numbers.pop(0)
1

>>> numbers
[2, 3]

>>> numbers.pop()
3

>>> numbers
[2]

>>> numbers.pop(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: pop index out of range

list.clear() की मदद से किसी list से सारे एलिमेंट हटाए जा सकते हैं। यह कोई पैरामीटर नहीं लेता।

>>> numbers = [1, 2, 3]
>>> numbers.clear()

>>> numbers
[]

उलटना और क्रम बदलना

<list>.reverse() मेथड एलिमेंट का क्रम मूल ऐरे में ही उलट देता है।

>>> numbers = [1, 2, 3]
>>> numbers.reverse()

>>> numbers
[3, 2, 1]

किसी ऐरे का क्रम <list>.sort() की मदद से मूल ऐरे में ही बदला जा सकता है। डिफॉल्ट क्रम बाईं ओर से आरोही होता है। Python के डॉक्स में सॉर्ट करने के कुछ और सुझाव और तरीके दिए गए हैं।

>>> names = ["Tony", "Natasha", "Thor", "Bruce"]

# The default sort order is *ascending*.
>>> names.sort()

>>> names
["Bruce", "Natasha", "Thor", "Tony"]

अगर अवरोही क्रम चाहिए, तो reverse=True आर्गुमेंट पास कीजिए:

>>> names = ["Tony", "Natasha", "Thor", "Bruce"]
>>> names.sort(reverse=True)

>>> names
["Tony", "Thor", "Natasha", "Bruce"]

जिन मामलों में मूल ऐरे को बदलना ठीक नहीं है, उनमें बिल्ट-इन sorted(<iterable>) फंक्शन का इस्तेमाल करके सॉर्ट की हुई कॉपी लौटाई जा सकती है।

>>> names = ["Tony", "Natasha", "Thor", "Bruce"]

>>> sorted(names)
['Bruce', 'Natasha', 'Thor', 'Tony']

ऐरे में कोई आइटम कितनी बार आता है

list.count(<item>) की मदद से पता लगाया जा सकता है कि किसी ऐरे में कोई एलिमेंट कितनी बार आता है। यह गिने जाने वाले item को अपना आर्गुमेंट बनाता है और लौटाता है कि वह एलिमेंट list में कुल कितनी बार आता है।

>>> items = [1, 4, 7, 8, 2, 9, 2, 1, 1, 0, 4, 3]

>>> items.count(1)
3

आइटम का इंडेक्स ढूँढना

<list>.index(<item>) पास किए गए आइटम के पहली बार आने की index संख्या लौटाता है। अगर वह आइटम एक बार भी न आए, तो एक ValueError उठाया जाता है। अगर किसी आइटम की सही जगह जानना ज़रूरी न हो, तो यह जाँचने के लिए कि किसी ऐरे में कोई दी गई वैल्यू है या नहीं, बिल्ट-इन in ऑपरेटर ज़्यादा कारगर है।

इंडेक्सिंग बाईं ओर से शून्य से शुरू होती है, इसलिए "पहले" आइटम की जगह 0 होती है। इंडेक्सिंग दाईं ओर से भी काम करती है, जो -1 से शुरू होती है।

>>> items = [7, 4, 1, 0, 2, 5]

>>> items.index(4)
1

>>> items.index(10)
ValueError: 10 is not in list

खोज को list के किसी खास हिस्से तक सीमित करने के लिए start और end इंडेक्स भी दिए जा सकते हैं:

>>> names = ["Tina", "Leo", "Thomas", "Tina", "Emily", "Justin"]

>>> names.index("Tina")
0

>>> names.index("Tina", 2, 5)
3