You've Read
Enough.
Now Let's Build.

A command-line todo manager that saves to a file. You interact with it by running python todo.py add "Buy milk" or python todo.py done 2 or python todo.py list.

What this forces you to learn: sys.argv for command-line arguments, reading and writing JSON files, handling the case where the file doesn't exist yet, and — most importantly — how to structure code that has multiple "commands."

import sys
import json
from pathlib import Path

DB = Path.home() / ".todos.json"

def load():
    if not DB.exists():
        return []
    return json.loads(DB.read_text())

def save(todos):
    DB.write_text(json.dumps(todos, indent=2))

def cmd_add(text):
    todos = load()
    todos.append({"text": text, "done": False})
    save(todos)
    print(f"Added: {text}")

def cmd_list():
    for i, t in enumerate(load(), 1):
        status = "✓" if t["done"] else "○"
        print(f"  {i}. [{status}] {t['text']}")

def cmd_done(n):
    todos = load()
    todos[n - 1]["done"] = True
    save(todos)

COMMANDS = {"add": cmd_add, "list": cmd_list, "done": cmd_done}

if __name__ == "__main__":
    if len(sys.argv) < 2 or sys.argv[1] not in COMMANDS:
        print("Usage: todo.py [add|list|done] [args]")
        sys.exit(1)

    cmd = sys.argv[1]
    args = sys.argv[2:]
    COMMANDS[cmd](*args)

Where you will get stuck: IndexError when the list is empty. The file not existing on first run. What to do when the user types done abc instead of done 2. Handle each one as it comes. That's the work.

Take any CSV file — sales data, exam scores, weather records — and write a script that reads it, computes summaries (mean, median, min, max per column), and outputs a clean report. No pandas. Do it with pure Python and the csv module.

Why no pandas? Because if you use pandas here you'll never learn to think about data as lists and dicts. Pandas is a tool for people who already understand what it's doing for them. Build that understanding first.

import csv
import statistics
from pathlib import Path
from collections import defaultdict

def load_csv(path):
    with open(path, encoding='utf-8') as f:
        reader = csv.DictReader(f)    # each row is a dict keyed by header
        return list(reader)            # [{col: val, ...}, ...]

def get_numeric_columns(rows):
    numeric = {}
    for col in rows[0]:
        try:
            values = [float(r[col]) for r in rows if r[col].strip()]
            numeric[col] = values
        except ValueError:
            pass   # not numeric — skip
    return numeric

def analyse(filepath):
    rows = load_csv(filepath)
    print(f"\n{filepath}  ({len(rows)} rows)\n")
    print(f"{'Column':20} {'Mean':>10} {'Median':>10} {'Min':>10} {'Max':>10}")
    print("-" * 62)

    for col, vals in get_numeric_columns(rows).items():
        print(
            f"{col:20}"
            f"{statistics.mean(vals):>10.2f}"
            f"{statistics.median(vals):>10.2f}"
            f"{min(vals):>10.2f}"
            f"{max(vals):>10.2f}"
        )

if __name__ == "__main__":
    import sys
    analyse(sys.argv[1])

Extend it yourself: Add filtering (only rows where score > 80). Add grouping (mean score per grade column). Add CSV output instead of printed tables. Each extension forces you to use something new.

Build a small banking system — not a toy example, a real one. Multiple account types (SavingsAccount, CurrentAccount), transfer between accounts, a transaction history, interest calculation, serialisation to JSON so data persists.

Why this project for OOP? Because banking is a domain where the real-world rules map cleanly onto class design decisions. "A savings account has a minimum balance" — that's an override in the subclass. "Every transfer creates two transaction records" — that's a method that touches two objects. "Account number is set once and never changes" — that's a property with no setter.

from dataclasses import dataclass, field
from datetime import datetime
from abc import ABC, abstractmethod
import uuid

@dataclass
class Transaction:
    kind:   str            # 'credit' | 'debit' | 'transfer'
    amount: float
    note:   str   = ""
    when:   datetime = field(default_factory=datetime.now)

class Account(ABC):
    def __init__(self, owner: str, initial: float = 0):
        self._id      = str(uuid.uuid4())[:8].upper()
        self._owner   = owner
        self._balance = initial
        self._history: list[Transaction] = []

    @property
    def balance(self) -> float: return self._balance

    @property
    def account_id(self) -> str: return self._id

    def deposit(self, amount: float, note="") -> 'Account':
        if amount <= 0: raise ValueError("Must be positive")
        self._balance += amount
        self._history.append(Transaction('credit', amount, note))
        return self

    @abstractmethod
    def withdraw(self, amount: float, note="") -> 'Account': ...

    def transfer(self, to: 'Account', amount: float):
        self.withdraw(amount, note=f"Transfer to {to.account_id}")
        to.deposit(amount, note=f"Transfer from {self.account_id}")

    def statement(self):
        print(f"\nAccount {self._id} — {self._owner}")
        print(f"Balance: ₹{self._balance:,.2f}\n")
        for t in self._history[-5:]:
            sign = "+" if t.kind == "credit" else "-"
            print(f"  {sign}₹{t.amount:10.2f}  {t.note}")

class SavingsAccount(Account):
    MIN_BALANCE = 1000

    def withdraw(self, amount, note=""):
        if self._balance - amount < self.MIN_BALANCE:
            raise ValueError(
                f"Must maintain ₹{self.MIN_BALANCE} minimum")
        self._balance -= amount
        self._history.append(Transaction('debit', amount, note))
        return self

Given a folder of .txt files, build an inverted index — a dictionary where every word maps to the list of files it appears in. Then build a search interface: user types a query, gets back the relevant files ranked by how many query words they contain.

Why this project? Because it's the first time all the data structure knowledge becomes unavoidable. You need sets for fast membership testing, dicts for the index, sorting with a key function for ranking. Nothing works cleanly without the right structure.

from pathlib import Path
from collections import defaultdict
import re

def tokenise(text: str) -> set[str]:
    # lowercase, extract words, remove noise
    words = re.findall(r'\b[a-z]{2,}\b', text.lower())
    return set(words)   # set: we only care about presence, not count

def build_index(folder: str) -> dict[str, set]:
    index: dict[str, set] = defaultdict(set)
    for path in Path(folder).glob("**/*.txt"):
        words = tokenise(path.read_text(errors='ignore'))
        for word in words:
            index[word].add(path.name)
    return dict(index)

def search(index, query: str) -> list[tuple]:
    query_words = tokenise(query)
    # Score each file by how many query words it contains
    scores: dict[str, int] = defaultdict(int)
    for word in query_words:
        for filename in index.get(word, set()):
            scores[filename] += 1
    return sorted(scores.items(), key=lambda x: x[1], reverse=True)

# Usage
index = build_index("./documents")
for filename, score in search(index, "machine learning python"):
    print(f"  [{score:2} hits] {filename}")

What breaks: Files with weird encodings. Very large folders (you'll want to add a loading indicator). Words that appear in every single file polluting results — that's how you discover TF-IDF naturally.

Scrape a public webpage — job listings, news headlines, a product catalogue, a Wikipedia table — parse the HTML with BeautifulSoup, store the data as JSON, and then generate a plain-text or CSV report from it. No API. The raw, messy, real web.

Why this project? Because real data is never clean. You will find missing fields. You will find inconsistent formatting. You will find pages that change structure between runs. Dealing with all of that gracefully — with good error handling, defensive attribute access, and sensible defaults — is the most practical skill in this list.

import requests
from bs4 import BeautifulSoup
import json
from dataclasses import dataclass, asdict
from typing import Optional

@dataclass
class Article:
    title:   str
    url:     str
    summary: Optional[str] = None

def fetch(url: str) -> Optional[BeautifulSoup]:
    try:
        resp = requests.get(url, timeout=10,
            headers={'User-Agent': 'Mozilla/5.0'})
        resp.raise_for_status()   # raises on 4xx/5xx
        return BeautifulSoup(resp.text, 'html.parser')
    except requests.RequestException as e:
        print(f"Failed to fetch {url}: {e}")
        return None

def parse_articles(soup: BeautifulSoup) -> list[Article]:
    articles = []
    for item in soup.select('article.preview'):
        title_el = item.find('h2')
        link_el  = item.find('a')
        # Defensive: skip if critical elements missing
        if not title_el or not link_el:
            continue
        articles.append(Article(
            title   = title_el.get_text(strip=True),
            url     = link_el.get('href', ''),
            summary = (p.get_text(strip=True)
                       if (p := item.find('p')) else None)
        ))
    return articles

def save_report(articles, path='report.json'):
    with open(path, 'w') as f:
        json.dump([asdict(a) for a in articles], f, indent=2)
    print(f"Saved {len(articles)} articles to {path}")

The real education here is in what you can't plan for. You'll write the selector 'article.preview' and discover the site uses 'div.story'. You'll access .text on an element and get AttributeError because it was None. You'll run the script twice and get different results because the page updated. Every one of those failures teaches you something real about defensive programming.