list — বদলানো যায় এমন ক্রম

১ · list কী — নম্বর দেওয়া লকারের সারি

এতদিন আপনি একটি ভ্যারিয়েবলে একটি মান রেখেছেন — একজনের নাম, একটি নম্বর। কিন্তু বাস্তবের ডেটা প্রায় কখনো একা আসে না। বাজারের ফর্দে দশটি জিনিস, ক্লাসে ষাট জনের নম্বর, একটি ক্রিকেট দলের এগারো জনের রান, আজকের কাজের তালিকা। প্রত্যেকটির জন্য আলাদা ভ্যারিয়েবল (item1, item2, …) বানানো অসম্ভব, আর ফর্দে একটি জিনিস বাড়লেই কোড বদলাতে হবে।

Python-এর উত্তর হলো list: অনেকগুলো জিনিস একটি নামের নিচে, নির্দিষ্ট ক্রমে। পর্ব ১২-এ for লুপে list দেখেছেন; এবার ভেতরে ঢুকি।

এই ছবির প্রতিটি অংশ list-এর একটি সত্য:

মিশ্র টাইপ নিয়ে একটি সৎ পরামর্শ। ["রহিম", 78, True] লেখা যায়, কিন্তু এমন list-এর প্রতিটি ঘরের অর্থ আলাদা — ঘর ০ নাম, ঘর ১ নম্বর, ঘর ২ পাস কি না। এমন “একটি রেকর্ডের কয়েকটি অংশ” রাখার জন্য tuple (পর্ব ১৫), dictionary (পর্ব ১৬) বা class (পর্ব ২৯) বেশি উপযুক্ত। list সবচেয়ে ভালো কাজ করে যখন সব ঘরে একই ধরনের জিনিস থাকে — সব নাম, বা সব নম্বর — যাতে একই কাজ প্রতিটির ওপর লুপ দিয়ে করা যায়।

২ · list তৈরি, index, slicing আর in

list তৈরির চারটি প্রচলিত উপায়:

list() একটি iterable নেয়, তার ওপর হেঁটে প্রতিটি জিনিস নতুন list-এ রাখে। তাই list("ঢাকা") দেয় প্রতিটি Unicode code point-এর আলাদা ঘর — ['ঢ', 'া', 'ক', 'া'], পর্ব ০৯-এ যেমন দেখেছেন।

index আর negative index

পর্ব ০৯-এ string-এর জন্য যা শিখেছেন, list-এ হুবহু একই। bazaar = ["চাল", "ডাল", "তেল", "আলু"] হলে bazaar[0] হলো "চাল", bazaar[3] হলো "আলু". শেষ থেকে গুনতে negative index: bazaar[-1] শেষটি ("আলু"), bazaar[-2] শেষের আগেরটি। সীমার বাইরে গেলে — যেমন bazaar[4] — আসে IndexError.

পার্থক্য একটাই, কিন্তু বড়: string-এর ঘর বদলানো যায় না, list-এর যায়। bazaar[2] = "সরিষার তেল" লিখলে ঘর ২-এর তীর নতুন string-এর দিকে ঘুরে যায়; list-এর বাকি সব যেমন ছিল তেমনই।

slicing — এবং slice দিয়ে বদলানো

slicing-এর নিয়মও string-এর মতো: a[start:stop:step], stop ভেতরে থাকে না। bazaar[1:3] দেয় ["ডাল", "তেল"], bazaar[::-1] উল্টো ক্রমে নতুন list. একটি গুরুত্বপূর্ণ কথা: slicing সবসময় একটি নতুন list বানায় — তাই bazaar[:] পুরো list-এর একটি কপি (অংশ ৮-এ আবার আসবে)।

list-এ একটি নতুন ক্ষমতা আছে যা string-এ নেই — slice-এ মান বসানো। বাঁ দিকে slice লিখলে সেই অংশটি ডান দিকের জিনিসগুলো দিয়ে বদলে যায়, আর দৈর্ঘ্য মিলতেই হবে এমন কোনো কথা নেই:

a = [10, 20, 30, 40, 50]
a[1:3] = [21, 22, 23]     # দুটি ঘরের জায়গায় তিনটি
print(a)                  # [10, 21, 22, 23, 40, 50]
a[1:4] = []               # তিনটি ঘর মুছে ফেলা
print(a)                  # [10, 40, 50]
a[1:1] = [15]             # কিছু না মুছে index 1-এ ঢোকানো
print(a)                  # [10, 15, 40, 50]

slice assignment শক্তিশালী, কিন্তু পড়তে একটু কঠিন। দৈনন্দিন কাজে নিচের নাম-ওয়ালা method-গুলো (insert, del, extend) বেশি পরিষ্কার। slice assignment চিনে রাখুন, যাতে অন্যের কোডে দেখে চমকে না যান।

len আর in

len(bazaar) দেয় ঘরের সংখ্যা — খুব দ্রুত, কারণ list নিজের দৈর্ঘ্য সবসময় মনে রাখে। "ডাল" in bazaar দেয় True বা False — এটি পর্ব ০৮-এর membership operator. কিন্তু in-এর গতি len-এর মতো নয়: Python প্রথম ঘর থেকে একটি একটি করে == দিয়ে মেলায় যতক্ষণ না পায়। দশ লাখ ঘরের list-এ না-থাকা জিনিস খুঁজলে দশ লাখ তুলনা। অংশ ৭-এ এর হিসাব দেখবেন।

৩ · list-এ যোগ করা — append, extend, insert

list বদলানোর কাজগুলো হয় method দিয়ে — list.নাম(...) ধাঁচে। যোগ করার তিনটি method:

• append(x) — x-কে শেষে একটি নতুন ঘরে রাখে। সবসময় ঠিক একটি ঘর বাড়ে।
• extend(iterable) — iterable-এর প্রতিটি জিনিসের জন্য শেষে একটি করে ঘর। a += [1, 2]-ও একই কাজ করে।
• insert(i, x) — x-কে index i-তে ঢোকায়; i থেকে শুরু করে বাকি সবাই এক ঘর ডানে সরে।

নতুনদের সবচেয়ে বেশি গুলিয়ে যায় append আর extend, যখন যোগ করার জিনিসটি নিজেই একটি list. বাজারের ব্যাগে দেখা যাক:

1bag = ["চাল", "ডাল"]2bag.append(["আলু", "ডিম"])3bag.extend(["আলু", "ডিম"])4bag.insert(1, "তেল")5print(len(bag), bag[3])

৪ · মোছা আর খোঁজা — remove, pop, del, clear, index, count

মোছার চারটি উপায়, আর প্রতিটির প্রশ্ন আলাদা — “কোন মান মুছব?” নাকি “কোন ঘর মুছব?”

কয়েকটি সূক্ষ্ম কথা:

• remove শুধু প্রথমটি মোছে। [8, 45, 8].remove(8)-এর পর থাকে [45, 8]. সব 8 মুছতে চাইলে নতুন list বানানোই পরিষ্কার উপায় (অংশ ৮)।
• pop একমাত্র মোছার method যা জিনিসটি হাতে দেয়। to-do list থেকে শেষ কাজটি তুলে নিয়ে করতে চাইলে task = todo.pop() — মোছা আর পাওয়া একসাথে। শেষ থেকে যোগ (append) আর শেষ থেকে তোলা (pop) মিলে list একটি stack-এর মতো কাজ করে — থালার স্তূপ, শেষে রাখা থালা আগে ওঠে।
• del একটি statement, method নয়। এটি ঘর মোছে, আর পুরো নামও মুছতে পারে (del a — তখন a নামটিই থাকে না, list object নয়)।
• clear() বনাম a = []: clear একই list object-কে খালি করে; a = [] নামটিকে নতুন একটি খালি list-এ লাগায়, পুরোনোটি অন্য কোনো নামে থাকলে ভরাই থাকে। পর্ব ১৯-এ এই পার্থক্য গুরুত্বপূর্ণ হবে।

খোঁজা: index আর count

a.index(x) দেয় প্রথম যে ঘরে x আছে তার নম্বর; না থাকলে ValueError (string-এর find-এর মতো −1 দেয় না)। তাই নিশ্চিত না হলে আগে if x in a: দেখে নিন। a.count(x) গোনে x কতবার আছে — ক্রিকেট দলের রানের list-এ কতজন শূন্য রানে আউট, এক লাইনে: runs.count(0). দুটিই পুরো list ঘাঁটে, তাই বড় list-এ বারবার ডাকলে ধীর।

৫ · সাজানো — sort বনাম sorted, key আর stable sort

Python-এ সাজানোর দুটি উপায়, আর দুটির পার্থক্য এই পর্বের সবচেয়ে গুরুত্বপূর্ণ শিক্ষাগুলোর একটি:

একইভাবে উল্টানোর জন্যও দুটি: a.reverse() জায়গায় উল্টায় আর None দেয়; reversed(a) কোনো list বানায় না, শুধু পেছন থেকে হাঁটার একটি অলস iterator দেয় (পর্ব ১২)। list হিসেবে চাইলে list(reversed(a)) বা a[::-1].

নিয়মটি: যে method বদলায়, সে None ফেরত দেয়

append, extend, insert, remove, sort, reverse, clear — list-কে বদলানো সব method None ফেরত দেয় (ব্যতিক্রম শুধু pop, কারণ তার কাজই একটি জিনিস হাতে দেওয়া)। এটি ইচ্ছাকৃত নকশা: Python চায় আপনি স্পষ্ট জানুন যে মূল list বদলে গেছে, নতুন কিছু তৈরি হয়নি। কিন্তু এই নিয়ম না জানলে একটি বিখ্যাত বাগ হয় — দেখুন:

1marks = [70, 45, 90]2marks = marks.sort()3print(marks)4marks.append(60)

key আর reverse — নিজের নিয়মে সাজানো

সংখ্যা ছোট থেকে বড়, string অভিধানের মতো (আসলে Unicode code point-এর ক্রমে, পর্ব ০৮-এর lexicographic order). বড় থেকে ছোট চাইলে reverse=True. কিন্তু ধরুন একটি ক্লাসের রোল কলের list, প্রতিটি জিনিস একটি জোড়া ("রহিম", 78) — নম্বর অনুযায়ী সাজাবেন কীভাবে?

এর জন্য key=. আপনি একটি ফাংশন দেন, যা প্রতিটি জিনিস থেকে “কী দিয়ে তুলনা করব” সেই মানটি বের করে — একে বলে key function. Python প্রতিটি জিনিসের জন্য ফাংশনটি একবার ডাকে, তারপর জিনিসগুলো সেই মান অনুযায়ী সাজায়। একাধিক নিয়ম লাগলে (আগে নম্বর, সমান হলে নাম) key ফাংশন একটি tuple ফেরত দিতে পারে, কারণ tuple-এর তুলনা হয় প্রথম ঘর থেকে, সমান হলে দ্বিতীয় ঘর — ঠিক অভিধানের মতো।

def get_mark(student):
    return student[1]

def mark_then_name(student):
    name, mark = student
    return (-mark, name)        # বেশি নম্বর আগে; সমান হলে নামের ক্রমে

students = [("রহিম", 78), ("সুমি", 91), ("করিম", 78), ("নাদিয়া", 65), ("আরিফ", 91)]

print(sorted(students, key=get_mark, reverse=True))
for pos, (name, mark) in enumerate(sorted(students, key=mark_then_name), start=1):
    print(pos, name, mark)

scores = [45, 12, 88, 30]
result = scores.sort()          # list বদলায়, ফেরত দেয় None
print(result, scores)
print(sorted(scores, reverse=True), scores)

৬ · list-এর ভেতরে list — নম্বরের টেবিল আর [[0]*3]*3-এর ফাঁদ

একটি list-এর ঘরে যেকোনো object-এর reference রাখা যায় — আরেকটি list-ও। এভাবে তৈরি হয় nested list, যা দিয়ে টেবিল বা গ্রিড বোঝানো যায়। তিনজন শিক্ষার্থীর তিন বিষয়ের নম্বর:

table = [
    [72, 65, 80],   # রহিম: বাংলা, ইংরেজি, গণিত
    [88, 91, 95],   # সুমি
    [40, 28, 55],   # করিম
]
print(table[1])        # [88, 91, 95] — সুমির পুরো সারি
print(table[1][2])     # 95 — সুমির গণিত
for row in table:
    print(sum(row))    # প্রত্যেকের মোট: 217, 274, 123

table[1][2] পড়ুন বাঁ থেকে ডানে: আগে table[1] — একটি সারি (নিজেই একটি list), তারপর সেই সারির [2]. প্রথম index সারি, দ্বিতীয় index কলাম।

এবার একটি ফাঁদ, যাতে প্রায় সবাই একবার পড়েন — নতুনরা তো বটেই, AI-ও। পর্ব ০৯-এ দেখেছেন "-" * 3 দেয় "---"; list-এও [0] * 3 দেয় [0, 0, 0]. তাহলে ৩×৩ শূন্যের গ্রিড বানাতে [[0] * 3] * 3 লিখলেই তো হয়?

1row = [0] * 32grid = [row] * 33grid[0][0] = 14print(grid)5good = [[0] * 3 for _ in range(3)]

৭ · ভেতরের ছবি — dynamic array আর কোন কাজ কত দ্রুত

এতক্ষণ list ব্যবহার করেছেন বাইরে থেকে। এবার দেখা যাক CPython-এর ভেতরে list কীভাবে তৈরি — কারণ এটি জানলে আপনি বুঝবেন কোন কাজ সস্তা, কোনটি দামি।

CPython-এ list হলো একটি dynamic array: মেমরিতে পাশাপাশি রাখা কিছু ঘর, প্রতিটি ঘরে একটি pointer (৬৪-বিট কম্পিউটারে ৮ বাইট), যা কোনো Python object-এর ঠিকানা। list object নিজে মনে রাখে তিনটি জিনিস — ঘরগুলো কোথায় শুরু, এখন কয়টি ঘর ভরা (len), আর মোট কয়টি ঘরের জায়গা বরাদ্দ (capacity). সব ঘর পাশাপাশি আর একই মাপের, তাই ঘর i-এর ঠিকানা সরাসরি হিসাব করা যায়: শুরু + i × 8. এজন্য a[500000] আর a[0] একই সময় নেয়।

কিন্তু পাশাপাশি ঘরের একটি সমস্যা: ঘর ফুরিয়ে গেলে পাশে আরেকটি ঘর জুড়ে দেওয়া যায় না — ওখানে মেমরিতে অন্য কিছু থাকতে পারে। তখন বড় একটি নতুন ব্লক নিতে হয়, সব pointer সেখানে কপি করতে হয়। প্রতিটি append-এ এটা করলে খুব ধীর হতো। তাই CPython চালাকি করে — দরকারের চেয়ে একটু বেশি জায়গা আগেই নিয়ে রাখে। ধাপে ধাপে দেখুন (সংখ্যাগুলো CPython 3.14-এ মাপা; সংস্করণভেদে সামান্য বদলাতে পারে):

1a = []2a.append(10)3a.extend([20, 30, 40])4a.append(50)5a.insert(0, 5)

দামি append মাঝে মাঝে আসে, কিন্তু যত বড় list, তত দূরে দূরে আসে — কারণ প্রতিবার ব্লক আনুপাতিক হারে বাড়ে। মোট খরচকে সব append-এর মধ্যে ভাগ করলে প্রতিটির গড় খরচ একটি ধ্রুবক থাকে। একে বলে amortized O(1): “প্রতিটি append সস্তা” নয়, বরং “অনেকগুলো append মিলিয়ে গড়ে সস্তা”. (Big-O ভাবনা পর্ব ০২-এ দেখেছেন।)

কখন list নয়

এই টেবিল থেকেই সিদ্ধান্ত আসে। ব্যাংকের লাইনের মতো সারি — পেছনে যোগ, সামনে থেকে তোলা — list দিয়ে করলে প্রতিটি pop(0) পুরো list সরায়। এর জন্য আছে collections.deque (উচ্চারণ “ডেক”), যার দুই প্রান্তেই যোগ-তোলা O(1); পর্ব ২৭-এ দেখবেন। আর বারবার “এটা কি আছে?” জিজ্ঞেস করতে হলে list-এর O(n) in-এর বদলে set (পর্ব ১৭) বা dictionary (পর্ব ১৬), যেখানে খোঁজা গড়ে O(1).

৮ · প্রতিদিনের প্যাটার্ন — লুপে বানানো, ছাঁকা, unpacking আর কপি

বাস্তবের কোডে list নিয়ে কয়েকটি কাজ বারবার ফিরে আসে। বাজারের ফর্দ আর একটি ক্রিকেট দলের রান দিয়ে সবগুলো একসাথে চালিয়ে দেখুন:

bazaar = ["চাল", "ডাল", "তেল"]
bazaar.append("পেঁয়াজ")
bazaar.extend(["আলু", "ডিম"])
bazaar.insert(0, "লবণ")
bazaar.remove("তেল")
last = bazaar.pop()
print(bazaar, "| শেষে তোলা:", last)
print("ডাল" in bazaar, bazaar.index("ডাল"), len(bazaar))

runs = [45, 8, 72, 0, 31, 8, 104, 15]
big = []
for r in runs:                  # ছাঁকা: শুধু ৩০ বা বেশি
    if r >= 30:
        big.append(r)
first, second, *rest = runs     # ওপেনার দুজন, বাকিরা একসাথে
print(big, first, second, rest)
print("মোট", sum(runs), "| সর্বোচ্চ", max(runs), "| শূন্য", runs.count(0))

grid = [[0] * 3] * 3
grid[0][0] = 1
print(grid)

লুপে list বানানো আর ছাঁকা — comprehension-এর ঝলক

“খালি list → লুপ → শর্ত → append” প্যাটার্ন এত বেশি ব্যবহৃত যে Python-এ এর একটি সংক্ষিপ্ত রূপ আছে: big = [r for r in runs if r >= 30]. পড়ুন: “runs-এর প্রতিটি r, যদি r ৩০ বা বেশি হয়”. এটি list comprehension, পর্ব ১৮-এর বিষয়। আপাতত লম্বা রূপটিই লিখুন — আগে প্যাটার্নটি হাতে বুঝুন, তারপর সংক্ষেপ।

enumerate আর built-in

to-do list ক্রমিক নম্বরসহ ছাপতে পর্ব ১২-এর enumerate: for n, task in enumerate(todo, start=1):. আর যোগফল, সর্বোচ্চ, সর্বনিম্নের জন্য লুপ নয়, sum(), max(), min(). খালি list-এ max([]) ValueError দেয় — দরকারে max(runs, default=0) লিখুন।

list কপি করা — অল্প কথায়

b = a লিখলে কোনো কপি হয় না — শুধু একই list-এ দ্বিতীয় একটি লেবেল লাগে; b.append(1) করলে a-তেও দেখা যাবে। সত্যিকারের নতুন list চাইলে তিনটি সমান উপায়: a[:], list(a), a.copy(). তবে এগুলো shallow copy — নতুন list, কিন্তু ঘরগুলোতে একই object-এর তীর। ভেতরের জিনিস mutable হলে (যেমন নম্বরের টেবিলের সারি) কপি আর মূল এখনো সেই সারিগুলো ভাগাভাগি করে। এর পুরো গল্প, আর copy.deepcopy কখন লাগে, পর্ব ১৯-এ।

৯ · AI-এর যুগে — AI-এর লেখা list কোড যাচাই

list নিয়ে AI-এর লেখা কোড সাধারণত চলে, আর ছোট ডেটায় ঠিক উত্তরও দেয়। সমস্যা লুকিয়ে থাকে দুই জায়গায় — চুপচাপ ভুল ফল (None, বাদ পড়া উপাদান), আর বড় ডেটায় হঠাৎ ধীর হয়ে যাওয়া। কয়েকটি পরিচিত ধরন:

O(n²)-এর হিসাবটি একবার দেখে নিন। ১০,০০০ জন গ্রাহকের list-এ ১০,০০০টি লেনদেনের প্রতিটির গ্রাহক আছে কি না in দিয়ে দেখলে, খারাপ ক্ষেত্রে প্রায় ১০ কোটি তুলনা। একই list থেকে একবার set বানালে কাজটি হয় প্রায় ১০,০০০টি খোঁজায়। পরীক্ষার ছোট ডেটায় দুটোই চোখের পলকে শেষ হয় — তাই AI-এর কোড “চলছে” দেখে নিশ্চিন্ত হবেন না।

AI-এর লেখা list কোড পেলে — যাচাইয়ের চেকলিস্ট

• x = x.sort(), x = x.append(...) বা এমন কোনো বদলানো method-এর ফল কোনো নামে রাখা হয়েছে কি না খুঁজেছি
• লুপের ভেতরে একই list-এ remove, insert, del হচ্ছে কি না দেখেছি
• লুপের ভেতরে in, index, count, pop(0) বা insert(0, …) আছে কি না — থাকলে ডেটা বড় হলে কত ধীর হবে, হিসাব করেছি
• list-এর জায়গায় set (অনন্য মান, দ্রুত খোঁজা), dict (চাবি দিয়ে খোঁজা) বা deque (সামনে থেকে তোলা) বেশি মানায় কি না ভেবেছি
• [[...] * n] * m বা b = a দিয়ে “কপি” আছে কি না, আর খালি list দিয়ে কোডটি নিজে চালিয়ে দেখেছি