Python আর ডেটার ইন্টারভিউ — NumPy, pandas আর live coding

import numpy as np
prices = np.array([120, 80, 450, 60, 300])   # বাজারঘরের ৫টি পণ্যের দাম (টাকা)
v = prices[1:4]          # basic slice → view
c = prices[[1, 2, 3]]    # fancy index → copy
m = prices[prices > 100] # boolean mask → copy
v[0] = 0; c[1] = 0; m[0] = 0
print("prices:", prices)
print("shares memory? view:", np.shares_memory(prices, v),
      "| fancy:", np.shares_memory(prices, c),
      "| mask:", np.shares_memory(prices, m))
print("default int dtype here:", prices.dtype)
paisa = np.full(100_000, 50_000)          # ১ লাখ অর্ডার, প্রতিটি ৫০০ টাকা = ৫০,০০০ পয়সা
print("sum, default dtype:", paisa.sum())
print("sum, int64        :", paisa.sum(dtype=np.int64))
print("0.1 + 0.2 == 0.3 ?", 0.1 + 0.2 == 0.3, "| isclose:", np.isclose(0.1 + 0.2, 0.3))

import pandas as pd
orders = pd.DataFrame({"order_id": [1, 2, 3, 4, 5, 6],
    "district": ["ঢাকা", "ঢাকা", "খুলনা", "খুলনা", "খুলনা", "রাজশাহী"],
    "taka": [500, 300, 200, 400, 600, 250]})
# Copy-on-Write: সাবসেট বদলালে মূল টেবিল বদলায় না
dhaka = orders[orders["district"] == "ঢাকা"]
dhaka.loc[:, "taka"] = 0
print("orders unchanged:", orders["taka"].tolist())
# agg → জেলাপ্রতি এক সারি; transform → প্রতিটি অর্ডারে এক মান
print(orders.groupby("district")["taka"].agg("sum"))
orders["share"] = orders["taka"] / orders.groupby("district")["taka"].transform("sum")
print(orders[["district", "taka", "share"]].round(2))
# merge-এ ডানের key দুবার থাকলে সারি বেড়ে যায়
zones = pd.DataFrame({"district": ["ঢাকা", "ঢাকা", "খুলনা", "রাজশাহী"],
                      "zone": ["মধ্য", "মধ্য-২", "দক্ষিণ", "উত্তর"]})
m = orders.merge(zones, on="district", how="left")
print("rows:", len(orders), "→", len(m), "| taka total:", orders["taka"].sum(), "→", m["taka"].sum())
try:
    orders.merge(zones, on="district", how="left", validate="many_to_one")
except pd.errors.MergeError as e:
    print("MergeError:", str(e).splitlines()[0])

import numpy as np
import pandas as pd
rng = np.random.default_rng(7)
orders = pd.DataFrame({
    "district": rng.choice(["ঢাকা", "চট্টগ্রাম", "খুলনা"], 60),
    "product": rng.choice(["চা", "মধু", "গামছা", "ইলিশ", "শাড়ি"], 60),
    "qty": rng.integers(1, 6, 60)})

def top_k(df, k=2):
    t = df.groupby(["district", "product"], as_index=False)["qty"].sum()
    t = t.sort_values(["district", "qty", "product"],
                      ascending=[True, False, True])   # সমান হলে নামের ক্রম
    return t.groupby("district").head(k).reset_index(drop=True)

res = top_k(orders)
print(res)

# test: ধীর কিন্তু নিশ্চিত পথে মিলিয়ে দেখা
for d, g in orders.groupby("district"):
    tot = {}
    for p, q in zip(g["product"], g["qty"]):
        tot[p] = tot.get(p, 0) + q
    best = sorted(tot.items(), key=lambda kv: (-kv[1], kv[0]))[:2]
    got = res[res["district"] == d][["product", "qty"]].values.tolist()
    assert got == [list(b) for b in best], d
assert top_k(orders.iloc[:0]).empty           # খালি ইনপুট
print("all tests passed")

import pandas as pd
sales = pd.DataFrame({
    "date": pd.to_datetime(["2026-04-01", "2026-04-02", "2026-04-02", "2026-04-04",
                            "2026-04-05", "2026-04-08", "2026-04-09"]),
    "taka": [1200, 500, 300, 1500, 700, 900, 1100]})

def rolling_7d(df):
    daily = df.groupby("date")["taka"].sum()          # একই দিনের অর্ডার যোগ
    days = pd.date_range(daily.index.min(), daily.index.max(), freq="D")
    daily = daily.reindex(days, fill_value=0)         # ফাঁকা দিন = ০ বিক্রি
    return pd.DataFrame({"taka": daily,
                         "roll7": daily.rolling(7, min_periods=7).sum()})

out = rolling_7d(sales)
print(out)

assert len(out) == 9                                   # ১ থেকে ৯ এপ্রিল, সব দিন
assert out.loc["2026-04-07", "roll7"] == 4200          # ১–৭ এপ্রিল
assert out.loc["2026-04-08", "roll7"] == 3900          # ২–৮ এপ্রিল
alt = sales.set_index("date")["taka"].rolling("7D").sum()
print("time-based window, last row:", alt.iloc[-1])
print("all tests passed")

import pandas as pd
events = pd.DataFrame({
    "order_id": [101, 102, 101, 103, 102, 101, 103],
    "status": ["placed", "placed", "paid", "placed", "cancelled", "delivered", "paid"],
    "updated_at": pd.to_datetime([
        "2026-04-01 10:00", "2026-04-01 10:05", "2026-04-01 12:00", "2026-04-02 09:00",
        "2026-04-01 11:00", "2026-04-03 16:30", "2026-04-02 09:00"]),
    "seq": [1, 2, 3, 4, 5, 6, 7]})        # সারি আসার ক্রম, সমান সময় ভাঙতে

def latest(df):
    return (df.sort_values(["order_id", "updated_at", "seq"])
              .drop_duplicates("order_id", keep="last")
              .reset_index(drop=True))

out = latest(events)
print(out)

assert out["order_id"].is_unique
assert dict(zip(out["order_id"], out["status"])) == {
    101: "delivered", 102: "cancelled", 103: "paid"}
# বিকল্প পথ: সময় ধরে সাজিয়ে প্রতিটি দলের শেষ সারি
alt = events.sort_values(["updated_at", "seq"]).groupby("order_id").tail(1)
assert set(zip(alt["order_id"], alt["status"])) == set(zip(out["order_id"], out["status"]))
assert latest(events.iloc[::-1]).equals(out)   # ইনপুটের ক্রমে ফল বদলায় না
print("all tests passed")

import unicodedata
import pandas as pd
bogura_1 = "বগু" + chr(0x09DC) + "া"               # ড় একটি অক্ষর
bogura_2 = "বগু" + chr(0x09A1) + chr(0x09BC) + "া"  # ড + নুক্তা, দেখতে একই
raw = pd.Series([" ঢাকা ", "Dhaka", "ঢাকা।", "dhaka city", "চট্রগ্রাম", "CTG",
                 bogura_1, bogura_2, None, "ঢাকা" + chr(0x200C), "কুমিল্লা"])
ZW = dict.fromkeys([0x200C, 0x200D])        # অদৃশ্য zero-width অক্ষর মুছতে

def norm(x):
    x = unicodedata.normalize("NFC", x).translate(ZW)
    return x.strip(" ।.,").casefold()

ALIASES = {norm(k): norm(v) for k, v in {
    "dhaka": "ঢাকা", "dhaka city": "ঢাকা", "ctg": "চট্টগ্রাম",
    "chattogram": "চট্টগ্রাম", "চট্রগ্রাম": "চট্টগ্রাম", "bogura": bogura_1}.items()}
KNOWN = {norm(k) for k in ["ঢাকা", "চট্টগ্রাম", "খুলনা", bogura_1]}

def clean_district(s):
    t = s.dropna().map(norm).replace(ALIASES)
    return t.where(t.isin(KNOWN)).reindex(s.index)   # অজানা → NaN

clean = clean_district(raw)
print(pd.DataFrame({"raw": raw, "clean": clean}))
assert bogura_1 != bogura_2 and clean[6] == clean[7]
assert set(clean.dropna()) <= KNOWN
print(clean.value_counts(dropna=False).to_dict())
print("needs review:", raw[clean.isna() & raw.notna()].tolist())

import numpy as np
rng = np.random.default_rng(42)
X = np.round(rng.random((4, 2)) * 10, 1)   # ৪টি গুদামের (x, y), কিলোমিটারে
print("X =\n", X)

def pairwise(X):
    diff = X[:, None, :] - X[None, :, :]     # (n,1,d) - (1,n,d) → (n,n,d)
    return np.sqrt((diff ** 2).sum(axis=-1)) # → (n,n)

def pairwise_gram(X):                        # কম memory: |a|² + |b|² − 2a·b
    sq = (X ** 2).sum(axis=1)
    d2 = sq[:, None] + sq[None, :] - 2 * X @ X.T
    return np.sqrt(np.maximum(d2, 0))        # ছোট ঋণাত্মক rounding কাটা

D = pairwise(X)
print("D =\n", D.round(2))
# test: সরল দুই-loop-এর সাথে মেলানো, আর distance-এর ধর্ম
n = len(X)
slow = np.array([[np.sqrt(((X[i] - X[j]) ** 2).sum()) for j in range(n)] for i in range(n)])
assert np.allclose(D, slow) and np.allclose(D, pairwise_gram(X))
assert np.allclose(D, D.T) and np.allclose(np.diag(D), 0)
print("nearest to warehouse 0:", np.argsort(D[0])[1])
print("all tests passed")

import numpy as np
import pandas as pd
from sklearn.model_selection import GroupShuffleSplit
rng = np.random.default_rng(42)
orders = pd.DataFrame({"customer": rng.integers(1, 21, 100),   # ২০ জন ক্রেতা, ১০০ অর্ডার
                       "taka": rng.integers(100, 2000, 100)})

def group_split(df, col, test_frac=0.2, seed=42):
    ids = np.sort(df[col].unique())
    r = np.random.default_rng(seed)
    test_ids = r.choice(ids, size=max(1, round(len(ids) * test_frac)), replace=False)
    is_test = df[col].isin(test_ids)
    return df[~is_test], df[is_test]

train, test = group_split(orders, "customer")
print("train rows:", len(train), "| test rows:", len(test))
print("test customers:", sorted(test["customer"].unique().tolist()))
assert set(train["customer"]).isdisjoint(test["customer"])     # কেউ দুই দিকে নেই
assert len(train) + len(test) == len(orders)
assert test["customer"].nunique() == 4
# লাইব্রেরির পথ: একই নিয়ম, ভিন্ন এলোমেলো বাছাই
gss = GroupShuffleSplit(n_splits=1, test_size=0.2, random_state=42)
tr_idx, te_idx = next(gss.split(orders, groups=orders["customer"]))
assert set(orders.iloc[tr_idx]["customer"]).isdisjoint(orders.iloc[te_idx]["customer"])
print("GroupShuffleSplit test customers:", sorted(orders.iloc[te_idx]["customer"].unique().tolist()))

import numpy as np
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler
rng = np.random.default_rng(42); n = 400
df = pd.DataFrame({"taka": rng.integers(200, 5000, n).astype(float),
                   "delivery_days": rng.integers(1, 8, n).astype(float),
                   "district": rng.choice(["ঢাকা", "খুলনা", "সিলেট"], n),
                   "payment": rng.choice(["cod", "bkash", "card"], n)})
df.loc[rng.random(n) < 0.1, "delivery_days"] = np.nan          # ১০% ফাঁকা
logit = 0.6 * (df["delivery_days"].fillna(4) - 4) + (df["payment"] == "cod") - 0.5
df["returned"] = (rng.random(n) < 1 / (1 + np.exp(-logit))).astype(int)

num, cat = ["taka", "delivery_days"], ["district", "payment"]
pre = ColumnTransformer([
    ("num", make_pipeline(SimpleImputer(strategy="median"), StandardScaler()), num),
    ("cat", make_pipeline(SimpleImputer(strategy="most_frequent"),
                          OneHotEncoder(handle_unknown="ignore")), cat)])
model = make_pipeline(pre, LogisticRegression(max_iter=1000))
X, y = df[num + cat], df["returned"]
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.25, random_state=42, stratify=y)
model.fit(Xtr, ytr)
print("test accuracy:", round(model.score(Xte, yte), 3), "| majority baseline:", round(max(yte.mean(), 1 - yte.mean()), 3))
new = pd.DataFrame([{"taka": 1200.0, "delivery_days": np.nan, "district": "বরিশাল", "payment": "cod"}])
print("new order, unseen district → P(return):", model.predict_proba(new)[0, 1].round(3))
print("features after transform:", model[0].get_feature_names_out().size)

import time
import numpy as np
import pandas as pd
rng = np.random.default_rng(42); n = 20_000
df = pd.DataFrame({"district": rng.choice(["ঢাকা", "চট্টগ্রাম", "খুলনা", "সিলেট"], n),
                   "weight_kg": rng.uniform(0.2, 8, n).round(1),
                   "taka": rng.integers(100, 6000, n)})

def fee_row(r):                                  # ধীর রূপ: প্রতি সারিতে Python
    base = 60 if r["district"] == "ঢাকা" else 120
    extra = 20 * max(0.0, np.ceil(r["weight_kg"] - 1))
    return 0 if r["taka"] >= 5000 else base + extra

def fee_vec(d):                                  # দ্রুত রূপ: পুরো কলাম একসাথে
    base = np.where(d["district"] == "ঢাকা", 60, 120)
    extra = 20 * np.ceil(d["weight_kg"] - 1).clip(lower=0)
    return pd.Series(np.where(d["taka"] >= 5000, 0, base + extra), index=d.index)

t0 = time.perf_counter(); slow = df.apply(fee_row, axis=1); t1 = time.perf_counter()
fast = fee_vec(df); t2 = time.perf_counter()
assert np.allclose(slow, fast)                   # আগে সঠিকতা, পরে গতি
edge = pd.DataFrame({"district": ["ঢাকা", "সিলেট"], "weight_kg": [1.0, 1.1], "taka": [5000, 4999]})
assert fee_vec(edge).tolist() == [0, 140]
print(f"apply: {1000 * (t1 - t0):.0f} ms | vectorised: {1000 * (t2 - t1):.1f} ms")
print("speed-up about", round((t1 - t0) / (t2 - t1)), "times")

import numpy as np
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline

rng = np.random.default_rng(0)
X = rng.normal(size=(200, 2000))     # ২০০ গ্রাহক, ২০০০টি একেবারে এলোমেলো feature
y = rng.integers(0, 2, 200)          # লক্ষ্যও এলোমেলো: আসল accuracy ~0.5

# বাগ: পুরো ডেটা দেখে feature বাছাই, তারপর ভাগ
X_sel = SelectKBest(f_classif, k=20).fit_transform(X, y)
Xtr, Xte, ytr, yte = train_test_split(X_sel, y, test_size=0.3, random_state=0)
bug = LogisticRegression(max_iter=1000).fit(Xtr, ytr).score(Xte, yte)

# ঠিক: আগে ভাগ, বাছাই pipeline-এর ভেতরে, শুধু train দেখে
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, random_state=0)
pipe = make_pipeline(SelectKBest(f_classif, k=20), LogisticRegression(max_iter=1000))
fixed = pipe.fit(Xtr, ytr).score(Xte, yte)
print(f"leaky test accuracy : {bug:.2f}")
print(f"honest test accuracy: {fixed:.2f}")
assert bug > 0.7 and abs(fixed - 0.5) < 0.15

import warnings
import pandas as pd
def make():
    return pd.DataFrame({"order_id": [1, 2, 3, 4],
                         "district": ["ঢাকা", "খুলনা", "ঢাকা", "সিলেট"],
                         "fee": [50, 80, 50, 80]})
# বাগওয়ালা রূপ: শিকলবাঁধা assignment
df = make()
with warnings.catch_warnings(record=True) as caught:
    warnings.simplefilter("always")
    df[df["district"] == "ঢাকা"]["fee"] = 60
print("bug  :", df["fee"].tolist(), "| warning:", type(caught[0].message).__name__)

# ঠিক রূপ ১: এক ধাপে loc[row_mask, column]
df = make()
df.loc[df["district"] == "ঢাকা", "fee"] = 60
print("fix 1:", df["fee"].tolist())

# ঠিক রূপ ২: নতুন টেবিল ফেরত, মূলটি অক্ষত
base = make()
new = base.assign(fee=base["fee"].mask(base["district"] == "ঢাকা", 60))
print("fix 2:", new["fee"].tolist(), "| base:", base["fee"].tolist())
assert df["fee"].tolist() == new["fee"].tolist() == [60, 80, 60, 80]

def add_to_cart(item, cart=[]):
    cart.append(item)
    return cart

rahim = add_to_cart("চা")
karim = add_to_cart("মধু")
print("rahim:", rahim)
print("karim:", karim)

import pandas as pd
orders = pd.DataFrame({"district": ["ঢাকা", "ঢাকা", "খুলনা"],
                       "product": ["চা", "মধু", "চা"],
                       "taka": [500, 300, 200]})
print(orders.groupby("district").mean())

import tzdata
import pandas as pd
orders = pd.DataFrame({"order_id": [1, 2, 3],
    "created_utc": pd.to_datetime(["2026-04-13 17:30", "2026-04-13 19:10",
                                   "2026-04-14 05:00"], utc=True),
    "taka": [900, 400, 700]})
bug = orders.groupby(orders["created_utc"].dt.date)["taka"].sum()
print(bug)
local = orders["created_utc"].dt.tz_convert("Asia/Dhaka")
fix = orders.groupby(local.dt.date)["taka"].sum()
print(fix)

import pandas as pd
qty = pd.Series(["2", "3", None, "5"])
print(qty.astype(float).astype(int))

import pandas as pd
packs = pd.DataFrame({"product": ["চা", "মসলা"], "kg_each": [0.1, 0.25], "n": [3, 2]})
packs["kg"] = packs["kg_each"] * packs["n"]
print(packs)
print(packs[packs["kg"] == 0.3])
print(repr(packs.loc[0, "kg"]))