Python · NumPy · Pandas
Everything You Need for ML

# ─── The 5 core types you use in ML ───────────────────────
x = 42          # int   — index, count, label (0 or 1)
y = 3.14        # float — price, probability, weight
b = True         # bool  — is_fraud, has_feature (True=1, False=0)
s = "income"    # str   — column name, category label
n = None         # NoneType — missing value (like NaN before pandas)

# ─── Type checking and conversion ─────────────────────────
type(x)           # → <class 'int'>
isinstance(x, int)  # → True  (use this, not type() == int)

float("3.14")    # → 3.14  (string to float — common when reading CSVs)
int(3.9)         # → 3    (truncates, does NOT round)
str(42)          # → "42"
bool(0)          # → False  (0, 0.0, "", [], None are all False)

# ─── ML gotcha: int division vs float division ─────────────
7 / 2     # → 3.5   (true division, always float)
7 // 2    # → 3     (floor division, int result)
7 % 2     # → 1     (modulo — remainder)
2 ** 10   # → 1024  (power — used for learning rate schedules)

# ─── F-strings — use these everywhere ─────────────────────
acc = 0.9342
epochs = 10
print(f"Epoch {epochs}: accuracy = {acc:.2f}")
# → Epoch 10: accuracy = 0.93
print(f"Loss: {0.00234:.4e}")  # → Loss: 2.3400e-03

# ─── if / elif / else ─────────────────────────────────────
score = 0.87

if score >= 0.9:
    print("Excellent model!")
elif score >= 0.7:
    print("Good — consider tuning")
else:
    print("Needs work")

# ─── for loop — the workhorse ──────────────────────────────
losses = [0.9, 0.7, 0.5, 0.3, 0.15]

for i, loss in enumerate(losses):       # enumerate gives (index, value)
    print(f"Epoch {i+1}: loss={loss:.2f}")

# ─── range() — for training epochs ────────────────────────
for epoch in range(1, 101):    # 1 to 100 inclusive
    pass                         # pass = placeholder

# ─── while loop — for convergence checks ──────────────────
loss = 1.0
threshold = 0.01
steps = 0

while loss > threshold:
    loss *= 0.85   # simulate loss decreasing
    steps += 1
    if steps > 1000:
        print("Did not converge!")
        break        # break exits the loop
print(f"Converged in {steps} steps")

# ─── zip() — iterate two lists together ───────────────────
features = ["age", "income", "score"]
weights  = [0.3, 0.5, 0.2]

for feat, w in zip(features, weights):
    print(f"{feat}: weight = {w}")

# ─── Basic function ────────────────────────────────────────
def accuracy(y_true: list, y_pred: list) -> float:
    """Calculate classification accuracy.
    
    Args:
        y_true: actual labels
        y_pred: predicted labels
    Returns:
        accuracy score between 0 and 1
    """
    correct = sum(t == p for t, p in zip(y_true, y_pred))
    return correct / len(y_true)

# ─── Default arguments ─────────────────────────────────────
def normalize(x: float, method: str = "minmax", clip: bool = False) -> float:
    # Default args must come AFTER positional args
    pass

normalize(5.0)                     # uses defaults
normalize(5.0, method="zscore")   # keyword arg
normalize(5.0, "zscore", True)     # positional

# ─── *args and **kwargs ────────────────────────────────────
def log_metrics(*metrics, **extra_info):
    # *args: any number of positional args → tuple
    # **kwargs: any keyword args → dict
    for m in metrics:
        print(f"metric: {m}")
    for k, v in extra_info.items():
        print(f"{k} = {v}")

log_metrics(0.92, 0.87, epoch=10, lr=0.001)

# ─── Returning multiple values (returns a tuple) ───────────
def train_test_split_manual(data, ratio=0.8):
    split = int(len(data) * ratio)
    return data[:split], data[split:]  # returns tuple

train, test = train_test_split_manual([1,2,3,4,5])
# train=[1,2,3,4]  test=[5]

# ─── LIST — ordered, mutable, allows duplicates ────────────
features = ["age", "income", "score", "age"]
features.append("city")       # add to end
features.remove("score")     # remove first occurrence
features.sort()              # sort in place
features[0]                  # → "age"  (first item)
features[-1]                 # → last item
features[1:3]               # → ["income", "score"] (slicing)
len(features)                # → count

# ─── DICT — key-value pairs, unordered, fast lookup ────────
hyperparams = {
    "lr": 0.001,
    "epochs": 100,
    "batch_size": 32,
    "optimizer": "adam"
}
hyperparams["lr"]           # → 0.001
hyperparams.get("dropout", 0.5)  # → 0.5 (default if missing)
"epochs" in hyperparams     # → True (key lookup)
hyperparams.keys()           # → dict_keys(["lr", "epochs"...])
hyperparams.values()         # → dict_values([0.001, 100...])
hyperparams.items()          # → for k,v in ...  ← use this!

# ─── TUPLE — immutable, used for shapes and coordinates ────
shape = (64, 3, 224, 224)   # batch, channels, H, W (image tensor shape)
batch_size, channels, h, w = shape  # unpacking

# ─── SET — unique items, fast membership check ─────────────
seen_labels = {"cat", "dog", "bird"}
"cat" in seen_labels         # → True  (O(1) vs O(n) for list)
seen_labels.add("fish")     # add element
set(features)               # remove duplicates from list

# ─── The pattern ALL sklearn models follow ─────────────────
class MinMaxScaler:
    """Scales features to [0, 1] range."""
    
    def __init__(self, feature_range=(0, 1)):
        self.feature_range = feature_range
        self.min_ = None     # underscore = "set by fit()"
        self.max_ = None
    
    def fit(self, X):
        """Learn min and max from training data."""
        self.min_ = min(X)
        self.max_ = max(X)
        return self           # return self enables chaining
    
    def transform(self, X):
        """Apply learned scaling to new data."""
        if self.min_ is None:
            raise RuntimeError("Call fit() before transform()")
        return [(x - self.min_) / (self.max_ - self.min_) for x in X]
    
    def fit_transform(self, X):
        return self.fit(X).transform(X)   # method chaining!
    
    def __repr__(self):
        return f"MinMaxScaler(feature_range={self.feature_range})"

# ─── Inheritance ───────────────────────────────────────────
class ClippingScaler(MinMaxScaler):  # inherits from MinMaxScaler
    def transform(self, X):            # override parent method
        scaled = super().transform(X)  # call parent's transform
        return [max(0, min(1, v)) for v in scaled]  # then clip

scaler = MinMaxScaler()
scaler.fit_transform([10, 20, 30, 40])  # → [0.0, 0.33, 0.67, 1.0]

# ─── List comprehension — the most used Python pattern ─────
squares = [x**2 for x in range(10)]
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# With filter condition:
pos_features = [x for x in values if x > 0]

# Transform and filter at once:
clean = [float(x) for x in raw_data if x is not None]

# ─── Dict comprehension ────────────────────────────────────
feature_names = ["age", "income", "score"]
feature_index = {name: i for i, name in enumerate(feature_names)}
# → {"age": 0, "income": 1, "score": 2}

# Invert a dictionary:
index_feature = {v: k for k, v in feature_index.items()}

# ─── Lambda — anonymous one-liner function ─────────────────
square = lambda x: x**2
square(5)    # → 25

# Most common use: as key= argument for sorting
models = [("RF", 0.92), ("SVM", 0.87), ("LR", 0.81)]
sorted(models, key=lambda x: x[1], reverse=True)
# → [("RF", 0.92), ("SVM", 0.87), ("LR", 0.81)]

# ─── map() and filter() ────────────────────────────────────
doubled = list(map(lambda x: x*2, [1,2,3]))   # [2, 4, 6]
positive = list(filter(lambda x: x>0, [-1,2,-3,4]))  # [2, 4]

# ─── any() and all() — used in validation ──────────────────
any([False, True, False])  # → True (at least one True)
all([True, True, True])   # → True (all True)
any(x > 0.9 for x in scores)  # any score above 0.9?

import numpy as np   # always aliased as np

# ─── Creating arrays ──────────────────────────────────────
a = np.array([1, 2, 3, 4, 5])           # from Python list
b = np.zeros((5, 3))                   # 5×3 zeros
c = np.ones((3, 3))                    # 3×3 ones
I = np.eye(4)                          # 4×4 identity matrix
r = np.random.randn(100, 10)          # 100 samples, 10 features (Gaussian)
u = np.random.uniform(0, 1, (50, 5))  # uniform random, 50×5
s = np.linspace(0, 1, 100)            # 100 evenly spaced from 0 to 1

# ─── Shape, dtype, size ───────────────────────────────────
X = np.random.randn(1000, 20)  # 1000 samples, 20 features
X.shape   # → (1000, 20)
X.ndim    # → 2
X.dtype   # → float64
X.size    # → 20000 (total elements)

# ─── VECTORIZED operations — FAST ──────────────────────────
X + 10         # add 10 to every element
X * 2          # multiply every element by 2
X ** 2         # square every element
np.exp(X)      # e^x for every element (sigmoid needs this!)
np.log(X)      # natural log (cross-entropy loss needs this!)
np.sqrt(X)     # square root
np.abs(X)      # absolute value (MAE loss!)

# ─── Aggregate operations ─────────────────────────────────
X.sum()              # total sum
X.sum(axis=0)        # sum each column (feature means)
X.sum(axis=1)        # sum each row (sample totals)
X.mean(), X.std()   # global mean and std
X.max(axis=0)        # max per feature
X.argmax()           # index of maximum (predicted class!)

# ─── dtype conversion ─────────────────────────────────────
X.astype(np.float32)  # float32 uses half the memory of float64
X.astype(int)        # convert to integer

import numpy as np

X = np.random.randn(100, 5)   # 100 samples, 5 features

# ─── Basic indexing ────────────────────────────────────────
X[0]            # first row (sample 0)
X[0, 2]         # row 0, column 2
X[-1]           # last row
X[5:10]         # rows 5-9
X[:, 0]         # entire first column (feature 0)
X[:, :3]        # first 3 features only
X[10:20, 1:4]   # rows 10-19, columns 1-3

# ─── Boolean indexing — most important for filtering ───────
X[X > 0]                   # all positive values (flattens!)
mask = X[:, 0] > 0         # mask: True/False for each sample
X[mask]                    # samples where feature 0 is positive
X[X[:, 0] > 0]             # one-liner version

# ─── Fancy indexing — select specific rows ─────────────────
indices = np.array([0, 5, 10, 50])
X[indices]   # select exactly those rows

# ─── Reshaping — critical for deep learning ────────────────
flat = X.reshape(-1)              # flatten to 1D (500,)
col = X.reshape(-1, 1)           # column vector (500, 1)
img = np.zeros((28*28,)).reshape(1, 28, 28)  # MNIST pixel → image
X_T = X.T                          # transpose

# ─── BROADCASTING — the magic ─────────────────────────────
mean = X.mean(axis=0)   # shape (5,) — per-feature mean
std  = X.std(axis=0)    # shape (5,)
X_norm = (X - mean) / std  # (100,5)-(5,) → broadcast! StandardScaler in one line

# Broadcasting rules:
# 1. Align shapes from the RIGHT
# 2. Dimensions of size 1 stretch to match
# (100,5) - (5,)  →  (100,5) - (1,5)  →  (100,5) ✓

# ─── np.where — vectorized if/else ─────────────────────────
labels = np.where(X[:, 0] > 0, 1, 0)  # 1 if positive else 0

import numpy as np

# ─── Matrix multiplication — the core of forward pass ──────
X = np.random.randn(64, 20)   # batch of 64, 20 features
W = np.random.randn(20, 10)   # weight matrix
b = np.zeros(10)               # bias vector

Z = X @ W + b                   # → shape (64, 10) — one linear layer!
# Same as: Z = np.dot(X, W) + b

# ─── Dot product — similarity between vectors ──────────────
a = np.array([1, 2, 3])
b_v = np.array([4, 5, 6])
np.dot(a, b_v)     # → 32   (1*4 + 2*5 + 3*6)

# Cosine similarity (used in RAG you already built!):
cos_sim = np.dot(a, b_v) / (np.linalg.norm(a) * np.linalg.norm(b_v))

# ─── Essential linalg ─────────────────────────────────────
np.linalg.norm(a)          # Euclidean norm (length of vector)
np.linalg.det(W[:10,:10]) # determinant
np.linalg.inv(W[:10,:10]) # matrix inverse (OLS formula needs this)
vals, vecs = np.linalg.eig(np.cov(X.T))  # eigenvalues/vectors → PCA!
U, S, Vt = np.linalg.svd(X, full_matrices=False)  # SVD → dimensionality reduction

# ─── Statistics ────────────────────────────────────────────
np.mean(X, axis=0)    # per-feature mean
np.std(X, axis=0)     # per-feature std
np.median(X, axis=0) # per-feature median (robust to outliers)
np.percentile(X, [25, 75], axis=0)  # Q1 and Q3 for IQR
np.corrcoef(X.T)       # correlation matrix (feature correlations)
np.cov(X.T)            # covariance matrix (input to PCA)

# ─── Random with seed — reproducibility ────────────────────
np.random.seed(42)                    # old way
rng = np.random.default_rng(42)     # modern way
rng.integers(0, 100, size=10)       # random ints
rng.shuffle(X)                        # shuffle rows in-place

import pandas as pd    # always aliased as pd
import numpy as np

# ─── Series — 1D labeled array ─────────────────────────────
ages = pd.Series([25, 30, 35, 28], index=["Alice", "Bob", "Charlie", "Diana"])
ages["Bob"]      # → 30  (label-based)
ages[1]          # → 30  (position-based)
ages > 27        # → boolean Series (True/False)
ages.mean()      # → 29.5

# ─── DataFrame — the main tool ─────────────────────────────
df = pd.DataFrame({
    "age":    [25, 30, 35, 28, 45],
    "income": [50000, 75000, 90000, 62000, 120000],
    "label":  [0, 1, 1, 0, 1]
})

# ─── First things you do with ANY new dataset ──────────────
df.shape           # → (5, 3) — rows, columns
df.head(5)         # first 5 rows
df.tail(3)         # last 3 rows
df.info()          # column types + null counts ← RUN THIS FIRST
df.describe()      # count, mean, std, min, quartiles, max
df.dtypes          # data type of each column
df.isnull().sum()  # missing values per column ← ALWAYS CHECK
df.columns         # column names

# ─── Column access ─────────────────────────────────────────
df["age"]             # → Series (single column)
df[["age", "income"]] # → DataFrame (multiple columns)
df.age                 # dot notation (only if no spaces in name)

# ─── .loc vs .iloc — IMPORTANT distinction ─────────────────
df.loc[0]               # row by INDEX LABEL
df.iloc[0]              # row by POSITION  ← usually want this
df.loc[0:2, "age"]       # rows 0-2 (inclusive!), column "age"
df.iloc[0:2, 0]          # rows 0-1 (exclusive), column 0

# ─── Load CSV — your most used line ────────────────────────
df = pd.read_csv("data.csv")
df = pd.read_csv("data.csv", sep=";", encoding="utf-8", low_memory=False)

# ─── Boolean filtering ─────────────────────────────────────
young = df[df["age"] < 30]
high_income = df[df["income"] > 80000]
fraud = df[(df["label"] == 1) & (df["income"] < 40000)]  # & not 'and'
either = df[(df["age"] > 50) | (df["label"] == 1)]       # | not 'or'

# .query() method — sometimes cleaner
df.query("age < 30 and income > 50000")
df.query("label in [0, 1] and age > @threshold")  # @ for variables

# .isin() — filter by list of values
df[df["city"].isin(["Mumbai", "Delhi", "Bangalore"])]

# ─── Sorting ───────────────────────────────────────────────
df.sort_values("income", ascending=False)           # by income desc
df.sort_values(["label", "income"], ascending=[True, False])

# ─── GroupBy — the most important Pandas operation ─────────
# Mean income per label (class 0 vs class 1)
df.groupby("label")["income"].mean()

# Multiple aggregations at once
df.groupby("label").agg({
    "income": ["mean", "std", "count"],
    "age":    ["mean", "min", "max"]
})

# Count per category
df["label"].value_counts()           # class distribution
df["city"].value_counts(normalize=True)  # as percentages

# GroupBy + transform — add group mean as new column
df["mean_income_by_label"] = df.groupby("label")["income"].transform("mean")

# ─── Missing values ────────────────────────────────────────
df.isnull().sum()             # null count per column
df.isnull().mean() * 100     # % missing per column

df.dropna()                   # drop ALL rows with any null
df.dropna(subset=["income"])  # drop only if income is null
df.dropna(thresh=3)           # keep rows with ≥3 non-null values

df["income"].fillna(df["income"].median())        # fill with median
df["city"].fillna("Unknown")                        # fill categorical
df.fillna(method="ffill")                           # forward fill (time series)

# ─── Duplicates ────────────────────────────────────────────
df.duplicated().sum()             # how many duplicate rows?
df.drop_duplicates(inplace=True)  # remove them

# ─── Type conversion ───────────────────────────────────────
df["age"] = df["age"].astype(int)
df["date"] = pd.to_datetime(df["date"])           # parse dates
df["income"] = pd.to_numeric(df["income"], errors="coerce")  # "coerce" → NaN on error

# ─── String cleaning ───────────────────────────────────────
df["name"].str.lower()                  # lowercase
df["name"].str.strip()                  # remove whitespace
df["name"].str.replace(",", "")          # remove commas
df["city"].str.contains("Mumbai")       # boolean mask
df["email"].str.extract(r"(\w+)@")      # regex extract

# ─── Merging (like SQL JOINs) ──────────────────────────────
result = pd.merge(df1, df2, on="user_id", how="left")
# how: "inner"(both), "left"(all left), "right", "outer"(all)

# Concatenate DataFrames
combined = pd.concat([df_train, df_val], ignore_index=True)   # rows
wide = pd.concat([df1, df2], axis=1)                          # columns

# ─── apply() — apply any function to rows/columns ──────────
df["income_log"] = df["income"].apply(np.log1p)  # log transform
df["age_bucket"] = df["age"].apply(lambda x: "young" if x < 30 else "senior")

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split

# ═══ STEP 1: Load and initial inspection ══════════════════
df = pd.read_csv("data.csv")
print(f"Shape: {df.shape}")
print(df.info())            # types + null counts
print(df.describe())        # stats
print(df.isnull().sum())   # missing per column

# ═══ STEP 2: Separate target and features ════════════════
X = df.drop("label", axis=1)   # features DataFrame
y = df["label"]               # target Series
print(f"Class distribution:\n{y.value_counts()}")

# ═══ STEP 3: Identify column types ═══════════════════════
numeric_cols = X.select_dtypes(include=[np.number]).columns.tolist()
cat_cols = X.select_dtypes(include=["object", "category"]).columns.tolist()
print(f"Numeric: {numeric_cols}")
print(f"Categorical: {cat_cols}")

# ═══ STEP 4: Check for problems ══════════════════════════
for col in numeric_cols:
    skewness = X[col].skew()
    if abs(skewness) > 1.0:
        print(f"{col}: skewness={skewness:.2f} → consider log transform")

# Correlation with target
correlations = df[numeric_cols + ["label"]].corr()["label"].abs().sort_values(ascending=False)
print("Feature-target correlations:")
print(correlations)

# ═══ STEP 5: Feature engineering ════════════════════════
X["income_log"] = np.log1p(X["income"])        # log transform skewed
X["income_per_age"] = X["income"] / X["age"]  # interaction feature

# ═══ STEP 6: Split (BEFORE any scaling!) ════════════════
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y   # stratify for imbalanced!
)
print(f"Train: {X_train.shape}, Test: {X_test.shape}")

# ═══ STEP 7: Now feed into sklearn Pipeline (from ML guide)
# The preprocessor fits on X_train only — no leakage!