Creating and Using Functions

1. Why Use Functions? The Art of Reusable Code

Before we dive into the syntax, let's understand why functions are so important in programming. At its core, a function allows you to write a piece of code once and then use it over and over again.

Imagine from your storekeeper experience that you frequently need to check if a product is close to its expiry date. Instead of copying and pasting the same checking logic everywhere, you can put it inside a function called check_expiry(). This has several advantages:

• Reusability: You can call check_expiry() for any product, saving you from rewriting code.
• Readability: Your main script becomes simpler. A line like check_expiry(product) is easier to understand than a big block of logic.
• Maintainability: If you need to change how the expiry check works (e.g., change the warning period from 30 days to 45 days), you only need to update it in one place: inside the function.

2. Defining and Calling a Function

Now, let's look at the syntax. In C, you define a function with a return type, a name, and curly braces {}. Python's syntax is a bit different, relying on the def keyword and indentation.

This image breaks down the syntax visually:

Here's a direct comparison to what you know from C.

To see this in action, let's watch a short video that demonstrates how to define and call a very simple function.

3. Making Functions Flexible with Parameters and Arguments

A function becomes truly powerful when you can pass data into it. For example, a greet() function is more useful if it can greet different people by name.

• Parameters are the variables you list inside the parentheses in the function definition. They are placeholders for the data the function expects to receive.
• Arguments are the actual values you pass to the function when you call it.

When you call a function, the arguments you provide are assigned to the parameters in order.

# 'name' and 'product_id' are parameters
def log_order_preparation(name, product_id):
    print(f"Preparing order for {name}, Product ID: {product_id}.")

# 'Alice' and 101 are positional arguments
log_order_preparation("Alice", 101) 
# Output: Preparing order for Alice, Product ID: 101.

# 'Bob' and 205 are positional arguments
log_order_preparation("Bob", 205)
# Output: Preparing order for Bob, Product ID: 205.

Keyword Arguments and Default Values

Python offers more flexibility. You can also pass arguments by specifying the parameter name. These are called keyword arguments. The advantage is that their order doesn't matter, which makes your code more readable.

You can also provide a default value for a parameter, making it optional.

Here's an example:

# 'status' is an optional parameter with a default value
def update_inventory(product, quantity, status="In Stock"):
    print(f"Product: {product}, Quantity: {quantity}, Status: {status}")

# Calling with only the required arguments
update_inventory("Scanner", 50)
# Output: Product: Scanner, Quantity: 50, Status: In Stock

# Overriding the default value by providing a third argument
update_inventory("Printer", 10, "Low Stock")
# Output: Product: Printer, Quantity: 10, Status: Low Stock

# Using keyword arguments (order doesn't matter)
update_inventory(quantity=5, product="Keyboard", status="Backordered")
# Output: Product: Keyboard, Quantity: 5, Status: Backordered

# Step 1-3: Initial function
def create_summary(report_name, author):
    print(f"Summary for '{report_name}' by '{author}'.")

create_summary("Daily Inventory", "Amine")
# Expected output: Summary for 'Daily Inventory' by 'Amine'.

print("---") # Separator

# Step 4-5: Modified function with default parameter
def create_summary(report_name, author="System"):
    print(f"Summary for '{report_name}' by '{author}'.")

create_summary("Error Log")
# Expected output: Summary for 'Error Log' by 'System'.

4. Getting Data Back with return

Functions can be divided into two main types:

1. Functions that perform a task: Like print(), they do something but don't give you a value back.
2. Functions that calculate and return a value: They process inputs and send a result back to where they were called.

To send a value back, you use the return statement.

When a function returns a value, you can store that value in a variable for later use.

# This function calculates and returns a value
def calculate_vat(price):
    vat_amount = price * 0.20
    return vat_amount

# Call the function and store the returned value
item_price = 150
tax = calculate_vat(item_price)
total_price = item_price + tax

print(f"Item price: {item_price}")
print(f"VAT: {tax}")
print(f"Total price: {total_price}")

# Expected output:
# Item price: 150
# VAT: 30.0
# Total price: 180.0

def format_full_name(first_name, last_name):
    full_name = f"{first_name} {last_name}"
    return full_name

# Call the function and capture the return value
my_full_name = format_full_name("Amine", "El Aabidi")

# Print the captured value
print(my_full_name)

# Expected output:
# Amine El Aabidi

5. Best Practices: Scope and Documentation

As you write more functions, two concepts will help you avoid common bugs: scope and documentation.

Variable Scope: A variable created inside a function (a "local variable") only exists within that function. This is a good thing! It prevents functions from accidentally modifying each other's data. You should generally avoid using "global variables" (variables defined outside all functions) inside your functions.

Documentation (Docstrings): It's good practice to write a brief description of what your function does, what parameters it expects, and what it returns. In Python, this is done using a special comment called a docstring (a multi-line string right after the def line).

def calculate_vat(price):
    """Calculates the 20% VAT for a given price.

    Args:
        price (float): The price of the item before tax.

    Returns:
        float: The calculated VAT amount.
    """
    vat_amount = price * 0.20
    return vat_amount

This makes it much easier for you (or others) to understand how to use your function in the future.

Conclusion

Great job! You've just learned one of the most important concepts in programming. Functions are the building blocks of any significant application, including automation scripts.

Key Takeaways:

• Functions help you organize code into reusable and manageable blocks using the def keyword.
• You can pass data into functions using parameters, and the values you send are called arguments.
• Keyword arguments and default parameter values make your functions more flexible and readable.
• The return statement allows a function to send a value back to the caller.
• Functions that don't explicitly return a value will return None by default.
• Variables defined inside a function are local to that function, which helps prevent bugs.

Next Lesson:
You now know how to build your own tools with functions. But what if the tool you need already exists? In the next lesson, we will learn how to import and use modules from the Python Standard Library. This will unlock a huge collection of pre-written functions that can do everything from working with dates and times to managing files on your computer, dramatically speeding up your automation development.