Learn Python 2026
A free, structured curriculum

🚀 What This Curriculum Covers

Python is used across an unusually wide range of work — AI research, office automation scripts, machine-learning pipelines, backend services. This curriculum walks through the language systematically so you're not left guessing which parts matter.

We cover 18 topic modules, sequenced from fundamentals to advanced:

• 🐍 Python Basics – Variables, data types, operators, control flow, loops, and functions — the foundation of everything.
• 📦 Data Structures – Strings, lists, dictionaries, tuples, and sets — the tools for organising data.
• 🏛️ Object‑Oriented Programming – Classes, inheritance, polymorphism, encapsulation, and the dunder methods that make Python objects behave predictably.
• ⚡ Advanced Python – Generators, decorators, context managers, async/await, type hints, and static analysis with mypy.
• 📁 File I/O & Modules – Read/write files, use pathlib, structure projects with packages, and handle exceptions properly.
• 🚀 Applied Domains – Web scraping, data analysis (pandas, NumPy, Matplotlib), AI (LLM APIs, NLP), machine learning (scikit‑learn, TensorFlow), and more.

Every concept is accompanied by runnable code you can execute directly in your browser using Pyodide, without installing anything. Step‑by‑step explanations break down each block so you're not left studying syntax in isolation.

🤔 Why This Curriculum Is Organised This Way

Python's Reach

Python shows up across nearly every domain of modern software — web backends, data pipelines, ML deployment, and everyday automation. Understanding it well opens doors across all of these.

Where Beginners Get Stuck

Not understanding Python's quirks tends to cause specific, avoidable problems:

• Floating‑point rounding errors in numeric code
• Memory‑hungry code that slows down or crashes on larger inputs
• Concurrency bugs that are hard to reproduce
• Bugs from mutable default arguments or unclear type handling

This curriculum tries to explain the why behind each feature, so these problems are recognisable before they cause real trouble.

The Standard Library as a Starting Point

Python's "batteries included" philosophy gives you a genuinely useful standard library: math, random, datetime, collections, itertools, asyncio, and dozens more — all available without installing anything. Combined with the third‑party ecosystem on PyPI, this is often enough to build real tools without much external dependency.

Theory Alongside Practice

Beyond syntax, this curriculum explains why Python behaves the way it does — the data model, the GIL, memory management, the type system. That understanding is what lets you write idiomatic code and debug issues that would otherwise be mysterious.

Where Python Is Actually Used

• Data Science & AI – one of the most common languages in the field
• Backend Development – Flask, Django, and FastAPI back a large share of web services
• DevOps & Automation – Python scripts frequently glue infrastructure together
• Scientific Computing – widely used for simulations and analysis in research settings
• General Software Engineering – a solid, readable choice for many kinds of projects

🌟 On Numbers, Data, and Abstraction

Numbers as a Foundation

Every digital system ultimately relies on numbers. When you write code, you're manipulating symbols that represent numbers underneath. Understanding how these numbers are stored, manipulated, and transformed is understanding a basic layer of how software works.

Building Blocks of Abstraction

Numbers are the foundation other abstractions are built on. Strings are numbers in disguise (ASCII/Unicode). Lists are numbers with addresses. Dictionaries are numbers used as keys. Files are numbers stored as bytes. Every data structure ultimately decomposes into numbers, so getting comfortable with numeric operations pays off broadly.

Python's Numeric Design

• Arbitrary precision integers — no silent overflow, useful for large-scale computations
• Seamless mixing of numeric types in operations (with implicit conversion)
• A standard library that covers a lot of common mathematical needs
• Mature external libraries (NumPy, SciPy, Pandas) built on this foundation

Where This Leads

Understanding Python's fundamentals is what makes the following genuinely accessible later on:

• NumPy – Multi‑dimensional arrays and vectorised operations
• SciPy – Scientific computing and optimisation
• Pandas – Data analysis and manipulation
• Matplotlib – Data visualisation
• Scikit‑learn – Machine learning
• TensorFlow/PyTorch – Deep learning

Each of these libraries is built on the fundamental numeric and structural capabilities this curriculum covers early on.

Beyond Syntax

The most useful thing this curriculum can offer is an understanding of why things work the way they do. Knowing about the GIL helps you choose the right concurrency model. Knowing about duck typing helps you write more flexible code. Knowing about the data model helps you create objects that feel native to Python. That's the difference between code that happens to work and code that's designed to be correct and maintainable.

🔵 Sets — Fast Unique Collections

A set is an unordered collection of unique, hashable objects. It's the fastest Python data structure for membership testing and is ideal for deduplication, intersection, and difference operations.

def demonstrate_sets():
    languages = {"Python", "JavaScript", "Rust", "Python"}
    print("Unique languages:", languages)

    backend  = {"Python", "Go", "Rust"}
    frontend = {"JavaScript", "TypeScript", "Python"}

    print("Union:", backend | frontend)
    print("Intersection:", backend & frontend)
    print("Backend only:", backend - frontend)

    names = ["Alice", "Bob", "Alice", "Charlie", "Bob"]
    unique = list(set(names))
    print("Deduplicated names:", unique)

demonstrate_sets()

📦 Organising Code — Modules, Packages & Virtual Environments

As projects grow beyond a single file, Python's module system keeps code organised, testable, and shareable. A module is a single .py file. A package is a folder containing an __init__.py.

Example code removed to avoid import errors in the browser; run this locally with proper file structure.

🛡️ Robust Exception Handling — Beyond try/except

Production Python code anticipates failure at every external boundary. The full try/except/else/finally structure handles each case cleanly. Custom exceptions communicate intent.

class AppError(Exception):
    pass

class ValidationError(AppError):
    def __init__(self, field: str, message: str):
        self.field = field
        super().__init__(f"{field}: {message}")

def parse_user_data(raw: str) -> dict:
    try:
        data = json.loads(raw)
    except json.JSONDecodeError as e:
        raise ValidationError("body", "Invalid JSON") from e
    else:
        return data
    finally:
        print("Parsing attempt finished")

⚡ Generators — Lazy, Memory-Efficient Iteration

A generator function uses yield instead of return. It produces values one at a time on demand — no memory is used to hold the full sequence. Essential for processing large files, infinite streams, and data pipelines.

def count_up(start: int, stop: int, step: int = 1):
    current = start
    while current < stop:
        yield current
        current += step

for n in count_up(0, 10, 2):
    print(n, end=" ")

print()

squares = (x**2 for x in range(5))
print("Squares:", list(squares))

def read_large_file(path: str):
    with open(path, encoding="utf-8") as f:
        for line in f:
            yield line.strip()

🚀 asyncio — Non-Blocking Python

Synchronous code waits for each I/O operation to complete before starting the next. Async code schedules many I/O tasks concurrently, dramatically improving throughput for network-heavy workloads like web scraping, API calls, and database queries.

The asyncio example is omitted because Pyodide's event loop prevents calling asyncio.run(); run this code locally to see it in action.

🎨 Factory Decorators & Real-World Patterns

A decorator factory is a function that returns a decorator, allowing parameters. This pattern powers every framework you'll use — Flask routes, pytest fixtures, Django views, and more.

import functools, time

def retry(times: int = 3, delay: float = 1.0):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(1, times + 1):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == times:
                        raise
                    print(f"Attempt {attempt} failed: {e}. Retrying...")
                    time.sleep(delay)
        return wrapper
    return decorator

@retry(times=2, delay=0.5)
def unstable_operation() -> str:
    import random
    if random.random() < 0.6:
        raise ValueError("Random failure!")
    return "Success!"

print(unstable_operation())

🔍 Type Hints — Modern Python Annotations

Type hints document your code and enable static analysis with mypy or pyright. They don't change runtime behaviour but catch entire classes of bugs before the code runs.

from typing import TypeVar, Generic, Protocol
from collections.abc import Sequence

T = TypeVar("T")

class Stack(Generic[T]):
    def __init__(self) -> None:
        self._items: list[T] = []

    def push(self, item: T) -> None:
        self._items.append(item)

    def pop(self) -> T:
        return self._items.pop()

stack: Stack[int] = Stack()
stack.push(42)
stack.push(100)
print("Popped:", stack.pop())

class Drawable(Protocol):
    def draw(self) -> None: ...

def render(shape: Drawable) -> None:
    shape.draw()

❌ Mistake 1 — Using a mutable default argument

Default argument values are evaluated once when the function is defined — not each time it is called. If you use a mutable object like a list as a default, all calls that use the default share the same object.

def add_item_bad(item, items=[]):
    items.append(item)
    return items

print(add_item_bad("apple"))
print(add_item_bad("banana"))

def add_item_good(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

print(add_item_good("apple"))
print(add_item_good("banana"))

❌ Mistake 2 — Confusing == with is

== checks whether two values are equal. is checks whether two names point to the exact same object in memory. For small integers and interned strings Python reuses objects, which can make is appear to work — until it silently does not.

a = 256
b = 256
print("256 is 256:", a is b)

a = 257
b = 257
print("257 is 257:", a is b)
print("257 == 257:", a == b)

if result is None:
    print("Use 'is' for None comparisons")

❌ Mistake 3 — Modifying a list while iterating over it

Changing the size of a list during a for loop causes items to be skipped silently — one of the hardest bugs to spot because Python gives no error, it just produces wrong output.

nums = [1, 2, 3, 4, 5, 6]
for n in nums:
    if n % 2 == 0:
        nums.remove(n)
print("After bad removal:", nums)

nums = [1, 2, 3, 4, 5, 6]
nums = [n for n in nums if n % 2 != 0]
print("After good removal:", nums)

❌ Mistake 4 — Catching too broad an exception

Writing bare except: swallows every error — including typos in variable names, import errors, and keyboard interrupts — making bugs nearly impossible to diagnose.

try:
    result = int("not a number")
except ValueError:
    print("Please enter a valid number")
except TypeError as e:
    print(f"Type error: {e}")
finally:
    print("Cleanup always runs")

❌ Mistake 5 — Not understanding variable scope (LEGB rule)

Python resolves variable names in a specific order: Local → Enclosing → Global → Built-in. Forgetting this leads to confusing UnboundLocalError bugs.

count = 0

def increment_bad():
    count += 1

def increment_good():
    global count
    count += 1

def increment_pure(count):
    return count + 1

count = increment_pure(count)
print("Count:", count)

❌ Mistake 6 — Using + to concatenate strings in a loop

Strings in Python are immutable. Every + creates a new string object and copies both into it. Inside a loop over thousands of items, this creates quadratic time complexity.

words = ["Python", "is", "fast", "and", "readable"]

result = ""
for word in words:
    result += word + " "
print(result)

result = " ".join(words)
print(result)

❌ Mistake 7 — Forgetting integers and strings do not auto-convert

Python is strongly typed. Unlike JavaScript, it never silently coerces a number to a string or vice versa. This causes TypeError that surprises beginners from loosely typed languages.

age = 25

print(f"I am {age} years old")

pi = 3.14159265
print(f"Pi to 2 dp: {pi:.2f}")

❌ Mistake 8 — Shallow copy vs deep copy confusion

Assigning a list to a new variable does not copy it — both names point to the same object. Only a deep copy is truly independent.

import copy

original = [[1, 2], [3, 4]]

alias = original
alias[0][0] = 99
print("Original after alias mutation:", original)

deep = copy.deepcopy(original)
deep[0][0] = 0
print("Original after deep copy mutation:", original)

❌ Mistake 9 — Ignoring return values from string methods

Strings are immutable. Methods like .upper(), .strip(), and .replace() return a new string, they do not modify in place.

name = "  glenn  "
name.strip()
print(name)

name = name.strip()
print(name)

text = "hello world"
text = text.upper().replace("WORLD", "PYTHON")
print(text)

❌ Mistake 10 — Writing loops when a built-in would do

Python ships with a rich set of built-in functions and comprehensions. Writing an explicit loop where a one-liner exists is slower and harder to read.

squares = []
for n in range(10):
    if n % 2 == 0:
        squares.append(n ** 2)
print(squares)

squares = [n**2 for n in range(10) if n % 2 == 0]
print(squares)

data = [1, 5, 3, 9, 2]
print("Sum:", sum(data))
print("Max:", max(data))
print("Min:", min(data))

📏 Follow PEP 8 — Python's Official Style Guide

PEP 8 covers naming conventions, indentation, line length, blank lines, and import ordering. Most professional Python codebases enforce it automatically with tools like black or ruff.

user_name = "Glenn"
def calculate_average(scores): ...

class UserAccount: ...
class DataProcessor: ...

MAX_RETRIES = 3
BASE_URL = "https://api.example.com"

_internal_helper = "not for external use"

📝 Write Docstrings for Every Public Function and Class

Docstrings are first-class documentation that tools like Sphinx, IDE tooltips, and help() can read. A function without a docstring forces the reader to study the implementation to understand intent.

def calculate_bmi(weight_kg: float, height_m: float) -> float:
    if height_m <= 0:
        raise ValueError("Height must be positive")
    return round(weight_kg / height_m ** 2, 2)

🔒 Use Type Hints — Standard Practice by 2026

Python's type hints don't change runtime behaviour, but they dramatically improve readability, enable IDE autocompletion, and allow static type checkers like mypy to catch bugs before your code runs.

from typing import Optional, TypedDict

def find_user(user_id: int) -> Optional[dict]:
    ...

def parse_value(raw: str) -> int | float:
    try:
        return int(raw)
    except ValueError:
        return float(raw)

class Article(TypedDict):
    title: str
    author: str
    word_count: int
    published: bool

🧪 Write Tests — Even Simple Ones

Untested code is broken code waiting to be discovered. Python's built-in unittest and the popular third-party pytest make testing straightforward. Even a handful of tests catches regressions before they reach production.

The pytest example is omitted because Pyodide does not include pytest; run this code locally with pytest installed.

📦 Use dataclasses to Eliminate Boilerplate

The @dataclass decorator (Python 3.7+) auto-generates __init__, __repr__, and __eq__ from annotated fields, reducing repetitive code dramatically.

from dataclasses import dataclass, field
from typing import List

@dataclass
class Student:
    name: str
    grade: int
    scores: List[float] = field(default_factory=list)

    @property
    def average(self) -> float:
        return sum(self.scores) / len(self.scores) if self.scores else 0.0

s = Student("Ana", 10)
s.scores.extend([88, 92, 95])
print(s)
print(f"Average: {s.average:.2f}")

📖 Reading and Writing Files Safely

Always use the with statement when opening files. It guarantees the file is closed even if an exception occurs — no resource leaks, no corrupted files.

The file I/O example is omitted because the browser environment lacks the actual files; run this code locally with existing files.

🗂️ pathlib — Modern File Path Handling

The pathlib module (Python 3.4+) provides an object-oriented interface to filesystem paths. It is cleaner, more readable, and cross-platform compared to old-style string manipulation with os.path.

from pathlib import Path

home    = Path.home()
project = Path("myproject")
data    = project / "data" / "input.csv"

print(f"Name: {data.name}")
print(f"Stem: {data.stem}")
print(f"Suffix: {data.suffix}")
print(f"Parent: {data.parent}")
print(f"Exists: {data.exists()}")

for pyfile in Path(".").glob("*.py"):
    print(pyfile)

📋 Working with CSV and JSON

CSV and JSON are the two formats you will encounter most often in real-world Python work — spreadsheet exports, API responses, and configuration files.

import csv, json

rows = [{"name":"Ana","score":95},{"name":"Bob","score":87}]
with open("results.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["name","score"])
    writer.writeheader()
    writer.writerows(rows)

data = {"user": "Glenn", "level": "advanced", "scores": [95, 88, 92]}
with open("user.json", "w") as f:
    json.dump(data, f, indent=2)

🏗️ Defining Classes & __init__

A class bundles data (attributes) and behaviour (methods). __init__ runs on every new instance. self refers to the instance — not a keyword, just a strong convention.

class BankAccount:
    def __init__(self, owner: str, balance: float = 0.0):
        self.owner   = owner
        self.balance = balance
        self._history = []

    def deposit(self, amount: float):
        if amount <= 0:
            raise ValueError("Amount must be positive")
        self.balance += amount
        self._history.append(f"+{amount}")

    def withdraw(self, amount: float):
        if amount > self.balance:
            raise ValueError("Insufficient funds")
        self.balance -= amount
        self._history.append(f"-{amount}")

    def statement(self) -> str:
        return f"{self.owner}: ${self.balance:.2f}"

acc = BankAccount("Alice", 500)
acc.deposit(200)
acc.withdraw(50)
print(acc.statement())

✨ Dunder Methods (Magic Methods)

Python calls dunder methods automatically in response to built-in operations. Implementing them makes your objects feel native — comparable with ==, printable, addable with +.

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

    def __len__(self):
        import math
        return int(math.hypot(self.x, self.y))

v1 = Vector(3, 4)
v2 = Vector(1, 2)
print(v1 + v2)
print(v1 == v2)
print("Length of v1:", len(v1))

🎯 @property, @classmethod, @staticmethod

@property turns a method into a computed attribute. @classmethod receives the class for alternative constructors. @staticmethod is a helper namespaced inside the class with no implicit argument.

class Temperature:
    def __init__(self, celsius: float):
        self._celsius = celsius

    @property
    def celsius(self):
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("Below absolute zero!")
        self._celsius = value

    @property
    def fahrenheit(self):
        return self._celsius * 9/5 + 32

    @classmethod
    def from_fahrenheit(cls, f: float):
        return cls((f - 32) * 5/9)

    @staticmethod
    def is_freezing(celsius: float) -> bool:
        return celsius <= 0

t = Temperature.from_fahrenheit(212)
print(f"Celsius: {t.celsius}")
print(f"Fahrenheit: {t.fahrenheit}")
print(f"Is freezing at -5°C? {Temperature.is_freezing(-5)}")

📦 Bytecode and the CPython Interpreter

When you run a .py file, CPython (the reference implementation most people mean by "Python") first compiles your source into an intermediate form called bytecode — a set of low-level instructions stored in .pyc files. The interpreter then executes this bytecode one instruction at a time in a loop. You can inspect it yourself:

import dis

def add(a, b):
    return a + b

dis.dis(add)

🔗 Names, Objects, and Reference Counting

A common early confusion is thinking that variables "contain" values the way boxes contain items. In Python, variables are names bound to objects. Assignment doesn't copy data — it points a name at an existing object in memory.

a = [1, 2, 3]
b = a
print("Same object?", a is b)
print("id(a):", id(a))
print("id(b):", id(b))

b.append(4)
print("a after b.append(4):", a)

Every object keeps a count of how many names point to it. When that count reaches zero, CPython frees the memory immediately — this is reference counting, and it's why Python generally doesn't need you to manage memory by hand. Circular references (an object that indirectly refers to itself) are handled separately by a periodic cyclic garbage collector.

⏱️ Why Some Operations Are Faster Than Others

Understanding the underlying data structures explains real performance differences you'll run into:

• ✓Lists are backed by contiguous arrays — appending at the end is fast (amortised O(1)), but inserting at the front is O(n) because every element has to shift.
• ✓Dictionaries and sets are hash tables — lookups are close to O(1) regardless of size, which is why x in my_dict is far faster than x in my_list for large collections.
• ✓Strings are immutable, so every concatenation with + allocates a new string — this is why repeated concatenation in a loop is quadratic, while "".join(parts) is linear.
• ✓Tuples are slightly cheaper than lists in both memory and creation time because they don't need to support resizing.

👉 Two Pointers

Two indices move through a sequence — usually from opposite ends or at different speeds — to avoid a nested loop. Useful for searching sorted data, detecting palindromes, or removing duplicates in place.

def is_palindrome(s: str) -> bool:
    left, right = 0, len(s) - 1
    while left < right:
        if s[left] != s[right]:
            return False
        left += 1
        right -= 1
    return True

print(is_palindrome("racecar"))
print(is_palindrome("python"))

🪟 Sliding Window

A window of fixed or variable size slides across a sequence, keeping a running total or count instead of recomputing from scratch each time. Common for "longest substring" or "maximum sum subarray" style problems.

def max_sum_subarray(nums: list[int], k: int) -> int:
    window_sum = sum(nums[:k])
    best = window_sum
    for i in range(k, len(nums)):
        window_sum += nums[i] - nums[i - k]
        best = max(best, window_sum)
    return best

print(max_sum_subarray([2, 1, 5, 1, 3, 2], 3))

🧮 Hash Map Counting

A dictionary used to count occurrences turns many "find duplicates" or "find the most frequent item" problems into a single linear pass instead of a nested loop.

from collections import Counter

words = "the quick brown fox jumps over the lazy dog the fox runs".split()
counts = Counter(words)
print(counts.most_common(2))

🔁 Recursion & Memoisation

Some problems are naturally defined in terms of smaller versions of themselves. Recursion expresses that directly; memoisation avoids recomputing the same subproblem twice.

from functools import lru_cache

@lru_cache(maxsize=None)
def fibonacci(n: int) -> int:
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print([fibonacci(n) for n in range(10)])

📦 Package Management — pip, venv, and poetry

Every Python project should live in a virtual environment — an isolated directory that contains its own Python interpreter and packages, completely separate from your system Python.

python -m venv .venv
source .venv/bin/activate
.venv\Scripts\activate

pip install requests pandas flask
pip freeze > requirements.txt
pip install -r requirements.txt

poetry new my-project
poetry add requests
poetry run python main.py

🎨 Code Quality Tools — Black, Ruff, mypy

Modern Python development automates code style. These tools run as pre-commit hooks or in CI/CD pipelines to ensure every line of code that enters the codebase meets a consistent standard.

pip install black
black .

pip install ruff
ruff check .
ruff check --fix .

pip install mypy
mypy main.py
mypy src/

pip install pre-commit
pre-commit install

📜 Reading a Traceback Top to Bottom (Then Bottom to Top)

A traceback lists the chain of function calls that led to an error, in the order they happened. Beginners often read it top-down like normal text, but the most useful information — the actual error type and message — is at the very bottom. Read the last line first, then walk upward to see which call led there.

def get_first_item(items):
    return items[0]

def process(data):
    return get_first_item(data)

process([])

🔎 Recognising Common Exception Types on Sight

Learning to recognise an exception type at a glance saves time — each one narrows down the search significantly before you even look at the message.

• ✓NameError — a name is used before it's defined, usually a typo or a variable used outside its scope
• ✓TypeError — an operation was applied to a type it doesn't support, like adding a string to an integer
• ✓ValueError — the type is correct but the value isn't acceptable, like int("abc")
• ✓KeyError — a dictionary lookup used a key that doesn't exist
• ✓IndexError — a sequence was accessed with an index outside its valid range
• ✓AttributeError — code tried to use a method or attribute an object doesn't have, often from a typo or a None where an object was expected

🖨️ Print Debugging — Simple, and Still Worth Doing Well

Sprinkling print() statements is often dismissed as unsophisticated, but done deliberately it's a fast way to confirm assumptions. The key is printing enough context to be useful, not just a bare value.

def calculate_discount(price, percent):
    print(f"[calculate_discount] price={price!r} percent={percent!r}")
    discount = price * (percent / 100)
    print(f"[calculate_discount] discount={discount!r}")
    return price - discount

print(calculate_discount(100, 15))

🛑 The Built-in Debugger — breakpoint()

Python 3.7+ includes a built-in breakpoint() function that drops you into an interactive debugger (pdb) at that exact line. It's more powerful than print debugging because you can inspect and change variables live, step through code line by line, and explore the call stack.

def total_price(items):
    total = 0
    for item in items:
        breakpoint()  # execution pauses here
        total += item["price"] * item["qty"]
    return total

Once paused, a few commands cover most needs: n (next line), s (step into a function call), c (continue running), p variable_name (print a variable), and q (quit the debugger).

🧭 A Repeatable Process for Chasing Down a Bug

Random trial and error tends to take longer than a deliberate process. A reasonably reliable sequence:

1. Reproduce the bug consistently before trying to fix anything — an intermittent bug you can't reliably trigger is much harder to confirm as fixed.
2. Read the full traceback, bottom to top, and identify the exact line that raised the exception.
3. Form a specific hypothesis about what the value of a variable is at that point, rather than a vague sense that "something's wrong."
4. Check that hypothesis directly — with a print statement, breakpoint(), or by running just that line in isolation.
5. Fix the actual cause, not just the symptom — a try/except that silently swallows the error usually just delays the same bug.
6. Add a small test or assertion that would have caught this case, so it doesn't come back unnoticed.

✅ A Minimal Test Case

A test case is a class that inherits from unittest.TestCase. Each method starting with test_ is run independently, and assertEqual, assertTrue, and similar methods report a clear failure message when something doesn't match.

import unittest

def apply_discount(price: float, percent: float) -> float:
    if not 0 <= percent <= 100:
        raise ValueError("percent must be between 0 and 100")
    return round(price * (1 - percent / 100), 2)

class TestApplyDiscount(unittest.TestCase):
    def test_typical_discount(self):
        self.assertEqual(apply_discount(100, 20), 80.0)

    def test_zero_percent_returns_original_price(self):
        self.assertEqual(apply_discount(50, 0), 50.0)

    def test_invalid_percent_raises(self):
        with self.assertRaises(ValueError):
            apply_discount(100, 150)

runner = unittest.TextTestRunner(verbosity=2)
suite = unittest.TestLoader().loadTestsFromTestCase(TestApplyDiscount)
runner.run(suite)

🎯 What Makes a Good Test

• ✓Test one behaviour per method — a failing test name should tell you roughly what broke without reading the assertion
• ✓Cover the typical case, an edge case (empty input, zero, boundary values), and an error case
• ✓Keep tests independent — one test's outcome should never depend on another test running first
• ✓Prefer assertRaises over manually catching an exception and checking a flag
• ✓Name test methods descriptively — test_negative_percent_raises is more useful than test_2

🏗️ setUp and tearDown

When several tests need the same starting state, setUp() runs before every test method and tearDown() runs after — useful for resetting objects, closing files, or cleaning up temporary state.

import unittest

class ShoppingCart:
    def __init__(self):
        self.items = []

    def add(self, name, price):
        self.items.append((name, price))

    def total(self):
        return sum(price for _, price in self.items)

class TestShoppingCart(unittest.TestCase):
    def setUp(self):
        self.cart = ShoppingCart()

    def test_empty_cart_total_is_zero(self):
        self.assertEqual(self.cart.total(), 0)

    def test_total_sums_item_prices(self):
        self.cart.add("Book", 12.5)
        self.cart.add("Pen", 1.5)
        self.assertEqual(self.cart.total(), 14.0)

runner = unittest.TextTestRunner(verbosity=2)
suite = unittest.TestLoader().loadTestsFromTestCase(TestShoppingCart)
runner.run(suite)

🔍 Same Algorithm, Different Languages

Finding all prime numbers up to N using the Sieve of Eratosthenes:

def sieve_of_eratosthenes(limit: int) -> list[int]:
    is_prime = [True] * (limit + 1)
    is_prime[0] = is_prime[1] = False

    for i in range(2, int(limit**0.5) + 1):
        if is_prime[i]:
            for multiple in range(i*i, limit + 1, i):
                is_prime[multiple] = False

    return [n for n, prime in enumerate(is_prime) if prime]

primes = sieve_of_eratosthenes(50)
print("Primes up to 50:", primes)

🐍 The Zen of Python — 19 Guiding Principles

Running import this in any Python interpreter prints the Zen of Python — 19 aphorisms that guide Python's design. The most relevant ones for everyday development emphasise clarity, simplicity, and explicitness over implicit magic.

import this

✍️ Pythonic Code vs. Non-Pythonic Code

Writing "Pythonic" code means leaning on Python's own idioms rather than translating patterns from another language line by line. The difference shows up in both readability and, sometimes, performance.

items = [1, 2, 3, 4, 5, 6]

i = 0
result = []
while i < len(items):
    if items[i] % 2 == 0:
        result.append(items[i] * 2)
    i += 1

result = [item * 2 for item in items if item % 2 == 0]

a, b = 10, 20
temp = a
a = b
b = temp

a, b = b, a

my_dict = {"key": "value"}
if "key" in my_dict:
    value = my_dict["key"]
else:
    value = "default"

value = my_dict.get("key", "default")

📅 Python's Timeline

print("1989 — Guido van Rossum begins writing Python over Christmas")
print("1991 — Python 0.9.0 released publicly on Usenet")
print("1994 — Python 1.0 released")
print("2000 — Python 2.0 released")
print("2008 — Python 3.0 released")
print("2020 — Python 2 officially reached end-of-life")
print("2021 — Python 3.10: match/case, better errors")
print("2022 — Python 3.11: significant interpreter speedups")
print("2023 — Python 3.12: f-string improvements")
print("2024 — Python 3.13: experimental free-threaded mode")

✅ What This Curriculum Covers

• The fundamentals: variables, data types, control flow, functions
• Python's data structures: lists, dicts, sets, tuples
• Object‑oriented programming: classes, inheritance, polymorphism, encapsulation
• Advanced topics: generators, decorators, async/await, type hints
• Real‑world skills: file I/O, web scraping, data analysis, LLM APIs
• A small portfolio of projects that demonstrate real problem‑solving
• The ecosystem: pip, venv, pytest, black, mypy, and more

📚 Treat It as a Reference, Too

This curriculum is meant to be a living resource, not just a one-time read. Bookmark it, revisit sections as needed, and treat the code examples as something to experiment with, not just read — modifying and breaking things is often how concepts actually stick.

🚀 Where This Can Lead

The fundamentals here are the entry point to several directions:

• Data Analysis – Process and analyse datasets with Pandas and NumPy
• Machine Learning – Build predictive models with scikit‑learn and TensorFlow
• Web Development – Create APIs and full‑stack applications with Flask, Django, FastAPI
• Automation – Write scripts that save real time on manual work
• Scientific Computing – Simulate, model, and visualise complex systems
• AI Engineering – Work with LLMs, NLP, and computer vision

💌 A Note From the Author

This curriculum was put together by Glenn Junsay Pansensoy. The goal, as much as possible, has been to make it:

• Comprehensive — covering the fundamentals thoroughly
• Interactive — learning by doing, not just reading
• Practical — tied to real applications, not abstract exercises
• Free — accessible to anyone, anywhere, without a paywall

If any part of this helped, sharing it with someone else who's learning is genuinely appreciated.

🌟 A Few Reminders

• Use the right tool for the job — not every problem needs the most advanced feature
• Know your tools — the standard library solves more than it gets credit for
• Test your assumptions — code isn't correct until it's been checked
• Understand the theory behind the code, not just the syntax
• Consistency beats intensity — regular, smaller sessions tend to work better than occasional long ones

🙏 Thanks for Reading This Far

Thank you for spending time with this material. The skills covered here tend to transfer well — across other languages and across whatever domain you end up working in.