Skip to content
CodeMDD.io | Coding Tutorials

Understanding Optional Arguments in Python

[

Using Python Optional Arguments When Defining Functions

Defining your own functions is an essential skill for writing clean and effective code. In this tutorial, we will explore the techniques you have available for defining Python functions that take optional arguments. Mastering Python optional arguments will allow you to define functions that are more powerful and flexible.

Table of Contents

Creating Functions in Python for Reusing Code

A function in Python can be thought of as a mini-program that runs within another program or within another function. The main program calls the function and sends information that the function will need as it runs. When the function completes all of its actions, it may send back some data to the main program that has called it.

The primary purpose of a function is to allow you to reuse code within it whenever you need it, using different inputs if required.

When you use functions, you are extending your Python vocabulary. This allows you to express the solution to your problem in a clearer and more concise way.

In Python, it is convention to name a function using lowercase letters with words separated by an underscore, such as do_something(). These conventions are described in PEP 8, which is Python’s style guide. It is best practice to start your function names with a verb to make your code more readable.

Defining Functions With No Input Parameters

In this tutorial, we will use the example of a basic program that creates and maintains a shopping list and prints it out when you’re ready to go to the supermarket.

Start by creating a shopping list:

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

Now, let’s create a function that will print out the shopping list:

def print_shopping_list():
    for item, quantity in shopping_list.items():
        print(f"{item}: {quantity}")


print_shopping_list()

This function does not take any input parameters. It simply accesses the shopping_list variable and prints out each item and quantity. By creating this function, we can easily reuse this code to print the shopping list whenever needed.

Defining Functions With Required Input Arguments

Sometimes, functions need to accept input arguments in order to perform their tasks. These arguments are specified in the function definition and can be used within the function body.

For example, let’s create a function that takes two arguments, item and quantity, and adds them to the shopping list:

def add_item_to_shopping_list(item, quantity):
    shopping_list[item] = quantity


add_item_to_shopping_list("Eggs", 6)

In this case, the add_item_to_shopping_list() function adds the specified item and quantity to the shopping_list dictionary. We can use this function to easily add new items to the shopping list.

Using Python Optional Arguments With Default Values

In addition to required arguments, Python also allows you to define optional arguments for your functions. Optional arguments have default values assigned to them, which means they can be omitted when calling the function. If the optional argument is not provided, the function will use the default value specified in the function definition.

Default Values Assigned to Input Parameters

To define an optional argument with a default value, you can simply assign the default value to the input parameter in the function definition. Here’s an example:

def create_shopping_list(item, quantity=1):
    shopping_list[item] = quantity

In this create_shopping_list() function, the quantity parameter is optional and has a default value of 1. If a value for quantity is not provided when calling the function, it will default to 1. However, if a value is provided, it will override the default value. This allows flexibility when creating the shopping list.

Common Default Argument Values

In Python, it is common to use the value None as the default value for optional arguments. This allows you to check if a value was explicitly provided when calling the function.

Here’s an example:

def greet(name=None):
    if name is None:
        print("Hello!")
    else:
        print(f"Hello, {name}!")


greet()
greet("Alice")

In this greet() function, the name parameter is optional and has a default value of None. If no name is provided, the function will print “Hello!“. Otherwise, it will print a personalized greeting.

Data Types That Shouldn’t Be Used as Default Arguments

When using default arguments, it’s important to note that mutable data types (such as dictionaries or lists) should be avoided as default values. This is because the default value is created once when the function is defined, and any subsequent modifications to the default value will affect all future calls to the function.

Here’s an example to illustrate this:

def append_to_list(item, my_list=[]):
    my_list.append(item)
    return my_list


print(append_to_list("apple"))
print(append_to_list("banana"))

In this example, the append_to_list() function accepts an item to be appended to a list. The optional my_list parameter has a default value of an empty list. If no list is provided, it will use the default empty list. However, if you call the function multiple times without providing a list, the same list will be used and appended to each time. This can lead to unexpected behavior and erroneous results.

To avoid this, it is recommended to use None as the default value and then handle it within the function:

def append_to_list(item, my_list=None):
    if my_list is None:
        my_list = []
    my_list.append(item)
    return my_list


print(append_to_list("apple"))
print(append_to_list("banana"))

In this version of append_to_list(), if no list is provided, a new empty list is created within the function. This ensures that each call to the function operates on a separate list.

When working with optional arguments, it’s important to pay attention to error messages related to input arguments. These messages can provide useful information about missing or unexpected arguments.

For example, if you forget to include a required argument when calling a function, you will get a TypeError:

def greet(name):
    print(f"Hello, {name}!")


greet()

Output:

TypeError: greet() missing 1 required positional argument: 'name'

This error message indicates that the function greet() was called without providing the required argument name.

Using args and kwargs

In addition to optional arguments with default values, Python also provides the capability to define functions that can accept any number of positional arguments and any number of keyword arguments. This is achieved using the special *args and **kwargs syntax.

Functions Accepting Any Number of Arguments

To define a function that can accept any number of positional arguments, you can use the *args syntax in the function definition. This allows you to pass any number of arguments to the function, which will be interpreted as a tuple.

Here’s an example:

def multiply(*args):
    result = 1
    for num in args:
        result *= num
    return result


print(multiply(2, 3, 4))
print(multiply(5, 6, 7, 8))

In this multiply() function, the *args parameter allows you to pass any number of arguments to the function. The function then multiplies all the numbers together and returns the result.

Functions Accepting Any Number of Keyword Arguments

Similarly, you can define a function that can accept any number of keyword arguments using the **kwargs syntax in the function definition. This allows you to pass any number of keyword arguments to the function, which will be interpreted as a dictionary.

Here’s an example:

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")


print_info(name="Alice", age=25)
print_info(city="New York", country="USA", population=8623000)

In this print_info() function, the **kwargs parameter allows you to pass any number of keyword arguments to the function. The function then prints out each key-value pair provided.

Conclusion

In this tutorial, we explored the techniques for defining Python functions that take optional arguments. By leveraging optional arguments with default values, as well as the args and kwargs syntax, you can create functions that are more powerful and flexible. With these skills, you’ll be able to write clean and effective Python code that is reusable and adaptable to different scenarios.