Functions, classes, and modules — Hinglish notes

1.4.2 · AI-ML › Python & Scientific Computing

Intuition Code ko organize kyun karna chahiye?

Socho tum ek machine learning pipeline bana rahe ho. Organization ke bina, ek hi massive script hogi hazaron lines ki – debugging nightmare hogi, code reuse impossible, aur collaboration ek disaster. Functions, classes, aur modules Python mein code organization ki teen fundamental units hain, har ek ek specific problem solve karta hai:

Functions: Reusable logic ko package karta hai (jaise "compute accuracy")
Classes: Data + behavior ko bundle karta hai (jaise "NeuralNetwork ke layers hain + forward-propagate kar sakta hai")
Modules: Related functions/classes ko files mein organize karta hai (jaise "preprocessing.py")

Ise ek kitchen organize karne ki tarah socho: functions recipes hain, classes appliances hain (state aur controls ke saath), modules cabinets hain jo related items group karte hain.

Functions: Reusable Logic Blocks

Definition Function

Ek function code ka ek named block hai jo inputs (parameters) leta hai, operations perform karta hai, aur optionally output return karta hai. Yeh logic ko reuse aur clarity ke liye encapsulate karta hai.

Syntax:

def function_name(param1, param2, param3=default_value):
   """Docstring explaining what this does"""
   # function body
   return result

ML/AI Mein Functions Kyun Zaroori Hain

AI/ML workflows mein, tum baar baar yeh karte ho:

Data preprocess karna (normalize, tokenize, augment)
Metrics compute karna (accuracy, F1, loss)
Models ko different hyperparameters ke saath train karna

Functions ke bina: Code ko har jagah copy-paste karo, bugs multiply hoti hain, changes karne ke liye 50 jagah edit karna padta hai.

Functions ke saath: Ek baar likho, baar baar call karo, ek hi jagah bugs fix karo.

Formula Function Anatomy Derivation

Chaliye derive karte hain ki functions ko apne components kyun chahiye, first principles se:

Problem: Tumhe apne training loop mein mean squared error (MSE) multiple times compute karna hai.

Naive approach (koi function nahi):

mse_epoch1 = sum((y_true[i] - y_pred[i])**2 for i in range(len(y_true))) / len(y_true)
mse_epoch2 = sum((y_true[i] - y_pred[i])**2 for i in range(len(y_true))) / len(y_true)
# ... repeat100 times

Problems: Repetition, typo-prone, formula modify karna mushkil.

Step 1 - Named block mein extract karo:

def compute_mse():
   return sum((y_true[i] - y_pred[i])**2 for i in range(len(y_true))) / len(y_true)

Yeh step kyun? Logic ko ek naam do taaki tum use naam se call kar sako, baar baar repeat karne ki jagah.

Step 2 - Inputs ko parameterize karo:

def compute_mse(y_true, y_pred):
   return sum((y_true[i] - y_pred[i])**2 for i in range(len(y_true))) / len(y_true)

Yeh step kyun? Function ko different datasets par kaam karna hai, sirf global variables par nahi.

Step 3 - Documentation add karo:

def compute_mse(y_true, y_pred):
   """Calculate mean squared error between true and predicted values.
   
   Args:
       y_true: List/array of ground truth values
       y_pred: List/array of predicted values
   Returns:
       Float MSE value
   """
   return sum((y_true[i] - y_pred[i])**2 for i in range(len(y_true))) / len(y_true)

Yeh step kyun? Future mein tum (ya teammates) ko samajhna hoga ki kaunse inputs expected hain.

Step 4 - Default parameters add karo (optional):

def compute_mse(y_true, y_pred, squared=True):
   """MSE or RMSE based on squared parameter."""
   mse = sum((y_true[i] - y_pred[i])**2 for i in range(len(y_true))) / len(y_true)
   return mse if squared else mse ** 0.5

Yeh step kyun? Common variations (MSE vs RMSE) sensible defaults ke saath code share kar sakte hain.

Worked example Example 1: Data Preprocessing Function

Task: Neural network ke liye features ko [0, 1] range mein normalize karo.

def normalize_features(X, feature_min=None, feature_max=None):
   """Min-max normalize features to [0, 1].
   
   Args:
       X: 2D array (samples × features)
       feature_min: Optional precomputed minimums (for test set)
       feature_max: Optional precomputed maximums (for test set)
   Returns:
       Normalized array, feature_min, feature_max (to reuse for test)
   """
   if feature_min is None:
       feature_min = X.min(axis=0)  # Min per column
   if feature_max is None:
       feature_max = X.max(axis=0)
   
   # Avoid division by zero for constant features
   range_vals = feature_max - feature_min
   range_vals[range_vals == 0] = 1
   
   X_norm = (X - feature_min) / range_vals
   return X_norm, feature_min, feature_max
# Usage
X_train_norm, mins, maxs = normalize_features(X_train)
X_test_norm, _, _ = normalize_features(X_test, mins, maxs)  # Use train stats

Har step kyun?

Min/max per column kyun compute karo? Har feature ki alag scale hoti hai (age: 0-100, income: 0-1M).
Min/max return kyun karo? Test set ko training set ke statistics use karne chahiye data leakage avoid karne ke liye.
Zero range handle kyun karo? Constant features (sab same value) division by zero cause karengi.

Figure — Functions, classes, and modules

Classes: Data + Behavior Bundles

Definition Class

Ek class objects banane ka blueprint hai jo data (attributes) aur functions (methods) ko bundle karta hai jo us data par operate karte hain. Ek object (ya instance) class ka ek specific realization hai.

Syntax:

class ClassName:
   def __init__(self, param1, param2):  # Constructor
       self.attribute1 = param1         # Instance attributes
       self.attribute2 = param2
   
   def method_name(self):               # Instance method
       return self.attribute1 + self.attribute2

Classes ko First Principles Se Derive Karna

Formula Classes Kyun? State Management Se Derivation

Problem: Tum ek simple neural network layer bana rahe ho. Isko chahiye:

Data: weights $W$ , biases $b$ , input size, output size
Behavior: forward pass, backward pass, parameter updates

Attempt 1 - Multiple variables:

layer1_weights = initialize_weights(100, 50)
layer1_biases = initialize_biases(50)
layer1_inputsize = 100
layer1_output_size = 50
def layer1_forward(x):
   return x @ layer1_weights + layer1_biases

Problem: Multiple layers ke liye, tumhe layer1_, layer2_, ... variables har jagah chahiye honge. Functions mein pass karna ek mess ban jaata hai.

Attempt 2 - Dictionary:

layer1 = {
   'weights': initialize_weights(100, 50),
   'biases': initialize_biases(50),
   'input_size': 100,
   'output_size': 50
}
 
def forward(layer, x):
   return x @ layer['weights'] + layer['biases']

Problem: Koi guarantee nahi ki dictionaries mein sahi keys hain, koi bundled behavior nahi, typo-prone hai.

Solution - Class:

class DenseLayer:
   def __init__(self, input_size, output_size):
       self.input_size = input_size
       self.output_size = output_size
       self.weights = self._initialize_weights()
       self.biases = self._initialize_biases()
   
   def _initialize_weights(self):
       # Xavier initialization
       limit = (6 / (self.input_size + self.output_size)) ** 0.5
       return np.random.uniform(-limit, limit, 
                                 (self.input_size, self.output_size))
   def _initialize_biases(self):
       return np.zeros(self.output_size)
   
   def forward(self, x):
       """Forward pass: y = xW + b"""
       return x @ self.weights + self.biases
# Usage
layer1 = DenseLayer(100, 50)
layer2 = DenseLayer(50, 10)
 
output = layer1.forward(input_data)
final = layer2.forward(output)

Yeh kyun kaam karta hai:

Data encapsulation: Har layer instance apne weights/biases khud rakhta hai
Method binding: layer1.forward() automatically layer1 ke weights par operate karta hai
Type safety: DenseLayer objects guaranteed hain ki expected attributes honge
Initialization logic: __init__ proper setup ensure karta hai

Worked example Example 2: K-Nearest Neighbors Classifier Class

Task: KNN classifier scratch se banao.

import numpy as np
from collections import Counter
 
class KNNClassifier:
   """K-Nearest Neighbors classifier with Euclidean distance."""
   def __init__(self, k=3):
       """
       Args:
           k: Number of nearest neighbors to consider
       """
       self.k = k
       self.X_train = None
       self.y_train = None
   
   def fit(self, X, y):
       """Store training data (lazy learning).
       
       Args:
           X: Training features (n_samples, n_features)
           y: Training labels (n_samples,)
       """
       self.X_train = X
       self.y_train = y
       return self  # Enable method chaining
   
   def _euclidean_distance(self, x1, x2):
       """Compute Euclidean distance between two vectors."""
       return np.sqrt(np.sum((x1 - x2) ** 2))
   
   def _predict_single(self, x):
       """Predict label for a single sample.
       
       Why this is a separate method? Decompose predict() for clarity.
       """
       # Compute distances to all training samples
       distances = [self._euclidean_distance(x, x_train) 
                    for x_train in self.X_train]
       
       # Get indices of k nearest samples
       k_indices = np.argsort(distances)[:self.k]
       # Get labels of k nearest neighbors
       k_nearest_labels = [self.y_train[i] for i in k_indices]
       
       # Return most common label (majority vote)
       most_common = Counter(k_nearest_labels).most_common(1)
       return most_common[0][0]
   def predict(self, X):
       """Predict labels for multiple samples."""
       return np.array([self._predict_single(x) for x in X])
   def score(self, X, y):
       """Compute accuracy on test set."""
       predictions = self.predict(X)
       return np.mean(predictions == y)
# Usage
knn = KNNClassifier(k=5)
knn.fit(X_train, y_train)
predictions = knn.predict(X_test)
accuracy = knn.score(X_test, y_test)

Har design choice kyun?

Training data fit() mein kyun store karo? KNN lazy hai – koi training computation nahi, bas data memorize karo.
_predict_single() alag kyun? Multiple samples predict karo single prediction logic apply karke.
fit() mein return self kyun? Chaining enable karta hai: KNNClassifier(k=3).fit(X, y).predict(X_test).
Underscore prefix _euclidean_distance() kyun? "Private" helper methods ka convention (internal use ke liye).

Modules: Code ko Files Across Organize Karna

Definition Module

Ek module ek Python file hai jisme functions, classes, aur variables hote hain. Modules related code organize karte hain aur import statements ke zariye projects mein reuse enable karte hain.

Basic structure:

my_ml_project/
├── data_preprocessing.py    # Module for data ops
├── models.py                # Module for model classes
├── metrics.py               # Module for evaluation
└── main.py                  # Script using the modules

Modules Kyun? Scale Se Derivation

Formula Single File Se Module System Tak

Stage 1 - Small script (100 lines):

# train.py - Everything in one file
def load_data(): ...
def preprocess(): ...
class Model: ...
def train(): ...
# Run
train()

Prototypes ke liye theek hai.

Stage 2 - Growing project (1000 lines):

# train.py - Getting unwieldy
def load_csv(): ...
def load_json(): ...
def normalize(): ...
def tokenize(): ...
class LinearRegression: ...
class LogisticRegression: ...
class NeuralNet: ...
def mse(): ...
def accuracy(): ...
# ... 900 more lines

Problems: Navigate karna mushkil, load karna slow, organization unclear.

Stage 3 - Module organization:

# data_utils.py
def load_csv(): ...
def load_json(): ...
def normalize(): ...
# models.py
class LinearRegression: ...
class LogisticRegression: ...
# metrics.py
def mse(y_true, y_pred): ...
def accuracy(y_true, y_pred): ...
# train.py
from data_utils import load_csv, normalize
from models import LinearRegression
from metrics import mse
data = load_csv('train.csv')
data = normalize(data)
model = LinearRegression()

Yeh kyun kaam karta hai:

Separation of concerns: Har module ki ek single responsibility hai
Namespace management: models.LinearRegression vs sklearn.linear_model.LinearRegression
Selective imports: Sirf wahi load karo jo chahiye
Reusability: Doosre scripts data_utils import kar sakte hain bina model code ke

Worked example Example 3: Text Preprocessing ke Liye Module Banana

Task: NLP tasks ke liye ek reusable text preprocessing module banao.

File: text_preprocessing.py

"""
Text preprocessing utilities for NLP tasks.
 
This module provides functions for common text cleaning operations:
- Lowercasing, punctuation removal
- Tokenization
- Stopword removal
"""
 
import re
from collections import Counter
 
# Module-level constant
COMMON_STOPWORDS = {'the', 'a', 'an', 'in', 'on', 'at', 'to', 'for'}
 
def remove_punctuation(text):
   """Remove punctuation from text, keeping only letters, numbers, spaces."""
   return re.sub(r'[^a-zA-Z0-9\s]', '', text)
def tokenize(text):
   """Split text into lowercase tokens."""
   return text.lower().split()
def remove_stopwords(tokens, stopwords=None):
   """Remove stopwords from token list.
   
   Args:
       tokens: List of string tokens
       stopwords: Set of stopwords (uses module default if None)
   """
   if stopwords is None:
       stopwords = COMMON_STOPWORDS
   return [token for token in tokens if token not in stopwords]
def get_vocabulary(documents, min_count=2):
   """Build vocabulary from documents, filtering rare words.
   
   Args:
       documents: List of token lists
       min_count: Minimum frequency to include word
   Returns:
       Dictionary mapping word -> unique_id
   """
   # Count all tokens
   counter = Counter()
   for doc in documents:
       counter.update(doc)
   # Filter by min_count
   vocab = {word: idx for idx, (word, count) in enumerate(counter.items())
            if count >= min_count}
   return vocab
 
def preprocess_pipeline(text, remove_stops=True):
   """Full preprocessing pipeline for a single text.
   
   Why a pipeline function? Combine common operations.
   """
   text = remove_punctuation(text)
   tokens = tokenize(text)
   if remove_stops:
       tokens = remove_stopwords(tokens)
   return tokens
# Only execute if run directly (not imported)
if __name__ == '__main__':
   # Test code
   sample = "The quick brown fox jumps over the lazy dog!"
   print(preprocess_pipeline(sample))
   # Output: ['quick', 'brown', 'fox', 'jumps', 'over', 'lazy', 'dog']

File: main.py (module use karte hue)

from text_preprocessing import preprocess_pipeline, get_vocabulary
 
documents = [
   "Machine learning is fascinating",
   "Deep learning uses neural networks",
   "Machine learning transforms data"
]
 
# Preprocess each document
processed_docs = [preprocess_pipeline(doc) for doc in documents]
 
# Build vocabulary
vocab = get_vocabulary(processed_docs, min_count=1)
print(f"Vocabulary size: {len(vocab)}")

Har choice kyun?

Module docstring kyun? Purpose explain karta hai jab koi import text_preprocessing; help(text_preprocessing) kare.
COMMON_STOPWORDS module level par kyun? Shared constant, ek baar load hota hai jab module import hota hai.
if __name__ == '__main__': kyun? Test code tab run hota hai jab tum python text_preprocessing.py execute karo, lekin import karne par nahi.

Advanced Concepts: `*args`, `**kwargs`, Decorators

Variable-Length Arguments

Formula *args aur **kwargs Derive Karna

Problem: Tum ek create_model() function chahte ho jo different numbers of layer sizes accept kare.

Rigid approach:

def create_model(layer1, layer2, layer3):  # Only works for 3 layers
   ...

Solution - *args (positional arguments):

def create_model(*layer_sizes):
   """Create model with arbitrary number of layers.
   
   Args:
       *layer_sizes: Variable number of integers (layer sizes)
   """
   print(f"Creating model with layers: {layer_sizes}")
   # layer_sizes is a tuple: (100, 50, 10)
   layers = []
   for in range(len(layer_sizes) - 1):
       layers.append(DenseLayer(layer_sizes[i], layer_sizes[i+1]))
   return layers
 
# Usage
model1 = create_model(784, 128, 10)        # 2 layers
model2 = create_model(784, 256, 128, 10)   # 3 layers

Problem: Tum configuration options named arguments ke roop mein pass karna chahte ho.

Solution - **kwargs (keyword arguments):

def train_model(model, X, y, **training_config):
   """Train model with flexible configuration.
   
   Args:
       **training_config: Variable keyword args (epochs=10, lr=0.01, etc.)
   """
   # training_config is a dictionary
   epochs = training_config.get('epochs', 100)  # Default 100
   learning_rate = training_config.get('learning_rate', 0.01)
   batch_size = training_config.get('batch_size', 32)
   
   print(f"Training for {epochs} epochs, lr={learning_rate}")
   # ... training loop
# Usage
train_model(model, X_train, y_train, epochs=50, learning_rate=0.001)
train_model(model, X_train, y_train, epochs=10)  # Uses default lr

Dono ko combine karna:

def flexible_function(*args, **kwargs):
   print(f"Positional args: {args}")    # Tuple
   print(f"Keyword args: {kwargs}")      # Dictionary
flexible_function(1, 2, 3, name='test', value=42)
# Positional args: (1, 2, 3)
# Keyword args: {'name': 'test', 'value': 42}

Common mistake Common Mistake: Mutable Default Arguments

Galat:

def add_sample(sample, dataset=[]):  # BUG: Mutable default
   dataset.append(sample)
   return dataset
result1 = add_sample(1)  # [1]
result2 = add_sample(2)  # [1, 2] - KYUN?!

Kyun sahi lagta hai: "Default empty list toh logical hai."

Kyun galat hai: Default arguments function definition ke time par ek baar create hote hain, har call par nahi. Wahi list object calls ke across persist karta hai.

Fix:

def add_sample(sample, dataset=None):
   if dataset is None:
       dataset = []  # Har call par naya list banao
   dataset.append(sample)
   return dataset

Steel-man the mistake: Mutable defaults actually caching/memoization patterns ke liye intentional ho sakta hai, lekin beginners ke liye yeh almost kabhi nahi chahiye hota.

Common mistake Common Mistake: Class Methods Mein

self Bhool Jana Galat:

class Model:
   def __init__(self, weights):
       self.weights = weights
   def predict(x):  # BUG: Missing self
       return x @ self.weights  # NameError: self not defined

Kyun sahi lagta hai: "Yeh class ke andar hai, kya yeh automatically self.weights ke baare mein nahi jaanta?"

Kyun galat hai: Python mein kuch languages ki tarah implicit this nahi hota. Methods ko instance attributes access karne ke liye explicit self parameter chahiye.

Fix:

def predict(self, x):  # First parameter hamesha instance hota hai
   return x @ self.weights

Deeper pattern: Jab tum model.predict(x) call karte ho, Python internally Model.predict(model, x) karta hai – instance pehle argument ke roop mein pass hota hai.

Recall Ek 12-saal ke bachche ko explain karo

Socho tum apna school backpack organize kar rahe ho: Functions labeled pouches ki tarah hain. Tumhare paas ek "pencil pouch" (function) hai jo saari pencils rakhta hai. Pencils ko loose har jagah dump karne ki jagah, tum unhe pouch mein rakhte ho. Jab pencil chahiye, tum exactly jaante ho kahan dekhna hai. Agar tuti pencils replace karni hain, tum sirf pouch fix karte ho, poora backpack search nahi karte.

Classes tumhare calculator ki tarah hain. Yeh sirf buttons (functions) nahi hai – yeh numbers bhi yaad rakhta hai jo tumne type kiye (data/state). Ek "Calculator" class mein memory slots (attributes) aur buttons (methods) hote hain. Har student ka apna calculator hai apne stored numbers ke saath, lekin sabhi calculators same tarike se kaam karte hain.

Modules alag textbooks ki tarah hain. Tum apni saari books har jagah nahi le jaate – math class mein math textbook le jaate ho, science class mein science textbook. Har book (module) mein related cheezein hoti hain. Tumhara homework script in books se "import" karta hai: from math_textbook import quadratic_formula.

AI banate waqt, tumhare paas ek data_cleaning.py module (textbook) ho sakta hai jisme remove_duplicates() function (pouch) aur ek NeuralNetwork class (fancy calculator jo weights yaad rakhta hai aur predictions compute kar sakta hai) hogi.

Doosre Topics Se Connections

Python basics - syntax, data types, control flow - Functions internally control flow use karte hain
NumPy arrays and vectorization - Classes aksar NumPy arrays ko attributes ke roop mein wrap karti hain
ML mein Object-oriented programming - Inheritance, polymorphism ka deep dive ML examples ke saath
scikit-learn API patterns - sklearn ka fit/predict pattern class-based design hai
Neural networks scratch se banana - Layer abstractions ke liye classes zaroori hain
Data pipelines aur preprocessing - Modules pipeline stages organize karte hain
ML ke liye Software engineering - Modules ki testing, documentation, version control

#flashcards/ai-ml

Python mein teen fundamental code organization units kya hain? :: Functions (reusable logic), classes (data + behavior), aur modules (related code organize karne wali files).

Python class mein __init__ method ka purpose kya hai?

Constructor method jo object create karte waqt instance attributes initialize karta hai. Automatically call hota hai jab tum obj = ClassName(args) likhte ho.

Function definitions mein mutable default arguments kyun avoid karne chahiye? :: Mutable defaults (jaise [] ya {}) function definition ke time par ek baar create hote hain aur calls ke across persist karte hain, unexpected shared state cause karte hain. None use karo aur function ke andar naya object banao.

Function signature mein *args kya allow karta hai?

Variable number of positional arguments ko tuple ke roop mein accept karta hai. Flexible functions enable karta hai jaise create_model(100, 50, 10) kisi bhi number of layers ke saath.

from module import function aur import module mein kya difference hai?

Pehla specific names ko current namespace mein import karta hai (function()), doosra module ko itself import karta hai jisme prefix chahiye (module.function()). Pehla convenient hai, doosra name conflicts avoid karta hai.

Class methods ko self pehle parameter ke roop mein kyun chahiye?

self us instance ko refer karta hai jo method call kar raha hai. Jab tum obj.method(x) call karte ho, Python internally Class.method(obj, x) karta hai, instance explicitly pass karta hai.

Module mein if __name__ == '__main__': kya karta hai?

Andar ka code sirf tab run hota hai jab file directly execute ki jaaye (python module.py), import karne par nahi. Testing aur demos ke liye use hota hai imports affect kiye bina.

KNN classifier class mein fit() sirf data kyun store karta hai?

KNN ek lazy learner hai – koi training computation nahi hoti. Yeh training data memorize karta hai aur prediction ke time saara kaam karta hai (stored samples tak distances compute karke).

Classes jo Scikit-learn API pattern follow karta hai kya hai?

Estimators ke paas training ke liye fit(X, y) aur inference ke liye predict(X) hota hai. Yeh convention different models ke across consistent interface enable karta hai.

fit() method se self kyun return karo?

Method chaining enable karta hai jaise Model().fit(X, y).predict(X_test), sklearn API design ka ek convenient pattern hai.