Function Parameters and Arguments

Defining a basic function using the def keyword bundles code. Functions become truly powerful when information can be passed into them. Imagine a function that greets a user; it needs to know the user's name. Or a function that adds two numbers; it needs to know which numbers to add. This is where parameters and arguments come in.

• Parameters: These are the names listed inside the parentheses in the function definition. Think of them as placeholders or variables that will receive values when the function is called.
• Arguments: These are the actual values that you pass to the function when you call it. These values are assigned to the corresponding parameters.

Let's look at a simple example:

# Define a function with one parameter named 'user_name'
def greet(user_name):
  """Prints a simple greeting."""
  print(f"Hello, {user_name}!")

# Call the function, passing the argument "Alice"
greet("Alice")

# Call the function again with a different argument
greet("Bob")

In this code:

1. user_name inside def greet(user_name): is the parameter. It's a placeholder within the function for the name we want to greet.
2. "Alice" and "Bob" are the arguments. These are the specific values we provide when we call the greet function. When greet("Alice") runs, the value "Alice" is assigned to the user_name parameter inside the function.

Passing Multiple Arguments

Functions can accept multiple parameters, separated by commas in the definition. When you call the function, you provide the corresponding arguments in the same order. This is called using positional arguments because the position determines which parameter receives which argument.

def describe_pet(animal_type, pet_name):
  """Displays information about a pet."""
  print(f"I have a {animal_type}.")
  print(f"My {animal_type}'s name is {pet_name}.")

# Call with positional arguments
describe_pet("hamster", "Harry")
print("---") # Just to separate outputs
describe_pet("dog", "Willie")

Output:

I have a hamster.
My hamster's name is Harry.
---
I have a dog.
My dog's name is Willie.

Here, in the first call describe_pet("hamster", "Harry"):

• "hamster" (the first argument) is assigned to animal_type (the first parameter).
• "Harry" (the second argument) is assigned to pet_name (the second parameter).

The order matters. If you called describe_pet("Max", "cat"), the output would be incorrect because "Max" would be assigned to animal_type and "cat" to pet_name.

Mapping of positional arguments to parameters. The first argument goes to the first parameter, the second to the second, and so on.

Keyword Arguments

Python also allows you to use keyword arguments. This involves specifying the parameter name followed by an equals sign (=) and the value you want to pass.

def describe_pet(animal_type, pet_name):
  """Displays information about a pet."""
  print(f"I have a {animal_type}.")
  print(f"My {animal_type}'s name is {pet_name}.")

# Call using keyword arguments
describe_pet(animal_type="hamster", pet_name="Harry")
print("---")
# Order doesn't matter with keyword arguments
describe_pet(pet_name="Willie", animal_type="dog")

Output:

I have a hamster.
My hamster's name is Harry.
---
I have a dog.
My dog's name is Willie.

When using keyword arguments:

• You explicitly link an argument value to a parameter name (pet_name="Willie").
• The order in which you provide keyword arguments doesn't matter, as Python matches them by name.

Mapping of keyword arguments to parameters. Arguments are matched to parameters based on the specified name, regardless of order.

Combining Positional and Keyword Arguments

You can mix positional and keyword arguments when calling a function. However, there's a rule: positional arguments must come before keyword arguments.

def describe_pet(animal_type, pet_name):
  """Displays information about a pet."""
  print(f"I have a {animal_type}.")
  print(f"My {animal_type}'s name is {pet_name}.")

# Valid: Positional argument first
describe_pet("cat", pet_name="Whiskers")

# Invalid: Keyword argument cannot be followed by a positional one
# describe_pet(animal_type="dog", "Buddy") # This would cause a SyntaxError

Why Use Both?

• Positional arguments are often concise for functions with few, clearly ordered parameters.
• Keyword arguments improve readability, especially for functions with many parameters or parameters where the meaning isn't immediately obvious from the position. They also allow you to skip parameters that have default values (which we'll cover next).

Understanding how to pass data into functions using parameters and arguments is fundamental to creating flexible and reusable code. You can now write functions that operate on different data each time they are called.