# Python *args

Summary: in this tutorial, you’ll learn about the Python `*args` parameters and how to use them for defining variadic functions.

## Tuple unpacking

The following unpacks a tuple into two variables:

`x, y = 10, 20`

Python assigns 10 to x and 20 to y. It’s similar to passing two arguments to a function:

`def add(x, y): return x + y`

`add(10, 20) `

Code language: JavaScript (javascript)

In this example, Python passed `10` to `x` and `20` to `y`.

Similarly, the following assigns `10` to `x`, `20` to `y`, and the list `[30, 40]` to `z`:

`x, y, *z = 10, 20, 30, 40`

`print(x) print(y) print(z) `

Code language: PHP (php)

Python uses the same concept for the function arguments. For example:

` def add(x, y, *args): total = x + y for arg in args: total += arg return total`

`result = add(10, 20, 30, 40) print(result)`

Code language: PHP (php)

The `add` function accepts three parameters `x`, `y`, and `*args`. The `*args` is a special argument preceded by a star (`*`).

When passing the positional arguments `10`, `20`, `30`, and `40` to the function, Python assigns `10` to `x`, `20` to `y`, and a tuple `(30, 40)` to `args`.

It’s like tuple unpacking except that the `args` is a tuple, not a list.

## Introduction to the Python *args parameter

When a function has a parameter preceded by an asterisk (`*`), it can accept a variable number of arguments. And you can pass zero, one, or more arguments to the `*args` parameter.

In Python, the parameters like `*args` are called variadic parameters. Functions that have variadic parameters are called variadic functions.

Note that you don’t need to name `args` for a variadic parameter. For example, you can use any meaningful names like `*numbers`, `*strings`, `*lists`, etc.

However, by convention, Python uses the `*args` for a variadic parameter.

Let’s take a look at the following example:

`def add(*args): print(args)`

`add()`

Code language: Python (python)

Output:

`()`

Code language: Python (python)

The `add` function shows an empty tuple.

The following shows the type of the `args` argument and its contents:

`def add(*args): print(type(args)) print(args)`

`add() `

Code language: Python (python)

Output

`<class 'tuple'> ()`

Code language: Python (python)

Since we didn’t pass any argument to the `add()` function, the output shows an empty tuple.

The following passes three arguments to the `add()` function:

`def add(*args): print(args)`

`add(1,2,3)`

Code language: Python (python)

Output:

`(1, 2, 3)`

Code language: Python (python)

Now, the `args` has three numbers 1, 2, and 3. To access each element of the `args` argument, you use the square bracket notation `[]` with an index:

`def add(*args): print(args) print(args) print(args)`

`add(1, 2, 3)`

Code language: Python (python)

Also, you an use a `for` loop to iterate over the elements of the tuple.

The following shows how to add all numbers of the `args` tuple in the `add()` function:

`def add(*args): total = 0 for arg in args: total += arg return total`

`total = add(1, 2, 3) print(total)`

Code language: Python (python)

Output:

`6`

Code language: Python (python)

## Python *args argument exhausts positional arguments

If you use the `*args` argument, you cannot add more positional arguments. However, you can use keyword arguments.

The following example results in an error because it uses a positional argument after the `*arg` argument:

`def add(x, y, *args, z): return x + y + sum(args) + z`

`add(10, 20, 30, 40, 50) `

Code language: JavaScript (javascript)

Error:

`TypeError: add() missing 1 required keyword-only argument: 'z'`

Code language: JavaScript (javascript)

To fix it, you need to use a keyword argument after the `*args` argument as follows:

`def add(x, y, *args, z): return x + y + sum(args) + z`

`add(10, 20, 30, 40, z=50) `

Code language: JavaScript (javascript)

In this example, Python assigns `10` to `x`, `20` to `y`,`(30,40)` to `args`, and `50` to `z`.

## Unpacking arguments

The following `point` function accepts two arguments and returns a string representation of a point with x-coordinate and y-coordinate:

`def point(x, y): return f'({x},{y})'`

Code language: JavaScript (javascript)

If you pass a tuple to the `point` function, you’ll get an error:

`a = (0, 0) origin = point(a)`

Error:

`TypeError: point() missing 1 required positional argument: 'y'`

Code language: JavaScript (javascript)

To fix this, you need to prefix the tuple `a` with the operator `*` like this:

`def point(x, y): return f'({x},{y})'`

`a = (0, 0) origin = point(*a) print(origin) `

Code language: PHP (php)

Output:

`(0,0)`

When you precede the argument `a` with the operator `*`, Python unpacks the tuple and assigns its elements to `x` and `y` parameters.

## Summary

• Use Python `*arg` arguments for a function that accepts a variable number of arguments.
• The `*args` argument exhausts positional arguments so you can only use keyword arguments after it.