Sometimes you may want to pass a variable number of positional arguments to a function, and Python provides you with the ability to do it. Let's look at a very common use case, the minimum function. This is a function that calculates the minimum of its input values:
# arguments.variable.positional.py
def minimum(*n):
# print(type(n)) # n is a tuple
if n: # explained after the code
mn = n[0]
for value in n[1:]:
if value < mn:
mn = value
print(mn)
minimum(1, 3, -7, 9) # n = (1, 3, -7, 9) - prints: -7
minimum() # n = () - prints: nothing
As you can see, when we specify a parameter prepending a * to its name, we are telling Python that that parameter will be collecting a variable number of positional arguments, according to how the function is called. Within the function, n is a tuple. Uncomment print(type(n)) to see for yourself and play around with it for a bit.
One other thing to note is that we may want to throw an error when we call the function with no arguments, instead of silently doing nothing. In this context, we're not concerned about making this function robust, but in understanding variable positional arguments.
Let's make another example to show you two things that, in my experience, are confusing to those who are new to this:
# arguments.variable.positional.unpacking.py
def func(*args):
print(args)
values = (1, 3, -7, 9)
func(values) # equivalent to: func((1, 3, -7, 9))
func(*values) # equivalent to: func(1, 3, -7, 9)
Take a good look at the last two lines of the preceding example. In the first one, we call func with one argument, a four-elements tuple. In the second example, by using the * syntax, we're doing something called unpacking, which means that the four-elements tuple is unpacked, and the function is called with four arguments: 1, 3, -7, 9.
This behavior is part of the magic Python does to allow you to do amazing things when calling functions dynamically.