Python *args and **kwargs Explained: A Practical Guide

If you've spent some time looking at Python code, especially in libraries and frameworks, you've almost certainly come across function definitions that include *args and **kwargs. These strange-looking parameters are a powerful feature that allows you to write incredibly flexible functions.

Let's break down what they are and how to use them.

What is *args?

The syntax *args in a function definition is used to pass a variable number of positional arguments. The name args is just a convention; you could call it *myargs or *items. The important part is the asterisk (*).

When you use *args, Python collects all the extra positional arguments that are passed to the function into a tuple.

Example: A function that can sum any number of arguments.

def sum_all(*args):
    print(f"The arguments are: {args}") # args is a tuple
    total = 0
    for num in args:
        total += num
    return total

print(sum_all(1, 2, 3))       # Output: 6
print(sum_all(10, 20, 30, 40)) # Output: 100

As you can see, *args allows our sum_all function to be incredibly flexible, accepting any number of arguments.

What is **kwargs?

Similarly, the syntax **kwargs is used to pass a variable number of keyword arguments. The name kwargs stands for "keyword arguments" and is also just a convention. The important part is the double asterisk (**).

When you use **kwargs, Python collects all the extra keyword arguments into a dictionary.

Example: A function that prints user information.

def print_user_info(**kwargs):
    print(f"The arguments are: {kwargs}") # kwargs is a dictionary
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_user_info(username="alice", email="alice@example.com", status="active")
# Output:
# username: alice
# email: alice@example.com
# status: active

The Order of Arguments

When you combine *args and **kwargs with standard arguments, you must follow a specific order:

1. Standard arguments
2. *args
3. **kwargs

def my_function(a, b, *args, **kwargs):
    print(f"a = {a}")
    print(f"b = {b}")
    print(f"args = {args}")
    print(f"kwargs = {kwargs}")

my_function(1, 2, 3, 4, 5, name="test", value=True)
# Output:
# a = 1
# b = 2
# args = (3, 4, 5)
# kwargs = {'name': 'test', 'value': True}

Unpacking with * and **

The * and ** operators can also be used in reverse when you are calling a function. This is called unpacking.

Unpacking a list or tuple with *:

If you have a list of arguments, you can unpack it into a function call using the * operator.

def add(a, b, c):
    return a + b + c

my_list = [10, 20, 30]

# This is equivalent to calling add(10, 20, 30)
print(add(*my_list))

Unpacking a dictionary with **:

Similarly, you can unpack a dictionary into keyword arguments using the ** operator.

def greet(name, message):
    return f"{message}, {name}!"

my_dict = {"name": "Bob", "message": "Good morning"}

# This is equivalent to calling greet(name="Bob", message="Good morning")
print(greet(**my_dict))

Practical Use Cases

• Function Decorators: Decorators often use *args and **kwargs in their wrapper functions to accept and pass on any arguments to the original function they are decorating.
• Inheritance: When you override a method in a subclass, you can use *args and **kwargs to pass all the arguments up to the parent class's method using super().

Conclusion

*args and **kwargs are powerful tools in Python that provide a high degree of flexibility. By allowing functions to accept a variable number of arguments, they enable you to write more generic and reusable code. While the syntax might seem strange at first, mastering *args and **kwargs is a key step in becoming a more proficient Python programmer.