Python functions

Introduction

Think about a coffee machine. You do not need to know how the inner water tubes heat up or how the grinder operates every time you want an espresso. You simply press a button, give it coffee beans, and wait for your cup. In programming, functions are your code's buttons. They allow you to bundle up a complex block of code, give it a simple name, and reuse it whenever you want without typing it out over and over again.

1. Defining and calling functions

To use a function, you must complete a two-step process: you build the button (define it), and then you press the button (call it).

Defining: You use the keyword def to tell Python you are making a function, followed by the name of your choice and a colon (:).

Calling: To run that saved code later, you type the function's name followed by parentheses ().

Code Snippet:

# Defining the function
def send_alert():
    print("System warning: Storage space low!")

# Calling the function
send_alert()  # This runs the code inside send_alert

Output: System Warning: Storage space low!

2. Parameters and arguments

Functions become incredibly powerful when you can pass data into them, allowing them to do different work depending on the inputs.

Parameters: These are the placeholder variables you write inside the parentheses when defining the function. Think of them as the slots on the machine.
Arguments: These are the actual, real values you pass into those slots when calling the function.

Code Snippet:

# 'username' is the parameter (the slot)
def greet_user(username):
    print(f"Welcome back, {username}!")

# "Alex" is the argument (the actual data filling the slot)
greet_user("Alex")

Output: Welcome back, Alex!

3. Return values

Sometimes, you don’t just want a function to print text to the screen. You want it to calculate an answer and hand that answer back to the main program so you can use it somewhere else. We do this using the return keyword.

Rule: Once a function hits a return statement, it hands back the value and stops running immediately.

Code Snippet:

def calculate_tax(amount):
    return amount * 0.08

# Saving the handed-back answer into a new variable
final_tax = calculate_tax(100)
print(f"Tax due: ${final_tax}")

Output: Tax due: $8.0

4. Scope

Where you create a variable determines where you are allowed to use it. This concept is called scope.

Local Scope: Variables created inside a function belong exclusively to that function. They disappear as soon as the function finishes running, and the outside world cannot see them.
Global Scope: Variables created outside all functions belong to the main program file. Any function can look at them.

Code Snippet:

# =====================================
# UNDERSTANDING VARIABLE SCOPE IN PYTHON
# =====================================

# GLOBAL VARIABLE
global_msg = "I am a GLOBAL variable!"

def sample_function():

    # LOCAL VARIABLE
    local_msg = "I am a LOCAL variable!"

    print("--- INSIDE THE FUNCTION ---")

    # Accessing a global variable
    print("Global:", global_msg)

    # Accessing a local variable
    print("Local:", local_msg)


# 1. Call the function
sample_function()

# 2. Access variables outside the function
print("\n--- OUTSIDE THE FUNCTION ---")

# Global variable works
print("Global:", global_msg)

# Local variable causes an error
try:
    print("Local:", local_msg)

except NameError:
    print("ERROR: local_msg is not accessible outside the function!")

Output:

Note:

• Trying to access a local variable outside its function causes a NameError.
• Notice that the try-except block prevents the program from crashing while demonstrating that local_msg is inaccessible outside the function.

5. Practical example : The Automated Shipping Fee Calculator

Let's combine definitions, parameters, return values, and scope rules into a practical project: an e-commerce shipping manager.

Code Snippet:

# --- GLOBAL SCOPE ---
# This variable lives outside and is accessible by any function below
COMPANY_TAX_RATE = 0.05

# 1. Defining a function with parameters and a return value
def calculate_shipping(weight, destination):
    # --- LOCAL SCOPE ---
    # This 'base_fee' variable only exists inside this specific function
    if destination.lower() == "international":
        base_fee = 15.00
    else:
        base_fee = 5.00

    weight_surcharge = weight * 1.50
    total_shipping = base_fee + weight_surcharge
    return total_shipping  # Handing the calculated answer back

# 2. Defining another function that wraps everything together
def generate_invoice(item_name, price, item_weight, destination):
    shipping_cost = calculate_shipping(item_weight, destination)
    tax_cost = price * COMPANY_TAX_RATE  # Using our global variable safely
    grand_total = price + shipping_cost + tax_cost

    print("\n--- OFFICIAL INVOICE ---")
    print(f"Product    : {item_name}")
    print(f"Item Price : ${price:.2f}")
    print(f"Shipping   : ${shipping_cost:.2f}")
    print(f"Tax Amount : ${tax_cost:.2f}")
    print(f"Grand Total: ${grand_total:.2f}")
    print("------------------------")

# 3. Calling our main function with real arguments
generate_invoice("Mechanical Keyboard", 120.00, 3.5, "international")
generate_invoice("Coffee Mug", 15.00, 0.8, "domestic")

Output:

Note:

• Modularity: Instead of writing complex shipping math twice, we isolated it in calculate_shipping(). The invoice function simply "calls" it to get the answer.
• Scope Protection: The base_fee calculation remains contained inside the shipping loop, keeping the rest of the application clean and conflict-free.
• Flexibility: By passing different arguments ("international" vs "domestic"), the identical logic yields customized invoices automatically.

Conclusion

Functions turn your code from long, disorganized scrolls of instructions into crisp, manageable toolboxes. By structuring your applications around defined blocks, parameters, and clean scope rules, you can scale your projects effortlessly without drowning in repetitive code blocks.