ऐरे मेथड में

ऐरे मेथड के बारे में

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

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

Python ऐरे के साथ काम करने के लिए कई काम के मेथड देता है।

चूँकि ऐरे परिवर्तनशील होते हैं, ये मेथड जिस ऐरे पर लगाए जाते हैं, उस मूल ऐरे ऑब्जेक्ट को बदल देते हैं। अगर बदलाव नहीं चाहिए, तो मूल list की एक shallow copy (कम से कम) slice या <list>.copy() से बनानी पड़ेगी।

आइटम जोड़ना

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

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

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

जोड़ने के बजाय, <list>.insert(<index>, <item>) आइटम को ऐरे के किसी खास इंडेक्स पर जोड़ता है। <index> उस आइटम का इंडेक्स है जिसके ठीक पहले आप नया आइटम देखना चाहते हैं। <item> वह एलिमेंट है जिसे डालना है।

नोट: अगर <index> 0 है, तो आइटम ऐरे की शुरुआत में जोड़ा जाएगा। अगर <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]

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

>>> 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]

आइटम हटाना

ऐरे से कोई एलिमेंट हटाने के लिए <list>.remove(<item>) इस्तेमाल किया जा सकता है। अगर एलिमेंट ऐरे में मौजूद नहीं है, तो <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 जिसे हटाना और return करना है। अगर वैकल्पिक <index> आर्गुमेंट नहीं दिया गया, तो ऐरे का अंतिम एलिमेंट हटाया और return किया जाएगा। अगर <index> ऐरे के अंतिम इंडेक्स से बड़ी संख्या है, तो IndexError एरर आती है।

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

>>> numbers
[2, 3]
>>> numbers.pop()
3

>>> numbers
[2]

# This will throw an error because there is only index 0.
>>> numbers.pop(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: pop index out of range

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

>>> 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"]

जहाँ मूल list को बदलना नहीं चाहते, वहाँ बिल्ट-इन फंक्शन sorted() और reversed() इस्तेमाल किए जा सकते हैं। sorted(<list>) एक सॉर्ट की हुई कॉपी लौटाता है, और <list>.sort() जैसे ही पैरामीटर लेता है। reversed(<list>) एक इटरेटर लौटाता है जो ऐरे के आइटम उलटे क्रम में देता है। Iterators पर पूरी जानकारी किसी दूसरे अभ्यास में मिलेगी।

ऐरे में किसी आइटम की गिनती

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

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

>>> items.count(1)
3

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

<list>.index(<item>) दिए गए आइटम की पहली आवृत्ति का इंडेक्स नंबर लौटाता है। अगर वह आइटम एक बार भी नहीं है, तो एक ValueError एरर आती है। बाईं ओर से इंडेक्स 0 से शुरू होता है, यानी पहले आइटम का इंडेक्स 0-based होता है। दाईं ओर से भी इंडेक्स किया जा सकता है, जो इंडेक्स -1 से शुरू होता है।

>>> items = [7, 4, 1, 0, 2, 5]
>>> items.index(4)
1

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

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

>>> names = ["Tina", "Leo", "Thomas", "Tina", "Emily", "Justin"]
>>> names.index("Tina")
0

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

अगर किसी एलिमेंट की ठीक जगह जानने की ज़रूरत नहीं है, तो यह देखने के लिए कि वह ऐरे में है या नहीं, बिल्ट-इन in ऑपरेटर ज़्यादा कारगर है।

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

>>> "Thomas" in names
True

कॉपी बनाना

याद रखिए कि Python में वेरिएबल ऐसे नाम होते हैं जो अंदर के ऑब्जेक्ट की ओर इशारा करते हैं। प्रोग्राम के चलने के दौरान नाम अलग-अलग ऑब्जेक्ट से जुड़ सकते हैं या दोबारा जुड़ सकते हैं। किसी list ऑब्जेक्ट को किसी नए वेरिएबल नाम को देने से ऑब्जेक्ट की या उसके किसी भी रेफर किए गए डेटा की कॉपी नहीं बनती। नया नाम और पुराना नाम, दोनों उसी list ऑब्जेक्ट की ओर इशारा करेंगे। इसके अलावा, ऐरे एक कंटेनर टाइप ऑब्जेक्ट होते हैं। जगह बचाने के लिए कंटेनर अपने सदस्य आइटमों के सिर्फ रेफरेंस रखते हैं, खुद आइटम नहीं। यह "ऑप्टिमाइज़ेशन" बेखबर लोगों के लिए अनजाने नतीजे लेकर आ सकता है।

<list>.copy() एक नया list ऑब्जेक्ट बनाता है, लेकिन रेफर किए गए ऐरे एलिमेंट के लिए नए ऑब्जेक्ट नहीं बनाता, यानी कॉपी "शैलो" होती है। जब आप एक list ऑब्जेक्ट में आइटम जोड़ना या हटाना चाहते हैं और दूसरे को बदलना नहीं चाहते, तो आम तौर पर shallow copy काफी होती है। लेकिन अगर कोई भी मौका है कि list के अंदर के एलिमेंट गलती से बदल जाएँ (और इससे उससे जुड़ी सारी शैलो कॉपी भी बदल जाएँ), तो copy मॉड्यूल में copy.deepcopy() इस्तेमाल करके सारे रेफरेंस और ऑब्जेक्ट की पूरी या "डीप" कॉपी बनाई जानी चाहिए।

नाम, वैल्यू, ऐरे और नेस्टेड ऐरे के व्यवहार की विस्तृत जानकारी के लिए, Ned Batchelder की यह बढ़िया ब्लॉग पोस्ट देखिए: नाम और वैल्यू: एक गेम बोर्ड बनाना। Python ऑब्जेक्ट की शैलो बनाम डीप कॉपी में भी कॉपी से जुड़ी बातों का अच्छा विवरण मिलता है।