Python Programming

Lesson 1: Setup and Your First Program

Python is the world's most popular first programming language — readable, versatile, and running everything from Instagram's backend to NASA's data analysis. To start, install Python 3 from python.org (or use an online editor like Replit — no install needed). Verify with python --version in your terminal. A good code editor (VS Code is free and excellent) with syntax highlighting will catch mistakes your eyes miss.

A program is a sequence of instructions the computer executes top to bottom. Python's print() function displays output. Your first program is tradition:

print("Hello, world!")
    print("My name is Ada.")
    print(2 + 3 * 4)

Errors are normal — even professionals write bugs daily. Read error messages bottom-up: the last line names the error type and line number. A SyntaxError means Python couldn't parse your code (often a missing quote or parenthesis); a NameError means you used a name that doesn't exist (check spelling and capitalization — Print is not print). Debugging is detective work: reproduce, read, hypothesize, test.

Try it yourself: Write a program that prints your name, your grade, and the result of (10 + 5) * 2. Then intentionally delete a closing quote, run it, and read the SyntaxError — fix it.

Lesson 2: Variables, Types, and Control Flow

A variable is a named box holding a value: score = 0 creates the name score pointing at 0. Python's core types: int (whole numbers), float (decimals), str (text), bool (True/False). Variables can be reassigned and even change type — Python is dynamically typed. F-strings embed values in text elegantly: f"Score: {score}".

input() reads user text (always as a string — convert with int() or float() for math):

name = input("What is your name? ")
    age = int(input("How old are you? "))
    print(f"{name}, next year you'll be {age + 1}.")

Loops repeat. while loops until a condition fails (great when the count is unknown); for loops iterate a known sequence, usually range(): range(5) gives 0–4, range(1, 11) gives 1–10. break exits a loop early; continue skips to the next iteration. An infinite while True loop needs a break — or Ctrl+C to escape.

Try it yourself: Write a program that asks for a test score and prints A/B/C/D/F (90+, 80+, 70+, 60+, below). Then write a for loop printing the 7-times table from 7×1 to 7×12.

Lesson 3: Strings and String Methods

A string is text in quotes: "hello". Strings support concatenation ("a" + "b" → "ab"), repetition ("ha" * 3 → "hahaha"), and indexing: in s = "python", s[0] is "p" and s[-1] is "n" (negative indices count from the end). A slice takes a range: s[1:4] is "yth" (up to but not including index 4). Strings are immutable: methods return new strings rather than changing the original.

Methods are functions attached to a value. "Hello".lower() gives "hello"; " hi ".strip() removes surrounding spaces; "a,b,c".split(",") gives ["a", "b", "c"]; "-".join(["a", "b"]) gives "a-b"; "hello world".replace("world", "Python") gives "hello Python". f-strings embed values: f"Hi, {name}! You are {age}.". The len() function counts characters, and in tests membership: "ell" in "hello" is True.

Strings drive real programs: cleaning user input (.strip().lower()), parsing CSV lines with split(","), and building messages with f-strings. A common bug is comparing strings with different cases — normalize case before comparing.

Try it yourself: Given email = "User@Example.COM", write code to normalize it to lowercase without spaces. What does "banana"[2:5] give? Answers: email.strip().lower() → "user@example.com"; "banana"[2:5] is "nan".

Lesson 4: Functions

A function is a named, reusable chunk of code: define once with def, call many times. Functions take parameters (inputs) and return values (outputs):

def area_circle(radius):
        pi = 3.14159
        return pi * radius ** 2

    print(area_circle(5))   # 78.53975
    print(area_circle(10))  # 314.159

Scope rules where variables live: variables created inside a function are local — invisible outside. This isolation is a feature, preventing name collisions across a big program. Docstrings (triple-quoted descriptions under def) document purpose, and good function names (calculate_tax, not ct) are documentation too. One function, one job — if you describe it with 'and', split it.

Functions compose into programs the way sentences compose into essays. Python's standard library is a giant toolbox: import math gives math.sqrt(); import random gives random.choice(). Reading documentation (docs.python.org) is a core programmer skill — nobody memorizes everything.

Try it yourself: Write is_even(n) returning True/False, and celsius_to_fahrenheit(c). Then write grade_letter(score) and use it to print letter grades for [95, 82, 71, 58].

Lesson 5: Lists, Dictionaries, and Loops

A list holds an ordered collection: scores = [88, 92, 75, 100]. Index from 0: scores[0] is 88; scores[-1] is the last item. Lists are mutable — append(), remove(), pop(), and assignment (scores[1] = 95) change them in place. len() counts items; sum(), max(), min() summarize numbers. Slicing grabs ranges: scores[1:3] is [92, 75].

A dictionary maps keys to values: capitals = {"France": "Paris", "Japan": "Tokyo"}. Look up with capitals["France"]; add with capitals["Peru"] = "Lima". Dictionaries power counting patterns:

votes = ["a", "b", "a", "c", "a"]
    counts = {}
    for v in votes:
        counts[v] = counts.get(v, 0) + 1
    print(counts)  # {'a': 3, 'b': 1, 'c': 1}

Loop idioms: iterate directly (for s in scores), with index (for i, s in enumerate(scores)), or over dict items (for k, v in capitals.items()). List comprehensions build lists declaratively: squares = [x**2 for x in range(10)]. Nested loops handle grids and tables — and nested data (a list of dictionaries) models real records, like a class roster.

Try it yourself: Given temps = [72, 68, 75, 79, 71], print the average and how many days were above 73. Build a dictionary mapping each of your friends' names to their favorite color, then print each pair.

Lesson 6: File Handling and Exceptions

Programs often outlive a single run by storing data in files. The safe pattern uses with: with open("notes.txt", "w") as f: f.write("hello") writes a file and closes it automatically, even if an error occurs. Modes: "r" read, "w" write (erases existing content!), "a" append. f.read() returns the whole file as one string; f.readlines() returns a list of lines. To save structured data, the json module converts Python lists and dictionaries to text and back: json.dump(scores, f) and json.load(f).

Things go wrong: a missing file, a bad conversion, a division by zero. An exception is Python's way of reporting the failure, and try/except lets you handle it gracefully instead of crashing: try: n = int(input("Age: ")) except ValueError: print("Please enter a number."). Catch specific exceptions, not a bare except, so real bugs are not silently hidden. finally runs cleanup code either way.

Combine the ideas: a quiz-game high-score file that loads on startup (creating an empty one if missing), updates after each game, and saves with json.dump. That is the skeleton of every app that remembers anything.

Try it yourself: Write code that appends the line "done" to log.txt without erasing it. Which exception type appears for int("abc")? Answers: with open("log.txt", "a") as f: f.write("done\n"); ValueError.

Key vocabulary: Exception — a runtime error object; try/except — handling an exception gracefully; JSON — a text format for structured data; with statement — automatic resource cleanup.

Lesson 7: Debugging Strategies and Testing

Debugging is not guessing — it is the scientific method applied to code. Reproduce the bug reliably first. Read the traceback bottom-up: the last line names the exception and the line that raised it. Isolate by bisecting: comment out half the code or test the suspicious function alone with known inputs. Print the values at the point of failure: is the variable what you expected? Most bugs are wrong assumptions about values, not mysterious language behavior.

Common Python traps: off-by-one errors (range(5) gives 0–4, not 1–5); comparing with = instead of ==; mutating a list while looping over it; using a variable before assignment; and the classic if x == 1 or 2, which is always True because it means (x == 1) or (2). Write if x in (1, 2) instead.

Testing prevents bugs from coming back. A unit test checks one function against known inputs and outputs: assert add(2, 3) == 5. Test edge cases: empty input, zero, negative numbers, the largest expected value. Professional teams run hundreds of such tests automatically before every release.

Try it yourself: What does if x == "yes" or "y": do when x is "no"? Why? Answers: It is True (because "y" is truthy), so the branch runs anyway. Write if x in ("yes", "y"):.

Key vocabulary: Traceback — Python's error report; unit test — a check of one function against expected output; edge case — an extreme or boundary input; assert — a statement that fails loudly if a condition is false.

Lesson 8: Algorithms — Searching and Sorting

An algorithm is a precise procedure for solving a problem. Linear search checks each item in turn: worst case, it scans the whole list (O(n)). Binary search works on a sorted list: compare the middle item, discard the half that cannot contain the target, and repeat. Finding a name in a sorted list of a million takes at most 20 comparisons by binary search, versus up to a million by linear search. The catch: the list must be sorted first.

Sorting arranges items in order. Bubble sort repeatedly swaps adjacent out-of-order pairs — simple but slow (O(n²)). Python's built-in sorted() uses Timsort, a fast hybrid algorithm (O(n log n)), and is almost always the right choice: sorted([3, 1, 2]) gives [1, 2, 3], and sorted(names, key=len) sorts by length. Understanding bubble sort matters because it teaches how to reason about correctness and speed — the skills behind every other algorithm.

Big-O notation describes how running time grows with input size: O(1) constant, O(log n) halving, O(n) scanning once, O(n log n) efficient sorting, O(n²) nested loops. An O(n²) algorithm on 10,000 items does 100 million operations — the difference between instant and unusable.

Try it yourself: How many comparisons (worst case) does binary search need on 1,024 sorted items? Sort [5, 2, 9, 1] by hand with bubble sort; how many passes? Answers: log₂(1024) = 10. Bubble sort: pass 1 → [2, 5, 1, 9], pass 2 → [2, 1, 5, 9], pass 3 → [1, 2, 5, 9].

Key vocabulary: Algorithm — a precise problem-solving procedure; binary search — halving search on sorted data; Big-O — how runtime grows with input size.

Lesson 9: Mini-Project — Quiz Game

Time to build something real: a complete quiz game combining everything — data structures for questions, loops for gameplay, conditionals for scoring, functions for organization, and file-free randomness via random.shuffle. Professional programs separate data (the questions), logic (asking, checking), and presentation (messages, scores).

Design first: each question is a dictionary with question, options (list), and answer (index). ask_question() handles one question and returns True/False; run_quiz() shuffles, loops, tallies, and reports a grade. Shuffling the options too (while tracking the correct one) prevents memorizing positions — a nice touch showing real software thinking.

Run it, then extend it: add a timer with the time module, load questions from a file, track high scores across runs, or add lifelines. Every feature you add practices the same cycle professionals use: design, code, test, refactor. The full program below is yours to type, run, and own.

Try it yourself: Type the full game and run it. Then add: (1) three questions you write yourself, (2) a 'streak' bonus message for 3 correct in a row, (3) a final percentage with one decimal place.

Lesson 10: Object-Oriented Programming — Classes and Objects

Object-oriented programming (OOP) bundles data and the functions that work on it into objects. A class is the blueprint; an object is an instance built from it. class Dog: def __init__(self, name): self.name = name; def bark(self): return f"{self.name} says woof!". Then d = Dog("Rex"); d.bark() returns "Rex says woof!". __init__ is the constructor that sets up each new object; self refers to the object itself.

OOP shines when a program has many similar things: a quiz app with many Question objects, a game with many Player objects, a school system with Student and Course objects. Each object keeps its own state (self.score) and behavior (add_points()), so code stays organized as programs grow.

Inheritance lets a class reuse another: class Cat(Pet): ... gets all of Pet's methods and can override or extend them. A bank account class with deposit and withdraw methods, plus a SavingsAccount subclass that adds interest, is the textbook example.

Try it yourself: Write a Rectangle class with __init__(width, height) and an area() method. What does Rectangle(3, 4).area() return? Answers: 12.

Key vocabulary: Class / object — blueprint / instance; __init__ — the constructor; method — a function defined on a class; inheritance — a class reusing another's behavior.

Lesson 11: Capstone — Build a Study Planner App

Time to combine everything: build a study planner that stores tasks, sorts them by due date, saves to a file, and runs from the terminal. Plan the program as pieces before coding: (1) a Task class with subject, title, due date, and done flag; (2) functions to add, list, mark done, and delete tasks; (3) file save/load with json; (4) a menu loop that keeps running until the user quits. Planning on paper first is what separates working programs from tangled ones.

Structure: keep data in a list of Task objects. Listing sorts by due date with sorted(tasks, key=lambda t: t.due). Saving converts each task to a dictionary (t.__dict__) and dumps the list; loading rebuilds objects from dictionaries. Wrap the menu's number parsing in try/except ValueError so a typo cannot crash the app.

Stretch goals: filter tasks by subject; show overdue tasks in a different color (ANSI codes or simple markers like [OVERDUE]); add a weekly review that counts completed tasks. When it works, you have built a real, useful application — the same architecture, at larger scale, behind every to-do app.

Try it yourself: Add a “mark done” feature: list tasks with numbers, read the user's number, set that task's done to True, and save. What should happen if the user enters a number with no matching task? Answers: Print a friendly error (guard with if 1 <= n <= len(tasks)) instead of crashing.

Key vocabulary: Capstone — a project combining everything learned; architecture — how a program's parts fit together; persistence — saving data between runs.

Lesson 12: Modules, Libraries, and Virtual Environments

A module is a Python file full of reusable code; a library (or package) is a collection of modules. Python ships with a large standard library — "batteries included" — so you rarely start from scratch. import math gives you math.sqrt() and math.pi; import datetime gives dates and times; import random gives shuffling and random choices. You can import a whole module (import math), specific names (from math import sqrt), or give it a nickname (import datetime as dt). Writing your own module is just saving functions in a .py file and importing it from another file in the same folder.

Beyond the standard library lies PyPI, the Python Package Index, with hundreds of thousands of third-party packages — requests for the web, matplotlib for charts, pygame for games. Install with pip install requests. Because different projects may need different versions of the same package, professionals isolate each project in a virtual environment: python -m venv venv creates one, and activating it keeps that project's packages separate from every other project's. A requirements.txt file (made with pip freeze > requirements.txt) records exactly which packages and versions a project needs, so anyone can reproduce your setup.

Real-world application: every professional Python project — from Instagram's backend to a data-science notebook — runs inside a virtual environment with a pinned requirements file, so "it works on my machine" becomes "it works on every machine."

Try it yourself: Use random to print a random number from 1 to 100, and use datetime to print how many days remain until your next birthday. Then create a module shapes.py with area_square(side) and import it. Answers: random.randint(1, 100); subtract datetime.date.today() from the birthday date and read .days.

Key vocabulary: Module — a reusable .py file; library/package — a collection of modules; PyPI — the public package index; pip — the package installer; virtual environment — an isolated per-project package setup; requirements.txt — a pinned list of a project's packages.

Lesson 13: Working with Data — CSV, JSON, and APIs

Real programs rarely work with data typed by hand — they read files and fetch data from the internet. CSV (comma-separated values) is the simplest table format: one row per line, columns separated by commas. Python's csv module reads it safely (handling quoted commas correctly, which a bare split(",") does not): csv.DictReader(f) turns each row into a dictionary keyed by the header row. JSON (JavaScript Object Notation) is the web's data format — it looks like Python lists and dictionaries, and json.load() / json.dump() convert between JSON text and Python objects.

An API (Application Programming Interface) is a URL that returns data instead of a web page. For example, a weather API might return {"city": "Boston", "temp_c": 18} as JSON. With the requests library (pip install requests), requests.get(url).json() fetches and parses that data in two lines. Always check the response status: 200 means success; 404 means not found. Many APIs need a free key and limit how many requests you can make — read their documentation first.

Real-world application: weather apps, stock tickers, sports scores, and map services all work by fetching JSON from APIs and displaying it — the same pattern you are learning here, at planetary scale.

Try it yourself: Write a CSV file with three friends' names and favorite numbers, read it with csv.DictReader, and print the average favorite number. Then use json.dumps to save a dictionary of your scores to a file. Answers: Convert each row's number with int() before averaging; json.dump(scores, open("scores.json", "w")) saves it.

Key vocabulary: CSV — comma-separated table format; JSON — the web's text data format; API — a URL that returns data; DictReader — a CSV reader yielding dictionaries; status code — a number like 200 (success) or 404 (not found) from a web request.

Lesson 14: Error Handling in Depth and Logging

Lesson 6 introduced try/except. Now go deeper: a full try block has four parts. try holds the risky code; except handles specific errors; else runs only if no error occurred (use it for the "success path" so the try stays small); finally always runs — ideal for closing files or network connections. Catch the most specific exception you can: except FileNotFoundError and except ValueError separately, rather than a bare except that hides every bug, including typos.

You can also raise your own exceptions when inputs break your function's contract: if age < 0: raise ValueError("Age cannot be negative"). For reusable checks, define a custom exception by subclassing Exception. And when something goes wrong in a long-running program, print() debugging is not enough — use the logging module: logging.warning("Low disk") writes timestamped messages with severity levels (DEBUG, INFO, WARNING, ERROR, CRITICAL) that you can send to a file instead of the screen.

Real-world application: web servers log every error with timestamps so engineers can diagnose outages at 3 a.m. without reproducing them — logging is how software explains itself.

Try it yourself: Write a function that reads an integer from the user, retrying up to 3 times on ValueError before giving up. Which clause runs whether or not an error occurs? Answers: Use a for loop with try/except ValueError: continue and a return on success; finally always runs.

Key vocabulary: else (in try) — runs only on success; finally — always runs; raise — deliberately trigger an exception; custom exception — your own Exception subclass; logging — timestamped, leveled diagnostic messages.

Lesson 15: Recursion and Functional Programming

Recursion is a function calling itself to solve smaller copies of a problem. Every recursive function needs two parts: a base case that stops the recursion, and a recursive step that moves toward it. The classic example: factorial(n) = n * factorial(n - 1) with base case factorial(0) = 1. Trace factorial(3): 3 * factorial(2) → 3 * (2 * factorial(1)) → 3 * (2 * (1 * factorial(0))) → 3 * 2 * 1 * 1 = 6. Each call waits on a stack of frames until the base case unwinds them. Python limits recursion depth (default 1000), so deep recursion raises RecursionError — iteration is often safer for very long sequences.

Functional programming treats functions as values: you can pass them to other functions. A lambda is a tiny anonymous function: lambda x: x ** 2. map() applies a function to every item (list(map(lambda x: x * 2, [1, 2, 3])) is [2, 4, 6]); filter() keeps items that pass a test (list(filter(lambda x: x % 2 == 0, [1, 2, 3, 4])) is [2, 4]); and sorted(names, key=len) sorts by a function. In modern Python, list comprehensions usually replace map/filter, but recognizing them matters because they appear throughout real code and other languages.

Real-world application: file-system search, JSON tree traversal, and directory-size tools are naturally recursive; data pipelines in libraries like pandas chain map-style transformations over millions of rows.

Try it yourself: Write recursive sum_list(nums) (base case: empty list → 0). What does list(map(lambda x: x ** 2, [2, 3])) give? Answers: return 0 if not nums else nums[0] + sum_list(nums[1:]); [4, 9].

Key vocabulary: Recursion — a function calling itself; base case — the stopping condition; recursive step — progress toward the base case; lambda — a tiny anonymous function; map / filter — apply-a-function / keep-matching-items; memoization — caching results to avoid recomputation.

Lesson 16: Object-Oriented Programming II — Inheritance, Polymorphism, and Dunder Methods

Lesson 10 built single classes. Real OOP adds three power tools. Inheritance lets a class reuse another: class Dog(Pet) inherits Pet's methods and can add or override its own. The child calls the parent's setup with super().__init__(name). Polymorphism ("many shapes") means different classes can share a method name and be used interchangeably: a Dog and a Cat both have speak(), so a loop can call animal.speak() on either without checking its type. Composition ("has-a" instead of "is-a") builds objects from other objects: a School has a list of Student objects.

Dunder methods (double-underscore, like __init__) let your objects behave like built-ins. Define __str__ to control print(), __len__ for len(), __eq__ for ==, and __add__ for +. A Vector class with __add__ can be added with v1 + v2 just like numbers. Encapsulation means an object guards its own data: methods like withdraw() enforce rules so outside code cannot put the object in an invalid state.

Real-world application: game engines model every character, item, and level as objects in inheritance hierarchies; web frameworks model database rows as objects with dunder-powered behavior.

Try it yourself: Create class SavingsAccount(BankAccount) (from Lesson 10) adding add_interest(rate). Then add __str__ to BankAccount showing the balance. What does super().__init__() do? Answers: It calls the parent class's __init__ so inherited setup still runs.

Key vocabulary: Inheritance — a class reusing a parent's behavior; super() — access to the parent class; polymorphism — different classes sharing a method name; composition — building objects from other objects; dunder method — a __name__ method giving built-in behavior; encapsulation — guarding an object's data behind methods.

Lesson 17: Testing, Style, and Code Quality

Professionals do not trust code that has not been tested. Test-driven development (TDD) flips the usual order: write a failing test first, then write the smallest code that passes it, then refactor. A test uses assert: assert add(2, 3) == 5 passes silently and raises AssertionError if wrong. For bigger projects, the pytest library (pip install pytest) discovers and runs test functions named test_* and reports exactly which failed. Good tests cover the happy path (normal input), edge cases (empty list, zero, negative numbers), and error cases (invalid input raises the right exception).

Style is part of quality. Python's style guide PEP 8 recommends: 4-space indentation, snake_case for functions and variables, CamelCase for classes, lines under 79–88 characters, and one blank line between functions. Docstrings (triple-quoted strings under def) explain what a function does, its parameters, and what it returns. Tools like black (auto-formatter) and flake8 (style checker) enforce style automatically — professionals let tools handle formatting so humans can focus on logic.

Real-world application: continuous-integration systems run a project's full test suite on every change; a single failing test blocks the release. Tests are a safety net that lets teams change code fearlessly.

Try it yourself: Write 3 tests for a function is_even(n) (even, odd, zero). What does TDD stand for, and which step comes first? Answers: assert is_even(4) is True; assert is_even(3) is False; assert is_even(0) is True; Test-Driven Development — the test comes first.

Key vocabulary: TDD — test-driven development (test first, then code); pytest — a popular test runner; happy path / edge case / error case — normal / boundary / invalid inputs; PEP 8 — Python's style guide; docstring — a function's built-in documentation.

Lesson 18: Turtle Graphics and Building a GUI

So far your programs have lived in the terminal. Turtle graphics — built into Python — lets you draw with code: a turtle moves around a canvas leaving a trail. import turtle; t = turtle.Turtle(); t.forward(100); t.left(90) draws two sides of a square. A for loop draws the whole square; change the turn angle and you get stars, spirals, and polygons. Turtle teaches state (the turtle's position and heading) and geometry in the most visible way possible: every bug shows up as a wrong picture.

For real applications, Python's built-in tkinter library builds windows with buttons, labels, and text boxes. The pattern: create a window, add widgets, and bind buttons to functions — when the user clicks, your function runs. This is event-driven programming: instead of running top-to-bottom, the program waits for events (clicks, keypresses) and responds. Every app on your phone works this way.

Real-world application: calculators, settings screens, and game menus are all event-driven GUIs — the same button-and-function pattern, with fancier widgets.

Try it yourself: Draw a hexagon with turtle (turn angle?). Add a "Reset" button to the counter that sets the count back to 0. Answers: Hexagon: 360 / 6 = 60 degrees; Reset button calls a function setting count = 0 and updating the label.

Key vocabulary: Turtle graphics — drawing by moving a virtual pen; tkinter — Python's built-in GUI library; widget — a GUI element (button, label, entry); event-driven programming — code that waits for and responds to events; mainloop — the event loop that keeps a GUI alive.

Lesson 19: Data Visualization and an Introduction to Data Science

Data science is the pipeline of collecting, cleaning, analyzing, and visualizing data to answer questions. The most powerful step is often visualization: a chart reveals patterns — trends, clusters, outliers — that a table of numbers hides. Python's matplotlib library (pip install matplotlib) makes line charts, bar charts, and scatter plots in a few lines. A line chart shows change over time; a bar chart compares categories; a scatter plot shows the relationship between two variables (for example, hours studied vs. test score).

Before charting, clean the data: handle missing values, fix inconsistent spellings, and convert text numbers to real numbers — real datasets are always messy. Then summarize: the mean (average), median (middle value), and mode (most common value) describe the center; the range and standard deviation describe the spread. Averages can mislead: one billionaire in a room of ten students makes the "average wealth" enormous while the median stays ordinary — always ask which summary fits.

Real-world application: election forecasts, sports analytics, public-health dashboards, and business reports all run this pipeline: clean → summarize → visualize → decide.

Try it yourself: Given [5, 8, 8, 9, 12], compute the mean and median. When would a bar chart beat a line chart? Answers: Mean = 42 / 5 = 8.4; median = 8; bar charts compare separate categories, line charts show change over time.

Key vocabulary: Data science — collecting, cleaning, analyzing, and visualizing data; visualization — charts that reveal patterns; matplotlib — Python's charting library; mean / median / mode — average / middle / most common value; outlier — an extreme value that distorts averages.

Lesson 20: Final Project — Build a Personal Finance Tracker

Your final project combines everything in this course: a Personal Finance Tracker that records income and expenses, sorts them by category, saves to a file, and shows a summary chart. Plan it as pieces before coding: (1) an Expense class (date, category, description, amount); (2) functions to add, list, and filter expenses; (3) JSON save/load for persistence; (4) a summary that totals spending by category; (5) a bar chart of spending by category with matplotlib; (6) a simple menu loop or tkinter GUI. Planning on paper first — classes, functions, file format — is what separates working programs from tangled ones.

Build in stages and test each stage: first the class and add/list functions with hard-coded data; then file saving; then the menu; then the chart. Use try/except around number parsing so a typo cannot crash the app, write docstrings for every function, and add at least five tests (adding, totaling, filtering, saving, loading). If a stage breaks, isolate it with a small test — the debugging strategy from Lesson 7.

Real-world application: budgeting apps like Mint and YNAB are this project at scale — the same classes, files, and summaries, plus bank connections and a polished interface. Your tracker is a genuine portfolio piece: put it on GitHub with a README explaining what it does and how to run it.

Try it yourself: Build the tracker in stages this week. As a final check: what happens if the JSON file is missing on first run, and how should your program handle it? Answers: json.load would raise FileNotFoundError — catch it and start with an empty list (the Lesson 6 pattern).

Key vocabulary: Portfolio project — a finished program demonstrating your skills; README — the file explaining a project; definition of done — the checklist a project must satisfy; persistence — saving data between runs.