Python syntax, data types, control flow

Why Python for AI/ML?

Python dominates AI/ML for three reasons:

1. Readable syntax → faster protyping and debugging
2. Rich ecosystem → NumPy, Pandas, Scikit-learn, PyTorch, TensorFlow
3. Dynamic typing → rapid experimentation (trade computational speed for development speed)

The dynamic typing means Python checks types at runtime, not compile-time. This flexibility is why you can quickly test ML hypotheses, but also why you need to understand types deeply to avoid subtle bugs.

Python Data Types: The Building Blocks

Why These Types Matter in ML

Integers and Floats: Represent features, labels, hyperparameters. Float precision affects numerical stability in gradient descent.

Lists vs Tuples: Lists for mutable data (e.g., collecting predictions), tuples for immutable configs (e.g., input_shape=(28, 28, 1)).

Dictionaries: Store model hyperparameters, config files, feature mappings. O(1) average lookup time.

None: Represent missing data before imputation, uninitialized model weights.

Type Conversion andercion

Python has explicit type conversion (no automatic coercion between numeric types in operations that could lose precision):

# Explicit conversions
x = int(3.7)      # 3 (truncates, doesn't round)
y = float("2.5")  # 2.5
z = str(42)       # "42"
 
# Mixed arithmetic promotes to most general type
result = 5 + 2.0  # 7.0 (int + float → float)

Why explicit? Prevents silent precision loss bugs. In ML, accidentally converting float weights to int would destroy model performance.

Python Syntax: Indentation as Grammar

# Correct indentation
if accuracy > 0.95:
    print("Model converged")
    save_checkpoint()  # Part of if-block
print("Training complete")  # Outside if-block
 
# WRONG: Inconsistent indentation causes IndentationError
if accuracy > 0.95:
    print("Model converged")
      save_checkpoint()  # ERROR: unexpected indent

Why this design? Forces readable code. In ML research code shared across teams, consistent structure reduces cognitive load.

Variables and Assignment

Python uses reference semantics:

# Assignment creates a reference, not a copy
weights_original = [0.5, 0.3, 0.8]
weights_backup = weights_original  # Both point to SAME list
 
weights_backup[0] = 0.9  # Modifies the original too!
print(weights_original)  # [0.9, 0.3, 0.8]
 
# Correct: explicit copy
import copy
weights_backup = copy.deepcopy(weights_original)

Why this matters in ML: Neural network layers often share weight references. Modifying one reference affects all unless you explicitly copy.

learning_rate = 0.01  # Global
 
def train_model():
    learning_rate = 0.001  # Local (shadows global)
    
    def update_weights():
        # Uses enclosing function's learning_rate (0.001)
        print(f"LR: {learning_rate}")
    
    update_weights()
 
train_model()  # Prints "LR: 0.001"

Control Flow: Directing Computation

Conditional Statements

Truthiness in Python: Objects have inherent boolean values. Empty containers ([], {}, "), 0, `None are falsy. All others are truthy.

# Checking if list is non-empty (Pythonic)
predictions = [0.9, 0.3, 0.7]
 
if predictions:  # Truthy because list is non-empty
    avg = sum(predictions) / len(predictions)

Loops: For and While

List Comprehensions: Concise syntax for creating lists from iterables.

# Standard loop
squared = []
for x in range(10):
    squared.append(x ** 2)
 
# List comprehension (Pythonic)
squared = [x ** 2 for x in range(10)]
 
# With condition (filter)
even_squared = [x ** 2 for x in range(10) if x % 2 == 0]
# [0, 4, 16, 36, 64]
 
# Why use this? More readable, often faster (optimized C implementation).
# Common in data preprocessing: [preprocess(x) for x in dataset]

Loop Control: Break and Continue

• break: Immediately exit innermost loop
• continue: Skip remaining loop body, proceed to next iteration

# Skip corrupted data samples
for i, sample in enumerate(dataset):
    if is_corrupted(sample):
        print(f"Skipping sample {i}")
        continue  # Skip to next iteration
    if i >= max_samples:
        break  # Exit loop entirely
    
    process(sample)

Functions: Encapsulation and Reusability

Argument Passing

Python uses pass-by-object-reference:

• Immutable objects (int, float, str, tuple): Behave like pass-by-value (can't modify)
• Mutable objects (list, dict, set): Modifications inside function affect original

def modify_list(lst):
    lst.append(4)  # Modifies original list
 
def modify_int(x):
    x += 10  # Creates new local int, doesn't affect original
 
my_list = [1, 2, 3]
modify_list(my_list)
print(my_list)  # [1, 2, 3, 4]—modified!
 
my_int = 5
modify_int(my_int)
print(my_int)  # 5—unchanged

Why this matters in ML: Passing large arrays/tensors to functions doesn't copy data (efficient), but unexpected modifications can cause bugs.

*args and **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}")
 
# Call with various arguments
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: Creating flexible APIs (like Keras model.fit() which accepts many optional hyperparameters).

Exception Handling

EAFP vs LBYL: Python favors "Easier to Ask Forgiveness than Permission" (try-except) over "Look Before You Leap" (if checks). Exceptions are not expensive in Python when uncomon.

Comprehensions Beyond Lists

Dictionary Comprehension:

# Create feature name to index mapping
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:

# Unique labels in dataset
labels = [0, 1, 0, 2, 1, 2]
unique_labels = {label for label in labels}
# {0, 1, 2}

Generator Expression (memory-efficient, lazy evaluation):

# Process large dataset without loading all into memory
data_generator = (preprocess(x) for x in huge_dataset)
 
# Values computed on-demand during iteration
for item in data_generator:
    train_on(item)

Why generators in ML? When dataset doesn't fit in RAM. TensorFlow's tf.data and PyTorch's DataLoader use this principle.

Connections NumPy arrays and vectorization - Built on Python lists but optimized for numerical computation

• Pandas DataFrames - Uses Python dicts internally, adds ML-focused data manipulation
• Python functions and lambda - Function definition extends to anonymous functions
• Object-oriented programming in Python - Classes build on function and scope concepts
• TensorFlow and PyTorch basics - ML frameworks use Python control flow for training loops
• Exception handling in data pipelines - Try-except patterns for robust ML systems
• Python iterators and generators - Extends loop concepts for memory efficiency

Practice Problems

1. Write a function that takes a list of model predictions and returns accuracy, precision, and recall.
2. Implement early stopping with a while loop that tracks validation loss.
3. Create a dict comprehension that maps layer names to parameter counts in a neural network.
4. Debug this code: Why does modifying layer_config inside a function change the original?

#flashcards/ai-ml

What is Python's LEGB rule for variable resolution? :: Local → Enclosing → Global → Built-in. Python searches these scopes in order to resolve variable names.

What does range(0, 100, 32) produce? :: [0, 32, 64, 96]. Start at 0, step by 32, stop before 100. Useful for batch indices.

Why is int vs float important in ML? :: Float precision affects numerical stability in gradient descent. Integer for discrete counts (epochs, batch indices). Mixing incorrectly causes shape errors or precision loss.

Concept Map

Hinglish (regional understanding)

Hinglish (regional understanding)