🗃️ Modules & Structure

Import math and print the square root of 16 and 25 → 4.0 then 5.0.

import math
print(math.sqrt(16))
print(math.sqrt(25))

Keep the calculation in add_all(numbers) and the wording in show(value) — two separate concerns, two separate functions. Use [4, 5, 6] and print the raw total, then the pretty line.

def add_all(numbers):
    return sum(numbers)

def show(value):
    return "Total is: " + str(value)

total = add_all([4, 5, 6])
print(total)
print(show(total))

Group two related helpers into one class that acts like a "text tools" module: loud(text) returns it in capitals and quiet(text) returns it in lowercase. Print loud("hello") then quiet("HELLO").

class TextTools:
    def loud(self, text):
        return text.upper()

    def quiet(self, text):
        return text.lower()

tools = TextTools()
print(tools.loud("hello"))
print(tools.quiet("HELLO"))

Python ships with hundreds of ready-made modules. Import statistics and print the mean, median and mode of [4, 1, 4, 9, 2]. Never write code that already exists!

import statistics

data = [4, 1, 4, 9, 2]
print(statistics.mean(data))
print(statistics.median(data))
print(statistics.mode(data))

Random results make testing impossible — unless you seed them. Import random, call random.seed(42), then print three dice rolls. Run it twice: identical every time, which is exactly what tests need.

import random

random.seed(42)
for roll in range(3):
    print(random.randint(1, 6))

Split a program in two: calculate_total(prices, tax) that only does math and returns a number, and show_total(total) that only prints. Call them together for [10, 20] with 10% tax. The logic function must contain no print at all — that is what makes it testable.

def calculate_total(prices, tax_rate):
    subtotal = sum(prices)
    return subtotal + subtotal * tax_rate

def show_total(total):
    print(f"Total: ${total:.2f}")

show_total(calculate_total([10, 20], 0.10))

Write a mini app with clearly separated sections: data (get_students() returning a list of dicts), logic (top_student(students)), and display (show(student)). Wire them together in one line at the bottom. Each function should do exactly one job.

# --- data layer ---
def get_students():
    return [
        {"name": "Ana", "score": 88},
        {"name": "Ben", "score": 94},
        {"name": "Cy", "score": 71},
    ]

# --- logic layer ---
def top_student(students):
    return max(students, key=lambda s: s["score"])

# --- display layer ---
def show(student):
    print(f"Top: {student['name']} with {student['score']}")

show(top_student(get_students()))

Code inside if __name__ == "__main__": runs only when the file is run directly, not when another file imports it — so your module can be a tool and a library. Write add(a, b), print __name__, and put a demo call inside the guard.

def add(a, b):
    return a + b

print(__name__)

if __name__ == "__main__":
    print(add(2, 3))

Design a temperature mini-module: c_to_f, f_to_c, and describe(celsius) returning "freezing" (≤0), "cold" (<15), "mild" (<25) or "hot". Every function must be pure — no printing. Then, under a __main__ guard, print a small demo table for −5, 10, 20 and 30 °C.

def c_to_f(celsius):
    return celsius * 9 / 5 + 32

def f_to_c(fahrenheit):
    return (fahrenheit - 32) * 5 / 9

def describe(celsius):
    if celsius <= 0:
        return "freezing"
    if celsius < 15:
        return "cold"
    if celsius < 25:
        return "mild"
    return "hot"

if __name__ == "__main__":
    for c in [-5, 10, 20, 30]:
        print(f"{c}C = {c_to_f(c):.1f}F ({describe(c)})")