Merge, join আর reshape — pivot, melt আর stack

আগের পর্বগুলোতে একটি টেবিল নিয়ে কাজ করেছেন: পর্ব ২০-এ Series আর DataFrame, পর্ব ২২-এ সারি বাছাই, পর্ব ২৩-এ পরিষ্কার করা, আর পর্ব ২৪-এ groupby দিয়ে সারাংশ। কিন্তু বাস্তবের ডেটা প্রায় কখনো এক টেবিলে থাকে না। বাজারঘরের অর্ডারের টেবিলে শুধু পণ্যের কোড, নাম বা দাম নয়; গ্রাহকের কোড, তাঁর জেলা নয়। প্রশ্নের উত্তর পেতে (“কোন জেলায় কোন ধরনের পণ্য বেশি বিকোয়?”) টেবিলগুলো জোড়া লাগাতে হয়। আবার জোড়ার পর টেবিলের আকার বদলাতে হয়: রিপোর্টে মাস যায় কলামে, chart-এর জন্য মাস ফেরে সারিতে। এই পর্ব এই দুই কাজের: জোড়া আর আকার বদল (reshape). SQL-এর JOIN-এর পুরো তত্ত্ব আছে DBMS কোর্সের JOIN — INNER, LEFT, RIGHT আর FULL আর cross, semi আর anti join পর্বে; এখানে তার এক-দুই লাইনের ঝালাই আর pandas-এর দিকটি।

১ · কেন টেবিল জোড়া লাগে — বাজারঘরের তিন টেবিল আর key

মুদি দোকানের হিসাব খাতার কথা ভাবুন। দোকানি প্রতিটি বিক্রির পাশে ক্রেতার পুরো ঠিকানা লেখেন না, লেখেন শুধু “রহিম ভাই, খাতা নং ১২”। ঠিকানা আছে আলাদা একটি খাতায়, যেখানে প্রতিটি ক্রেতা একবারই লেখা। রহিম ভাই বাসা বদলালে এক জায়গায় কাটাকুটি করলেই চলে। কিন্তু মাসের শেষে “কোন মহল্লা থেকে কত বিক্রি” জানতে হলে দুটি খাতা পাশাপাশি খুলে প্রতিটি বিক্রির খাতা নম্বর মিলিয়ে মহল্লা খুঁজতে হয়। ডেটাবেসের ভাষায় তথ্য এভাবে ভাগ করে রাখাকে বলে normalization, আর মিলিয়ে আবার জোড়া লাগানোকে বলে join.

বাজারঘরের ডেটাও তিন টেবিলে ভাগ। orders-এ প্রতিটি অর্ডারের একটি সারি: order_id, customer_id, product_id আর পরিমাণ (qty). products-এ প্রতিটি পণ্যের একটি সারি: নাম আর দাম (পয়সায়)। customers-এ প্রতিটি গ্রাহকের একটি সারি: জেলা। যে কলামের মান মিলিয়ে সারি জোড়া হয়, তাকে বলে join key. Products আর customers হলো lookup table: প্রতিটি key-র জন্য সেখানে একটিই সারি থাকার কথা, আর orders সেখান থেকে তথ্য “খুঁজে আনে”। একটি পণ্যের অনেক অর্ডার হতে পারে, কিন্তু একটি অর্ডারের পণ্য একটিই। এই সম্পর্ককে বলে one-to-many (পণ্যের দিক থেকে দেখলে), বা many-to-one (অর্ডারের দিক থেকে)।

ছবির লাল দুটি ঘর এই পর্বের প্রথম শিক্ষা। অর্ডার ১০৬-এর পণ্য P5 ক্যাটালগে এখনো যোগ হয়নি (হয়তো নতুন পণ্য, কেউ products-এ তোলেননি)। অর্ডার ১০৫-এর গ্রাহক C9 customers-এ নেই (হয়তো অতিথি হিসেবে কেনা)। আবার C4-এর কোনো অর্ডার নেই। জোড়া লাগানোর সময় এই “মিল না পাওয়া” সারিগুলোর কী হবে, সেটিই join-এর ধরন ঠিক করে। আর এটি কোনো ব্যতিক্রম নয়: বাস্তবের প্রায় প্রতিটি ডেটাসেটে কিছু key মেলে না। প্রশ্ন শুধু, আপনি তা জানেন কি না।

২ · merge-এর মূল কথা — on, left_on/right_on আর how

pandas-এ জোড়ার মূল হাতিয়ার merge: left.merge(right, on="key", how="..."), বা একই কাজ pd.merge(left, right, ...). যে টেবিলে .merge ডাকছেন সেটি “বাঁ” (left), যেটি ভেতরে দিচ্ছেন সেটি “ডান” (right) টেবিল। তিনটি parameter সবচেয়ে জরুরি:

• on: দুই টেবিলে একই নামের key কলাম, যেমন on="product_id". একাধিক কলামে মেলাতে list দিন: on=["district", "month"]. কিছু না দিলে pandas দুই দিকের সব একই নামের কলামে মেলায়, যা প্রায়ই অনিচ্ছাকৃত; তাই সবসময় স্পষ্ট লিখুন।
• left_on / right_on: key-র নাম দুই দিকে আলাদা হলে, যেমন orders-এ customer_id কিন্তু customers-এ cust: left_on="customer_id", right_on="cust". ফলে দুটি কলামই থেকে যায়; দরকার না হলে পরে একটি বাদ দিন।
• how: মিল না পাওয়া সারির ভাগ্য। Default "inner".

Inner join মিল না পাওয়া সারি চুপচাপ ফেলে দেয়, আর default সেটিই। তাই অর্ডারে পণ্যের তথ্য জুড়তে বেশির ভাগ সময় দরকার left join: অর্ডার টেবিলের প্রতিটি সারি থাকবে, পণ্য না মিললে নাম আর দামের ঘর হবে missing, মানে NaN. Right join তার আয়না। Outer join দুই দিকের সব রাখে; দুটি তালিকা মেলাতে (গুদামের খাতা বনাম অনলাইনের খাতা) এটি কাজের। Cross join-এ key দেওয়া যায় না (দিলে MergeError), বাঁয়ের m আর ডানের n সারি থেকে হয় m × n সারি। pandas 3-এ এর সঙ্গে আছে "left_anti" আর "right_anti": শুধু সেই সারি, যার অন্যদিকে মিল নেই (SQL-এর anti join, DBMS কোর্সের advanced join পর্বে আছে)।

ফলের সারির ক্রমও নিয়ম মানে। pandas-এর নথি অনুযায়ী left আর inner বাঁ টেবিলের key-র ক্রম রাখে, right ডানের, আর outer key-গুলোকে বর্ণানুক্রমে সাজায়। এবার ধাপে ধাপে একটি left join দেখুন। ভেতরের আসল পদ্ধতি দ্রুততর (আরও গভীরে বাক্সে আছে), কিন্তু ফল ঠিক এই ছবির মতো।

শেষ ধাপের কথাটি একটি সূত্রে লেখা যায়। বাঁয়ের i-তম সারির key ডানে m_i বার থাকলে (m_i = 0 মানে মিল নেই):

inner-এর সারি = ∑ m_i   ·   left-এর সারি = ∑ max(1, m_i)

এখানে ∑ মানে বাঁয়ের সব সারির ওপর যোগ, আর max(1, m_i) মানে “মিল না থাকলেও একটি সারি থাকবে”। ওপরের উদাহরণে m = 1, 1, 0, 1: inner = ৩, left = ৪. সব m_i যদি ০ বা ১ হয়, left join-এর সারি ঠিক বাঁয়ের সমান। কোনো m_i ২ হলেই সারি বাড়ে; অংশ ৪ সেই বিপদের গল্প।

৩ · indicator=True — কোন সারি কোথা থেকে এল

বিয়ের দাওয়াতের তালিকা আর আসলে কারা এলেন, দুটি মেলানোর সময় তিন রকম মানুষ পাওয়া যায়: দাওয়াত পেয়ে এসেছেন, দাওয়াত পেয়েও আসেননি, আর দাওয়াত ছাড়াই এসেছেন। merge(..., indicator=True) ঠিক এই তিন ভাগ একটি নতুন কলামে লিখে দেয়। কলামের নাম _merge, মান both, left_only বা right_only, আর এর dtype category. নিচের কোডে বাজারঘরের তিন টেবিল (ছবির মতো, পুরো ৮টি অর্ডারসহ) জোড়া হচ্ছে। প্রথমবার চালালে pandas নামাতে কয়েক সেকেন্ড লাগতে পারে।

import pandas as pd
pd.set_option("display.width", 60)

products = pd.DataFrame({
    "product_id": ["P1", "P2", "P3", "P4"],
    "name": ["চাল", "তেল", "ডাল", "চা"],
    "price_paisa": [42000, 18500, 13000, 9000]})
customers = pd.DataFrame({
    "cust": ["C1", "C2", "C3", "C4"],
    "district": ["ঢাকা", "খুলনা", "সিলেট", "রাজশাহী"]})
orders = pd.DataFrame({
    "order_id": range(101, 109),
    "customer_id": ["C1", "C2", "C1", "C3", "C9", "C2", "C1", "C3"],
    "product_id": ["P1", "P2", "P3", "P2", "P1", "P5", "P4", "P2"],
    "qty": [1, 2, 3, 1, 2, 1, 4, 2]})

# ১) প্রতিটি অর্ডারের পাশে পণ্যের নাম আর দাম
op = orders.merge(products, on="product_id", how="left",
                  indicator=True)
print("সারি:", len(orders), "→", len(op))
print(op["_merge"].value_counts())
print(op.loc[op["_merge"] == "left_only",
             ["order_id", "product_id", "name"]])

# ২) দুই দিকের কলামের নাম আলাদা: left_on / right_on
full = orders.merge(customers, left_on="customer_id",
                    right_on="cust", how="outer", indicator=True)
print(full.loc[full["_merge"] != "both",
               ["order_id", "customer_id", "cust", "_merge"]])
print("order_id-এর dtype:", full["order_id"].dtype)

সারি: 8 → 8
_merge
both          7
left_only     1
right_only    0
Name: count, dtype: int64
   order_id product_id name
5       106         P5  NaN
   order_id customer_id cust      _merge
7       NaN         NaN   C4  right_only
8     105.0          C9  NaN   left_only
order_id-এর dtype: float64

৪ · Duplicate key আর সারি বিস্ফোরণ — validate দিয়ে ধরা

ধরুন তেলের দাম ১৮৫ থেকে ১৯৫ টাকা হলো। কেউ products টেবিলে P2-এর নতুন একটি সারি যোগ করলেন, কিন্তু পুরোনোটি মুছলেন না। এখন lookup-এ P2 দুবার। পরের দিন বিশ্লেষক যথারীতি orders.merge(products, on="product_id", how="left") চালালেন। কোনো error নেই, কোনো সতর্কবার্তা নেই। কিন্তু P2-এর প্রতিটি অর্ডার এখন দুবার আছে, একবার পুরোনো দামে, একবার নতুন দামে। এর নাম row explosion বা fan-out, আর SQL-এ একই বিপদ DBMS কোর্সের fan-out অংশে আছে। ধাপে ধাপে দেখুন সারি কীভাবে গুণ হয়।

validate নিজে কোনো জোড়া বদলায় না; এটি একটি দাবি (assertion), যে “এই দুই টেবিলের সম্পর্ক এমন হওয়ার কথা”। চারটি মান আছে: "one_to_one" (দুই দিকেই key অনন্য), "one_to_many" (শুধু বাঁ দিকে অনন্য), "many_to_one" (শুধু ডান দিকে অনন্য) আর "many_to_many" (কিছুই যাচাই করে না)। সংক্ষেপে "1:1", "1:m", "m:1", "m:m"-ও লেখা যায়। কোনটি দেবেন, তা নির্ভর করে কোন টেবিল বাঁয়ে: orders.merge(products)-এ products ডানে, তাই "many_to_one"; products.merge(orders)-এ products বাঁয়ে, তাই "one_to_many". নিচের কোডে দুটিই চালিয়ে দেখুন।

import pandas as pd

# দাম বদলের পর কেউ নতুন সারি যোগ করেছেন, পুরোনোটি মোছেননি
products = pd.DataFrame({
    "product_id": ["P1", "P2", "P2", "P3"],
    "price_paisa": [42000, 18500, 19500, 13000]})
orders = pd.DataFrame({
    "order_id": range(101, 107),
    "product_id": ["P1", "P2", "P3", "P2", "P2", "P1"],
    "qty": [1, 2, 3, 1, 2, 1]})

m = orders.merge(products, on="product_id", how="left")
print("সারি:", len(orders), "→", len(m))
print("P2-এর অর্ডার:", (orders["product_id"] == "P2").sum(),
      "→", (m["product_id"] == "P2").sum())
bill = (m["qty"] * m["price_paisa"]).sum()
print("মোট বিক্রি (টাকা):", bill / 100)

print("lookup-এ duplicate key:",
      products["product_id"].duplicated().sum())
try:
    orders.merge(products, on="product_id", validate="many_to_one")
except pd.errors.MergeError as e:
    print("MergeError:", e)
try:
    products.merge(orders, on="product_id", validate="one_to_many")
except pd.errors.MergeError as e:
    print("MergeError:", e)

latest = products.drop_duplicates("product_id", keep="last")
ok = orders.merge(latest, on="product_id", how="left",
                  validate="many_to_one")
assert len(ok) == len(orders)
print("ঠিক করার পর:", len(ok), "সারি, মোট",
      (ok["qty"] * ok["price_paisa"]).sum() / 100, "টাকা")

সারি: 6 → 9
P2-এর অর্ডার: 3 → 6
মোট বিক্রি (টাকা): 3130.0
lookup-এ duplicate key: 1
MergeError: Merge keys are not unique in right dataset; not a many-to-one merge

Duplicates in right:
 product_id
        P2 ...
MergeError: Merge keys are not unique in left dataset; not a one-to-many merge
Duplicates in left:
 product_id
        P2 ...
ঠিক করার পর: 6 সারি, মোট 2205.0 টাকা

৫ · নামের সংঘাত, index-এ join আর concat

Suffixes. দুই টেবিলে key ছাড়া একই নামের আরেকটি কলাম থাকলে (যেমন পুরোনো আর নতুন দামের তালিকা, দুটিতেই price), merge দুটিকেই রাখে আর নামের শেষে _x আর _y জুড়ে দেয়। কোনটি কোন টেবিলের, তা মনে রাখা কঠিন, তাই নিজের নাম দিন। লেখকের ল্যাপটপে একটি সত্যিকারের run (Python 3.14.4, pandas 3.1.1):

~/bazarghar-ai$ python concat_join.py      # (শেষ অংশ)
  product_id  price_x  price_y
0         P1    42000    43000
1         P2    18500    18500
  product_id  price_old  price_new
0         P1      42000      43000
1         P2      18500      18500

দ্বিতীয় টেবিলটি এসেছে a.merge(b, on="product_id", suffixes=("_old", "_new")) থেকে। এখন df["price_new"] - df["price_old"] লিখলে কোডটি নিজেই পড়া যায়।

Index ধরে join. DataFrame.join হলো merge-এর একটি সুবিধাজনক রূপ, যা ডান টেবিলের index ধরে মেলায়, আর তার default how="left" (merge-এর default inner, এই পার্থক্যটি মনে রাখার মতো)। পণ্যের কোড যখন index-এ বসানো (পর্ব ২০-এ set_index দেখেছেন), তখন এটি সবচেয়ে ছোট লেখা। দুই দিকে একই নামের কলাম থাকলে join ValueError দেয়, যতক্ষণ না lsuffix/rsuffix দেন। orders.join(products, on="product_id") লিখলে বাঁয়ের একটি কলাম ডানের index-এর সঙ্গে মেলে।

concat: মেলানো নয়, জুড়ে দেওয়া। জানুয়ারির অর্ডার এক ফাইলে, ফেব্রুয়ারির আরেকটিতে; কলাম একই। এদের নিচে নিচে জুড়তে concat: pd.concat([jan, feb]). এখানে কোনো key মেলানো হয় না। একই লেখকের run-এর প্রথম অংশ:

~/bazarghar-ai$ python concat_join.py      # (প্রথম অংশ)
pandas 3.1.1
   order_id  paisa
0       101  42000
1       102  37000
0       201  18500
1       202   9000
   order_id  paisa
0       101  42000
1       102  37000
2       201  18500
3       202   9000
       order_id  paisa
Jan 0       101  42000
    1       102  37000
Feb 0       201  18500
    1       202   9000
    stock  rating
P1     12     4.5
P2      0     NaN
P3      7     3.9

প্রথম টেবিলে index 0, 1, 0, 1: দুটি ফাইলের নিজস্ব index জুড়ে গেছে, তাই এখন df.loc[0] দুটি সারি দেয়, যা পরে অদ্ভুত bug আনে। ignore_index=True নতুন করে 0, 1, 2, 3 দেয় (দ্বিতীয় টেবিল)। keys=["Jan", "Feb"] দিলে কোন সারি কোন ফাইলের, তা একটি বাইরের index স্তরে লেখা থাকে (তৃতীয় টেবিল, যা একটি MultiIndex; অংশ ৭-এ আবার আসবে)। শেষ টেবিলটি pd.concat([stock, rating], axis=1): পাশাপাশি জোড়া, যেখানে pandas সারি মেলায় index-এর label দিয়ে, আর P2-এর রেটিং না থাকায় NaN. stock.join(rating) এখানে হুবহু একই টেবিল দেয়।

একটি পুরোনো অভ্যাস নিয়েও সতর্ক থাকুন: লুপের ভেতরে df = df.append(row). DataFrame.append pandas 2.0-তে সরানো হয়েছে; আর loop-এ বারবার concat করাও ধীর, কারণ প্রতিবার পুরো টেবিল নতুন করে কপি হয়। ঠিক পথ হলো টুকরোগুলো একটি list-এ জমিয়ে শেষে একবার pd.concat(list_of_frames, ignore_index=True).

৬ · Wide বনাম long — tidy data

ক্রিকেটের স্কোরকার্ড দুইভাবে লেখা যায়। একটিতে প্রতিটি ব্যাটারের একটি সারি, আর প্রতিটি ম্যাচের রান আলাদা কলামে: ম্যাচ ১, ম্যাচ ২, ম্যাচ ৩। চোখে পড়তে সুন্দর, তুলনা সহজ। অন্যটিতে প্রতিটি (ব্যাটার, ম্যাচ) জোড়ার একটি সারি, আর রান একটি কলামে। লম্বা, কিন্তু নতুন ম্যাচ এলে শুধু সারি বাড়ে, কলাম নয়। প্রথমটিকে বলে wide format, দ্বিতীয়টিকে long format. দুটিতে একই তথ্য; শুধু “ম্যাচ” কথাটি কোথায় লেখা, তা আলাদা: wide-এ কলামের নামে, long-এ একটি কলামের মানে।

Hadley Wickham ২০১৪ সালে Journal of Statistical Software-এ “Tidy Data” প্রবন্ধে এই পার্থক্যের একটি নাম আর নিয়ম দেন। তাঁর সংজ্ঞায় tidy data মানে: (১) প্রতিটি variable একটি কলাম, (২) প্রতিটি পর্যবেক্ষণ (observation) একটি সারি, (৩) প্রতিটি ধরনের পর্যবেক্ষণ একটি টেবিল। বাজারঘরের বিক্রিতে variable তিনটি: জেলা, মাস, বিক্রি। তাই tidy টেবিলের তিনটি কলাম, আর প্রতিটি (জেলা, মাস)-এর একটি সারি। “২০২৬-০১”, “২০২৬-০২” কলামের নামে থাকলে মাস নামের variable-টি লুকিয়ে আছে শিরোনামে; Wickham এটিকে অগোছালো ডেটার সবচেয়ে সাধারণ ধরন বলেছেন (“column headers are values, not variable names”). তিনি নিজেই প্রবন্ধে লিখেছেন, এই নিয়মগুলো Codd-এর relational database-এর normal form-এর খুব কাছের, শুধু পরিসংখ্যানবিদের ভাষায়।

Wide থেকে long-এ যাওয়ার pandas হাতিয়ার melt: wide.melt(id_vars="district", var_name="month", value_name="taka"). id_vars হলো যে কলামগুলো যেমন আছে থাকবে (পরিচয়ের কলাম); বাকি সব কলাম সারিতে নামবে। কলামের নাম যাবে var_name-এর কলামে, মান যাবে value_name-এর কলামে। ধাপে ধাপে দেখুন।

৭ · pivot, pivot_table আর melt — রিপোর্ট বানানো আর ফেরানো

pivot শুধু আকার বদলায়, কোনো হিসাব করে না। তাই প্রতিটি (index, column) জোড়া একবারের বেশি থাকলে সে জানে না কোন মান বসাবে, আর ValueError দেয়। আসল অর্ডারের টেবিলে একই জেলায় একই মাসে অনেক অর্ডার থাকে, তাই সেখানে দরকার pivot table: pivot_table প্রতিটি ঘরের সব মান একটি aggregation দিয়ে এক করে (পর্ব ২৪-এর groupby-র মতোই, শুধু ফল wide আকারে)। চারটি parameter বিশেষভাবে জরুরি:

• aggfunc: default হলো "mean", যোগফল নয়! বিক্রির রিপোর্টে প্রায় সবসময় aggfunc="sum" লিখতে হয়; গোনার জন্য "count" বা "size".
• fill_value: যে ঘরে কোনো সারিই নেই, সেখানে NaN-এর বদলে কী বসবে। বিক্রিতে ০ যুক্তিসংগত; গড় ডেলিভারি-সময়ে ০ বসালে মিথ্যা বলা হবে।
• margins=True: শেষে একটি মোট-সারি আর মোট-কলাম, যার নাম default-এ “All”; margins_name দিয়ে বদলানো যায়। মোটগুলো মূল ডেটা থেকে একই aggfunc দিয়ে হিসাব হয়।
• observed: category কলামে শুধু যে জোড়া ডেটায় আছে সেগুলো দেখাবে কি না; pandas 3-এ default True.

নিচের কোডে seeded NumPy দিয়ে বাজারঘরের ৪০টি অর্ডার বানানো হয়েছে, তারপর মার্চে সিলেটের অর্ডারগুলো বাদ (ধরুন সেই মাসে বন্যায় ডেলিভারি বন্ধ ছিল), যাতে একটি ঘর সত্যিই খালি থাকে।

import numpy as np
import pandas as pd
pd.set_option("display.width", 60)

rng = np.random.default_rng(42)
n = 40
sales = pd.DataFrame({
    "district": rng.choice(["ঢাকা", "চট্টগ্রাম", "খুলনা", "সিলেট"], n),
    "month": rng.choice(["2026-01", "2026-02", "2026-03"], n),
    "paisa": rng.integers(5_000, 200_000, n)})
# ধরুন মার্চে সিলেটে ডেলিভারি বন্ধ ছিল
sales = sales[~((sales["district"] == "সিলেট")
                & (sales["month"] == "2026-03"))]
print("লম্বা টেবিল:", sales.shape)

try:
    sales.pivot(index="district", columns="month", values="paisa")
except ValueError as e:
    print("pivot:", e)

wide = sales.pivot_table(index="district", columns="month",
                         values="paisa", aggfunc="sum",
                         fill_value=0, margins=True,
                         margins_name="মোট")
print(wide // 100)          # পয়সা থেকে টাকা

long = (wide.drop(index="মোট", columns="মোট")
            .reset_index()
            .melt(id_vars="district", var_name="month",
                  value_name="paisa"))
print(long.shape)
print(long.head(4))
print("মোট মিলল?", long["paisa"].sum() == sales["paisa"].sum())

লম্বা টেবিল: (35, 3)
pivot: Index contains duplicate entries, cannot reshape
month      2026-01  2026-02  2026-03    মোট
district
খুলনা         3498     4009     3868  11376
চট্টগ্রাম     1278     3627     2924   7829
ঢাকা          4836     4151     3220  12208
সিলেট         2676     3755        0   6432
মোট          12290    15544    10012  37848
(12, 3)
    district    month   paisa
0      খুলনা  2026-01  349893
1  চট্টগ্রাম  2026-01  127804
2       ঢাকা  2026-01  483687
3      সিলেট  2026-01  267678
মোট মিলল? True

stack আর unstack: MultiIndex দিয়ে একই কাজ। pandas-এ index-এর একাধিক স্তর থাকতে পারে, যাকে বলে MultiIndex; প্রতিটি সারির label তখন একটি tuple, যেমন খুলনা আর 2026-01-এর জোড়া। stack কলামের label-কে index-এর ভেতরের স্তরে নামায় (wide থেকে long), আর unstack index-এর একটি স্তরকে কলামে তোলে, ফলে long থেকে wide হয়। melt আর pivot কাজ করে সাধারণ কলাম নিয়ে, stack আর unstack কাজ করে index নিয়ে; groupby-র ফল যেহেতু প্রায়ই MultiIndex, সেখানে unstack খুব কাজের। লেখকের ল্যাপটপে সত্যিকারের run (pandas 3.1.1; জেলার নাম এখানে ইংরেজিতে):

~/bazarghar-ai$ python stack_demo.py
pandas 3.1.1
month     2026-01  2026-02
district
Khulna       3498     4009
Dhaka        4836     4151
district  month
Khulna    2026-01    3498
          2026-02    4009
Dhaka     2026-01    4836
          2026-02    4151
dtype: int64
2 ['district', 'month']
month     2026-01  2026-02
district
Khulna       3498     4009
Dhaka        4836     4151
district  Khulna  Dhaka
month
2026-01     3498   4836
2026-02     4009   4151

wide.stack() একটি Series দিয়েছে, যার index-এর দুটি স্তর: district আর month. s.unstack() default-এ সবচেয়ে ভেতরের স্তর (month) কলামে তোলে, তাই আগের টেবিল ফিরে এসেছে। s.unstack(level="district") উল্টো স্তর তুলেছে, ফলে টেবিলটি transpose হয়ে গেছে। একটি pandas 3-নির্দিষ্ট কথা: pandas 2.1-এ stack-এর একটি নতুন বাস্তবায়ন আসে (future_stack=True), যা pandas 3-এ default; এটি আর আগের মতো NaN-ওয়ালা সারি নিজে থেকে বাদ দেয় না, আর পুরোনো dropna parameter এর সঙ্গে চলে না। পুরোনো টিউটোরিয়ালের ফল তাই এক-দুই সারি আলাদা হতে পারে।

৮ · crosstab, আর কোন আকার কোন কাজে

“কোন জেলায় কোন পেমেন্ট পদ্ধতি কতবার?” এই প্রশ্নে কোনো সংখ্যার কলাম নেই, আছে দুটি শ্রেণিবাচক (categorical) কলাম। এর টেবিলকে পরিসংখ্যানে বলে contingency table, আর pandas-এ crosstab: pd.crosstab(df["district"], df["payment"]) প্রতিটি জোড়া কতবার এসেছে, তা গোনে। normalize গোনাকে অনুপাতে বদলায়: "index" দিলে প্রতিটি সারির যোগ ১ (জেলার ভেতরে কোন পদ্ধতির ভাগ কত), "columns" দিলে প্রতিটি কলামের যোগ ১, আর "all" বা True দিলে পুরো টেবিলের যোগ ১. নিচের ডেটা বানানো: আমরা নিজেরাই ধরে নিয়েছি ঢাকার বাইরে cash on delivery (COD) বেশি। এগুলো বাস্তব বাংলাদেশের কোনো পরিসংখ্যান নয়।

import numpy as np
import pandas as pd
pd.set_option("display.width", 60)

rng = np.random.default_rng(7)
n = 300
district = rng.choice(["ঢাকা", "চট্টগ্রাম", "খুলনা", "সিলেট"], n,
                      p=[0.4, 0.3, 0.15, 0.15])
probs = {"ঢাকা": [0.35, 0.40, 0.25], "চট্টগ্রাম": [0.50, 0.35, 0.15],
         "খুলনা": [0.60, 0.30, 0.10], "সিলেট": [0.55, 0.35, 0.10]}
pay = [rng.choice(["COD", "bKash", "card"], p=probs[d])
       for d in district]
orders = pd.DataFrame({"district": district, "payment": pay})

counts = pd.crosstab(orders["district"], orders["payment"],
                     margins=True, margins_name="মোট")
print(counts)

pct = pd.crosstab(orders["district"], orders["payment"],
                  normalize="index").mul(100).round(1)
print(pct)
print(pct.sum(axis=1).round(1).tolist())

# একই গোনা groupby দিয়ে: MultiIndex-এর Series, তারপর unstack
s = orders.groupby(["district", "payment"]).size()
print(s.head(3))
alt = s.unstack(fill_value=0)
print(alt.equals(counts.drop(index="মোট", columns="মোট")))

payment    COD  bKash  card  মোট
district
খুলনা       27     16     3   46
চট্টগ্রাম   36     42    11   89
ঢাকা        39     52    29  120
সিলেট       29     12     4   45
মোট        131    122    47  300
payment     COD  bKash  card
district
খুলনা      58.7   34.8   6.5
চট্টগ্রাম  40.4   47.2  12.4
ঢাকা       32.5   43.3  24.2
সিলেট      64.4   26.7   8.9
[100.0, 100.0, 100.0, 100.0]
district  payment
খুলনা     COD        27
          bKash      16
          card        3
dtype: int64
True

Long না wide — chart আর মডেলের চোখে

কোন আকার “ঠিক”, তার উত্তর নির্ভর করে পরের কাজের ওপর। Chart-এর জন্য সাধারণত long. seaborn-এর মতো library একটি tidy টেবিল চায়, যেখানে আপনি বলবেন x="month", y="taka", hue="district"; নতুন জেলা এলে কোড বদলায় না। কোন ধরনের chart কখন, তা আসবে পর্ব ২৯-এ। রিপোর্ট আর মানুষের চোখের জন্য wide: মাস কলামে, জেলা সারিতে, শেষে মোট। মডেলের জন্য সাধারণত wide, তবে একটি নির্দিষ্ট অর্থে: scikit-learn চায় একটি feature matrix, যেখানে প্রতিটি সারি একটি নমুনা (যেমন একজন গ্রাহক) আর প্রতিটি কলাম একটি feature. গ্রাহকের লম্বা অর্ডার-ইতিহাস থেকে “মাসওয়ারি খরচ” বা “পেমেন্ট পদ্ধতির ভাগ” কলাম বানানো ঠিক এই পর্বের pivot_table আর crosstab-এর কাজ; feature engineering-এর পুরো আলোচনা পর্ব ৬৩-এ।

আর মডেলের জন্য একটি জরুরি সতর্কতা: feature টেবিল বানাতে merge-এর সময় ভবিষ্যতের তথ্য যেন না ঢোকে। গ্রাহক পরের মাসে ফিরবেন কি না অনুমান করতে চাইলে, সেই মাসের অর্ডার থেকে বানানো কোনো কলাম জুড়ে দিলে মডেল পরীক্ষায় দারুণ দেখায়, বাস্তবে ব্যর্থ হয়। একে বলে data leakage, আর merge হলো এটি ঢোকার সবচেয়ে সাধারণ দরজাগুলোর একটি।

৯ · AI-এর যুগে — AI সহকারীর merge আর pivot যাচাই

“এই দুটি CSV জোড়া লাগিয়ে জেলাভিত্তিক রিপোর্ট বানাও” লিখলে AI সহকারী কয়েক সেকেন্ডে চলার মতো কোড দেবে। চলার মতো, কিন্তু ঠিক কি না, তা আলাদা প্রশ্ন; কারণ merge-এর ভুল প্রায় কখনো error দেয় না, শুধু সংখ্যা বদলে দেয়। এই বিষয়ে AI সহকারীরা প্রায়ই যা করে:

• how না লিখে default inner join ব্যবহার করে, ফলে মিল না পাওয়া অর্ডার নিঃশব্দে বাদ পড়ে; বা উল্টো, NaN দেখে fillna(0) বসিয়ে অমিলটি লুকিয়ে ফেলে।
• Lookup টেবিলের key অনন্য কি না দেখে না; validate বা সারি-গোনার কোনো যাচাই রাখে না, আর যোগফল ফুলে উঠলেও আত্মবিশ্বাসী সারাংশ লেখে।
• পুরোনো বা বানানো API লেখে: সরানো df.append, merge-এ না থাকা parameter, বা pandas 3-এ বদলানো stack(dropna=...).
• দুই টেবিল pd.concat(..., axis=1) দিয়ে “পাশাপাশি” বসায়, যা key নয়, index মেলায়; ক্রম আলাদা হলে ভুল গ্রাহকের পাশে ভুল অর্ডার।
• pivot_table-এ aggfunc না লিখে default mean নেয়, অথচ রিপোর্টের শিরোনাম লেখে “মোট বিক্রি”; আর margins-সহ টেবিল melt করে “All” নামে ভুয়া জেলা বানায়।

AI-এর merge আর reshape কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• প্রতিটি merge-এর আগে-পরে len() আর মূল সংখ্যার কলামের যোগফল নিজে মিলিয়েছি
• Lookup টেবিলে duplicated().sum() দেখেছি, আর merge-এ validate দিয়েছি
• indicator=True দিয়ে left_only/right_only গুনে কারণ খুঁজেছি; কোনো fillna অমিল লুকায়নি
• pivot_table-এর aggfunc প্রশ্নের সঙ্গে মেলে (যোগফল, গড় না গোনা), আর margins-এর সারি পরের ধাপের আগে বাদ দিয়েছি
• কয়েকটি সারি হাতে মিলিয়েছি: একটি অর্ডার ধরে কাঁচা টেবিল থেকে রিপোর্টের ঘর পর্যন্ত
• প্রতিটি অচেনা function আর parameter নিজের pandas version-এর অফিসিয়াল নথিতে মিলিয়েছি, আর ক্রেতার আসল ডেটা AI-তে পেস্ট করিনি