Defining and Calling Functions

A function is a named, reusable block of code that performs a specific task. Think of it as your own custom command that you teach Python. Instead of writing the same five lines of code every time you need to greet a user, you write a function called 'greet_user' once, and then call it whenever needed.

To create a function, you use the 'def' keyword (short for 'define'), followed by the function name, parentheses (), and a colon. The code that belongs to the function is indented underneath. The basic structure looks like this:

def function_name(): print("Hello from the function")

The name should describe what the function does — use lowercase letters and underscores to separate words (e.g., 'calculate_total'). Once defined, you call (run) the function by writing its name followed by parentheses:

function_name()

This tells Python: "jump to the function definition, execute all the indented lines, then come back to where you were."

Now let's talk about parameters. Parameters are placeholders in the function definition that accept input values. They let the function work with different data each time it's called. When you define the function, you list parameter names inside the parentheses. For example:

def greet_user(username): print(f"Hello, {username}!")

Here, 'username' is a parameter. When you call the function, you provide an actual value, called an argument, that fills in that placeholder:

greet_user("Alice")

This passes the string "Alice" into the function, so 'username' holds "Alice" and the message prints "Hello, Alice!". You can have multiple parameters separated by commas.

Parameters give your functions flexibility. You can write one function that works with many different inputs, which saves you from writing separate functions for every possible value.

The 'return' statement is how a function sends a result back to the code that called it. Without 'return', the function runs its instructions but gives nothing back — it just prints to the screen or performs an action. With 'return', the function produces a value that you can store in a variable or use in an expression.

For example:

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

sum_value = add(3, 5) print(sum_value) # Outputs: 8

The 'return' statement immediately exits the function and gives back the value 'result' to the line that called it. You can only have one value returned (though it can be a complex data type like a list). Once Python hits a 'return' statement, it stops executing the rest of the function.

Why do functions exist? They solve several problems:

Before functions, you would have to copy and paste the same instructions everywhere, leading to huge, error-prone programs. Functions are a way to organise your code into logical, manageable chunks.

Here are the key rules to remember:

Imagine you work for an online clothing store that needs to apply discounts to different orders. Your boss asks you to write a program that calculates the final price after a 10% discount on all items over $50. Without functions, you would write the same discount logic for every single item in your code — copying and pasting it dozens of times. Every time the discount rules change (say, to 15% for orders over $100), you would have to hunt down every copy and update it, inevitably missing some.

Instead, a professional IT developer writes a single function called 'apply_discount' that takes the original price and the discount percentage as parameters and returns the final price. Here is the step-by-step process of what happens in a real business scenario:

The development team starts by discussing the business rule: \"Apply a 10% discount on all items priced above $50.\" They translate this into a function:

def apply_discount(price, discount_percent): if price > 50: discounted_price = price - (price * discount_percent / 100) return discounted_price else: return price

Now, when the sales system receives an order, it calls this function for each item. For example:

item_price = 75 final_price = apply_discount(item_price, 10) print(final_price) # Outputs: 67.5

The function is tested in isolation — the QA team feeds it different prices (0, 50, 51, 200, -10) to ensure it handles edge cases correctly. Later, when the business changes the discount to 15% for orders over $100, the developer only needs to modify this one function, not every line of code that calculates a discount.

In a larger company, functions are often stored in separate files called modules, which can be imported into different programs. The 'apply_discount' function might be in a module called 'discounts.py', and the main shopping cart program imports it to use the same logic everywhere. - Code reusability: The same function is called from the website checkout, the mobile app backend, and the admin panel. - Testing: A function can be tested automatically with unit tests that verify it returns the correct values for known inputs. - Collaboration: Different developers can work on different functions simultaneously without stepping on each other's code.