Skip to content

Effortlessly Use args: A Python Tutorial


Python args and kwargs: Demystified



When working with Python functions, you may come across the terms *args and **kwargs. These special variables allow you to pass multiple arguments or keyword arguments to a function, providing flexibility in function definitions. In this tutorial, we will demystify *args and **kwargs and learn how to use them effectively in Python.

By the end of this tutorial, you’ll know:

  1. What *args and **kwargs actually mean
  2. How to use *args and **kwargs in function definitions
  3. How to unpack iterables using the single asterisk operator (*)
  4. How to unpack dictionaries using the double asterisk operator (**)

Table of Contents

Passing Multiple Arguments to a Function

Let’s start by understanding how to pass multiple arguments to a function. Consider the following example function that takes two arguments and returns their sum:

def my_sum(a, b):
return a + b

While this function works fine for adding two numbers, it becomes limiting when you need to sum varying numbers of arguments at runtime. It would be ideal to have a function that can sum any number of integers passed to it.

Using the Python args Variable in Function Definitions

One way to pass a varying number of arguments to a function is by using the *args variable. This allows you to pass a list of arguments to the function. For example:

def my_sum(*args):
result = 0
for x in args:
result += x
return result
print(my_sum(1, 2, 3))

In this example, the *args parameter accepts any number of positional arguments and stores them as a tuple within the function. You can then iterate over this tuple to perform the desired operation, such as finding the sum in this case.

Using *args provides more flexibility as you can pass any number of arguments without explicitly creating a list beforehand. This is particularly useful when you don’t know the exact number of arguments in advance.

Using the Python kwargs Variable in Function Definitions

In addition to *args, Python also provides the **kwargs variable for passing keyword arguments to a function. “kwargs” stands for keyword arguments. Let’s see how this works:

def greet(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")
greet(name="Alice", age=25, location="New York")

In this example, the **kwargs parameter allows you to pass any number of keyword arguments to the function. Within the function, these arguments are stored as a dictionary. You can then access the key-value pairs using the items() method and perform operations based on the passed arguments.

Using **kwargs provides flexibility in function calls as you can specify any number of named arguments without constraints. This is especially useful when functions need to handle different sets of keyword arguments in different scenarios.

Ordering Arguments in a Function

When defining functions that accept both positional and keyword arguments, it’s important to understand the order in which these arguments should be placed. In Python, the recommended order is as follows:

  1. Positional arguments
  2. *args (variable-length positional arguments)
  3. Keyword arguments
  4. **kwargs (variable-length keyword arguments)

Following this order ensures that arguments are parsed correctly by the interpreter and maintains consistency in function definitions.

Unpacking With the Asterisk Operators: * & **

Apart from using *args and **kwargs in function definitions, you can also use the asterisk operators to unpack iterables and dictionaries, respectively.

The single asterisk operator (*) can be used to unpack iterables, such as lists or tuples. For example:

numbers = [1, 2, 3]
print(*numbers) # Unpacks to 1 2 3

In this example, the *numbers expression unpacks the list numbers and passes each element as separate arguments to the print() function.

Similarly, the double asterisk operator (**) can be used to unpack dictionaries. For example:

details = {'name': 'Alice', 'age': 25, 'location': 'New York'}
print(**details) # Unpacks to name=Alice age=25 location=New York

In this example, the **details expression unpacks the dictionary details and passes each key-value pair as separate keyword arguments to the print() function.


In this tutorial, you’ve learned how to use *args and **kwargs in Python to pass multiple arguments or keyword arguments to a function. These special variables provide flexibility and allow you to handle varying numbers of arguments effectively.

You’ve also seen how to order arguments in function definitions and use the asterisk operators to unpack iterables and dictionaries.

By understanding and utilizing *args and **kwargs, you can write more flexible and versatile functions in Python.