Functions with Parameters and Return Values

What Are Functions and Why Do We Use Them?

At its heart, a function is a named, reusable block of code that performs a specific task. Think of it as creating your own custom command. Instead of writing the same sequence of instructions multiple times, you can define it once as a function and then "call" it by name whenever you need it.

This principle is called abstraction. It allows you to focus on what a piece of code does, rather than getting lost in the details of how it does it. For someone aspiring to build large-scale systems, mastering abstraction is non-negotiable.

Let's begin with a short, formal introduction to this concept from a university-level resource.

Defining and Calling Your First Function

Now for the theory of how to create and use a function. A function has two parts:

1. Definition: This is where you create the function. You specify its name and the code it contains. The definition doesn't run the code immediately; it just makes the function available for later use.
2. Call: This is where you execute the function's code.

The syntax for defining a function in Python involves the def keyword, a function name, parentheses (), and a colon :. The code belonging to the function must be indented.

To see this in action and understand the flow of execution, let's watch a short, visually-driven explanation.

Passing Information to Functions: Parameters and Arguments

Functions become truly powerful when they can operate on different data. You can pass data into a function when you call it. This requires understanding two key terms:

• Parameter: A variable name listed in the function's definition. It acts as a placeholder for the data that will be passed in.
• Argument: The actual value or data that you send to the function when you call it.

For example, in def greet(name):, name is the parameter. In greet("Alex"), "Alex" is the argument.

This next video provides a very clear explanation of this crucial distinction.

Types of Arguments

Python is flexible in how you can pass arguments:

1. Positional Arguments: These are the standard arguments you've just seen. They are matched to parameters based on their order.
2. Keyword Arguments: You can explicitly name the parameter you're assigning the argument to (e.g., increment(number=2, by=1)). This makes your code more readable, especially for functions with many inputs.
3. Default Arguments: You can give a parameter a default value in the function definition (e.g., def increment(number, by=1):). If you don't provide an argument for by when you call the function, it will automatically use the default value of 1.

This next segment of the same video explains these useful features.

Getting Results: The return Statement

Some functions just perform an action (like print()), but many are designed to compute a value and send it back to the code that called it. This is done with the return statement.

When Python executes a return statement, it immediately exits the function and sends the specified value back. This returned value can then be stored in a variable or used in another expression.

A very common point of confusion for beginners is the difference between print() and return.

• print() displays a value on the screen for a human to see. It does not send any data back to the program itself.
• return sends a value back to the program for further processing. This value is invisible to the user unless you explicitly print it.

Let's dive into a detailed reading that clarifies this and other important aspects of returning values.

Your Turn: Putting It All Together

It's time to apply these concepts. We'll create a function to perform a simple physics calculation, which directly relates to building the kind of analytical tools you're interested in.

Hands-On Exercise:

Your task is to write a function that calculates the kinetic energy of a moving object. The formula for kinetic energy (KE) is:
$KE=\frac{1}{2}m{v}^2$
where $m$ is mass and $v$ is velocity.

1. Define the function:

   • Create a function named calculate_kinetic_energy.
   • It should accept two parameters: mass_kg and velocity_mps.

2. Inside the function:

   • Calculate the kinetic energy using the formula above. Use the exponentiation operator ** that you learned in the last lesson.
   • Use the return statement to send the calculated energy value back.

3. Call the function:

   • Outside the function, create two variables, object_mass and object_velocity, and assign them values (e.g., 100 kg and 25 m/s).
   • Call your calculate_kinetic_energy function, passing your variables as arguments.
   • Store the returned value in a new variable called kinetic_energy_joules.

4. Display the result:

   • Use an f-string with the print() function to display the result in a readable format, like: "The kinetic energy is 31250.0 Joules."

Example Code Structure:

# 1. Define the function with two parameters
def calculate_kinetic_energy(mass_kg, velocity_mps):



    # 2. Calculate the energy and return it
    energy = 0.5 * mass_kg * (velocity_mps ** 2)
    return energy




# 3. Set up variables and call the function
object_mass = 100  # in kilograms
object_velocity = 25  # in meters per second

kinetic_energy_joules = calculate_kinetic_energy(object_mass, object_velocity)




# 4. Print the final result
print(f"The kinetic energy is {kinetic_energy_joules} Joules.")

Run this code in your environment. This exercise confirms your ability to define a function, pass it arguments, perform a calculation using knowledge from the previous lesson, and correctly capture and use its return value.

Conclusion

Congratulations on mastering one of the most important concepts in programming. Functions allow you to move beyond simple scripts to writing organized, scalable, and maintainable code—the foundation for any complex application, including advanced AI.

Key Takeaways:

• Functions are reusable, named blocks of code defined with the def keyword.
• They help in abstraction, separating what a task is from how it's done.
• Parameters are the placeholders in a function's definition, while arguments are the actual values you pass during a function call.
• The return statement sends a value back from the function to the calling code, enabling functions to produce results that can be used elsewhere.
• A function that doesn't explicitly return a value will implicitly return None.

Preview of the Next Lesson:
You can now create functions, but your code still runs every line in order. The next critical step is to give your programs decision-making power. In the next lesson, we will explore conditional statements (if, elif, else). You'll learn how to control which blocks of code are executed based on specific conditions, making your programs dynamic and intelligent.