Function Basics

🧙‍♂️ Functions: Your Magic Recipe Book

Imagine you’re a chef with a magic recipe book. Every time you want to make cookies, you don’t need to remember every step. You just say “Make Cookies!” and the recipe does all the work. That’s exactly what a function is in Python!

A function is like a recipe you write once and use forever.

🍪 Function Definition: Writing Your First Recipe

Think of defining a function like writing a recipe card. You give it a name, list what ingredients (inputs) it needs, and describe the steps (code) inside.

def say_hello():
    print("Hello, friend!")

What’s happening here?

• def = “I’m defining a new recipe!”
• say_hello = the recipe name
• () = ingredients go here (empty for now)
• : = “here comes the recipe steps”
• The indented part = the actual steps

To use your recipe:

say_hello()
# Output: Hello, friend!

You just call it by name with () and magic happens!

🎁 Positional and Keyword Arguments

Now let’s add ingredients! Arguments are the things you give to your function.

Positional Arguments: Order Matters!

Like following a recipe: first ingredient goes first, second goes second.

def make_sandwich(bread, filling):
    print(f"A {filling} on {bread}!")

make_sandwich("wheat", "cheese")
# Output: A cheese on wheat!

The order matters! “wheat” becomes bread, “cheese” becomes filling.

Keyword Arguments: Name Your Ingredients

What if you want to be super clear? Use names!

make_sandwich(filling="ham", bread="rye")
# Output: A ham on rye!

Now order doesn’t matter because you told Python which is which!

graph TD
    A["Call Function"] --> B{How do you pass values?}
    B -->|By position| C["Positional: first, second..."]
    B -->|By name| D["Keyword: name=value"]

🎯 Default Parameter Values

What if someone forgets an ingredient? Give it a backup!

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

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

greet("Emma", "Howdy")
# Output: Howdy, Emma!

The rule: Default values are like safety nets. If you don’t provide a value, Python uses the default!

⚠️ Important: Put defaults at the END:

# ✅ Correct
def func(required, optional="backup"):

# ❌ Wrong - Python will complain!
def func(optional="backup", required):

📦 Return Statements: Getting Something Back

So far, our recipes just do things. But what if you want to get something back?

That’s what return does - it’s like a recipe that gives you the finished dish!

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

answer = add_numbers(5, 3)
print(answer)  # Output: 8

Without return, your function gives back None (nothing special).

def no_return():
    x = 5 + 5
    # forgot to return!

result = no_return()
print(result)  # Output: None

Multiple Returns

You can return multiple things - Python packs them together!

def get_stats(numbers):
    smallest = min(numbers)
    biggest = max(numbers)
    return smallest, biggest

low, high = get_stats([4, 2, 9, 1])
print(f"Low: {low}, High: {high}")
# Output: Low: 1, High: 9

🎒 Variable-Length Arguments

Sometimes you don’t know how many ingredients someone will give you. Maybe 2? Maybe 100?

*args: Any Number of Positional Arguments

The * is like saying “pack everything into one bag!”

def add_all(*numbers):
    total = 0
    for num in numbers:
        total += num
    return total

print(add_all(1, 2))        # 3
print(add_all(1, 2, 3, 4))  # 10

**kwargs: Any Number of Keyword Arguments

The ** packs named arguments into a dictionary!

def print_info(**details):
    for key, value in details.items():
        print(f"{key}: {value}")

print_info(name="Luna", age=8)
# Output:
# name: Luna
# age: 8

graph TD
    A["Variable-Length Args"] --> B["*args"]
    A --> C["**kwargs"]
    B --> D["Packs positional args into tuple"]
    C --> E["Packs keyword args into dict"]

🔒 Special Parameter Syntax

Python lets you be very specific about how arguments must be passed.

Positional-Only Parameters (/)

Everything before / MUST be positional:

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

greet("Max")        # ✅ Works
greet(name="Max")   # ❌ Error!

Keyword-Only Parameters (*)

Everything after * MUST use keywords:

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

greet(name="Max")   # ✅ Works
greet("Max")        # ❌ Error!

Mix Them Together

def example(pos_only, /, normal, *, kw_only):
    print(pos_only, normal, kw_only)

example(1, 2, kw_only=3)        # ✅
example(1, normal=2, kw_only=3) # ✅

📝 Docstrings: Explaining Your Recipe

A docstring is a little note explaining what your function does. It’s like writing instructions on your recipe card!

def bake_cake(flavor, layers=2):
    """
    Bake a delicious cake!

    Args:
        flavor: The cake flavor
        layers: Number of layers (default 2)

    Returns:
        A message about your cake
    """
    return f"A {layers}-layer {flavor} cake!"

Why use docstrings?

• Future-you will thank present-you
• Others can understand your code
• Python can show it with help(bake_cake)

Quick Docstring Rules

• Use triple quotes """
• Put it right after def line
• First line = short summary
• Add more details below if needed

🚀 Putting It All Together

Here’s a function using EVERYTHING we learned:

def create_profile(
    name, /,           # positional only
    age,               # normal
    *hobbies,          # variable positional
    city="Unknown",    # default value
    **extra            # variable keyword
):
    """
    Create a user profile dictionary.

    Args:
        name: User's name (positional only)
        age: User's age
        *hobbies: List of hobbies
        city: User's city (default: Unknown)
        **extra: Any additional info

    Returns:
        dict: Complete profile
    """
    profile = {
        "name": name,
        "age": age,
        "hobbies": hobbies,
        "city": city,
    }
    profile.update(extra)
    return profile

Using it:

result = create_profile(
    "Alex", 25,
    "coding", "music",
    city="Boston",
    job="Developer"
)

🎯 Key Takeaways

You did it! 🎉

You now know how to write, customize, and document functions like a pro. Functions are the building blocks of clean, reusable code. Every time you write a function, you’re creating a little helper that will work for you forever!

Remember: A good function is like a good recipe - clear, reusable, and makes everyone’s life easier! 🍪