Quest 6: Functions - Magic Spells

Create Reusable Code with Functions

✨ QUEST 6 | Difficulty: Beginner | Time: 5 minutes

📊 Complexity Level: Beginner ⭐

Perfect for students with no programming experience. This lesson introduces fundamental concepts that are essential for all programming. Great for college fair visitors and first-time coders!

📖 Introduction: The Spell Book

Imagine being a wizard who needs to cast the same spell repeatedly. Would you say the entire incantation every time?

“By the power of the ancient stars, I summon thee, healing light!” “By the power of the ancient stars, I summon thee, healing light!” “By the power of the ancient stars, I summon thee, healing light!”

No way! You’d create a magic word like “HEAL!” that triggers the whole spell. That’s exactly what functions do in programming!

🧙 Story Time: You’re a coding wizard learning to create magical spells (functions). Each spell has a name, might need some ingredients (parameters), and produces a result. Once you create a spell, you can use it over and over with just one word!

💡 Explanation: What are Functions?

A function is a reusable block of code that performs a specific task. Think of it as a recipe or a machine: - Input (ingredients/parameters) → Process (your code) → Output (result/return value)

Basic Function Structure

def function_name():
    # Code goes here
    print("This function does something!")

# Call (use) the function
function_name()

Function with Parameters

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

greet("Alice")  # Output: Hello, Alice!

Function with Return Value

def add_numbers(a, b):
    result = a + b
    return result

total = add_numbers(5, 3)  # total = 8

🎯 Key Parts of a Function:

1. def - Keyword that starts a function definition
2. function_name - What you call the function
3. parameters - Inputs the function needs (optional)
4. code block - Indented code that runs when called
5. return - Sends a value back to the caller (optional)

Example dissected:

def calculate_damage(attack_power, defense):  # parameters
    damage = attack_power - defense            # calculation
    return damage                               # return value

🎮 Activity: Create Your Spells

Let’s create some useful game functions:

🎯 Challenge: Create your own function:

1. Make a function called calculate_total_gold that takes two parameters: old_gold and new_gold
2. It should return the sum of both
3. Test it by calling calculate_total_gold(50, 25)
4. Print the result

👨‍💻 Code Example: Functions Working Together

Functions can call other functions!

💡 Function Best Practices:

1. Good names: Use descriptive names that say what the function does

   • ✅ calculate_score(), heal_player()
   • ❌ func1(), do_stuff()

2. One task: Each function should do ONE thing well

   • ✅ Separate functions for calculating damage and applying effects
   • ❌ One giant function that does everything

3. Documentation: Add docstrings to explain what the function does

   def my_function():
       """This string explains what the function does"""
       pass

🧩 Puzzle Time!

What will this code print? Follow the flow carefully:

🔑 Solution Explained:

The output is: “The answer is: 25”

Step-by-step trace:

1. Call process_number(10)
   • num = 10
2. Inside process_number, call multiply_by_two(num)
   • multiply_by_two(10) returns 10 * 2 = 20
   • result = 20
3. Still inside process_number, call add_five(result)
   • add_five(20) returns 20 + 5 = 25
   • result = 25
4. Return result (which is 25)
   • answer = 25
5. Print answer

The flow: 10 → multiply by 2 → 20 → add 5 → 25

This demonstrates how functions can chain together, with one function’s output becoming another’s input!

🎮 Bonus: Default Parameters

Functions can have default values for parameters:

🎯 Key Takeaways

✨ Quest 6 Complete! ✨

You’ve learned:

✅ Functions are reusable blocks of code
✅ Define functions with def keyword
✅ Functions can take parameters (inputs)
✅ Functions can return values (outputs)
✅ Functions can call other functions
✅ Use default parameters for flexibility
✅ Good function names are descriptive and clear

Next Quest: Ready for key-value pairs? Try Quest 7: Dictionaries!

🚀 Try This at Home!

Create a simple calculator using functions:

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

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b != 0:
        return a / b
    else:
        return "Error: Cannot divide by zero"

# Test your calculator
print("Calculator Test:")
print(f"10 + 5 = {add(10, 5)}")
print(f"10 - 5 = {subtract(10, 5)}")
print(f"10 * 5 = {multiply(10, 5)}")
print(f"10 / 5 = {divide(10, 5)}")

Or create a character stats generator:

import random

def roll_stat():
    """Roll a random stat between 1-20"""
    return random.randint(1, 20)

def generate_character(name):
    return {
        "name": name,
        "strength": roll_stat(),
        "intelligence": roll_stat(),
        "agility": roll_stat()
    }

hero = generate_character("Merlin")
print(hero)

---

📱 You’re on Fire! Functions are the building blocks of organized code. Master them! 🔥