tuple আর unpacking — স্থির রেকর্ড আর বাক্স খোলা

১ · tuple কী — একটি স্থির রেকর্ড

আগের পর্বে আপনি list শিখেছেন — একটি সারি, যাতে জিনিস যোগ হয়, মোছে, ক্রম বদলায়। দোকানের দিনের বিক্রি, ক্লাসের সব শিক্ষার্থীর নাম, একটি ফাইলের লাইন — এগুলো list-এর কাজ। সবগুলো জিনিস একই রকম, আর সংখ্যাটা বাড়ে-কমে.

কিন্তু কিছু তথ্য এমন, যা একসাথে মিলে একটিই জিনিস বোঝায়। ঢাকার অবস্থান বলতে দুটি সংখ্যা লাগে — অক্ষাংশ প্রায় 23.81, দ্রাঘিমাংশ প্রায় 90.41. এই দুটি আলাদা থাকলে কোনো অর্থ নেই; একসাথে থাকলে একটি বিন্দু। একজন শিক্ষার্থীর রেকর্ড — নাম, রোল, GPA — তিনটি ভিন্ন ধরনের মান, কিন্তু একজন মানুষের। এমন “কয়েকটি সম্পর্কিত মান, যারা একসাথে থাকে” রাখার জন্য Python-এ আছে tuple.

tuple-এর মূল বৈশিষ্ট্য হলো এটি immutable: একবার তৈরি হলে এর ঘরগুলোতে অন্য object বসানো যায় না, ঘর যোগ বা বাদও দেওয়া যায় না। তবু এটি list-এর মতোই একটি sequence — ক্রম আছে, index দিয়ে পড়া যায়, লুপ চালানো যায়।

২ · tuple বানানো — কমাই আসল, বন্ধনী নয়

সবচেয়ে পরিচিত রূপ হলো বন্ধনীর ভেতরে কমা দিয়ে মান লেখা: dhaka = (23.81, 90.41). কিন্তু এখানে একটি গোপন সত্য আছে — tuple বানায় কমা, বন্ধনী শুধু দলবদ্ধ করে পড়তে সাহায্য করে। dhaka = 23.81, 90.41 লিখলেও একই tuple তৈরি হয়। কয়েকটি মান কমা দিয়ে একটি tuple-এ ভরে ফেলাকে বলে packing. পর্ব ০৬-এ a, b = b, a দিয়ে যে swap শিখেছিলেন, তার ডান দিকে আসলে এই packing-ই ঘটে।

এই নিয়ম থেকেই নতুনদের সবচেয়ে পরিচিত ফাঁদটি আসে। ধাপে ধাপে দেখুন, চারটি প্রায় একই রকম লাইন কী কী বানায়:

1x = (5)2y = (5,)3z = 5,4e = ()

আরেকটি উপায় হলো tuple() ফাংশন, যা যেকোনো iterable থেকে tuple বানায়: tuple([1, 2, 3]) দেয় (1, 2, 3), tuple("ঢাকা") দেয় প্রতিটি অক্ষরের একটি tuple, tuple(range(3)) দেয় (0, 1, 2). একটি list-কে “জমিয়ে” স্থির করতে চাইলে এটিই সহজ পথ।

৩ · immutability — কী বদলায় না, আর কী বদলাতে পারে

tuple-এর কোনো ঘরে নতুন কিছু বসাতে গেলে Python সরাসরি থামিয়ে দেয়: dhaka[0] = 24.0 লিখলে আসে TypeError: 'tuple' object does not support item assignment. tuple-এ append, remove, sort — এমন কোনো method-ই নেই। বদলাতে চাইলে নতুন tuple বানাতে হয়: dhaka = (24.0, dhaka[1]). এতে পুরোনো tuple বদলায়নি; dhaka নামের লেবেলটি নতুন একটি object-এ সরেছে (পর্ব ০৬-এর লেবেল-ছবি মনে করুন)।

কিন্তু “বদলায় না” কথাটির একটি সূক্ষ্ম সীমা আছে। পর্ব ০৫-এ দেখেছেন, Python-এ সবকিছু object, আর একটি সংগ্রহ আসলে object-গুলোর reference রাখে। tuple যা প্রতিজ্ঞা করে তা হলো: কোন ঘরে কোন object, তা কখনো বদলাবে না। সেই object নিজে যদি mutable হয় — যেমন একটি list — তবে তার ভেতরটা বদলাতেই পারে। একে বলে shallow immutability (অগভীর অপরিবর্তনীয়তা)। ধাপে ধাপে দেখুন:

1team = ("বাংলাদেশ", ["তামিম", "মুশফিক"])2team[1].append("সাকিব")3team[1] = ["নতুন দল"]4hash(team)5team[1] += ["লিটন"]

৪ · বদলানো যায় না — তাতে লাভ কী?

প্রথমে মনে হতে পারে, যে জিনিস কম কাজ পারে, তা রাখার কারণ কী? কিন্তু “বদলানো যায় না” একটি প্রতিশ্রুতি, আর প্রতিশ্রুতির দাম আছে। তিনটি বড় লাভ:

১. নিরাপদে ভাগ করা যায়

একটি list ফাংশনে পাঠালে ফাংশনটি চাইলে তাতে কিছু যোগ বা মুছে ফেলতে পারে — আর আপনার মূল list-ও বদলে যায়, কারণ দুজনেই একই object দেখছে। tuple পাঠালে এই দুশ্চিন্তা নেই। জেলা সদরের স্থানাঙ্কের একটি tuple দশটি ফাংশনে পাঠান, কেউ ভুল করেও সেটি নষ্ট করতে পারবে না। বড় প্রোগ্রামে, বিশেষ করে একাধিক thread-এ (পর্ব ৪১), এই নিশ্চয়তা অনেক বাগ আগেই আটকে দেয়।

২. dict-এর চাবি আর set-এর সদস্য হতে পারে

পর্ব ১৬-এ dictionary শিখবেন — চাবি দিয়ে মান খোঁজা। চাবি হতে গেলে একটি object-কে hashable হতে হয়: তার একটি hash সংখ্যা থাকবে, যা জীবনভর একই থাকবে। tuple-এর ভেতরে সব উপাদান hashable হলে tuple-ও hashable. তাই একটি ম্যাপে স্থানাঙ্ক দিয়ে জায়গার নাম রাখা যায়:

places = {
    (23.81, 90.41): "ঢাকা",
    (22.36, 91.78): "চট্টগ্রাম",
    (24.37, 88.60): "রাজশাহী",
}
print(places[(22.36, 91.78)])     # চট্টগ্রাম
# [23.81, 90.41]-কে চাবি বানালে: TypeError: unhashable type: 'list'

দাবার বোর্ডের ঘর (row, col), গ্রিডের বিন্দু, (জেলা, বছর) জোড়া ধরে বৃষ্টিপাত — এমন “একাধিক অংশের চাবি” Python-এ সবসময় tuple দিয়েই লেখা হয়। set-এর ক্ষেত্রেও একই নিয়ম (পর্ব ১৭)।

৩. একটু হালকা, একটু দ্রুত

list-কে সবসময় বাড়ার জন্য কিছু বাড়তি জায়গা রাখতে হয়; tuple-এর আকার জন্ম থেকেই নির্দিষ্ট, তাই সাধারণত একটু কম মেমরি নেয়। এছাড়া কোডে (1, 2, 3)-এর মতো শুধু ধ্রুবক দিয়ে লেখা tuple-কে CPython bytecode তৈরির সময়েই একটি ধ্রুবক হিসেবে বানিয়ে রাখে (পর্ব ০৫-এর constant folding) — প্রতিবার নতুন করে বানাতে হয় না। তবে এই পার্থক্য ছোট; শুধু গতির জন্য tuple বেছে নেবেন না। বেছে নিন অর্থের জন্য: এটি কি একটি স্থির রেকর্ড?

৫ · tuple-এর method আর অপারেশন

tuple বদলায় না বলে এর কাজের তালিকা ছোট — শুধু পড়া আর নতুন tuple বানানো। পর্ব ০৯-এর string আর পর্ব ১৪-এর list-এর সাথে এর মিল অনেক:

তুলনা: অভিধানের নিয়মে

দুটি tuple তুলনা হয় lexicographic order-এ — অভিধানে শব্দ সাজানোর মতো। প্রথম ঘর মেলানো হয়; আলাদা হলে সেখানেই সিদ্ধান্ত। সমান হলে দ্বিতীয় ঘর, তারপর তৃতীয়… (1, 2) < (1, 3) সত্য, কারণ প্রথম ঘর সমান আর দ্বিতীয়তে 2 < 3. আবার (2,) < (1, 9, 9) মিথ্যা — প্রথম ঘরেই 2 > 1, বাকিগুলো দেখাই হয় না।

এর বড় ব্যবহার সাজানোয়। sorted([(3, 1), (1, 2), (3, 0), (1, 1)]) দেয় [(1, 1), (1, 2), (3, 0), (3, 1)] — প্রথম ঘর ধরে সাজানো, প্রথম ঘর সমান হলে দ্বিতীয় ঘর ধরে। অর্থাৎ “আগে X ধরে, X সমান হলে Y ধরে সাজাও” — এই কাজ tuple আপনাআপনি করে দেয়। মেধাতালিকায় আগে GPA, GPA সমান হলে রোল — দুটিকে একটি tuple-এ রাখলেই হলো। নিচের কোডে দেখবেন।

৬ · unpacking — বাক্স খুলে প্রতিটি জিনিসে নাম দেওয়া

packing-এর উল্টো কাজ হলো unpacking: একটি tuple (বা যেকোনো iterable)-এর মানগুলো খুলে আলাদা আলাদা নামে বসানো। পর্ব ০৬-এ a, b = b, a আর পর্ব ১৩-এ ফাংশন থেকে দুটি মান ফেরত দেখেছেন — দুটোই unpacking. এবার এর পুরো ক্ষমতা দেখা যাক।

মৌলিক unpacking আর _

name, roll, gpa = ("রহিম", 12, 3.75) — বাম দিকে যতটি নাম, ডান দিকে ঠিক ততটি মান লাগবে। ডান দিক tuple না হয়ে list, string, range — যেকোনো iterable হতে পারে: name, age, city = "Rahim,23,Dhaka".split(",") একটি CSV লাইনকে এক লাইনেই তিনটি নামে ভাগ করে।

কোনো মান দরকার না হলে প্রচলিত রীতি হলো তাকে _ নামে বসানো: name, _, gpa = student. Python-এর কাছে _ একটি সাধারণ নাম — বিশেষ কিছু নয় — কিন্তু পাঠকের কাছে এটি একটি স্পষ্ট বার্তা: “এই মানটি ইচ্ছে করে ফেলে দিলাম।” একে বলে throwaway variable.

লুপে unpacking

জোড়ার একটি list-এ লুপ চালানোর সময় loop variable-এর জায়গাতেই unpacking করা যায় — পর্ব ১২-এ zip আর enumerate-এর সাথে এটিই করেছিলেন:

results = [("রহিম", 78), ("সুমি", 91), ("করিম", 29)]
for name, marks in results:          # প্রতিটি জোড়া খুলে দুটি নাম
    print(name, "পাস" if marks >= 33 else "ফেল")

for pair in results: লিখে ভেতরে pair[0], pair[1] লেখাও যায় — কিন্তু তখন পাঠককে মনে রাখতে হয় কোন index-এ কী। নাম দিয়ে খুলে ফেললে কোড নিজেই নিজের ব্যাখ্যা।

nested unpacking আর কয়েকটির swap

রেকর্ডের ভেতরে রেকর্ড থাকলে বাম দিকেও একই আকার মেনে বন্ধনী দিন — একে বলে nested unpacking: city, (lat, lon) = ("সিলেট", (24.89, 91.87)). লুপেও চলে: for i, (name, marks) in enumerate(results, start=1):.

swap শুধু দুটির মধ্যে নয়। a, b, c = b, c, a তিনটি মান এক ধাপ ঘুরিয়ে দেয়। কারণ Python আগে ডান দিকের পুরো tuple বানায় (পুরোনো মানগুলো দিয়ে), তারপর বাম দিকের নামগুলোতে একে একে বসায় — মাঝখানে কোনো মান হারিয়ে যায় না।

starred unpacking — “বাকি সব”

কতগুলো মান আসবে আগে জানা না থাকলে একটি নামের আগে * দিন — সেই নাম “বাকি সবগুলো” একটি list হিসেবে নেবে। একে বলে starred assignment বা extended unpacking, যা Python 3.0-তে এসেছে। ধাপে ধাপে দেখুন Python কীভাবে মান ভাগ করে:

1nums = [10, 20, 30, 40, 50]2first, *middle, last = nums3print(first, middle, last)4a, *b, c = [10]       # যদি এমন হতো?

দুটি প্রচলিত রূপ মনে রাখুন: head, *tail = items (প্রথমটি আর বাকিগুলো) আর *_, last = items (শুধু শেষটি দরকার, বাকি সব ফেলে দাও)। এবার এই পর্যন্ত যা শিখলেন, সব একসাথে চালিয়ে দেখুন:

students = [("রহিম", 12, 3.75), ("সুমি", 7, 3.90), ("করিম", 21, 3.75)]
for name, _, gpa in students:              # roll লাগবে না, তাই _
    print(name, gpa)

ranking = sorted((gpa, roll) for name, roll, gpa in students)
print(ranking)                              # tuple তুলনা: আগে gpa, সমান হলে roll

def price_range(prices):
    return min(prices), max(prices)         # একটি tuple ফেরত যায়

low, high = price_range([120, 95, 140, 88, 110])
print(f"সর্বনিম্ন {low}, সর্বোচ্চ {high} টাকা")

name, age, city = "Rahim,23,Dhaka".split(",")
print(name, int(age) + 1, city)

first, *middle, last = [10, 20, 30, 40, 50]
print(first, middle, last)
*_, newest = ["v1", "v2", "v3"]
print(newest, *middle, sep=" | ")

৭ · unpacking-এর ভুল — error বার্তা পড়তে শিখুন

unpacking-এর একটি কঠোর নিয়ম: (তারা না থাকলে) বাম দিকের নামের সংখ্যা আর ডান দিকের মানের সংখ্যা ঠিক সমান হতে হবে। না মিললে Python অনুমান করে না, সরাসরি ValueError দেয়। ধরুন একটি GPS যন্ত্র অক্ষাংশ-দ্রাঘিমাংশের সাথে উচ্চতাও পাঠাচ্ছে, অথচ কোড দুটি নামই আশা করে:

point = (23.81, 90.41, 8)
lat, lon = point

Traceback (most recent call last):
  File "gps.py", line 2, in <module>
    lat, lon = point
    ^^^^^^^^
ValueError: too many values to unpack (expected 2, got 3)

বার্তাটি পড়ুন: “unpack করার জন্য মান বেশি — ২টি আশা করেছিলাম, পেয়েছি ৩টি।” উল্টোটা হলে, যেমন a, b, c = [1, 2], বার্তা হয় not enough values to unpack (expected 3, got 2). বার্তার “got 3” অংশটি নতুন version-এ যোগ হয়েছে; পুরোনো Python-এ শুধু (expected 2) দেখতে পারেন, আর string-এর মতো কিছু iterable-এ এখনো শুধু expected অংশটিই আসে।

৮ · ফাংশন থেকে কয়েকটি মান, আর * দিয়ে ছড়িয়ে দেওয়া

পর্ব ১৩-এ দেখেছেন, return min(prices), max(prices) লিখলে ফাংশন “দুটি মান” ফেরত দেয়। এখন আপনি জানেন আসলে কী ঘটে: কমা একটি tuple বানায়, ফাংশন একটিই object — সেই tuple — ফেরত দেয়, আর ডাকার জায়গায় low, high = ... তাকে খুলে ফেলে। Python-এ “একাধিক return value” মানে আসলে packing আর unpacking-এর জুটি।

একটি খুব প্রচলিত নকশা হলো “ফল আর বার্তা” একসাথে ফেরত দেওয়া। ধরুন একটি bKash নম্বর যাচাই করবেন:

def check_mobile(number):
    if len(number) != 11 or not number.isdigit():
        return False, "নম্বর ১১ অঙ্কের হতে হবে"
    if not number.startswith("01"):
        return False, "নম্বর 01 দিয়ে শুরু হবে"
    return True, "ঠিক আছে"

ok, message = check_mobile("01712345678")
if not ok:
    print("ভুল:", message)

এই (ok, message) নকশা ছোট ফাংশনে চমৎকার। তবে দুটি সতর্কতা: তিন-চারটির বেশি মান ফেরত দিলে ডাকার জায়গায় ক্রম মনে রাখা কঠিন হয় — তখন নিচের namedtuple ভালো; আর সত্যিকারের ভুলের পরিস্থিতিতে Python-এ সাধারণত exception ছোড়াই প্রচলিত (পর্ব ২৪)।

ডাকার সময় * — একটি sequence-কে ছড়িয়ে দেওয়া

unpacking-এর একটি আত্মীয় হলো argument unpacking. ফাংশন ডাকার সময় একটি list বা tuple-এর আগে * দিলে তার প্রতিটি উপাদান আলাদা argument হয়ে যায়:

• items = ["চাল", "ডাল", "তেল"]; print(items) ছাপে ['চাল', 'ডাল', 'তেল'], কিন্তু print(*items) ছাপে চাল ডাল তেল — যেন আপনি print("চাল", "ডাল", "তেল") লিখেছেন।
• dhaka = (23.81, 90.41) থাকলে distance_from(*dhaka) মানে distance_from(23.81, 90.41).
• Python 3.5 থেকে list বা tuple বানানোর সময়ও ছড়ানো যায়: [*range(3), *"ab"] দেয় [0, 1, 2, 'a', 'b'], আর (*a, *b) দুটি tuple জোড়া লাগায়।

উল্টো দিকটি — ফাংশন নিজে যত খুশি argument গ্রহণ করবে (def total(*prices):) — পর্ব ২০-এ *args আর **kwargs-এ বিস্তারিত দেখবেন। মজার ব্যাপার, সেখানে বাড়তি argument-গুলো একটি tuple হিসেবেই আসে।

৯ · namedtuple — ঘরগুলোর নাম দেওয়া রেকর্ড

সাধারণ tuple-এর একটি দুর্বলতা আছে। কোডে student[2] দেখে কি বোঝা যায় এটি GPA? ছয় মাস পরে আপনি নিজেই ভুলে যাবেন। কেউ রেকর্ডে নতুন একটি ঘর (যেমন বয়স) মাঝখানে ঢোকালে সব [2] নিঃশব্দে ভুল জিনিস পড়বে। সমাধান: প্রতিটি ঘরের একটি নাম।

collections module-এর namedtuple একটি নতুন tuple-type বানিয়ে দেয়, যার ঘরগুলো নাম দিয়েও পড়া যায়। ধাপে ধাপে দেখুন নাম আর index কীভাবে একই ঘরে পৌঁছায়:

1City = namedtuple("City", ["name", "lat", "lon"])2ctg = City("চট্টগ্রাম", 22.36, 91.78)3ctg.lat4ctg[1]5ctg.lat = 0

Python 3.6 থেকে একই জিনিস আরও পড়তে সুবিধাজনক class-রূপে লেখা যায় typing.NamedTuple দিয়ে — প্রতিটি ঘরের type hint আর চাইলে default মানসহ। নিচের কোডে দুটি রূপ আর tuple-এর ভেতরে list-এর আচরণ একসাথে দেখুন:

from collections import namedtuple
from typing import NamedTuple

City = namedtuple("City", ["name", "lat", "lon"])
dhaka = City("ঢাকা", 23.81, 90.41)
print(dhaka.lat == dhaka[1], dhaka)

class Student(NamedTuple):
    name: str
    roll: int
    gpa: float = 0.0

s = Student("সুমি", 7)
print(s, s._replace(gpa=3.9).gpa)

team = ("বাংলাদেশ", ["তামিম", "মুশফিক"])
team[1].append("সাকিব")                   # ভেতরের list বদলায়
print(team)
try:
    hash(team)
except TypeError as err:
    print("TypeError:", err)

আরও নমনীয় রেকর্ড দরকার হলে — যেমন ঘরের মান বদলাতে চাইলে, বা method যোগ করতে চাইলে — Python 3.7 থেকে আছে dataclass. পর্ব ৩২-এ এটি দেখবেন। আপাতত সিদ্ধান্তের নিয়ম সহজ: ছোট, স্থির, tuple-এর মতো আচরণ চাইলে NamedTuple; বড়, বদলানো যায় এমন রেকর্ড চাইলে dataclass.

tuple বনাম list — এক নজরে

১০ · AI-এর যুগে — AI-এর লেখা রেকর্ড-কোড যাচাই

tuple-এর কোড AI সাধারণত ঠিকঠাকই লেখে, কিন্তু কয়েকটি ভুল বারবার ফিরে আসে। বেশিরভাগই “চলে, কিন্তু পড়তে কঠিন” বা “চলে, যতক্ষণ না ডেটা একটু বদলায়” ধরনের:

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

• স্থির রেকর্ড (স্থানাঙ্ক, RGB রং, শিক্ষার্থীর তথ্য) list-এ রাখা হয়েছে কি না দেখেছি
• এক উপাদানের প্রতিটি tuple-এ শেষের কমা আছে কি না খুঁজেছি
• t[2]-এর মতো সংখ্যার index-এর জায়গায় unpacking বা ঘরের নাম ব্যবহার করা যায় কি না ভেবেছি
• প্রতিটি unpacking-এ বাম আর ডান দিকের সংখ্যা মেলে কি না, আর ভুল ডেটায় কী হবে — নিজে চালিয়ে দেখেছি
• dict-এর চাবি বা set-এ রাখা tuple-এর ভেতরে কোনো list নেই — নিশ্চিত হয়েছি