Python syntax, data types, control flow — Hinglish notes

1.4.1 · AI-ML › Python & Scientific Computing

Why Python for AI/ML?

Python AI/ML mein teen wajahon se dominate karta hai:

Readable syntax → faster prototyping aur debugging
Rich ecosystem → NumPy, Pandas, Scikit-learn, PyTorch, TensorFlow
Dynamic typing → rapid experimentation (computational speed ki jagah development speed milti hai)

Dynamic typing ka matlab hai ki Python types ko runtime par check karta hai, compile-time par nahi. Yahi flexibility ki wajah se aap quickly ML hypotheses test kar sakte ho, lekin subtle bugs se bachne ke liye types ko deeply samajhna bhi zaroori hai.

Python Data Types: The Building Blocks

Why These Types Matter in ML

Integers aur Floats: Features, labels, hyperparameters represent karte hain. Float precision gradient descent mein numerical stability ko affect karti hai.

Lists vs Tuples: Lists mutable data ke liye (jaise predictions collect karna), tuples immutable configs ke liye (jaise input_shape=(28, 28, 1)).

Dictionaries: Model hyperparameters, config files, feature mappings store karte hain. Average lookup time O(1) hoti hai.

None: Imputation se pehle missing data represent karta hai, uninitialized model weights ke liye bhi.

Worked example Type Behavior in ML Context

# Integer division subtlety
epochs = 100
batch_size = 32
dataset_size = 1000
 
# WRONG: Python 3 division returns float
steps_per_epoch = dataset_size / batch_size  # 31.25 (float)
 
# CORRECT: Use floor division for discrete steps
steps_per_epoch = dataset_size // batch_size  # 31 (int)
# Why this step? ML training mein integer number of steps chahiye.
# Fractional steps meaningless hote hain—0.25 of a batch update nahi ho sakti.

Type Conversion aur Coercion

Python mein explicit type conversion hoti hai (operations mein numeric types ke beech automatic coercion nahi hoti jahan precision loss ho sake):

# Explicit conversions
x = int(3.7)      # 3 (truncates, rounds nahi karta)
y = float("2.5")  # 2.5
z = str(42)       # "42"
 
# Mixed arithmetic most general type par promote karta hai
result = 5 + 2.0  # 7.0 (int + float → float)

Explicit kyun? Silent precision loss bugs se bachata hai. ML mein accidentally float weights ko int mein convert karna model performance destroy kar deta.

Common mistake Common Type Confusion

Galat soch: "Python sab kuch auto-convert kar leta hai, mujhe types ki chinta nahi karni." Yeh sahi kyun lagta hai: Dynamic typing prototyping easy banata hai—variables koi bhi type hold kar sakte hain.

Fix yeh hai: Python mein strong typing hai (incompatible types ke beech implicit conversions nahi hoti). Aapko samajhna hi padega ki operations kaunse types expect karte hain.

# Yeh FAIL hoga—str aur int concatenate nahi ho sakte
message = "Epoch " + 5  # TypeError
# Correct: explicit conversion
message = "Epoch " + str(5)  # "Epoch 5"

Python Syntax: Indentation as Grammar

# Correct indentation
if accuracy > 0.95:
    print("Model converged")
    save_checkpoint()  # if-block ka part hai
print("Training complete")  # if-block ke bahar
 
# WRONG: Inconsistent indentation causes IndentationError
if accuracy > 0.95:
    print("Model converged")
      save_checkpoint()  # ERROR: unexpected indent

Yeh design kyun? Readable code force karta hai. Teams mein share hone wale ML research code mein, consistent structure cognitive load kam karta hai.

Variables and Assignment

Python reference semantics use karta hai:

# Assignment ek reference banata hai, copy nahi
weights_original = [0.5, 0.3, 0.8]
weights_backup = weights_original  # Dono SAME list ko point karte hain
 
weights_backup[0] = 0.9  # Original ko bhi modify kar deta hai!
print(weights_original)  # [0.9, 0.3, 0.8]
 
# Correct: explicit copy
import copy
weights_backup = copy.deepcopy(weights_original)

ML mein yeh kyun matter karta hai: Neural network layers aksar weight references share karti hain. Ek reference modify karne se sab affect hote hain jab tak explicitly copy na karo.

learning_rate = 0.01  # Global
 
def train_model():
    learning_rate = 0.001  # Local (global ko shadow karta hai)
    
    def update_weights():
        # Enclosing function ka learning_rate use karta hai (0.001)
        print(f"LR: {learning_rate}")
    
    update_weights()
 
train_model()  # Prints "LR: 0.001"

Control Flow: Directing Computation

Conditional Statements

Formula If-Elif-Else Logic

General form:

if condition1:
    block1
elif condition2:
    block2
else:
    block3

Evaluation order: Conditions sequentially check hoti hain. Pehli true condition apna block execute karti hai, phir poora statement exit ho jaata hai. Agar koi condition true nahi, to else block execute hota hai (agar present ho).

Yeh structure kyun? ML mein decision trees mirror karta hai—match milne tak sequential rule evaluation.

Worked example Adaptive Learning Rate

epoch = 50
initial_lr = 0.1
 
# Step decay schedule
if epoch < 30:
    lr = initial_lr  # 0.1
elif epoch < 60:
    lr = initial_lr * 0.1  # 0.01
elif epoch < 90:
    lr = initial_lr * 0.01  # 0.001
else:
    lr = initial_lr * 0.001  # 0.0001
# Why this step? Epoch 50 par, condition (epoch < 60) pehli true hai.
# lr 0.01 ban jaata hai. Baaki elif/else blocks skip ho jaate hain.
print(lr)  # 0.01

Python mein Truthiness: Objects ke inherent boolean values hote hain. Empty containers ([], {}, ""), 0, None falsy hain. Baaki sab truthy hain.

# Check karna ki list non-empty hai (Pythonic)
predictions = [0.9, 0.3, 0.7]
 
if predictions:  # Truthy kyunki list non-empty hai
    avg = sum(predictions) / len(predictions)

Loops: For aur While

Definition For Loop

Kisi bhi iterable (sequences, iterators, generators) par iterate karta hai:

for item in iterable:
    # item process karo

Hood ke neeche: iter(iterable) call karta hai iterator lene ke liye, phir StopIteration exception tak baar baar __next__() call karta hai.

Worked example Training Loop Structure

import numpy as np
 
# Training data (simplified)
X_train = np.random.rand(100, 10)  # 100 samples, 10 features
y_train = np.random.randint(0, 2, 100)  # Binary labels
 
epochs = 50
batch_size = 32
 
for epoch in range(epochs):
    # Why range()? 0, 1, .., 49 sequence generate karta hai
    # Har epoch mein data shuffle karo
    indices = np.random.permutation(len(X_train))
    for i in range(0, len(X_train), batch_size):
        # Why this step? range(0, 100, 32) deta hai [0, 32, 64, 96]
        # Batch start indices banata hai
        batch_indices = indices[i:i+batch_size]
        X_batch = X_train[batch_indices]
        y_batch = y_train[batch_indices]
        
        # Yahan: forward pass, loss compute, backprop, weights update
        # (syntax demonstration ke liye simplified)

List Comprehensions: Iterables se lists banane ka concise syntax.

# Standard loop
squared = []
for x in range(10):
    squared.append(x ** 2)
 
# List comprehension (Pythonic)
squared = [x ** 2 for x in range(10)]
 
# Condition ke saath (filter)
even_squared = [x ** 2 for x in range(10) if x % 2 == 0]
# [0, 4, 16, 36, 64]
 
# Yeh kyun use karein? Zyada readable, aksar faster (optimized C implementation).
# Data preprocessing mein common: [preprocess(x) for x in dataset]

Worked example Early Stopping Implementation

max_epochs = 1000
patience = 10
best_loss = float('inf')
epochs_without_improvement = 0
epoch = 0
 
while epoch < max_epochs and epochs_without_improvement < patience:
    # Why this condition? Max epochs pahunch jaaye YA patience khatam ho jaaye to stop karo.
    
    current_loss = train_one_epoch()  # Placeholder function
    
    if current_loss < best_loss:
        best_loss = current_loss
        epochs_without_improvement = 0
        save_model()  # Best model checkpoint karo
    else:
        epochs_without_improvement += 1
    
    epoch += 1
    
    # Why this step? Har iteration mein epoch aur patience counter increment karo.
    # Loop tab exit hota hai jab validation loss `patience` epochs tak plateau kare.
 
print(f"Stopped at epoch {epoch}")

Loop Control: Break aur Continue

break: Innermost loop se turant bahar nikal jao
continue: Loop body ka bacha hua hissa skip karo, next iteration par jao

# Corrupted data samples skip karo
for i, sample in enumerate(dataset):
    if is_corrupted(sample):
        print(f"Skipping sample {i}")
        continue  # Next iteration par jump karo
    if i >= max_samples:
        break  # Loop se poori tarah bahar nikal jao
    
    process(sample)

Common mistake Infinite Loop Pitfall

Galat soch: "While loops hamesha tab terminate hote hain jab condition false ho jaaye." Yeh sahi kyun lagta hai: Aapne ek condition set ki hai jo eventually false honi chahiye.

Fix yeh hai: Agar loop body condition mein variables ko modify nahi karti, to loop hamesha chalti rahegi.

# INFINITE LOOP—loss loop body mein update nahi hota
loss = 10.0
while loss > 0.01:
    print("Training...")  # Koi loss update nahi!
 
# Correct: termination ki taraf progress ensure karo
while loss > 0.01:
    loss = train_step()  # Loss update karta hai

Functions: Encapsulation aur Reusability

Definition Function Definition

def function_name(param1, param2, param3=default_value):
    """Docstring: purpose, parameters, return value describe karo."""
    # Function body
    return result

Parameters: Default values ho sakte hain (non-default params ke baad aane chahiye)
Return: Agar koi return nahi, to function None return karta hai
Docstring: Pehla string literal; help() aur documentation ke liye use hota hai

Worked example Model Evaluation Function

def compute_accuracy(y_true, y_pred, threshold=0.5):
    """
    Binary classification accuracy compute karo.
    
    Parameters:
    - y_true: Ground truth labels (0 ya 1)
    - y_pred: Predicted probabilities (0.0 se 1.0)
    - threshold: Decision boundary (default 0.5)
    Returns:
    - accuracy: Correct predictions ka fraction
    """
    # Why this step? Probabilities ko binary predictions mein convert karo
    y_pred_binary = (y_pred >= threshold).astype(int)
    
    # Why this step? True aur predicted labels ke beech matches count karo
    correct = (y_true == y_pred_binary).sum()
    # Why this step? Fraction pane ke liye total se divide karo
    accuracy = correct / len(y_true)
    return accuracy
# Usage
y_true = [0, 1, 0, 1]
y_pred = [0.2, 0.8, 0.6, 0.3, 0.9]
acc = compute_accuracy(y_true, y_pred)  # Default threshold=0.5 use karta hai

Argument Passing

Python pass-by-object-reference use karta hai:

Immutable objects (int, float, str, tuple): Pass-by-value jaisa behave karte hain (modify nahi ho sakte)
Mutable objects (list, dict, set): Function ke andar modifications original ko affect karti hain

def modify_list(lst):
    lst.append(4)  # Original list modify karta hai
 
def modify_int(x):
    x += 10  # Naya local int banata hai, original affect nahi hota
 
my_list = [1, 2, 3]
modify_list(my_list)
print(my_list)  # [1, 2, 3, 4]—modify ho gaya!
 
my_int = 5
modify_int(my_int)
print(my_int)  # 5—unchanged

ML mein yeh kyun matter karta hai: Functions ko large arrays/tensors pass karne se data copy nahi hoti (efficient hai), lekin unexpected modifications bugs create kar sakti hain.

*args aur **kwargs

def train_model(model, data, *args, **kwargs):
    """
    *args: Positional arguments as tuple
    **kwargs: Keyword arguments as dict
    """
    epochs = kwargs.get('epochs', 100)  # Default 100
    lr = kwargs.get('learning_rate', 0.01)
    
    print(f"Extra args: {args}")
    print(f"Extra kwargs: {kwargs}")
 
# Alag-alag arguments ke saath call karo
train_model(my_model, my_data, "extra", "values", 
            epochs=50, learning_rate=0.001, batch_size=32)
# args = ("extra", "values")
# kwargs = {'epochs': 50, 'learning_rate': 0.001, 'batch_size': 32}

Use case: Flexible APIs banana (jaise Keras ka model.fit() jo bahut saare optional hyperparameters accept karta hai).

Exception Handling

Definition Try-Except-Finally

try:
    # Code jo exception raise kar sakta hai
except ExceptionType1 as e:
    # Specific exception handle karo
except ExceptionType2:
    # Doosri exception handle karo
else:
    # Tab run hota hai jab koi exception raise na ho
finally:
    # Hamesha run hota hai (cleanup code)

Control flow: Python try block try karta hai. Agar exception aaye, except clauses se order mein match karta hai. Match mila to woh block execute hota hai. else sirf tab run hota hai jab koi exception na ho. finally hamesha run hota hai.

Worked example Robust Data Loading

def load_dataset(filepath):
    try:
        # Why this step? File open karne ki koshish
        with open(filepath, 'r') as f:
            data = f.read()
        # Why this step? Data parse karo (corrupted hone par fail ho sakta hai)
        parsed_data = parse_csv(data)
        
    except FileNotFoundError:
        # Why this handler? File exist nahi karti
        print(f"Error: {filepath} not found")
        return None
    
    except ValueError as e:
        # Why this handler? Parsing fail hui (malformed CSV)
        print(f"Error parsing data: {e}")
        return None
    
    else:
        # Why this block? Sirf tab run hota hai jab koi exception nahi (successful load)
        print(f"Loaded {len(parsed_data)} samples")
    finally:
        # Why this block? Cleanup hamesha hoti hai (jaise connections band karna)
        print("Load attempt completed")
    
    return parsed_data

EAFP vs LBYL: Python "Easier to Ask Forgiveness than Permission" (try-except) ko prefer karta hai "Look Before You Leap" (if checks) ke muqable mein. Python mein exceptions expensive nahi hote jab uncommon hon.

Comprehensions Beyond Lists

Dictionary Comprehension:

# Feature name se index mapping banao
feature_names = ['age', 'income', 'score']
feature_to_idx = {name: i for i, name in enumerate(feature_names)}
# {'age': 0, 'income': 1, 'score': 2}

Set Comprehension:

# Dataset mein unique labels
labels = [0, 1, 0, 2, 1, 2]
unique_labels = {label for label in labels}
# {0, 1, 2}

Generator Expression (memory-efficient, lazy evaluation):

# Bade dataset ko poora memory mein laade bina process karo
data_generator = (preprocess(x) for x in huge_dataset)
 
# Values iteration ke dauran on-demand compute hoti hain
for item in data_generator:
    train_on(item)

ML mein generators kyun? Jab dataset RAM mein fit nahi hota. TensorFlow ka tf.data aur PyTorch ka DataLoader yahi principle use karte hain.

Recall 12 saal ke bacche ko explain karo

Socho tum ek robot ko khana banana sikha rahe ho. Python instruction booklet ki language hai.

Data types ingredient categories jaisi hain: numbers (kitne ande), text (recipe ka naam), lists (shopping list jo change ho sakti hai), tuples (ingredient ratios jo kabhi nahi badalte).

Control flow recipe steps hain: "AGAR oven garam hai TO cake daal do, WARNA wait karo." Ya "HAR 12 cupcake ke liye, frosting lagao."

Functions sub-recipes hain: "mix flour, sugar, butter" baar baar likhne ki jagah ek "make_dough()" recipe banao jo reuse ho sake.

Indentation (lines se pehle wale spaces) dikhata hai ki kaunsi instructions saath hain—jaise recipe steps "Baking" ke neeche indent hoti hain us heading ke under.

ML mein, aap computers ko patterns seekhna sikha rahe ho. Python woh teaching instructions clearly dene ka tarika hai. Jaise recipes mein exact measurements chahiye, ML code mein exact data types chahiye. Jaise aap keh sakte ho "SMOOTH hone TAK mix karte raho," ML WHILE loops use karta hai tab TAK train karne ke liye jab TAK model kaafi achha na ho jaaye.

Connections NumPy arrays and vectorization - Python lists par built hai lekin numerical computation ke liye optimized

Pandas DataFrames - Python dicts ko internally use karta hai, ML-focused data manipulation add karta hai
Python functions and lambda - Function definition anonymous functions tak extend hoti hai
Object-oriented programming in Python - Classes function aur scope concepts par build hoti hain
TensorFlow and PyTorch basics - ML frameworks training loops ke liye Python control flow use karte hain
Exception handling in data pipelines - Robust ML systems ke liye try-except patterns
Python iterators and generators - Memory efficiency ke liye loop concepts extend karta hai

Practice Problems

Ek function likho jo model predictions ki list le aur accuracy, precision, aur recall return kare.
While loop se early stopping implement karo jo validation loss track kare.
Ek dict comprehension banao jo neural network mein layer names ko parameter counts se map kare.
Is code ko debug karo: Kyon function ke andar layer_config modify karne se original change ho jaata hai?

Figure — Python syntax, data types, control flow

#flashcards/ai-ml

Variable resolution ke liye Python ka LEGB rule kya hai? :: Local → Enclosing → Global → Built-in. Python variable names resolve karne ke liye in scopes mein is order mein search karta hai.

Python braces ki jagah code blocks ke liye indentation kyun use karta hai?

Readable code structure enforce karta hai. Cognitive load kam karta hai aur codebases mein consistent style ensure karta hai—collaborative ML research ke liye critical hai.

Python mein = aur == mein kya fark hai?

= assignment hai (variable reference banata/update karta hai). == comparison hai (equality test karta hai, boolean return karta hai).

Jab aap y = x karte ho aur x ek list hai, to kya hota hai?

y aur x dono SAME list object ko reference karte hain. y modify karne se x bhi modify hota hai. Independent copy ke liye copy.deepcopy() use karo.

ML mein while loop vs for loop kab use karein?

For loop: Known iterations ke liye (epochs, batches). While loop: Unknown iterations ke liye (convergence tak train karo, metrics par based early stopping).

range(0, 100, 32) kya produce karta hai? :: [0, 32, 64, 96]. 0 se start, 32 se step, 100 se pehle stop. Batch indices ke liye useful hai.

ML mein int vs float kyun important hai? :: Float precision gradient descent mein numerical stability affect karti hai. Discrete counts ke liye Integer (epochs, batch indices). Galat mixing se shape errors ya precision loss hoti hai.

break aur continue mein kya fark hai?

break poore loop se turant bahar nikal jaata hai. continue current iteration mein baaki statements skip karta hai aur next iteration par jump karta hai.

if predictions: kya check karta hai?

Kya predictions truthy hai. Empty list/dict/string, 0, None falsy hain. Non-empty containers aur non-zero numbers truthy hain.

For loops ke mukable list comprehensions kyun use karein?

Zyada concise, readable, aur aksar faster (optimized C implementation). Common pattern: [preprocess(x) for x in dataset].

[x**2 for x in range(5) if x % 2 == 0] ka output kya hai?

[0, 4, 16]. Sirf 0-4 mein se even numbers ke squares.

*args aur **kwargs mein kya fark hai?

*args positional arguments ko tuple mein capture karta hai. **kwargs keyword arguments ko dict mein capture karta hai. Flexible function APIs ke liye use hota hai.

Python mein if-checks ki jagah try-except kyun use karein?

EAFP principle: "Easier to Ask Forgiveness than Permission." Try-except idiomatic Python hai, exceptions rare hone par expensive nahi hota.

Exception handling mein finally kya karta hai?

Hamesha execute hota hai, chahe exception aaye ya try block mein return statement ho. Cleanup ke liye use hota hai (files band karna, resources release karna).

Generators memory-efficient kyun hote hain?

Lazy evaluation—values iteration ke dauran on-demand compute hoti hain, memory mein store nahi hoti. Tab critical jab dataset RAM mein fit nahi hota.

List aur tuple mein kya fark hai?

List mutable hai (elements modify ho sakte hain), tuple immutable hai (creation ke baad fixed). Jo config change nahi honi chahiye uske liye tuples use karo.

Python mein float 3.7 ko int mein kaise convert karo?

int(3.7) returns 3 (zero ki taraf truncate karta hai, round nahi karta). Rounding ke liye pehle round(3.7) phir int() use karo.

Python mein 5 + 2.0 ka result kya hai?

7.0 (float). Mixed arithmetic most general type par promote karta hai (int + float → float).

Python 3 mein dataset_size / batch_size float kyun return karta hai?

/ hamesha true division karta hai (float return karta hai). Discrete step counts ke liye // (floor division, int return karta hai) use karo.

Agar aap function ko pass ki gayi list modify karo to kya hota hai?

Modifications original list ko affect karti hain (mutable object, pass-by-reference). Immutable types (int, str) naye local objects banate hain.