Python
Functions
Arguments

Understanding Function Arguments in Python

Function arguments are pieces of data that are passed to a function when it is called. These arguments enable the function to perform specific tasks using the provided data. Arguments are specified within the parentheses () when defining a function. When calling the function, you provide actual values for those arguments, which the function uses to execute its logic.

Positional Arguments

Positional arguments are the most basic and commonly used type of function arguments. When defining a function, you specify the names of the arguments, and when calling the function, you pass the values for those arguments in the same order as they appear in the function definition. The number of arguments provided during the function call must match the number and order of parameters specified in the function definition. Let's start with an example:

def greet(name, age):
    """
    Display a personalized greeting message.
 
    This function takes a person's name and age as input and prints a greeting message that includes the person's name and age.
 
    Parameters:
    name (str): The name of the person.
    age (int): The age of the person.
 
    Returns:
    None: This function does not return a value; it simply prints the greeting message.
 
    Example:
    >>> greet("John", 30)
    Hello, John! You are 30 years old.
    """
    print(f"Hello, {name}! You are {age} years old.")
 
 
# Calling the function with positional arguments
greet("John", 30)
 
# Output: Hello, John! You are 30 years old.

It is essential to provide arguments in the correct order, as positional arguments are matched based on their positions. If you swap the order of arguments during the function call, the values will be assigned to the wrong parameters, leading to unexpected results.

# Incorrect usage - Swapping the order of arguments
greet(30, "John")

Output:

Hello, 30! You are John years old.

In this example, the argument 30 is assigned to the name parameter, and "John" is assigned to the age parameter. As a result, the greeting message becomes incorrect.

Positional arguments are simple and intuitive to use, but it is essential to keep track of the order of arguments to ensure that the function works as expected. When calling functions with many arguments, it can be easy to make mistakes, so it is always a good practice to double-check the order of arguments to avoid errors.

Keyword Arguments

Keyword arguments allow you to specify the argument name along with its corresponding value during a function call. This feature provides more flexibility when calling functions, as you can provide arguments in any order, regardless of their positions in the function definition. Keyword arguments are particularly useful when a function has multiple parameters, and you want to provide values for specific arguments without relying on their positions. Using keyword arguments can make function calls more readable and less prone to errors, especially when a function has many parameters.

def greet(name, age):
    print(f"Hello, {name}! You are {age} years old.")
 
# Calling the function with keyword arguments
greet(age=30, name="John")  # Output: Hello, John! You are 30 years old.

In this example, we called the greet function using keyword arguments. By specifying age=30 and name="John", we explicitly associate each value with its corresponding parameter. The order of the arguments doesn't matter, as Python matches the provided values with the parameter names based on the keywords.

It is important to note that you can use both positional and keyword arguments in the same function call. However, positional arguments must come before keyword arguments.

# Function with multiple parameters
def greet(name, age):
    print(f"Hello, {name}! You are {age} years old.")
 
# Calling the function with both positional and keyword arguments
greet("Alice", age=25)  # Output: Hello, Alice! You are 25 years old.

Keyword arguments not only provide clarity but also help in avoiding errors when calling functions with many parameters. They enhance the readability and maintainability of your code by making it clear which values correspond to which arguments, leading to more expressive and error-resistant function calls.

Default Arguments

Default arguments are parameters that have predefined values set in the function definition. When you call a function that has default arguments, you can omit providing values for those arguments during the function call. If no value is provided for a default argument, the function will use the predefined default value. This feature allows you to make certain arguments optional, providing flexibility and convenience when calling the function.

Using Default Arguments

To specify default values for function arguments, you simply assign the desired default value to the corresponding parameter in the function definition. It is essential to place default arguments after the non-default (positional) arguments in the function signature. This is because, during a function call, Python matches the arguments based on their positions. If you place a default argument before a non-default argument, it may lead to unexpected results.

def greet(name, age=18):
    """
    Display a personalized greeting message.
 
    This function takes a person's name as input and an optional age. It then prints a greeting message
    that includes the person's name and, if provided, their age. If age is not provided, the default age is 18.
 
    Parameters:
    name (str): The name of the person.
    age (int, optional): The age of the person. Default is 18.
 
    Returns:
    None: This function does not return a value; it simply prints the greeting message.
 
    Example:
    >>> greet("John", 30)
    Hello, John! You are 30 years old.
 
    >>> greet("Alice")
    Hello, Alice! You are 18 years old.
    """
    print(f"Hello, {name}! You are {age} years old.")
 
 
# Calling the function without providing age argument
greet("Alice")  # Output: Hello, Alice! You are 18 years old.
 
# Calling the function with age argument
greet("Bob", 25)  # Output: Hello, Bob! You are 25 years old.

In this example, the function greet has a default argument age set to 18. When we call the function without providing the age argument (greet("Alice")), the default value 18 is used. However, when we call the function with the age argument (greet("Bob", 25)), the provided value 25 is used instead of the default value.

Best Practices for Default Arguments

While default arguments can be useful, there are some best practices to keep in mind to avoid potential pitfalls:

  1. Immutable Default Values: It is recommended to use immutable objects (e.g., integers, strings, tuples) as default values for function arguments. Avoid using mutable objects (e.g., lists, dictionaries) as default values, as they can lead to unexpected behavior.
# Avoid using a mutable list as the default argument
def add_item(item, items=[]):
    items.append(item)
    return items
 
print(add_item(1))  # Output: [1]
print(add_item(2))  # Output: [1, 2] (Unexpected behavior)
  1. None as Default: Instead of using a mutable object as a default, you can use None as a default value and create a new object inside the function if needed.
def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items
 
print(add_item(1))  # Output: [1]
print(add_item(2))  # Output: [2] (Correct behavior)
  1. Avoid Modifying Default Values: Be cautious when modifying default values within the function, as these changes persist across subsequent function calls.
def greet(name, greetings=[]):
    greetings.append(f"Hello, {name}!")
    return greetings
 
print(greet("Alice"))  # Output: ['Hello, Alice!']
print(greet("Bob"))    # Output: ['Hello, Alice!', 'Hello, Bob!'] (Unexpected behavior)

Instead of modifying the default argument, consider creating a new list inside the function to avoid unexpected behavior.

Variable-Length Arguments

You can also define functions that accept a variable number of arguments using special symbols: * for positional arguments and ** for keyword arguments. This feature allows your functions to be more flexible, as they can handle an arbitrary number of arguments. Variable-length arguments are useful when you are unsure of the exact number of values you need to pass to a function or when the number of arguments can vary based on different use cases.

Variable-Length Positional Arguments

To define a function with a variable number of positional arguments, you use the * symbol followed by a parameter name. Inside the function, the args parameter becomes a tuple that contains all the positional arguments passed to the function.

def sum_numbers(*args):
    """
    Calculate the sum of a variable number of input numbers.
 
    This function takes any number of input arguments and calculates their sum.
 
    Parameters:
    *args (float or int): Any number of numeric values.
 
    Returns:
    float or int: The sum of the input numeric values.
 
    Example:
    >>> result = sum_numbers(1, 2, 3, 4, 5)
    >>> print(result)
    15
 
    >>> result = sum_numbers(10, 20, 30)
    >>> print(result)
    60
    """
    total = 0
    for num in args:
        total += num
    return total
 
result = sum_numbers(1, 2, 3, 4)
print(result)  # Output: 10

Function is defined using the docstring. Then, we call the function with 4 arguments, which returns their sum. We stored the sum inside variable and printed its value.

Variable-Length Keyword Arguments

To define a function with a variable number of keyword arguments, you use the ** symbol followed by a parameter name. Inside the function, the kwargs parameter becomes a dictionary that contains all the keyword arguments passed to the function.

def print_info(**kwargs):
    """
    Print key-value pairs of provided information.
 
    This function takes a variable number of keyword arguments and prints their key-value pairs.
 
    Parameters:
    **kwargs (any type): Variable keyword arguments in the form of key=value pairs.
 
    Returns:
    None: This function does not return a value; it simply prints the key-value pairs.
 
    Example:
    >>> print_info(name="John", age=30, city="New York")
    name: John
    age: 30
    city: New York
 
    >>> print_info(item="Laptop", price=1200, brand="HP")
    item: Laptop
    price: 1200
    brand: HP
    """
    for key, value in kwargs.items():
        print(f"{key}: {value}")
 
 
print_info(name="John", age=30, city="New York")

Output:

name: John
age: 30
city: New York

In this example, the print_info function can accept any number of keyword arguments. The kwargs parameter acts as a dictionary, allowing us to iterate over the keys and values of the provided keyword arguments.

Mixing Different Argument Types

In Python, you have the flexibility to mix different types of arguments in a function definition. When defining a function, you can use positional arguments, default arguments, variable-length positional arguments (*args), and variable-length keyword arguments (**kwargs) all in the same function signature. This feature allows you to create highly flexible and versatile functions that cater to a wide range of use cases.

def example_function(name, age=18, *args, city="New York", **kwargs):
    pass

In this example, the function example_function accepts the following types of arguments:

  1. Positional Arguments: The name parameter is a mandatory positional argument, meaning it must be provided when calling the function.

  2. Default Arguments: The age parameter is a default argument with a default value of 18. If a value for age is not provided during the function call, it will automatically take the default value of 18.

  3. Variable-Length Positional Arguments (*args): The *args parameter allows the function to accept any number of positional arguments as a tuple. These additional positional arguments are not required and can be omitted during the function call.

  4. Keyword Argument with Default Value: The city parameter is a keyword argument with a default value of "New York." If no value for city is provided during the function call, it will default to "New York."

  5. Variable-Length Keyword Arguments (**kwargs): The **kwargs parameter allows the function to accept any number of keyword arguments as a dictionary. Similar to *args, these additional keyword arguments are optional and can be omitted during the function call.

Using this combination of argument types, you can create functions that cater to a wide variety of data and use cases. The *args and **kwargs parameters provide the flexibility to work with unknown numbers of arguments, while positional and keyword arguments with default values ensure that certain data is always provided, even if not explicitly specified.

def example_function(name, age=18, *args, city="New York", **kwargs):
    """
    Demonstrate the usage of various types of function parameters.
 
    This function showcases the use of positional arguments, default argument values, variable-length
    positional arguments (*args), keyword arguments with default values, and variable-length keyword arguments (**kwargs).
 
    Parameters:
    name (str): The name of the person.
    age (int, optional): The age of the person. Default is 18.
    *args (any type): Variable-length positional arguments.
    city (str, optional): The city the person resides in. Default is "New York".
    **kwargs (any type): Variable-length keyword arguments.
 
    Returns:
    None: This function does not return a value; it simply prints the provided information.
 
    Example:
    >>> example_function("John", 30, "argument1", "argument2", city="London", occupation="Engineer")
    Name: John
    Age: 30
    Additional positional arguments: ('argument1', 'argument2')
    City: London
    Additional keyword arguments: {'occupation': 'Engineer'}
 
    >>> example_function("Alice", city="Paris", country="France")
    Name: Alice
    Age: 18
    Additional positional arguments: ()
    City: Paris
    Additional keyword arguments: {'country': 'France'}
    """
    print(f"Name: {name}")
    print(f"Age: {age}")
    print(f"Additional positional arguments: {args}")
    print(f"City: {city}")
    print(f"Additional keyword arguments: {kwargs}")
 
 
# Calling the function with different argument combinations
example_function("John")  # Output: Name: John, Age: 18, Additional positional arguments: (), City: New York, Additional keyword arguments: {}
 
# Calling the function with all arguments
example_function("Alice", 25, "argument1", "argument2", city="London", country="UK")

Output:

Name: Alice
Age: 25
Additional positional arguments: ('argument1', 'argument2')
City: London
Additional keyword arguments: {'country': 'UK'}

In this example, we called the example_function with different combinations of arguments. The function handles all the provided arguments accordingly, showcasing the flexibility and power of mixing different argument types.

BasicsLambda Functions