Adventures in Machine Learning

Mastering *args and **kwargs: Passing Multiple Arguments in Python

Passing Multiple Arguments to a Function: Understanding *args and **kwargs in Python

When it comes to programming in Python, understanding how to pass multiple arguments to a function is essential. Fortunately, this process is made far more straightforward by utilizing two essential tools, namely *args and **kwargs.

In this article, we will explore what *args and **kwargs mean, how to use them, and other crucial aspects of passing multiple arguments to a function in Python. What *args and **kwargs mean

*args and **kwargs are special syntaxes in Python functions that allow you to pass multiple arguments in a concise and efficient way.

The asterisk (*) is utilized before ‘args’ or ‘kwargs’ to indicate that you are passing a variable number of arguments. Using *args to pass varying numbers of positional arguments

A positional argument is an argument that is passed to the function without any preceding keywords or attribute names.

Typically, functions that accept a varying number of positional arguments utilize the *args syntax to process those arguments. Here’s a simple example:

def sum_two_numbers(*args):

result = sum(args)


The above function accepts a variable number of arguments and adds them up.

When calling this function, you would write:

sum_two_numbers(1, 2, 3, 4, 5)

This will result in the sum of all the numbers passed, which, in this particular case, would be 15. Using **kwargs to pass varying numbers of keyword arguments

On the other hand, keyword arguments are passed to the function using attribute names and values, usually to provide additional context or functionality to the function.

The **kwargs syntax is utilized to accept varying numbers of keyword arguments. Here’s another simple example:

def get_info(name, age, **kwargs):

print(f”Name: {name}”)

print(f”Age: {age}”)


Calling this function would look like:

get_info(“Alice”, 30, country=”USA”, occupation=”Engineer”)

In the above code, the function accepts ‘Name’ and ‘Age’ as positional arguments and then accepts varying numbers of keyword arguments through **kwargs.

The output of this code should be:

Name: Alice

Age: 30

{‘country’: ‘USA’, ‘occupation’: ‘Engineer’}

Correct order for function parameters

It’s important to note that when defining Python functions with multiple parameters, you must maintain the correct order. The standard positional arguments should come first, followed by *args for variable positional arguments, and then **kwargs for keyword arguments.

This order must be maintained, or you will encounter syntax errors.

Creating a function to sum two arguments

Now that we have an understanding of the basics, let’s create a basic function that sums two arguments. It should be easy to understand the code below and should shed more light on how to incorporate the syntax we have discussed earlier:

def sum_two_numbers(a, b):

result = a + b

return result

Using lists or sets to pass a varying number of arguments

The function as explained above only accepts two arguments, which will limit our ability to work on a large dataset. To overcome the limitations of only accepting two arguments, you can pass a varying number of arguments using lists or sets.

Let’s see an example of how we can do this:

def sum_all_numbers(numbers_list):

result = sum(numbers_list)

return result

Here, instead of accepting two arguments, we have passed a list of numbers, and through the ‘sum’ function, we can sum all the numbers present in the list. Using *args to pass a varying number of positional arguments

Alternatively, we can use *args to pass a variable list of arguments to a function:

def sum_all_numbers(*args):

result = sum(args)

return result

In this example, all the inputs are passed as arguments, and they are processed as a tuple using the *args syntax.

Understanding that *args returns a tuple, not a list

It’s important to note that when you use *args in your function definition, the arguments will be returned as a tuple. This means that although a list will work correctly when passed to a function, its prosodic counterpart is used to accept *args.


In conclusion, understanding how to pass multiple arguments to a function is a fundamental skill in Python. Through the use of syntax like *args and **kwargs, you can pass a variable number of arguments to your functions, allowing them to be as flexible as possible.

When designing functions that require multiple arguments, be sure to maintain the correct order and use the appropriate syntax to pass or receive varying numbers of inputs. Expanding on Using the Python kwargs Variable in Function Definitions and Unpacking With the Asterisk Operators: * & **

In Python, there are many ways to use special syntax to pass arguments to functions.

Two of the most commonly used in more advanced programming are *args and **kwargs. They are used to pass a varying number of arguments to a function and are beneficial when you don’t know ahead of time how many arguments you’ll need.

Also, asterisk operators are employed to unpack and perform computations on iterables or passed arguments. This article will provide more details on functioning with keyword arguments using **kwargs and unpacking techniques with * and ** operators.

Using a function to concatenate keyword arguments

A simple example of **kwargs implementation is when you need a function to concatenate a series of keyword arguments into a single string. This function would accept any number of keyword arguments, merge all of them, and return them as a concatenated string.

Here’s what the code for this function would look like:

def concatenate(**kwargs):

result = “”

for arg in kwargs.values():

result += arg + ” “

return result.strip()

The above function accepts any number of keyword arguments and concatenates them together into a single string. If someone calls this function as follows:

concatenate(first=”John”, last=”Doe”, middle=”Smith”)

…the function would concatenate the provided keyword arguments and return a string of:

“John Smith Doe”

Understanding the use of **kwargs for keyword arguments

The use of **kwargs is an essential syntax to understand when working with keyword arguments.

It allows you to pass an unknown number of keyword arguments to a function that can vary each time the function is called. In Python, **kwargs converts the input arguments passed to the function during runtime into a dictionary.

The name kwargs an acronym for Keyword arguments. Lets use an example to clarify this.

def my_function(**kwargs):

for key, value in kwargs.items():

print(“{} : {}”.format(key, value))

my_function(first_name=’Jane’, last_name=’Doe’, age=25)


first_name : Jane

last_name : Doe

age : 25

In this example, any keyword argument passed to the function is caught and stored as a key-value pair in the dictionary passed. The **kwargs syntax is used to catch these statements.

Important note on using .values() to return dictionary values

In the concatenate() function described above, we used the ‘.values()’ function to return the values in the dictionary stored in **kwargs. It is crucial to note that dictionary unpacking is unsorted.

As such, if you rely on .values() to return the values in your dictionary, you could end up with unexpected results. For this reason, it is often recommended that you explicitly call the keyword arguments by name to ensure that the parameters are used in the correct order.

Correct order for function parameters: standard arguments, *args, **kwargs

It is important to remember that function parameters have to be ordered correctly. In a function or method, parameters need to appear in the following order:


Standard arguments

2. *args



The reason why the order is so vital is that Python handles these parameters differently. Standard arguments are handled positionally, *args are reserved for accepting extra arguments like a list or tuple.

Lastly, **kwargs allows for variable keyword arguments to be passed in. Following this structure ensures that the syntaxes work correctly to provide the expected output.

Unpacking with the Asterisk Operators: * & **

Unpacking is an important concept in Python that allows you to extract elements from a sequence, such as a list or tuple, and assign them to individual variables. The asterisk operators, * and **, are used to unpack elements from iterables to improve the overall efficiency of the code.

Understanding how the unpacking operators work

The unpacking operators *, and ** are utilized in Python to remove an iterables container to access its contents. The * operator is used to unpack sequences such as lists, tuples, or strings, and the ** operator does the same job but works only for dictionaries.

Using * to unpack iterables

The unpacking operator returns an iterable object in its unpacked form. That means it extracts all the elements of a container and binds each element to a new variable.


numbers = [1, 2, 3, 4]



1 2 3 4

Using * to call a function with multiple arguments

It is also commonly used to call a function with multiple arguments unpacked from a container. Lets see an example:

def add_numbers(a, b, c):

return a + b + c

numbers = [1, 2, 3]

result = add_numbers(*numbers)

In this code, the list variable is converted to individual elements and passed into the function as three separate arguments.

Differences between iterable objects and mutable vs immutable objects

Mutable objects are those objects that can be modified once they have been initialized, such as lists and dictionaries. On the other hand, immutable objects are those whose value can not be changed once the initialization has been done, such as integers, strings, and tuples.

Knowing the differences can help prevent unintended issues when unpacking elements from the sequences.

Combining multiple unpacking operators

Multiple unpacking operators can also be used to chain multiple function calls in Python. Heres an example:

def product(x, y):

return x * y

numbers = [2, 3]




Here, the * operator is used to unpack the elements of the numbers list and pass it as two separate arguments to the product function.

Using the comma syntax for tuple assignment

The comma syntax is another way of performing tuple unpacking. For example:

a, b = (1, 2)







In summary, knowing how to use **kwargs in function definitions and using unpacking operators, like * and **, are critical skills for Python programmers. These tools help you gain control of the inputs and enable significant speed improvements in your code.

However, it is essential to follow the correct order of the parameters and to understand the distinction between iterable objects and mutable and immutable objects. In conclusion, understanding how to pass multiple arguments to Python functions using *args and **kwargs is crucial for advanced programming.

It enables flexible programming when you don’t know the exact number of inputs.

Correct order for function parameters, using **kwargs for keyword arguments, and the usage of the comma syntax for tuple assignment must be known.

Unpacking techniques with * and ** operators increase code efficiency and speed. It is essential to remember the differences between iterable objects and mutable vs.

immutable objects to avoid unintended issues. Learning these techniques will help open new opportunities in programming.

Popular Posts