Lesson 9: One Tool, Infinite Uses

Part 1

Specific vs. General

In Lesson 8, we built functions like enthusiastic_reply() and sarcastic_reply(). Each one did one specific thing. That's useful — but what if you could build one function that handles all response styles?

Think about a real Swiss Army knife. Instead of carrying a separate knife, screwdriver, bottle opener, and scissors, you carry one tool that adapts based on what you need. That's generalization — creating solutions that work across many situations.

You already do this in life. When someone asks "how do I get to the store?" you don't have a memorized script for every possible store. You have a general skill — giving directions — that works for any destination. You adapt the details (left on Queens Boulevard, right on Austin Street) but the process is always the same.

Today, we're going to make our functions general-purpose — one tool, infinite uses.

Part 2

Parameters With Backup Plans

Sometimes you want a function to work even if the user doesn't provide every detail. That's what default parameters do — they give a parameter a backup value:

# width has a default value of 20
def make_bar(value, max_value, width=20):
    filled = int((value / max_value) * width)
    return "█" * filled + "░" * (width - filled)

# Use the default width (20)
print("Default: " + make_bar(7, 10))

# Override the default with a custom width
print("Wide:    " + make_bar(7, 10, 30))
print("Narrow:  " + make_bar(7, 10, 10))

# The first two parameters are still required
# make_bar(7) would cause an error — max_value has no default

How Default Parameters Work

def make_bar(value, max_value, width=20): — the =20 means "if nobody provides a width, use 20."

make_bar(7, 10) — we didn't give a width, so Python uses the default: 20.

make_bar(7, 10, 30) — we gave a width, so Python uses 30 instead of the default.

Default parameters must come after required parameters. You can't have def f(a=1, b): — Python wouldn't know which argument is which.

Part 3

One Function, Many Behaviors

In Lesson 8, we had separate functions for each response style. Let's generalize — one function that takes the style as a parameter:

import random

def respond(name, message, style="friendly"):
    if style == "enthusiastic":
        reactions = ["OMG", "NO WAY", "YESSS"]
        return f"{name}: {random.choice(reactions)}!! 🔥🔥"
    elif style == "sarcastic":
        comebacks = ["wow how original", "cool story", "shocking"]
        return f"{name}: ...{random.choice(comebacks)} 🙄"
    elif style == "supportive":
        support = ["So proud of you!", "You deserve it!", "Amazing!"]
        return f"{name}: {random.choice(support)} 💙"
    elif style == "chill":
        return f"{name}: nice 👍"
    else:
        return f"{name}: That's cool! 😊"

# ONE function, FIVE different behaviors
print(respond("Lena", "I got an A", "enthusiastic"))
print(respond("Sam", "I got an A", "sarcastic"))
print(respond("Zoe", "I got an A", "supportive"))
print(respond("Arielle", "I got an A", "chill"))
print(respond("Aidan", "I got an A"))  # uses default: "friendly"

Why This Is Better

In Lesson 8, we had five separate functions. Now we have one function that handles all five styles.

Adding a new style? Just add another elif. No new function needed.

The default style="friendly" means you don't even have to specify a style if you just want the basic version. The function adapts to what you give it.

Part 4

Adding Levels of Intensity

Let's take generalization further. What if a function could adjust how intense its output is? Think about how you adjust your communication based on the situation — you roast your best friend harder than someone you just met.

import random

def compliment(name, intensity="medium"):
    if intensity == "mild":
        options = [
            f"{name} is pretty cool.",
            f"{name}, you're alright!",
            f"Hey {name}, nice job."
        ]
    elif intensity == "medium":
        options = [
            f"{name} is genuinely awesome!",
            f"The world is better with {name} in it!",
            f"{name}, you're a real one. 💯"
        ]
    elif intensity == "spicy":
        options = [
            f"{name} is literally the greatest human alive and I will not be taking questions!! 🔥🔥🔥",
            f"If {name} isn't in your life, you're doing it WRONG!! 🏆✨💫",
            f"EVERYONE STOP WHAT YOU'RE DOING AND APPRECIATE {name.upper()} RIGHT NOW!! 🎉🎉🎉"
        ]
    else:
        return f"{name} is nice."
    
    return random.choice(options)

print(compliment("Lena", "mild"))
print(compliment("Lena", "medium"))
print(compliment("Lena", "spicy"))

Same function, same friend, but the intensity dial changes the output dramatically. This is generalization — one tool that adapts.

Part 5

The Friendly Roast Generator

Now let's build the fun part — a roast generator that adjusts based on the target's name, their quirk, and how hard you want to go:

import random

def roast(name, quirk, level="mild"):
    if level == "mild":
        templates = [
            f"{name} is the kind of person who {quirk}... and honestly? We let it slide.",
            f"We don't talk about {name}'s habit of {quirk}. It's fine. Everything's fine.",
            f"{name} {quirk}. That's the whole joke."
        ]
    elif level == "medium":
        templates = [
            f"Imagine being {name} and thinking it's OK to {quirk}. Couldn't be me. 😂",
            f"Scientists are still trying to figure out why {name} insists on {quirk}.",
            f"{name} has two modes: {quirk}, and sleeping. That's it."
        ]
    elif level == "spicy":
        templates = [
            f"BREAKING NEWS: {name} caught {quirk} AGAIN. Area residents unsurprised. 📰",
            f"If '{quirk}' was an Olympic sport, {name} wouldn't just win gold — they'd be the ENTIRE Olympics. 🥇",
            f"Nobody: \nAbsolutely nobody: \n{name}: *{quirk} with full confidence* 😭😭😭"
        ]
    else:
        return f"{name} does stuff. Whatever."
    
    return random.choice(templates)

# Test it out
name = "Lena"
quirk = "talks to their plants"

print("ROAST INTENSITY TEST")
print("═" * 40)
print()
print("🟢 MILD:")
print(roast(name, quirk, "mild"))
print()
print("🟡 MEDIUM:")
print(roast(name, quirk, "medium"))
print()
print("🔴 SPICY:")
print(roast(name, quirk, "spicy"))

Try changing the name and quirk. "Sam" who "eats cereal for dinner." "Zoe" who "takes 200 selfies before posting one." The same function handles any combination.

Part 6

Generalize Even Further: Mode Switch

What if the same function could do both roasts AND compliments? We just add another parameter — a mode:

import random

def generate(name, trait, mode="compliment", level="medium"):
    if mode == "compliment":
        if level == "mild":
            options = [f"{name} is good at {trait}.", f"{name}, solid {trait} skills."]
        elif level == "medium":
            options = [f"{name}'s {trait} game is seriously impressive!", f"Everyone wishes they could {trait} like {name}."]
        else:
            options = [f"IF YOU'RE NOT FOLLOWING {name} FOR THEIR {trait.upper()} YOU ARE MISSING OUT ON LIFE ITSELF 🔥🔥🔥", f"{name}'s {trait} is a gift to humanity and I WILL die on this hill!! 💯✨"]
    
    elif mode == "roast":
        if level == "mild":
            options = [f"{name} tries really hard at {trait}. Bless.", f"{name} and {trait}... it's a journey."]
        elif level == "medium":
            options = [f"Someone needs to tell {name} that {trait} isn't their calling. 😬", f"{name} thinks they're amazing at {trait}. The delusion is almost inspiring."]
        else:
            options = [f"BREAKING: {name} has been BANNED from {trait} for the safety of the general public 📰", f"{name}'s {trait} is so bad it should be classified as a war crime 😭😭"]
    else:
        return f"{name} exists. That's all we know."
    
    return random.choice(options)

# Same function, different modes
name = "Lena"
trait = "soccer"

print(f"About {name}'s {trait}:")
print("═" * 40)
print()
print("😊 Compliment (mild):  " + generate(name, trait, "compliment", "mild"))
print("😊 Compliment (spicy): " + generate(name, trait, "compliment", "spicy"))
print()
print("😈 Roast (mild):       " + generate(name, trait, "roast", "mild"))
print("😈 Roast (spicy):      " + generate(name, trait, "roast", "spicy"))

The Power of Parameters

We now have one function that handles: 2 modes × 3 levels = 6 different behaviors, each with multiple random options.

The function signature tells us everything: generate(name, trait, mode, level) — give it a person, a trait, whether to roast or compliment, and how intense.

This is the heart of generalization: what changes? Those things become parameters. What stays the same? That's the function body.

Part 7

Building a Toolkit

Good programmers build a toolkit of general-purpose functions they can reuse in any project. Let's build some:

def header(text, char="═", width=35):
    """Display a formatted header."""
    line = char * width
    print(line)
    print(f"  {text}")
    print(line)

def bar(value, max_val, width=15, filled_char="█", empty_char="░"):
    """Create a visual bar."""
    fill = int((value / max_val) * width)
    return filled_char * fill + empty_char * (width - fill)

def stars(rating, max_rating=5):
    """Convert a rating to stars."""
    full = int(rating)
    empty = max_rating - full
    return "★" * full + "☆" * empty

def center(text, width=35):
    """Center text in a given width."""
    spaces = (width - len(text)) // 2
    return " " * spaces + text

# Now use the toolkit!
header("MY GAME CHARACTER")
print(f"  Name: Shadow")
print(f"  Health: {bar(8, 10)} 8/10")
print(f"  Energy: {bar(5, 10)} 5/10")
print(f"  Stealth: {stars(4)}")
print(f"  Combat:  {stars(3)}")
print()
header("REVIEW", char="─")
print(center("⭐ LEGENDARY PLAYER ⭐"))
print()

New Thing · Docstrings

The text in triple quotes """...""" right after def is called a docstring. It describes what the function does. Python ignores it when running the code, but it helps anyone reading your code understand the function's purpose.

Notice how bar() and header() have default parameters for everything except the essential values. You can customize them, but you don't have to. That's the Swiss Army knife principle — works out of the box, but adapts when you need it.

Part 8

The Complete Roast & Compliment Generator

import random

# === TOOLKIT ===

def header(text, char="═", width=35):
    print(char * width)
    print(f"  {text}")
    print(char * width)

def generate(name, trait, mode="compliment", level="medium"):
    if mode == "compliment":
        mild = [
            f"{name} is pretty good at {trait}.",
            f"{name}, not bad at {trait}!"
        ]
        medium = [
            f"{name}'s {trait} is genuinely impressive!",
            f"Everyone could learn from {name}'s {trait}.",
            f"{name} + {trait} = perfection."
        ]
        spicy = [
            f"NOBODY on this PLANET does {trait} like {name}!! I said what I said!! 🔥🔥",
            f"{name}'s {trait} brings me to TEARS of joy every single time 😭✨💯",
            f"The fact that {name} exists and does {trait} is proof the universe is kind!! 🌟"
        ]
    else:
        mild = [
            f"{name} and {trait}... at least they try.",
            f"Bless {name}'s heart for attempting {trait}."
        ]
        medium = [
            f"Someone needs to stage an intervention for {name}'s {trait}. 😬",
            f"{name} thinks they're great at {trait}. Nobody tell them.",
            f"If {trait} was easy, {name} would still struggle. 💀"
        ]
        spicy = [
            f"ALERT: {name} spotted doing {trait} AGAIN. This is not a drill. Run. 🚨🚨",
            f"{name}'s {trait} is the reason aliens won't visit Earth 👽😭",
            f"In a world of people who can {trait}, {name} chose chaos 💀💀💀"
        ]
    
    if level == "mild":
        return random.choice(mild)
    elif level == "spicy":
        return random.choice(spicy)
    else:
        return random.choice(medium)

# === MAIN PROGRAM ===

header("🎤 ROAST & COMPLIMENT GENERATOR")
print()

name = input("Enter a friend's name: ")
trait = input("Something they do or are known for: ")

print()
header("CHOOSE YOUR MODE", char="─")
print("  1 — Compliment 😊")
print("  2 — Roast 😈")
print("  3 — Both! 😊😈")
mode_choice = input("Your choice (1/2/3): ")

print()
header("CHOOSE INTENSITY", char="─")
print("  1 — Mild 🟢")
print("  2 — Medium 🟡")
print("  3 — Spicy 🔴")
print("  4 — All levels!")
level_choice = input("Your choice (1/2/3/4): ")

levels = {"1": "mild", "2": "medium", "3": "spicy"}
level_emojis = {"mild": "🟢", "medium": "🟡", "spicy": "🔴"}

print()
header(f"RESULTS FOR {name.upper()}")
print()

if level_choice == "4":
    level_list = ["mild", "medium", "spicy"]
else:
    level_list = [levels.get(level_choice, "medium")]

for level in level_list:
    emoji = level_emojis[level]
    
    if mode_choice == "1" or mode_choice == "3":
        print(f"  {emoji} Compliment ({level}):")
        print(f"  {generate(name, trait, 'compliment', level)}")
        print()
    
    if mode_choice == "2" or mode_choice == "3":
        print(f"  {emoji} Roast ({level}):")
        print(f"  {generate(name, trait, 'roast', level)}")
        print()

header("Run again for different results! 🎲")

Try mode "3" (both) and intensity "4" (all levels) to see the full range. Same friend, same trait — six completely different outputs, all from one function.

Part 9

What You Just Did

You learned to build functions that aren't locked into one specific behavior. By adding parameters — mode, intensity level, style — a single function can handle many different situations.

That's generalization.

This is one of the most important ideas in all of thinking: instead of creating a separate solution for every situation, ask "What changes between situations?" Make those things the inputs, and keep everything else the same.

It's how one recipe becomes infinite meals (change the protein, change the spice, change the sauce). It's how one formula in math works for any number. It's how one app serves millions of different users.

The Big Idea

When you build a solution, ask: "What if the inputs were different? Would this still work?" If not, figure out what would need to change and make those things parameters. The most powerful tools are the ones that adapt to any situation.

Thinking Questions

What's the difference between a specific solution ("make Lena a birthday card") and a general solution ("make anyone a birthday card given their name and age")?
When is it better to have a specific function versus a general one? (Hint: sometimes simpler is better.)
Can you think of a real-world tool that's "general purpose"? What makes it adaptable?

Challenges

Level Up

Challenge 1 · Universal Greeting

Create a greet(name, language="english", formality="casual") function that generates greetings in different languages (English, Spanish, French) at different formality levels (casual, polite, formal). One function, many combinations.

Challenge 2 · Story Generator

Build a tell_story(hero, villain, setting, genre="adventure") function that creates a short 3-sentence story. Different genres (adventure, mystery, comedy, sci-fi) should produce different styles. Use default parameters so it works even with just a hero name.

Challenge 3 · Smart Display

Create a display(data, style="simple") function that takes a list of items and displays them in different formats: "simple" (numbered list), "fancy" (with borders and decorations), "compact" (all on one line separated by |). One function, three visual styles.

Summary

What You Learned

Thinking Skill

Generalization — building solutions that work across many situations by identifying what changes (make it a parameter) and what stays the same (keep it in the function body). Ask: "How can this work for any input?"

Python Concepts

Default parameters — def f(x, y=10): — backup values when no argument is given

Multiple parameters for behavior — using parameters like mode and level to change what a function does

Docstrings — """Description""" right after def

General-purpose toolkit — building reusable functions with sensible defaults

.get() on dictionaries — d.get(key, fallback) returns the fallback if the key doesn't exist

Lessons 1–9

Decomposition — break big problems into small steps

Abstraction — decide what details matter

Deductive Reasoning — rules + facts = conclusions

Categorization — organize items into groups

Pattern Recognition — spot what repeats and changes

Automation — templates for repetitive tasks

Inductive Reasoning — observations → conclusions

Encapsulation — package complexity into functions

Generalization — build solutions that adapt to any input

One Tool, Infinite Uses: The Swiss Army Knife of Code