একটি 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 কনসেপ্টটি সম্পূর্ণ করুন।
লার্নিং অনুশীলনী
