Core Python Programming (2nd Edition)

11.6. Variable-Length Arguments
There may be situations where your function is required to process an unknown number of arguments.
These are called variable-length argument lists. Variable-length arguments are not named explicitly in
function declarations because the number of arguments is unknown before runtime (and even during
execution, the number of arguments may be different on successive calls), an obvious difference from
formal arguments (positional and default), which are named in function declarations. Python supports
variable-length arguments in two ways because function calls provide for both keyword and nonkeyword
argument types.
In Section 11.2.4, we looked at how you can use the * and ** characters in function calls to specify
grouped sets of arguments, non-keyword and keyword arguments. In this section, we will see the same
symbols again, but this time in function declarations, to signify the receipt of such arguments when
functions are called. This syntax allows functions to accept more than just the declared formal
arguments as defined in the function declaration.
11.6.1. Non-keyword Variable Arguments (Tuple)
When a function is invoked, all formal (required and default) arguments are assigned to their
corresponding local variables as given in the function declaration. The remaining non-keyword variable
arguments are inserted in order into a tuple for access. Perhaps you are familiar with "varargs" in C (i.
e., va_list, va_arg, and the ellipsis [ ... ]). Python provides equivalent supportiterating over the tuple
elements is the same as using va_arg in C. For those who are not familiar with C or varargs, they just
represent the syntax for accepting a variable (not fixed) number of arguments passed in a function call.
The variable-length argument tuple must follow all positional and default parameters, and the general
syntax for functions with tuple or non-keyword variable arguments is as follows:
def function_name([formal_args,] *vargs_tuple):
"function_documentation_string"
function_body_suite
The asterisk operator ( * ) is placed in front of the variable that will hold all remaining arguments once
all the formal parameters if have been exhausted. The tuple is empty if there are no additional
arguments given.
As we saw earlier, a TypeError exception is generated whenever an incorrect number of arguments is
given in the function invocation. By adding a variable argument list variable at the end, we can handle
the situation when more than enough arguments are passed to the function because all the extra (nonkeyword)
ones will be added to the variable argument tuple. (Extra keyword arguments require a
keyword variable argument parameter [see the next section].)
As expected, all formal arguments must precede informal arguments for the same reason that positional
arguments must come before keyword arguments.
def tupleVarArgs(arg1, arg2='defaultB', *theRest):
'display regular args and non-keyword variable args'