# Python-এর তালিকা (list): মেথড, স্লাইস, সর্টিং, append, tuple ও set

URL: https://skillaria.top/bn/guides/python/lists-python

Python-এর list হলো কোণ বন্ধনীতে লেখা একটি ক্রমানুসারী ও পরিবর্তনযোগ্য কালেকশন, যেমন [250, 1200, 99]: উপাদান append দিয়ে যোগ করা, বসানো, মোছা, স্লাইস নেওয়া এবং সাজানো যায়। sort তালিকাটিকে নিজের জায়গায় সাজায় এবং None ফেরত দেয়, আর sorted একটি নতুন সাজানো তালিকা ফেরত দেয়।

Python-এর তালিকা (`list`) হলো কোণ বন্ধনীতে যেকোনো মানের একটি ক্রমানুসারী সেট, যা বদলানো যায়: শেষে উপাদান যোগ, মাঝখানে বসানো, মোছা, সাজানো — সবই সম্ভব। এটি ভাষার সবচেয়ে ব্যবহৃত কালেকশন: ফাইলের লাইন, মাসের খরচ, API-র উত্তর — প্রায় সব কিছুই তালিকা দিয়ে শুরু হয়। এখানে python list-এর পুরোটা দেখা যাক: তৈরি, মেথড, স্লাইস, সর্টিং, list comprehension, কপি, এবং শেষে tuple ও set।

## Python-এর তালিকা কী

তালিকা উপাদানগুলো যে ক্রমে আপনি দেন, সেভাবেই রাখে এবং শূন্য থেকে গোনা সূচক দিয়ে সেগুলো পাওয়া যায়। একটি তালিকায় বিভিন্ন ধরনের মান থাকতে পারে, যদিও বাস্তবে সাধারণত একই ধরনের ডেটা রাখা হয়।

```
amounts = [250, 1200, 99]
print(amounts[0])     # 250 — প্রথম উপাদান
print(amounts[-1])    # 99 — শেষ উপাদান
amounts[1] = 1300     # তালিকা পরিবর্তনযোগ্য
print(len(amounts))   # 3 — দৈর্ঘ্য
```

তালিকার আকার জানা যায় `len()` ফাংশনে। না থাকা সূচক দিলে আসে `IndexError: list index out of range`।

## তালিকা তৈরি

```
empty = []                       # খালি তালিকা
also_empty = list()              # একই কাজ list ফাংশন দিয়ে
nums = [1, 2, 3]
chars = list("abc")              # ['a', 'b', 'c']
digits = list(range(5))          # [0, 1, 2, 3, 4]
zeros = [0] * 4                  # [0, 0, 0, 0]
```

`list()` যেকোনো iterable-কে তালিকায় রূপান্তর করে: স্ট্রিং, `range`, set, dictionary-র key।

## append ও অন্যান্য তালিকা-মেথড

`append` একটি উপাদান শেষে যোগ করে — Python-এর সবচেয়ে বেশি ব্যবহৃত মেথড। এটি তালিকাটি নিজের জায়গাতেই বদলায় এবং `None` ফেরত দেয়।

```
amounts = [250, 1200]
amounts.append(450)          # [250, 1200, 450]
amounts.extend([10, 20])     # [250, 1200, 450, 10, 20]
amounts.insert(0, 5)         # [5, 250, 1200, 450, 10, 20]
amounts.remove(1200)         # প্রথম 1200 মুছে ফেলা
last = amounts.pop()         # 20 — শেষটি মুছে ফেরত দেওয়া
```

একটি সাধারণ ভুল: `a.append([10, 20])` একটি উপাদান যোগ করে — ভেতরে একটি তালিকা, দুটি সংখ্যা নয়। একাধিক উপাদান যোগ করতে লাগে `extend`।

| মেথড | কাজ |
| --- | --- |

| `append(x)` | x-কে শেষে যোগ করা |

| `extend(iter)` | ক্রমের সব উপাদান যোগ করা |

| `insert(i, x)` | সূচক i-এর আগে x বসানো |

| `remove(x)` | প্রথম x মুছে ফেলা (না থাকলে ValueError) |

| `pop(i=-1)` | সূচক অনুযায়ী উপাদান মুছে ফেরত দেওয়া |

| `index(x)` | প্রথম x-এর সূচক |

| `count(x)` | x কতবার আছে |

| `sort()` | নিজের জায়গায় সাজানো |

| `reverse()` | নিজের জায়গায় উল্টে দেওয়া |

| `copy()` | অগভীর কপি |

| `clear()` | তালিকা খালি করা |

সূচক বা পুরো পরিসর মুছতে `del` অপারেটরও চলে: `del a[0]`, `del a[1:3]`। তালিকার জন্য কাজের কিছু অন্তর্নির্মিত ফাংশন: `len`, `sum`, `min`, `max`, `sorted`, `reversed`, `enumerate`, `zip`।

## Python-এর স্লাইস

স্লাইস তালিকার একটি অংশ নেয়, `a[start:stop:step]` নিয়মে: `start` থেকে শুরু (অন্তর্ভুক্ত), `stop` পর্যন্ত (অন্তর্ভুক্ত নয়), `step` ধাপে। যেকোনো অংশ বাদ দেওয়া যায়। স্লাইস সব সময় নতুন একটি তালিকা ফেরত দেয়।

```
a = [0, 1, 2, 3, 4, 5]
print(a[1:4])     # [1, 2, 3]
print(a[:2])      # [0, 1] — প্রথম দুটি
print(a[-2:])     # [4, 5] — শেষ দুটি
print(a[::2])     # [0, 2, 4] — প্রতি দ্বিতীয়টি
print(a[::-1])    # [5, 4, 3, 2, 1, 0] — উল্টানো
print(a[:])       # পুরো তালিকার কপি
```

সূচকের মতো নয়, স্লাইস সীমার বাইরে গেলে ত্রুটি দেয় না: `a[10:20]` শুধু `[]` ফেরত দেবে। স্লাইসে মান বসিয়ে তালিকার একটি অংশ বদলানোও যায়: `a[1:3] = ["x", "y", "z"]`।

### স্ট্রিংয়ের স্লাইস

স্লাইস যেকোনো ক্রমের উপর একইভাবে কাজ করে, স্ট্রিং ও tuple-সহ:

```
s = "Python 3.15"
print(s[:6])      # Python
print(s[-4:])     # 3.15
print(s[::-1])    # 51.3 nohtyP
```

স্ট্রিং স্লাইস দিয়ে বদলানো যায় না — স্ট্রিং অপরিবর্তনীয়, স্লাইস একটি নতুন স্ট্রিং বানায়।

## তালিকা সাজানো: sort ও sorted

এখানেই নতুনেরা সবচেয়ে বেশি বিভ্রান্ত হন। `sort` মেথড তালিকার উপাদানগুলো তালিকাটির ভেতরেই সাজায় এবং `None` ফেরত দেয়। `sorted` ফাংশন মূল তালিকায় হাত দেয় না এবং একটি নতুন সাজানো তালিকা ফেরত দেয়।

```
amounts = [250, 1200, 99]
amounts.append(450)
print(sorted(amounts))     # [99, 250, 450, 1200] — নতুন কপি
print(amounts)             # [250, 1200, 99, 450] — মূলটি অক্ষত

result = amounts.sort()    # নিজের জায়গায় সাজায়
print(result, amounts)     # None [99, 250, 450, 1200]
```

এখান থেকেই বিখ্যাত প্রশ্ন «কেন আমার None আসছে»: `a = a.sort()` তালিকাকে `None` মান দিয়ে মুছে দেয়। লিখুন হয় `a.sort()`, নয়তো `a = sorted(a)`।

### key ও উল্টো ক্রম

দুটি উপায়েই `key` ও `reverse` প্যারামিটার নেওয়া যায়। `key` একটি ফাংশন, যার ফলাফল দিয়ে উপাদানগুলো তুলনা হয়।

```
words = ["tea", "Taxi", "subscription"]
print(sorted(words, key=len))               # ['tea', 'Taxi', 'subscription']
print(sorted(words, key=str.lower))         # বড়-ছোট হাতের অক্ষর উপেক্ষা করে
print(sorted([3, 1, 2], reverse=True))      # [3, 2, 1]

expenses = [("Food", 650), ("Cinema", 120), ("Taxi", 300)]
expenses.sort(key=lambda e: e[1])           # পরিমাণ অনুযায়ী
```

Python-এর সর্টিং স্থিতিশীল: একই key-র উপাদানগুলো আগের ক্রম ধরে রাখে। পার্থক্য আরেকটি বিষয়েও: `sorted` যেকোনো ক্রম নেয় (স্ট্রিং, dictionary, set), আর `sort` শুধু তালিকায় থাকে।

## তালিকা উল্টানো

তিনটি উপায়, আচরণ আলাদা:

- `a.reverse()` — নিজের জায়গায় উল্টায়, `None` ফেরত দেয়;
- `a[::-1]` — নতুন উল্টানো তালিকা;
- `reversed(a)` — অলস iterator, লুপে সুবিধাজনক: `for x in reversed(a):`।

## তালিকার উপর লুপ

```
items = ["coffee", "bus", "cinema"]
for item in items:
    print(item)

for i, item in enumerate(items, start=1):
    print(i, item)          # 1 coffee, 2 bus, 3 cinema

print("cinema" in items)    # True — উপস্থিতি যাচাই
```

যে তালিকার উপর লুপ চলছে, সেখান থেকে উপাদান মুছবেন না — কিছু উপাদান বাদ পড়বে। নতুন তালিকা বানান comprehension দিয়ে, নয়তো অনুলিপির উপর লুপ চালান: `a[:]`।

## List comprehension

List comprehension একটি লাইনে নতুন তালিকা বানায়: একটি এক্সপ্রেশন, একটি লুপ এবং ঐচ্ছিক একটি শর্ত।

```
squares = [n * n for n in range(6)]          # [0, 1, 4, 9, 16, 25]
big = [a for a in [250, 1200, 99] if a > 200]  # [250, 1200]
names = [s.strip().title() for s in [" anika ", "karim"]]
```

Comprehension সাধারণত `append`-সহ লুপের চেয়ে দ্রুত ও পড়তে সহজ। তবে যুক্তি একটি পরিষ্কার লাইনে না ধরলে সাধারণ লুপই ভালো।

## তালিকা জোড়া, যোগ ও বিয়োগ

```
a = [1, 2, 3]
b = [3, 4]
print(a + b)       # [1, 2, 3, 3, 4] — নতুন তালিকা
a += b             # একই কাজ a.extend(b)
print([*a, *b])    # আনপ্যাক করে নতুন তালিকা
```

তালিকায় `-` অপারেটর নেই। একটি তালিকা থেকে অন্যটির উপাদান বাদ দিতে comprehension লিখুন: `[x for x in a if x not in set(b)]`। দুটি তালিকার মিল খোঁজার সবচেয়ে সহজ উপায় set: `set(a) & set(b)` (তবে ক্রম ও ডুপ্লিকেট হারায়)।

## নেস্টেড ও দ্বিমাত্রিক তালিকা

তালিকার ভেতরে তালিকা একটি টেবিল বা ম্যাট্রিক্স রাখার সহজ উপায়:

```
matrix = [[1, 2, 3], [4, 5, 6]]
print(matrix[1][2])     # 6
grid = [[0] * 3 for _ in range(2)]   # সঠিক উপায়
bad = [[0] * 3] * 2                  # ফাঁদ: একই তালিকার দুটি রেফারেন্স
bad[0][0] = 9
print(bad)              # [[9, 0, 0], [9, 0, 0]]
```

## তালিকা আনপ্যাক

```
first, second, third = [10, 20, 30]
head, *rest = [1, 2, 3, 4]      # head=1, rest=[2, 3, 4]
print(*["a", "b"], sep=", ")    # a, b — বন্ধনী ছাড়া তালিকা ছাপানো
```

ভেরিয়েবলের সংখ্যা তালিকার দৈর্ঘ্যের সঙ্গে না মিললে আসবে `ValueError` — এখানে তারকাচিহ্ন বাঁচায়।

## তালিকা কপি করা

`b = a` তালিকা কপি করে না, শুধু একই অবজেক্টে দ্বিতীয় নাম দেয়: `b` দিয়ে বদলালে `a`-তেও দেখা যায়। স্বাধীন কপি করতে স্পষ্টভাবে লিখুন: `a.copy()`, `list(a)` বা `a[:]`। নেস্টেড ডেটার জন্য এটুকু যথেষ্ট নয় — ভেতরের তালিকাগুলো ভাগাভাগি থেকে যায়, তখন লাগে `copy.deepcopy(a)`।

```
import copy
a = [[1, 2], [3]]
b = a.copy()
b[0].append(99)
print(a)                 # [[1, 2, 99], [3]] — ভেতরের তালিকা ভাগাভাগি
c = copy.deepcopy(a)     # সম্পূর্ণ স্বাধীন কপি
```

## Tuple: অপরিবর্তনীয় তালিকা

Tuple (`tuple`) তালিকার মতো, কিন্তু তৈরির পরে বদলানো যায় না। এটি পাঠকের জন্য স্পষ্ট বার্তা: এটি নির্দিষ্ট ঘরের একটি রেকর্ড, বাড়তে থাকা সেট নয়। Tuple সহজে আনপ্যাক হয়, আর ফাংশন একাধিক মান ফেরত দিতে সাধারণত tuple ব্যবহার করে।

```
expense = (250, "Coffee")
amount, item = expense
expense[0] = 300
# TypeError: 'tuple' object does not support item assignment
```

অপরিবর্তনীয় মানের tuple হ্যাশযোগ্য, তাই dictionary-র key হতে পারে। একটিমাত্র উপাদানের tuple লিখতে হয় কমাসহ: `(5,)`।

## Set: শুধু অনন্য মান

Set (`set`) শুধু অনন্য মান রাখে এবং ক্রম মনে রাখে না। ডুপ্লিকেট সরানো এবং «এটি আছে কিনা» যাচাই করার সবচেয়ে দ্রুত উপায় এটি, আর এতে সংযোগ, মিলন ও বিয়োগও সম্ভব।

```
jan = {"Food", "Taxi", "Cinema"}
feb = {"Food", "Subscriptions"}
print(jan & feb)    # {'Food'}
print(feb - jan)    # {'Subscriptions'}
unique = list(dict.fromkeys([3, 1, 3, 2]))   # [3, 1, 2] — ডুপ্লিকেট ছাড়া, ক্রম বজায়
empty = set()       # {} — এটি খালি dictionary!
```

## কোন কালেকশন বেছে নেবেন

| কাজ | কালেকশন |
| --- | --- |

| ক্রম ও পরিবর্তন | `list` |

| নির্দিষ্ট রেকর্ড | `tuple` |

| key দিয়ে খোঁজা | `dict` |

| অনন্যতা, «আছে কিনা» যাচাই | `set` |

| অপরিবর্তনীয় সেটিংস | `frozendict` (Python 3.15) |

`x in list` উপাদানগুলো একে একে দেখে, আর `x in set` প্রায় তাৎক্ষণিক কাজ করে। লুপে বড় তালিকায় বারবার উপস্থিতি যাচাই করলে তালিকাটিকে set-এ বদলান।

## সারসংক্ষেপ

Python-এর list ক্রমানুসারী ও পরিবর্তনযোগ্য কালেকশন: `append` ও `extend` যোগ করে, `pop` ও `remove` মোছে, `a[start:stop:step]` স্লাইস অংশ নেয়, `sort` নিজের জায়গায় সাজিয়ে `None` দেয়, আর `sorted` নতুন তালিকা দেয়। কপি স্পষ্টভাবে করুন, স্থির রেকর্ডের জন্য tuple নিন, অনন্য মানের জন্য set। তালিকা, tuple, dictionary ও set কোর্সের «Python 3.15: শূন্য থেকে পেশাদার পর্যন্ত»-এর একটি লেকচারে বাস্তব উদাহরণে শেখানো হয়েছে।

## FAQ

**Python-এর তালিকা কি অন্য ভাষার অ্যারের মতো?**

Python-এ অন্য ভাষার মতো আলাদা অ্যারে নেই; তালিকাই তার জায়গা নেয় এবং একসঙ্গে বিভিন্ন ধরনের মান রাখতে পারে। কমপ্যাক্ট সংখ্যার অ্যারের জন্য আছে array মডিউল এবং NumPy লাইব্রেরি।

**তালিকায় কোনো উপাদানের সূচক কীভাবে খুঁজব?**

a.index(x) মেথড প্রথম মিলের সূচক দেয়, না থাকলে ValueError ছোঁড়ে। তাই ডাকার আগে x in a যাচাই করা ভালো।

**ক্রম ঠিক রেখে তালিকা থেকে ডুপ্লিকেট কীভাবে সরাব?**

list(dict.fromkeys(a)) ব্যবহার করুন: dictionary key-গুলো অনন্য রাখে এবং সন্নিবেশের ক্রম ধরে রাখে। list(set(a)) ডুপ্লিকেট সরায়, তবে ক্রম রাখে না।

**স্ট্রিংয়ের তালিকাকে কীভাবে একটি স্ট্রিংয়ে জোড়া দেব?**

স্ট্রিংয়ের join মেথডে: ", ".join(["a", "b", "c"]) দেয় "a, b, c"। সব উপাদান স্ট্রিং হতে হবে; সংখ্যা হলে আগে map(str, a) দিয়ে রূপান্তর করুন।

**তালিকায় বিভিন্ন ধরনের উপাদান রাখা যায় কি?**

হ্যাঁ, তালিকায় একসঙ্গে সংখ্যা, স্ট্রিং, অন্য তালিকা ও যেকোনো অবজেক্ট থাকতে পারে। তবে key ছাড়া সেই তালিকা সাজানো সাধারণত যায় না — সংখ্যা ও স্ট্রিংয়ের তুলনায় TypeError আসবে।


---
Source: Skillaria.Top (https://skillaria.top)