Function parameters & arguments in Python

def say_hello(audience):
	print("Hello " + audience)

# Function declaration:
def say_hello(audience):
	print("Hello " + audience)

# Function call:
say_hello("humans") # Output: Hello humans

def printPerson(name, age):
	print(name + ", aged " + str(age))

# Let's call it:
printPerson("John", 30) # Output: John, aged 30
printPerson("Mary", 26) # Output: Mary, aged 26

def printPerson(name, age):
	print(name + ", aged " + str(age))

name = "Andy"
age = 28

printPerson(name, age) # Output: Andy, aged 28

printPerson("Mary", age) # Output: Mary, aged 28

Introduction

In this lesson, we will explore the concept of function parameters and arguments in Python. Understanding how to use parameters and arguments is crucial for writing flexible and reusable code. Functions that accept parameters can perform tasks based on the input provided, making them more versatile and powerful.

Understanding the Basics

Function parameters are placeholders for the values that will be passed to the function when it is called. These values are known as arguments. When defining a function, you specify its parameters within the parentheses following the function name. When calling the function, you provide the arguments within the parentheses.

For example, consider the function say_hello(audience). Here, audience is a parameter. When we call say_hello("humans"), the string "humans" is the argument passed to the function.

Main Concepts

Let's delve deeper into the key concepts of function parameters and arguments:

• Single Parameter: A function can have a single parameter to accept one input.
• Multiple Parameters: A function can have multiple parameters to accept multiple inputs.
• Order of Parameters: The order in which arguments are passed must match the order of parameters in the function definition.
• Variables as Arguments: Variables can be used as arguments when calling a function.

Examples and Use Cases

Here are some examples to illustrate the use of function parameters and arguments:

# Example 1: Single Parameter
def greet(name):
    print("Hello, " + name)

greet("Alice")  # Output: Hello, Alice
greet("Bob")    # Output: Hello, Bob

# Example 2: Multiple Parameters
def add(a, b):
    return a + b

result = add(5, 3)
print(result)  # Output: 8

# Example 3: Variables as Arguments
def multiply(x, y):
    return x * y

num1 = 4
num2 = 7
product = multiply(num1, num2)
print(product)  # Output: 28

Common Pitfalls and Best Practices

When working with function parameters and arguments, be mindful of the following:

• Order Matters: Ensure that the order of arguments matches the order of parameters.
• Type Consistency: Pass arguments of the expected type to avoid errors.
• Default Values: Use default parameter values to make functions more flexible.

Advanced Techniques

Advanced techniques include using keyword arguments, variable-length arguments, and unpacking arguments. These techniques provide additional flexibility and functionality.

# Keyword Arguments
def describe_pet(animal_type, pet_name):
    print(f"I have a {animal_type} named {pet_name}.")

describe_pet(animal_type="dog", pet_name="Rex")

# Variable-Length Arguments
def sum_all(*numbers):
    return sum(numbers)

total = sum_all(1, 2, 3, 4, 5)
print(total)  # Output: 15

# Unpacking Arguments
def show_info(name, age):
    print(f"Name: {name}, Age: {age}")

person_info = ("Alice", 30)
show_info(*person_info)

Code Implementation

Let's implement a function that demonstrates the use of multiple parameters and keyword arguments:

# Function with multiple parameters and keyword arguments
def create_profile(first_name, last_name, age=None, city="Unknown"):
    profile = {
        "first_name": first_name,
        "last_name": last_name,
        "age": age,
        "city": city
    }
    return profile

# Creating profiles
profile1 = create_profile("John", "Doe", age=28, city="New York")
profile2 = create_profile("Jane", "Smith")

print(profile1)
print(profile2)

Debugging and Testing

When debugging functions, use print statements to check the values of parameters and arguments. Writing tests for functions ensures they work as expected. Here are some tips:

• Use print statements to trace the flow of data.
• Write unit tests to validate function behavior.
• Use assertions to check expected outcomes.

# Example of a simple test
def test_add():
    assert add(2, 3) == 5
    assert add(-1, 1) == 0
    assert add(0, 0) == 0

test_add()
print("All tests passed!")

Thinking and Problem-Solving Tips

When solving problems related to function parameters and arguments, consider the following strategies:

• Break down the problem into smaller parts.
• Write pseudocode to outline the logic.
• Test functions with different inputs to ensure they handle various scenarios.

Conclusion

In this lesson, we covered the importance of function parameters and arguments in Python. We explored how to define functions with parameters, call them with arguments, and use advanced techniques. Mastering these concepts will help you write more flexible and reusable code.

Practice writing functions with different parameters and arguments to reinforce your understanding. Experiment with keyword arguments, variable-length arguments, and unpacking to gain confidence in using these techniques.

Additional Resources

For further reading and practice, check out the following resources:

• Python Official Documentation: Defining Functions
• LearnPython.org: Functions
• HackerRank: 10 Days of Python