ताश के खेल

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

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

अंदर से lists को डायनैमिक ऐरे के रूप में लागू किया जाता है, जो Java के ArrayList टाइप जैसा होता है। इसका इस्तेमाल अक्सर अज्ञात लंबाई वाले समान डेटा (स्ट्रिंग, संख्याएँ, सेट आदि) के समूह संग्रहीत करने के लिए किया जाता है। ऐरे बहुत लचीली और उपयोगी डेटा संरचनाएँ हैं, और Python में कई बिल्ट-इन मेथड तथा ऑपरेशन अपने आउटपुट के रूप में ऐरे देते हैं।

निर्माण

एक list को चौकोर [] ब्रैकेट और एलिमेंट के बीच कॉमा के साथ लिटरल के रूप में घोषित किया जा सकता है:

>>> no_elements = []

>>> no_elements
[]

>>> one_element = ["Guava"]

>>> one_element
['Guava']

>>> elements_separated_with_commas = ["Parrot", "Bird", 334782]

>>> elements_separated_with_commas
['Parrot', 'Bird', 334782]

पढ़ने में आसानी के लिए, जब किसी list में बहुत सारे एलिमेंट या नेस्टेड डेटा स्ट्रक्चर हों, तब लाइन ब्रेक इस्तेमाल किए जा सकते हैं:

>>> lots_of_entries = [
      "Rose",
      "Sunflower",
      "Poppy",
      "Pansy",
      "Tulip",
      "Fuchsia",
      "Cyclamen",
      "Lavender"
   ]
   
>>> lots_of_entries
['Rose', 'Sunflower', 'Poppy', 'Pansy', 'Tulip', 'Fuchsia', 'Cyclamen', 'Lavender']

# Each data structure is on its own line to help clarify what they are.
>>> nested_data_structures = [
      {"fish": "gold", "monkey": "brown", "parrot": "grey"},
      ("fish", "mammal", "bird"),
      ['water', 'jungle', 'sky']
   ]
   
>>> nested_data_structures
[{'fish': 'gold', 'monkey': 'brown', 'parrot': 'grey'}, ('fish', 'mammal', 'bird'), ['water', 'jungle', 'sky']]

list() कंस्ट्रक्टर को खाली या आर्गुमेंट के रूप में किसी इटरेबल के साथ इस्तेमाल किया जा सकता है। कंस्ट्रक्टर इटरेबल के एलिमेंट पर एक-एक करके चलता है और उन्हें क्रम में list में जोड़ देता है:

>>> no_elements = list()

>>> no_elements
[]

# The tuple is unpacked and each element is added.
>>> multiple_elements_from_tuple = list(("Parrot", "Bird", 334782))

>>> multiple_elements_from_tuple
['Parrot', 'Bird', 334782]

# The set is unpacked and each element is added.
>>> multiple_elements_from_set = list({2, 3, 5, 7, 11})

>>> multiple_elements_from_set
[2, 3, 5, 7, 11]

किसी string या dict के साथ list कंस्ट्रक्टर इस्तेमाल करने पर नतीजे चौंकाने वाले हो सकते हैं:

# String elements (Unicode code points) are iterated through and added *individually*.
>>> multiple_elements_string = list("Timbuktu")

>>> multiple_elements_string
['T', 'i', 'm', 'b', 'u', 'k', 't', 'u']

# Unicode separators and positioning code points are also added *individually*.
>>> multiple_code_points_string = list('अभ्यास')

>>> multiple_code_points_string
['अ', 'भ', '्', 'य', 'ा', 'स']

# The iteration default for dictionaries is over the keys, so only key data is inserted into the list.
>>> source_data = {"fish": "gold", "monkey": "brown"}

>>> multiple_elements_dict_1 = list(source_data)
['fish', 'monkey']

चूँकि list कंस्ट्रक्टर आर्गुमेंट के रूप में सिर्फ़ इटरेबल (या कुछ नहीं) लेता है, जो ऑब्जेक्ट इटरेबल नहीं हैं वे टाइप एरर देंगे। इसलिए एक एलिमेंट वाला list लिटरल तरीके से बनाना कहीं ज़्यादा आसान है।

# Numbers are not iterable, and so attempting to create a list with a number passed to the constructor fails.
>>> one_element = list(16)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

# Tuples *are* iterable, so passing a one-element tuple to the constructor does work, but it's awkward
>>> one_element_from_iterable = list((16,))

>>> one_element_from_iterable
[16]

एलिमेंट तक पहुँचना

ऐरे के अंदर के एलिमेंट (और दूसरे सीक्वेंस टाइप str तथा tuple के एलिमेंट भी) तक 0-based index और ब्रैकेट नोटेशन के ज़रिए पहुँचा जा सकता है। इंडेक्स left से right की ओर (शून्य से शुरू) या right से left की ओर (-1 से शुरू) हो सकते हैं।

बाईं ओर से इंडेक्स ⟹

0 👇🏾 1 👇🏾 2 👇🏾 3 👇🏾 4 👇🏾 5 👇🏾 P y t h o n 👆🏾 -6 👆🏾 -5 👆🏾 -4 👆🏾 -3 👆🏾 -2 👆🏾 -1

⟸ दाईं ओर से इंडेक्स

>>> breakfast_foods = ["Oatmeal", "Fruit Salad", "Eggs", "Toast"]

# Oatmeal is at index 0 or index -4.
>>> breakfast_foods[0]
'Oatmeal'

>>> breakfast_foods[-4]
'Oatmeal'

# Eggs are at index -2 or 2
>>> breakfast_foods[-2]
'Eggs'

>>> breakfast_foods[2]
'Eggs'

# Toast is at -1
>>> breakfast_foods[-1]
'Toast'

किसी list के अंदर एलिमेंट के एक हिस्से तक स्लाइस नोटेशन (<list>[start:stop]) के ज़रिए पहुँचा जा सकता है। किसी स्लाइस को index स्थिति पर मौजूद एलिमेंट के क्रम के रूप में परिभाषित किया जाता है, जहाँ start <= index < stop हो। स्लाइसिंग "स्लाइस किए गए" एलिमेंट की एक कॉपी लौटाती है और मूल list को नहीं बदलती।

list के एलिमेंट को "छोड़ने" या फ़िल्टर करने के लिए [start:stop:step] में step पैरामीटर भी इस्तेमाल किया जा सकता है (उदाहरण के लिए, step का मान 2 रेंज में हर दूसरा एलिमेंट चुन लेगा):

>>> colors = ["Red", "Purple", "Green", "Yellow", "Orange", "Pink", "Blue", "Grey"]

# If there is no step parameter, the step is assumed to be 1.
>>> middle_colors = colors[2:6]

>>> middle_colors
['Green', 'Yellow', 'Orange', 'Pink']

# If the start or stop parameters are omitted, the slice will
# start at index zero, and will stop at the end of the list.
>>> primary_colors = colors[::3]

>>> primary_colors
['Red', 'Yellow', 'Blue']

ऐरे के साथ काम करना

किसी ऐरे पर बिल्ट-इन sum() फंक्शन इस्तेमाल करने से ऐरे की सभी संख्याओं का जोड़ लौटता है:

>>> number_list = [1, 2, 3, 4]
>>> sum(number_list)
10

आप len() फंक्शन इस्तेमाल करके ऐरे की लंबाई भी पता कर सकते हैं:

>>> long_list = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]
>>> len(long_list)
10

ऐरे को कई तरीकों से जोड़ा भी जा सकता है:

# Using the plus + operator unpacks each list and creates a new list, but it is not efficient.
>>> new_via_concatenate = ["George", 5] + ["cat", "Tabby"]

>>> new_via_concatenate
['George', 5, 'cat', 'Tabby']

# Likewise, using the multiplication operator * is the equivalent of using + n times.
>>> first_group = ["cat", "dog", "elephant"]
>>> multiplied_group = first_group * 3

>>> multiplied_group
['cat', 'dog', 'elephant', 'cat', 'dog', 'elephant', 'cat', 'dog', 'elephant']

ऐरे एक इटरेटर देते हैं, और इन पर दूसरे सीक्वेंस टाइप की तरह ही लूप चलाया जा सकता है।

#  Looping through the list and printing out each element.
>>> colors = ["Orange", "Green", "Grey", "Blue"]

>>> for item in colors:
...     print(item)
...
Orange
Green
Grey
Blue

loops और iterators की अधिक गहराई से व्याख्या के लिए, loops कॉन्सेप्ट पूरा कीजिए।