Argument

1. Arguments in Python

Welcome to the next level of Python functions! So far, you've learned how to create basic functions that perform the exact same action every time they run. But what if you want a function to behave differently depending on the situation? That's where arguments come in. By passing data into your functions, you can make them flexible, dynamic, and truly reusable.

Learning Objectives

• Understand how to pass data into a function.
• Clearly differentiate between parameters and arguments.
• Pass multiple arguments into a single function.
• Use the return keyword to capture values from functions.

2. What is an Argument?

An argument is simply a piece of data (like a string, integer, or variable) that you hand over to a function when you call it. The function takes this data, processes it, and executes its code based on that specific input. Think of a function like a blender: the argument is the fruit you put inside. If you put in strawberries, you get a strawberry smoothie. If you put in bananas, you get a banana smoothie. The blender (the function) works the same way, but the output changes based on the input (the argument).

3. Parameters vs Arguments

You will often hear programmers use the terms "parameter" and "argument" interchangeably, but there is an important technical difference between the two:

• Parameter: This is the variable listed inside the parentheses in the function definition. It acts as a placeholder for the data that will be passed in.
• Argument: This is the actual value or data that is sent to the function when it is called.

Python code example:

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

# "Alice" and "Bob" are the ARGUMENTS (the actual data)
greet_user("Alice")  # Output: Welcome back, Alice!
greet_user("Bob")    # Output: Welcome back, Bob!

4. Passing Multiple Arguments

Functions aren't limited to just one argument. You can pass as many arguments as you need by separating them with commas. By default, Python matches arguments to parameters based on their position (order). The first argument goes to the first parameter, the second to the second, and so on. These are called positional arguments.

Python code example:

def create_profile(name, age, city):
    print(f"{name} is {age} years old and lives in {city}.")

# Order matters! name="Sam", age=25, city="New York"
create_profile("Sam", 25, "New York")
# Output: Sam is 25 years old and lives in New York.

# If you mess up the order, the output won't make sense:
create_profile(25, "New York", "Sam")
# Output: 25 is New York years old and lives in Sam.

5. Returning Values

Until now, our functions have mostly printed text to the screen. But in real-world programming, you usually want a function to calculate a value and hand it back to you so you can store it in a variable or use it later. We do this using the return keyword.

Important: When Python hits a return statement, the function immediately stops running and "returns" the specified value. print() just shows it on the screen; return actually gives the data back to the program.

Python code example:

def add_numbers(num1, num2):
    total = num1 + num2
    return total  # Gives the result back to the caller

# We can save the returned value into a variable
result = add_numbers(10, 5)

print(f"The result is {result}")  
# Output: The result is 15

# We can also use it in further calculations
print(result * 2)  # Output: 30

6. Real World Example

Let's look at a practical scenario. Imagine you are building an e-commerce checkout system. You need a function that takes a base price and a tax rate, calculates the final price, and returns it so the customer can be billed properly.

def calculate_final_price(base_price, tax_rate):
    tax_amount = base_price * tax_rate
    final_price = base_price + tax_amount
    return final_price

cart_total = 100.00
tax = 0.08  # 8% tax

total_to_pay = calculate_final_price(cart_total, tax)
print(f"Please pay: ${total_to_pay}")
# Output: Please pay: $108.0

7. Common Beginner Mistakes

Interactive Practice

Mini Practice: Student Profile

Create a function named student() that accepts three parameters: name, course, and semester. The function should use an f-string to print a summary like "Anna is studying Python in semester 2". Call the function with your own arguments.

0% complete

Your code

Check when done

I defined a function named student with 3 parameters I used print() and an f-string inside the function I called the function and passed 3 arguments to it

Quiz

Test Your Understanding

1. What is the difference between a parameter and an argument?

There is no difference; they are just two different words for the exact same thing. A parameter is the placeholder in the definition, and an argument is the actual value passed in the call. An argument is the placeholder in the definition, and a parameter is the actual value passed.

2. What happens if you define a function with 2 parameters, but only pass 1 argument when calling it?

The second parameter is automatically set to 0. The function runs normally but skips the second parameter. Python will crash and raise a TypeError.

3. Why is the return keyword useful?

It allows a function to send a value back to the main program to be stored or used. It is the only way to display text on the user's screen. It allows you to call the function multiple times in a row.

4. What is the output of the following code?

def double(num):
    return num * 2

result = double(4)
print(result + 2)

8 10 TypeError

Submit Answers

8. Challenge Project

The Calculator: Try building a function named calculator() that takes three arguments: a number, a mathematical operator (like "+", "-", "*", or "/"), and a second number. Use if/elif statements inside the function to check the operator, perform the correct math, and return the final answer. Call your function and print the result!

9. Key Takeaways

• Arguments make your functions dynamic by feeding them custom data.
• Parameters are the placeholders in the definition; Arguments are the actual values passed during the call.
• Order matters! Always pass positional arguments in the exact sequence the parameters were defined.
• Use return instead of print() when you need the function to compute a value that your program will use later on.