Learn Python
through a real program

Two import styles

import json imports the whole module — you then write json.dumps() to call it. The module name acts as a namespace, so there are no name collisions.

from pathlib import Path imports just the Path class directly into your namespace. You write Path("file.txt") instead of pathlib.Path("file.txt").

Line-by-line

• json Built-in JSON encoder/decoder — serialize Python objects to strings and back.
• functools Higher-order functions: wraps, reduce, lru_cache, partial.
• datetime Dates, times, and time arithmetic.
• Path Object-oriented file-path manipulation — much cleaner than os.path.
• dataclass Decorator that auto-generates __init__, __repr__, __eq__ from annotations.
• Optional Type hint: Optional[str] means the value can be str or None.
• Counter Dict subclass that auto-counts hashable objects.

Three collection types in one block

This section uses three different collection types on purpose — each chosen for its properties:

Dict comprehension

The last line builds a dict from the COLOURS tuple using a dict comprehension:

C = {name: code for name, code in COLOURS}

This is equivalent to a for loop that calls d[name] = code — but in one expressive line.

How a decorator works

@log_errors above def add() is syntactic sugar for:

add = log_errors(add)

The original add function is replaced by wrapper, which calls the original inside a try/except.

• *args Collects all extra positional arguments into a tuple. The * "unpacks" them when calling the original function.
• **kwargs Collects all keyword arguments into a dict. The ** unpacks them on call.
• @wraps Copies __name__, __doc__ from func to wrapper. Without it, every decorated function looks like "wrapper" in tracebacks.
• as e Binds the exception object to the name e so you can print or inspect it.

def add(self, title):
    try:
        # actual logic
        ...
    except (ValueError, KeyError) as e:
        print(f"Error: {e}")

def remove(self, idx):
    try:
        ...
    except (ValueError, KeyError) as e:
        print(f"Error: {e}")

Field declarations

Each line is a field: name: type = default. Fields without a default are required arguments to Task(). Fields with a default are optional.

Special methods (dunders)

• __str__Called by print(obj) and str(obj). Should return a human-readable string.
• __repr__Called by repr(obj) and in the interactive console. Should be unambiguous and ideally eval-able.
• @classmethodReceives the class (cls) as the first arg instead of an instance (self). Used as an alternate constructor here: Task.from_dict(data).

Lambda as default factory

lambda: datetime.datetime.now().strftime("%Y-%m-%d") is an anonymous zero-argument function. It's called each time a Task is created, capturing the current date at that moment.

Class vs instance variables

@property — computed attribute

book.stats looks like an attribute access but runs a function. The caller writes book.stats (not book.stats()), which makes the API cleaner and hides implementation details.

Generator — yield

pending() uses yield. This makes it a generator function. Nothing is computed until the caller iterates: for task in book.pending():. Values are produced lazily — one at a time — saving memory.

Context manager — with open()

with open(...) as f: guarantees the file is closed even if an exception occurs. It calls f.__enter__() on entry and f.__exit__() on exit.

Lambda in sorted()

sorted(self.tasks, key=lambda t: priority_order.get(t.priority, 99)) — the key= argument is called on each element to produce the value to sort by. lambda t: ... is an anonymous function: "given task t, return..."

Default arguments

def display_tasks(tasks, heading="Tasks") — heading has a default value. Callers can omit it: display_tasks(book.tasks) works fine.

enumerate() — never use range(len())

for i, task in enumerate(tasks, start=1): gives both the index (1-based here) and the value. Idiomatic Python: never write for i in range(len(lst)): lst[i].

List comprehension as filter+transform

parse_tags turns "work, home , URGENT" into ['work', 'home', 'urgent'] in one line:

[t.strip().lower() for t in raw.split(",") if t.strip()]

Pattern: [expr for item in iterable if condition]

or as a default fallback

return raw or default — if raw is any falsy value (empty string, None, 0, empty list), the expression short-circuits and returns default. This is extremely common Python idiom.

Functions as first-class objects

In Python, functions are objects like any other. They can be stored in a dict — this is the dispatch table pattern:

dispatch = {"a": run_add, "l": run_list, ...}

Instead of a long if/elif chain, you look up and call: dispatch[cmd](book). Adding a new command only requires adding one line to the dict.

match / case (Python 3.10+)

• case "q"Exact string match — only matches the string "q".
• case "" | "?"OR pattern — matches either the empty string or "?".
• case cmd if…Capture + guard. Assigns input to cmd, then checks the guard condition. Only matches when both succeed.
• case _Wildcard — matches anything not caught above. Like default in other languages.

while True / break

An infinite loop that runs until a break statement exits it. This is the standard pattern for "keep running until the user quits." The break happens inside case "q".

How Python sets __name__

Without this guard, importing taskbook anywhere would immediately launch the interactive menu — which is never what you want.

Why define main() at all?

You could put all the code at the top level without a main() function. But wrapping it in main() means all your variables are local (faster, no global namespace pollution) and the code is testable.