Python Examples Library

A useful example answers one concrete question with clear inputs and outputs. Before copying one, identify:

• Input: what data does it expect, in what shape? A list of (item, quantity) tuples is different from a dictionary.
• Output: does it return a value, print, or change something in place?
• Assumptions: does it assume no negative quantities, unique names, sorted data, a file that exists?

Copying a program without its assumptions is a common source of bugs: an example that assumes quantities are integers will silently misbehave when your data contains "3" as text.

Trace an example by hand before running it: write down each variable's value after each line. For equipment_report above:

item     quantity   totals
cones    3          {'cones': 3}
lamps    2          {'cones': 3, 'lamps': 2}
cones    4          {'cones': 7, 'lamps': 2}

Then run the code and compare. If your prediction was wrong, you've found exactly the part you didn't understand, which is far more useful than reading a correct output.

Output alone can hide behaviour. A function might print the right total but also change the list it was given, or keep state between calls. Add print() calls or use the = specifier, print(f"{totals=}"), at key points, or step through with the debugger, to see what happens inside, not just what comes out.

Once an example works, change one meaningful assumption and predict the result before running it:

• Add an item that appears once: does it show up correctly?
• Pass an empty list: does it return {} or crash?
• Add a negative quantity, representing a returned item: is that allowed or should it raise an error?
• Use mixed capitalisation, "Cones" and "cones": should they be counted together?

print(equipment_report([]))                               # {}
print(equipment_report([("Cones", 1), ("cones", 2)]))     # counted separately

Each variation tests one idea. Changing several details at once makes it impossible to tell which change caused a difference. If a variation reveals behaviour you don't want, such as separate counts for "Cones" and "cones", fix it explicitly and add the case to your tests.

Real programs are built by joining small, well-defined functions. Each function should take its inputs as parameters and return its result, rather than reading or changing global variables, so pieces can be combined and tested independently:

def parse_requests(lines):
    for line in lines:
        item, qty = line.split(",")
        yield item.strip().lower(), int(qty)

def format_report(totals):
    return "\n".join(f"{item:<8}{qty:>3}" for item, qty in sorted(totals.items()))

lines = ["Cones, 3", "lamps,2", "cones, 4"]
print(format_report(equipment_report(parse_requests(lines))))

parse_requests cleans the text, equipment_report counts, and format_report presents. Each can be tested on its own, and replacing one, such as reading from a CSV file instead of a list, doesn't affect the others. A function that depends on an unexplained global variable can't be reused this way, because it only works in the program it was written in.

Task: build an original mini library of counting, filtering, formatting, file parsing and class-based examples with one documented assumption each. Start from this template:

"""Equipment examples. Each function states one assumption."""

def count_items(names):
    """Assumes names are already lower-case."""
    counts = {}
    for name in names:
        counts[name] = counts.get(name, 0) + 1
    return counts

def available(stock, minimum):
    """Assumes quantities are integers."""
    return sorted(item for item, qty in stock.items() if qty >= minimum)

def label(item, qty):
    """Assumes qty is non-negative."""
    return f"{item.title():<10}{qty:>4}"

print(count_items(["cones", "bibs", "cones"]))     # {'cones': 2, 'bibs': 1}
print(available({"cones": 20, "nets": 1}, 5))      # ['cones']
print(label("cones", 20))                          # Cones       20

Add a CSV-parsing function and a class of your own, each with its assumption, then write one variation test per function. For the worked check, before adapting an example you should identify its inputs, outputs and assumptions.

The official Python tutorial contains many runnable examples. Continue with coding challenges and practice problems, and try the Python exercises and Python quiz.