Writing Python

Chapter 05 Functions, Logic, and Control Flow

In Phase 1 you learned to read code. Now you write it. This chapter covers the three building blocks that appear in every program: functions (reusable blocks), conditionals (decision points), and loops (repetition).

Functions

A function is like a recipe card in a kitchen: it has a name, a list of ingredients (parameters), and step-by-step instructions. You write the recipe once, then use it every time you need that dish. In code terms: you define it once, then call it whenever you need it. One function, one job.

def greet(name):
    return f"Hello, {name}!"

print(greet("World"))  # Hello, World!

def defines the function. name is a parameter—the input. return sends a value back. Defining a function does NOT run it; calling it does.

Comparison and Boolean Operators

Before your program can make decisions, it needs a way to ask yes-or-no questions. Comparison operators compare two values and produce a Boolean (True or False):

Boolean operators combine True/False values:

age = 25
has_license = True
can_drive = age >= 16 and has_license  # True

The in operator tests membership—whether a value exists inside a collection:

print("a" in "apple")     # True
print(3 in [1, 2, 3])     # True
print("quit" in "quilts") # True — checks substrings too

In TaskForge, you'll see patterns like if command == "add": using comparison operators and for task in tasks: using in to iterate. These operators are the glue that connects data to decisions—and they're the prerequisite for conditionals below.

Conditionals

if/elif/else lets your program choose a path. The program executes the first true branch and skips the rest.

Loops

for loops process each item in a collection. while loops repeat until a condition changes.

Scope

Variables defined inside a function are invisible outside it. This is called scope. It's a common source of bugs in AI-generated code—the AI sometimes references a variable that only exists inside another function.

Here's a concrete example. This function looks like it updates a counter, but it doesn't:

# BUG: this does NOT modify the outer variable
count = 0

def increment():
    count = count + 1  # UnboundLocalError!

increment()
print(count)  # never reached

Python sees count = ... inside the function and treats count as a local variable. But you're also trying to read count on the right side before it's been assigned locally—hence the error. The fix: pass the value in and return the result out.

# FIX: pass in, return out
count = 0

def increment(current):
    return current + 1

count = increment(count)
print(count)  # 1

Micro-Exercises

def greet(name):
    return f"Hello, {name}!"

print(greet("World"))

def is_positive(n):
    if n > 0:
        return True
    return False

for num in [1, 2, 3, 4, 5]:
    print(num * 10)

TaskForge Connection

Look at TaskForge's complete_task: it uses a for loop with an if conditional inside a function. Every concept from this chapter appears in that one function.

String Methods

Strings are everywhere—user input, file paths, API responses, log messages. Python gives you built-in methods to slice, clean, and reassemble them. You'll use these constantly when processing text data and parsing AI output.

f-strings

f-strings let you embed expressions directly inside a string. Prefix the string with f and put variables or expressions in curly braces:

name = "Alice"
tasks = 5
print(f"{name} has {tasks} tasks")  # Alice has 5 tasks
print(f"Double: {tasks * 2}")       # Double: 10

Essential String Methods

These methods return new strings—they never modify the original. Strings in Python are immutable.

raw = '  alice,bob,charlie  '
names = [name.strip().capitalize() for name in raw.strip().split(",")]
print(names)  # ['Alice', 'Bob', 'Charlie']

Interactive Exercises

Functions as Values: Higher-Order Functions and Closures

In Python, functions are first-class values — you can assign them to variables, pass them as arguments, and return them from other functions. AI generates these patterns constantly.

Built-in Higher-Order Functions

map(), filter(), and sorted() with a key function are the most common. Each takes a function as an argument:

# map: apply a function to every element
names = ["alice", "bob", "charlie"]
upper_names = list(map(str.upper, names))  # ["ALICE", "BOB", "CHARLIE"]

# filter: keep elements where function returns True
numbers = [1, 2, 3, 4, 5, 6]
evens = list(filter(lambda x: x % 2 == 0, numbers))  # [2, 4, 6]

# sorted with key: sort by a custom criterion
tasks = [{"title": "B task", "priority": 2}, {"title": "A task", "priority": 1}]
by_priority = sorted(tasks, key=lambda t: t["priority"])

Lambda Expressions

A lambda is an anonymous function — useful as a short, throwaway argument:

# Lambda: anonymous function for one-time use
square = lambda x: x ** 2  # equivalent to def square(x): return x ** 2

# Most useful as arguments to higher-order functions
sorted_tasks = sorted(tasks, key=lambda t: t["due_date"])

Rule of thumb: If a lambda is more than one expression, use a named function instead. Readability matters more than brevity.

In practice, PEP 8 recommends using def for named functions. Lambdas shine as inline arguments: sorted(names, key=lambda n: len(n)).

Closures

A closure is a function that remembers variables from the scope where it was defined:

def make_multiplier(n):
    def multiplier(x):
        return x * n  # 'n' is remembered from the outer scope
    return multiplier

double = make_multiplier(2)
triple = make_multiplier(3)
print(double(5))  # 10
print(triple(5))  # 15

AI generates closures in callbacks, event handlers, and factory patterns. Understanding them means you can read and debug these patterns when they appear.

Chapter 06 Data Structures — Lists, Dicts, and How Data Lives

Functions process data. But where does the data live? In data structures—containers that organize information. Two structures dominate Python and AI tooling: lists (ordered sequences) and dictionaries (key-value pairs).

Lists

A list is an ordered collection, indexed starting at 0:

signals = ["speed", "rpm", "fuel"]
print(signals[0])   # "speed"
print(signals[-1])  # "fuel" (last item)
signals.append("temp")  # adds to end

Dictionaries

A dictionary maps keys to values. This is THE most important structure for APIs and AI tools, because JSON (the universal data format) is essentially nested dictionaries.

warning = {"level": "critical", "system": "brakes"}
print(warning["level"])  # "critical"

Nested Structures

Real data is almost always nested—dicts containing lists containing dicts:

vehicles = [
    {"name": "eCanter", "type": "EV", "range_km": 200},
    {"name": "Super Great", "type": "diesel", "range_km": 800}
]
print(vehicles[0]["name"])  # "eCanter"

Choosing the Right Structure

TaskForge Connection

TaskForge stores tasks as a list of dictionaries: tasks = [{"id": 1, "description": "...", "status": "pending"}, ...]. This is the same pattern you'll see in every API response and every JSON file.

Micro-Exercises

nums = [10, 20, 30, 40, 50]
print(nums[2])  # 30

person = {"name": "Alice", "age": 30, "city": "Tokyo"}
print(person["city"])  # Tokyo

List Comprehensions

A list comprehension builds a new list in a single line. It's a compact alternative to a for loop that appends to a list. AI-generated Python uses comprehensions heavily, so you need to read them fluently.

Basic Syntax

[expression for item in iterable]

This reads as: "For each item in the iterable, evaluate expression and collect the results into a list."

With a Condition

[expression for item in iterable if condition]

This adds a filter: only items where condition is true get included.

Before and After

Here's the same logic written as a loop and as a comprehension:

# Loop version
squares = []
for n in range(5):
    squares.append(n ** 2)

# Comprehension version
squares = [n ** 2 for n in range(5)]
# Both produce: [0, 1, 4, 9, 16]

# Loop with filter
evens = []
for n in range(10):
    if n % 2 == 0:
        evens.append(n)

# Comprehension with filter
evens = [n for n in range(10) if n % 2 == 0]
# Both produce: [0, 2, 4, 6, 8]

names = ["alice", "bob", "charlie"]
upper = []
for name in names:
    upper.append(name.upper())

# Answer
upper = [name.upper() for name in names]

short = [w for w in ["hi", "hello", "hey", "greetings"] if len(w) <= 3]

# Answer
short = []
for w in ["hi", "hello", "hey", "greetings"]:
    if len(w) <= 3:
        short.append(w)
# Both produce: ["hi", "hey"]

Interactive Exercises

Chapter 07 Classes and Object-Oriented Basics

So far you've stored data in dictionaries and processed it with functions. That works—until your data and the functions that operate on it start drifting apart across your codebase. Classes solve this by bundling data and behavior into a single unit called an object.

What Is a Class?

A class is a blueprint for creating objects. Think of it like a cookie cutter: the class defines the shape, and each cookie you stamp out is an instance—an individual object created from that blueprint. The cookie cutter itself isn't a cookie; it's the template that produces cookies. Every cookie has the same shape, but each one can have different frosting (different data).

In programming terms: a class defines what attributes (data) and methods (behavior) every instance will have. Each instance gets its own copy of the data, but they all share the same methods.

Defining a Class

Here's the simplest useful class:

class Task:
    def __init__(self, title):
        self.title = title
        self.done = False

Let's break this down piece by piece:

• class Task: — declares a new class named Task. Class names use CamelCase by convention (not snake_case like functions).
• __init__ — the initializer (sometimes called the constructor). Python calls this automatically when you create a new instance. The double underscores (called "dunder") mark it as a special method.
• self — a reference to the specific instance being created. When you write self.title = title, you're saying "this particular object's title is whatever was passed in." Every method in a class receives self as its first parameter.
• self.title and self.done — these are instance attributes. Each Task object gets its own title and done.

Methods vs Functions

A method is a function that belongs to a class. The only syntactic difference: methods take self as their first parameter, which gives them access to the instance's data. A regular function stands alone; a method is attached to an object and operates on that object's data.

# Regular function — stands alone
def mark_done(task_dict):
    task_dict["done"] = True

# Method — belongs to the class, operates on self
class Task:
    def __init__(self, title):
        self.title = title
        self.done = False

    def mark_done(self):
        self.done = True

When you call task.mark_done(), Python automatically passes the instance as self. You don't write task.mark_done(task)—Python handles that.

Creating Instances

You create an instance by calling the class like a function:

task = Task("Buy groceries")
print(task.title)  # Buy groceries
print(task.done)   # False

Notice you pass "Buy groceries" but not self. Python fills in self automatically. Each call to Task(...) creates a brand-new, independent object.

Instance Attributes

Every instance carries its own data. Changing one object doesn't affect another:

task1 = Task("Buy groceries")
task2 = Task("Write report")

task1.mark_done()
print(task1.done)  # True
print(task2.done)  # False — completely independent

You access attributes with dot notation: task.title, task.done. This is the same syntax you've been using with strings ("hello".upper()) and lists (my_list.append(x))—because strings and lists are objects too.

A Complete Example

Here's a Task class with an initializer, a behavior method, and a string representation:

class Task:
    def __init__(self, title):
        self.title = title
        self.done = False

    def mark_done(self):
        self.done = True

    def __str__(self):
        status = "done" if self.done else "pending"
        return f"[{status}] {self.title}"

# Usage
task = Task("Buy groceries")
print(task)          # [pending] Buy groceries
task.mark_done()
print(task)          # [done] Buy groceries

__str__ is another dunder method. Python calls it automatically when you print() an object or convert it to a string. Without it, printing a Task would show something unhelpful like <__main__.Task object at 0x...>.

Inheritance Basics

Sometimes you need a class that's almost like an existing class, but with a few extras. Inheritance lets you create a new class that builds on an existing one. The new class (called the child or subclass) inherits all attributes and methods from the existing class (the parent or superclass) and can add or override them.

Here's a PriorityTask that extends Task with a priority field:

class PriorityTask(Task):
    def __init__(self, title, priority="medium"):
        super().__init__(title)
        self.priority = priority

    def __str__(self):
        status = "done" if self.done else "pending"
        return f"[{status}] ({self.priority}) {self.title}"

The parentheses in class PriorityTask(Task) mean "PriorityTask inherits from Task." The super().__init__(title) call runs the parent's __init__, so the child gets self.title and self.done without duplicating that code. Then the child adds its own self.priority.

PriorityTask gets mark_done() for free—it inherits it from Task. But it overrides __str__ with its own version that includes the priority. This is the core idea: reuse what works, change only what's different.

task = PriorityTask("Fix login bug", "high")
print(task)          # [pending] (high) Fix login bug
task.mark_done()
print(task)          # [done] (high) Fix login bug
print(task.done)     # True — inherited from Task

When to Use Classes vs Dictionaries

Classes and dictionaries both store data. The question is: does your data need behavior?

Rule of thumb: start with dictionaries. When you find yourself writing multiple functions that all take the same dictionary as their first argument, that's a sign the data and behavior want to live together in a class.

Common Misconceptions

TaskForge Connection

TaskForge v0.1 stores tasks as dictionaries in a list. This works, but notice how functions like complete_task and add_task all operate on the same dictionary structure. That's a signal that a class might be a better fit. Here's the before and after, side by side:

# TaskForge v0.1 — dictionary-based
task = {
    "id": 1,
    "title": "Buy groceries",
    "status": "pending"
}

def complete_task(tasks, task_id):
    for t in tasks:
        if t["id"] == task_id:
            t["status"] = "done"
            return True
    return False

# TaskForge refactored — class-based
class Task:
    def __init__(self, task_id, title):
        self.id = task_id
        self.title = title
        self.status = "pending"

    def complete(self):
        self.status = "done"

    def to_dict(self):
        return {
            "id": self.id,
            "title": self.title,
            "status": self.status
        }

# Usage
task = Task(1, "Buy groceries")
task.complete()
print(task.to_dict())
# {"id": 1, "title": "Buy groceries", "status": "done"}

The class version keeps data and behavior together. task.complete() is clearer than complete_task(tasks, task_id) because the task itself knows how to mark itself done. The to_dict() method means JSON serialization still works—you get the best of both worlds.

Micro-Exercises

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    def bark(self):
        return f"{self.name} says Woof!"

dog = Dog("Rex", "Labrador")
print(dog.bark())   # Rex says Woof!
print(dog.breed)    # Labrador

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        self.balance += amount
        return self.balance

    def withdraw(self, amount):
        if amount > self.balance:
            return "Insufficient funds"
        self.balance -= amount
        return self.balance

account = BankAccount("Alice", 100)
print(account.deposit(50))    # 150
print(account.withdraw(30))   # 120
print(account.withdraw(200))  # Insufficient funds

Interactive Exercises

Decorators: Functions That Modify Functions

A decorator is a function that takes a function and returns a modified version. The @decorator syntax is shorthand:

# This:
@app.route("/tasks")
def get_tasks():
    pass

# Is equivalent to:
def get_tasks():
    pass
get_tasks = app.route("/tasks")(get_tasks)

You'll see decorators constantly in later chapters — @app.route() in Flask, @staticmethod in classes, @pytest.fixture in tests. AI generates decorated functions constantly. Here's how to build one:

import time

def timer(func):
    """Decorator that prints how long a function takes."""
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        print(f"{func.__name__} took {elapsed:.4f}s")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(0.1)
    return "done"

slow_function()  # Prints: slow_function took 0.1001s

Production decorators should also use @functools.wraps(func) to preserve the original function's name and docstring. We skip that for simplicity here.

Chapter 08 Files, Modules, and the Standard Library

So far, your data disappears when the program ends. Files make data persist. Modules let you organize code across multiple files. The standard library gives you hundreds of pre-built tools.

Reading and Writing Files

# Write
with open("data.txt", "w") as f:
    f.write("Hello, file!")

# Read
with open("data.txt", "r") as f:
    content = f.read()
    print(content)  # Hello, file!

The with statement (a context manager) automatically closes the file when you're done. Always use it.

JSON: The Universal Data Format

JSON (JavaScript Object Notation) is how AI tools and APIs exchange data. It looks almost identical to Python dictionaries:

import json

# Dict to JSON string
data = {"name": "TaskForge", "version": "0.1"}
json_string = json.dumps(data, indent=2)

# JSON string to dict
parsed = json.loads(json_string)

# Dict to JSON file
with open("config.json", "w") as f:
    json.dump(data, f, indent=2)

# JSON file to dict
with open("config.json", "r") as f:
    loaded = json.load(f)

Modules and Imports

A module is a .py file containing functions—think of it like a toolbox. Instead of carrying every tool everywhere, you import just the toolbox you need for the current job:

import json          # entire module
from pathlib import Path  # one thing from a module

The if __name__ == "__main__": pattern (which you saw in TaskForge) means "only run this block when the file is executed directly, not when it's imported."

TaskForge Connection

In Phase 2's gate exercise, you'll add save_tasks(filepath) and load_tasks(filepath) to TaskForge using json.dump and json.load. Tasks will survive between sessions.

Micro-Exercises

with open("hello.txt", "w") as f:
    f.write("Hello!")

with open("hello.txt", "r") as f:
    print(f.read())  # Hello!

import json
data = {"name": "test", "count": 5}
print(json.dumps(data, indent=2))

Interactive Exercises

Chapter 09 Error Handling, Debugging, and Testing

Code breaks. That's normal. What separates professionals from beginners is how they handle and prevent breakage. This chapter covers three tools: try/except (handling errors gracefully), debugging (finding what went wrong), and testing (proving your code is correct).

Try/Except

try:
    task_id = int(input("Task ID: "))
except ValueError:
    print("Please enter a number.")

Without try/except, invalid input crashes your program. With it, you handle the error gracefully. Always catch specific exceptions—never write bare except:.

Debugging

When something goes wrong, read the stack trace from the bottom up. The last line tells you the error type and message. The lines above show you where it happened.

Testing with Assert

An assertion is a statement that must be true. If it's false, the program crashes—which is exactly what you want in a test.

assert 2 + 2 == 4      # passes silently
assert 2 + 2 == 5      # AssertionError!

pytest

Put tests in files named test_*.py. Run them: python3 -m pytest. pytest discovers and runs all test functions.

# test_math.py
def test_addition():
    assert 2 + 2 == 4

def test_string_concat():
    assert "hello " + "world" == "hello world"

TaskForge Connection

TaskForge v0.1 has no error handling—int(input("Task ID: ")) crashes on non-numeric input. In the Phase 2 Gate, you'll fix this and write tests proving it works.

Micro-Exercises

try:
    print(1 / 0)
except ZeroDivisionError:
    print("Cannot divide by zero")

Interactive Exercises

Phase 2 Gate Checkpoint & TaskForge Extension

def filter_tasks(tasks, status):
    # Return a list of tasks where task["status"] == status
    pass  # replace with one line

def save_tasks(tasks, filepath):
    # Open filepath for writing, then json.dump(tasks, f, indent=2)
    pass

def load_tasks(filepath):
    # Try to open and json.load(). If FileNotFoundError, return []
    pass

TaskForge Checkpoint

TaskForge now has filtering, persistence (JSON), and tests. Still a single directory with no git, no structure. Phase 3 fixes that.

What You Can Now Do