Batch 02: Python

You understood history in Batch 01. Now you write code. From your very first print("Hello World") to building a text classifier with AI — this is where the real journey begins.

Where Batch 02 Fits

You completed Batch 01 — the history and foundations. Now Python gives you the hands on the keyboard. Every batch builds directly on the last.

From Hello World to AI Engineer

Each chapter is a complete skill level-up. By the end of Chapter 7, you will have built a working AI script and know how PyTorch uses the same Python patterns you learned in Chapter 5.

First Contact with Python

No experience needed. This chapter takes you from "I've never written code" to understanding how Python reads and runs your programs. We cover setup, variables, text, numbers, and getting Python to talk back to you. Every concept is animated and connected to your Batch 01 knowledge — binary, memory, and how computers work.

Why learn Python and not Java, C++, or JavaScript? We answer this with data: 70% of ML engineers use Python, every major AI framework (PyTorch, TensorFlow, LangChain) is Python-first. We also see Python in action — a 5-line script that scrapes data, a 10-line neural network, a 3-line web server. The motivation is set.

Step-by-step setup for Windows, macOS, and Linux. Install Python 3.12, VS Code, and the Python extension. Learn the terminal basics you need. Write and run your first Python file. We also explain what actually happens when you press Run — the interpreter reads your text, converts to bytecode, and executes it. Full animation of Python's execution model.

Variables are labels for memory locations — exactly what Batch 01 taught us about RAM. We cover Python's core types: str, int, float, bool, and None. We show how Python dynamically assigns types (no need to declare), what type() does, and how to check types. Then we animate what actually happens in RAM when you create a variable — the connection to binary representation.

String creation, f-strings (the modern way), string methods (upper, lower, strip, split, replace, find), slicing with indices, and multiline strings. We animate how strings are stored as arrays of characters — each character is a number (ASCII/UTF-8 from Batch 01). By the end, students can manipulate any text — which matters because LLMs run on text.

Integer vs float, arithmetic operators (+, -, *, /, //, %, **), operator precedence, math module, scientific notation (1e-3), and augmented assignment (+=, *=). We show real AI formulas — loss calculation, gradient descent step, softmax normalization — written in pure Python arithmetic. Math stops being abstract when it's running AI.

int(), float(), str(), list(), bool() conversions. input() for user interaction. Implicit vs explicit conversion. Why type errors happen and how to fix them. Then we cover why type conversion matters in AI: converting image pixels from uint8 to float32, converting string labels to integer class IDs, converting tensors to numpy arrays — these are real ML pipeline operations.

Control Flow — Making Decisions

Remember George Boole from Batch 01? He gave us TRUE and FALSE in 1847. Python's control flow IS Boolean algebra — if/else uses the exact same AND/OR/NOT logic. This chapter shows how a program chooses paths, repeats actions, and stops when needed. It's how all algorithms — including AI training loops — are structured.

True/False, comparison operators (==, !=, < , >, < =, >=), logical operators (and, or, not), identity operators (is, is not), membership (in, not in), and operator chaining. We animate how Python evaluates boolean expressions — exactly what logic gates do in hardware. The historical thread from Boole → Shannon → Python is made explicit here.

Conditional statements from simple if to nested if-elif-else chains. Indentation as structure (Python's unique design). Ternary expressions (x if condition else y). Match statements (Python 3.10+). We build a complete AI model evaluation script that checks accuracy, loss, and overfitting — using only what's covered in this episode.

for loops with range(), iterating over lists/strings/dicts, enumerate() for index+value, zip() for parallel iteration, nested loops, and loop variables. We animate the epoch/batch training loop structure — the exact nested for loop pattern inside every deep learning training script — using the syntax from this episode.

while loop syntax, loop conditions, infinite loops and how to avoid them, do-while pattern, while/else. We build an early-stopping simulation — train while loss is above threshold, stop when converged — exactly what early stopping in ML does. Animates how gradient descent "runs until convergence" as a while loop.

break (exit loop), continue (skip iteration), pass (do nothing placeholder), for/else and while/else patterns. We build a data cleaning loop that skips None values, continues past corrupted rows, and breaks when hitting a sentinel. Exactly the kind of preprocessing loops used in real datasets before training.

Functions — Reusable Code Blocks

Functions are how you stop repeating yourself and start building systems. From simple def to *args, **kwargs, lambda, and higher-order functions — this chapter gives you the tools that professional Python engineers use every day. And we connect them to neural network layers — which are literally just functions composed together.

def keyword, function naming conventions, docstrings, type hints, calling functions, return values vs print(). We animate function execution as a "black box" — input goes in, output comes out — which is exactly how neural network layers work. We implement actual activation functions (ReLU, sigmoid) as plain Python functions.

Positional args, keyword args, default values, multiple return values (tuples), named return with dictionary. We build a complete training_step() function with parameters matching real PyTorch patterns — model, optimizer, criterion, device — using only Python built-ins. Bridges function basics to real ML code structure.

Local vs global scope, the LEGB rule (Local → Enclosing → Global → Built-in), global and nonlocal keywords, closures, and why scope prevents bugs. We animate scope as nested boxes — each function has its own memory space. Then we show how PyTorch uses closure scope for gradient computation.

*args (any number of positional arguments as tuple), **kwargs (any number of keyword arguments as dict), combining both, unpacking with * and **, and practical patterns. We build a model configuration function matching the actual PyTorch nn.Sequential() signature — which uses *args to accept any number of layers.

Lambda expressions, map(), filter(), sorted() with key, functools.reduce(). We build a complete data preprocessing pipeline using only functional tools: normalize → filter outliers → apply activation → sort by confidence. This exact pattern is used in inference pipelines for processing model outputs.

Data Structures — How Python Stores the World

Lists. Tuples. Dictionaries. Sets. Comprehensions. These aren't just data containers — they're the exact structures that datasets, model configs, API responses, and training batches use. Every AI pipeline starts with a list of samples. Every model config is a dictionary. Every vocabulary is a set. This chapter makes data intuitive.

Creating lists, indexing and slicing (negative indices!), list methods (append, extend, insert, remove, pop, sort, reverse), list copying pitfalls, and multi-dimensional lists as matrices. We animate a training dataset as a list, mini-batching as slicing, and a confusion matrix as a 2D list — all real ML operations.

Tuples vs lists (when to use which), tuple unpacking, named tuples, returning multiple values, and why immutability matters. Tensor shapes in PyTorch are tuples: (batch_size, channels, height, width). We show how shape arithmetic works with tuple operations.

Creating dicts, CRUD operations, .get() with defaults, .keys()/.values()/.items(), dict merging (|=), nested dicts, and defaultdict. Animated explanation of hash maps from Batch 01's memory concepts. We parse a real OpenAI API response dictionary — response['choices'][0]['message']['content'].

Set creation, add/remove, union/intersection/difference, set comprehensions, frozensets, and O(1) membership testing. We build a vocabulary builder for an NLP tokenizer — converting raw text to a unique set of tokens — exactly how tokenization preprocessing works.

List, dict, and set comprehensions with conditions. Generator expressions. Nested comprehensions for matrix operations. Performance comparison vs loops. We build a vocabulary encoder, a prediction filter, and a matrix normalization — three real ML operations — each as a single comprehension line.

Lists of dicts, dicts of lists, deeply nested JSON, safe navigation with .get(), json module (loads/dumps), reading data files, and error-safe parsing. We parse a real Anthropic Claude API response, an OpenAI ChatGPT response, and a HuggingFace model output — three real structures students will use from Batch 09 onward.

Object-Oriented Python — Classes, Objects & PyTorch

The most important conceptual shift in programming: from writing procedures to designing objects. Classes are blueprints. Objects are instances. PyTorch neural networks are literally classes inheriting from nn.Module. This chapter makes OOP click — and when it does, ML code becomes readable for the first time.

Class vs instance, __init__ constructor, instance attributes, instance methods, the self parameter. We build a Neuron class with weights, bias, and a forward() method — implementing a perceptron (the building block of neural networks) using only the Python taught in this batch. Every concept in this episode maps to PyTorch's nn.Linear.

Instance vs class attributes, @classmethod (receives class), @staticmethod (no self/cls), @property for computed attributes, and private naming conventions (_name, __name). We build a Layer class with a class-level counter — mirroring how PyTorch tracks registered modules in nn.Module.

Single inheritance, super(), method overriding, abstract base classes, isinstance() and issubclass(), mixin classes. We build a base model and extend it — exactly the pattern class MyModel(nn.Module) uses. When students see PyTorch's class definition pattern, they'll understand it completely.

__init__, __repr__, __str__, __len__, __add__, __mul__, __getitem__, __iter__, __call__, __enter__/__exit__ (context managers). We build a mini-Tensor class that supports t1 + t2, t[0], len(t) — demystifying how PyTorch tensors work under the hood. Students see that t1 + t2 in PyTorch is literally __add__.

Grand synthesis of the whole chapter: we read a complete PyTorch model class line by line, explaining every OOP concept as it appears. Then we write our own model from scratch — a multi-layer perceptron for digit classification — using every pattern taught in episodes 23–26. The first real AI code students run.

Python's AI Toolkit — NumPy, Pandas, Matplotlib

The essential libraries every AI engineer installs first. NumPy makes Python fast for math — arrays, matrices, broadcasting. Pandas lets you load and explore any dataset. Matplotlib makes your data visible. These three libraries alone can get you through 80% of data science and ML preprocessing work.

ndarray creation, shape/dtype/ndim, array operations, broadcasting rules, matrix multiplication (@), slicing, vectorization vs loops (speed demo), universal functions (ufuncs), and the connection between NumPy arrays and PyTorch tensors. We implement a forward pass of a neural network layer using only NumPy — no PyTorch.

DataFrame and Series, read_csv/read_json, .head()/.describe()/.info(), selecting columns, filtering rows, handling missing values, groupby + aggregation, and merging dataframes. We clean the classic Titanic dataset end-to-end — the exact same preprocessing workflow used for every real ML project.

Line plots, scatter plots, histograms, subplots, figure styling, and the data visualization patterns used in ML: loss curves, accuracy over epochs, confusion matrix heatmaps, and feature distributions. We visualize training results from a complete experiment run — the skill every ML engineer needs to debug and present models.

open() with context managers, read/write modes, CSV reading with csv module, JSON load/dump, pathlib for file paths, and glob for file discovery. We build a complete experiment logger — reads config.json, trains (simulated), saves results.json — the core pattern of every ML experiment tracking system.

pip install, requirements.txt, virtual environments (venv), pyproject.toml intro, project folder structure for AI projects, .gitignore, and conda basics. We set up the exact project structure we'll use for the capstone project — clean, professional, reproducible.

Python Mastery & Your First AI Project

The final chapter polishes your Python and puts everything to use. Error handling, decorators, generators — then the capstone: a text sentiment classifier built from scratch using Python + NumPy + real data. No PyTorch yet. Just pure Python, turning what you've learned into something that actually works.

try/except/else/finally, built-in exceptions (ValueError, TypeError, FileNotFoundError, KeyError), raising exceptions, custom exception classes, and graceful degradation. We wrap a dataset loading and training pipeline in proper error handling — because production AI code fails on corrupt data, missing files, and GPU errors constantly.

Functions as first-class objects, higher-order functions, building a decorator from scratch, functools.wraps, common decorators (@staticmethod, @classmethod, @property), and the @ syntax. We build timer, logger, and retry decorators — then show how @torch.no_grad() is implemented the exact same way.

yield keyword, generator functions vs list-returning functions, generator expressions, itertools, and why generators are essential for large datasets. We build a batched dataset loader that reads files line-by-line without loading everything into RAM — the core design of PyTorch's DataLoader class.

Your First AI Project — Built With Pure Python

No PyTorch. No magic libraries. Just Python, NumPy, and everything from Chapters 1–7. You'll build a working sentiment classifier that tells you if a movie review is positive or negative.

🎯 Batch 02 Capstone — Sentiment Classifier

Episodes 36 (build) + 37 (ship & review): Build a text sentiment classifier using everything in Batch 02. Tokenize text (Ch1), filter stop words (Ch2), vectorize with functions (Ch3), store vocab in a dict (Ch4), wrap in a class (Ch5), use NumPy for math (Ch6), handle errors and log results (Ch7). Every chapter is in this one project.

Python Skills — Batch 02 Outcomes

Concrete, testable skills you'll have after completing all 35 episodes. Each skill maps directly to AI engineering work you'll do in later batches.

After Batch 02, Batch 03 Awaits

Python is your tool. Batch 03 teaches you how to use it efficiently — Data Structures & Algorithms, the engine of all intelligent software.

Your programming language of AI

Batch 03: DSA

Arrays, trees, graphs, Big O — AI's algorithms

Mathematics for AI

Linear algebra in Python (NumPy!)

Machine Learning

sklearn + PyTorch — Python pays off here

Generative AI & LLMs

Build with GPT using Python skills

Ready to Write Your First Line of Python?

35 episodes. 7 chapters. One capstone project. Everything from "what is a variable" to building a working AI sentiment classifier — free, on YouTube, under Codebitbybit × Tavro Studio.