{"id":505,"date":"2020-10-13T06:22:41","date_gmt":"2020-10-13T06:22:41","guid":{"rendered":"https:\/\/www.pythontutorial.net\/?page_id=505"},"modified":"2025-03-31T04:28:31","modified_gmt":"2025-03-31T04:28:31","slug":"python-args","status":"publish","type":"page","link":"https:\/\/www.pythontutorial.net\/python-basics\/python-args\/","title":{"rendered":"Python *args"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn about the Python *args<\/code> parameters and how to use them for defining variadic functions.<\/p>\n\n\n\n

Tuple unpacking #<\/a><\/h2>\n\n\n\n

The following unpacks a tuple<\/a> into two variables<\/a>:<\/p>\n\n\n

x, y = 10<\/span>, 20<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Python assigns 10 to x and 20 to y. It’s similar to passing two arguments to a function:<\/p>\n\n\n
def<\/span> add<\/span>(x, y)<\/span>:<\/span>\n    return<\/span> x + y\n\n\nadd(10<\/span>, 20<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, Python passed 10<\/code> to x<\/code> and 20<\/code> to y<\/code>.<\/p>\n\n\n\n
x, y, *z = 10<\/span>, 20<\/span>, 30<\/span>, 40<\/span>\n\nprint(x)\nprint(y)\nprint(z)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
10<\/span>\n20<\/span>\n[30<\/span>, 40<\/span>]<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Python uses the same concept for the function arguments. For example:<\/p>\n\n\n
def<\/span> add<\/span>(x, y, *args)<\/span>:<\/span>\n    total = x + y\n    for<\/span> arg in<\/span> args:\n        total += arg\n\n    return<\/span> total\n\n\nresult = add(10<\/span>, 20<\/span>, 30<\/span>, 40<\/span>)\nprint(result)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
100<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The add<\/code> function accepts three parameters x<\/code>, y<\/code>, and *args<\/code>. The *args<\/code> is a special argument preceded by a star (*<\/code>).<\/p>\n\n\n\n
When passing the positional arguments 10<\/code>, 20<\/code>, 30<\/code>, and 40<\/code> to the function, Python assigns 10<\/code> to x<\/code>, 20<\/code> to y<\/code>, and a tuple (30, 40)<\/code> to args<\/code>. <\/p>\n\n\n\n
Introduction to the Python *args parameter #<\/a><\/h2>\n\n\n\n
When a function has a parameter preceded by an asterisk (*<\/code>), it can accept a variable number of arguments. And you can pass zero, one, or more arguments to the *args<\/code> parameter.<\/p>\n\n\n\n
In Python, the parameters like *args<\/code> are called variadic parameters. Functions that have variadic parameters are called variadic functions.<\/p>\n\n\n\n
Note that you don’t need to name args<\/code> for a variadic parameter. For example, you can use any meaningful names like *numbers<\/code>, *strings<\/code>, *lists<\/code>, etc. <\/p>\n\n\n\n
However, by convention, Python uses  the *args<\/code> for a variadic parameter.<\/p>\n\n\n\n
Let’s take a look at the following example:<\/p>\n\n\n
def<\/span> add<\/span>(*args)<\/span>:<\/span>\n    print(args)\n\nadd()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output: <\/p>\n\n\n
()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The following shows the type of the args<\/code> argument and its contents:<\/p>\n\n\n
def<\/span> add<\/span>(*args)<\/span>:<\/span>\n    print(type(args))\n    print(args)\n\nadd()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output<\/p>\n\n\n
<class<\/span> 'tuple<\/span>'>\n()<\/span><\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Since we don’t pass any argument to the add()<\/code> function, the output shows an empty tuple.<\/p>\n\n\n\n
The following passes three arguments to the add()<\/code> function:<\/p>\n\n\n
def<\/span> add<\/span>(*args)<\/span>:<\/span>\n    print(args)\n\n\nadd(1<\/span>,2<\/span>,3<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
(1<\/span>, 2<\/span>, 3<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Now, the args<\/code> has three numbers 1, 2, and 3. To access each element of the args<\/code> argument, you use the square bracket notation []<\/code> with an index:<\/p>\n\n\n
def<\/span> add<\/span>(*args)<\/span>:<\/span>\n    print(args[0<\/span>])\n    print(args[1<\/span>])\n    print(args[2<\/span>])\n\n\nadd(1<\/span>, 2<\/span>, 3<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
1<\/span>\n2<\/span>\n3<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The following shows how to add all numbers of the args<\/code> tuple in the add()<\/code> function:<\/p>\n\n\n
def<\/span> add<\/span>(*args)<\/span>:<\/span>\n    total = 0<\/span>\n    for<\/span> arg in<\/span> args:\n        total += arg\n    return<\/span> total\n\n\ntotal = add(1<\/span>, 2<\/span>, 3<\/span>)\nprint(total)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
6<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Python *args argument exhausts positional arguments #<\/a><\/h2>\n\n\n\n
If you use the *args<\/code> argument, you cannot add more positional arguments. However, you can use keyword arguments<\/a>.<\/p>\n\n\n\n
The following example results in an error because it uses a positional argument after the *arg<\/code> argument:<\/p>\n\n\n
def<\/span> add<\/span>(x, y, *args, z)<\/span>:<\/span>\n    return<\/span> x + y + sum(args) + z\n\n\nadd(10<\/span>, 20<\/span>, 30<\/span>, 40<\/span>, 50<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Error:<\/p>\n\n\n
TypeError: add() missing 1<\/span> required keyword-only argument: 'z'<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
def<\/span> add<\/span>(x, y, *args, z)<\/span>:<\/span>\n    return<\/span> x + y + sum(args) + z\n\n\nresult = add(10<\/span>, 20<\/span>, 30<\/span>, 40<\/span>, z=50<\/span>)\nprint(result)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
150<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, Python assigns 10<\/code> to x<\/code>, 20<\/code> to y<\/code>,(30,40)<\/code> to args<\/code>, and 50<\/code> to z<\/code>.<\/p>\n\n\n\n
Unpacking arguments #<\/a><\/h2>\n\n\n\n
The following point<\/code> function accepts two arguments and returns a string representation of a point with x-coordinate and y-coordinate:<\/p>\n\n\n
def<\/span> point<\/span>(x, y)<\/span>:<\/span>\n    return<\/span> f'({x}<\/span>,{y}<\/span>)'<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
If you pass a tuple to the point<\/code> function, you’ll get an error:<\/p>\n\n\n
a = (0<\/span>, 0<\/span>)\norigin = point(a)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Error:<\/p>\n\n\n
TypeError: point() missing 1<\/span> required positional argument: 'y'<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
To fix this, you need to prefix the tuple a<\/code> with the operator *<\/code> like this:<\/p>\n\n\n
def<\/span> point<\/span>(x, y)<\/span>:<\/span>\n    return<\/span> f'({x}<\/span>,{y}<\/span>)'<\/span>\n\n\na = (0<\/span>, 0<\/span>)\norigin = point(*a)\nprint(origin)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
(0<\/span>,0<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
When you precede the argument a<\/code> with the operator *<\/code>, Python unpacks the tuple and assigns its elements to x<\/code> and y<\/code> parameters.<\/p>\n\n\n\n
Summary #<\/a><\/h2>\n\n\n\n
Try it<\/a><\/p>\n\n\n\n
Try it<\/a><\/p>\n\n\n\n
To fix it, you need to use a keyword argument<\/a> after the *args<\/code> argument as follows:<\/p>\n\n\n
Try it<\/a><\/p>\n\n\n\n
Try it<\/a><\/p>\n\n\n\n
Also, you an use a for<\/code> loop<\/a> to iterate over the elements of the tuple.<\/p>\n\n\n\n
Try it<\/a><\/p>\n\n\n
Try it<\/a><\/p>\n\n\n\n
Try it<\/a><\/p>\n\n\n\n
The add<\/code> function shows an empty tuple<\/a>.<\/p>\n\n\n\n
Try it<\/a><\/p>\n\n\n\n
It’s like tuple unpacking<\/a> except that the args<\/code> is a tuple, not a list.<\/p>\n\n\n\n
Try it<\/a><\/p>\n\n\n\n
Try it<\/a><\/p>\n\n\n\n
Similarly, the following assigns 10<\/code> to x<\/code>, 20<\/code> to y<\/code>, and the list<\/a> [30, 40]<\/code> to z<\/code>:<\/p>\n\n\n