Variadic Positional Parameter

A variadic positional parameter allows a function to accept an arbitrary number of positional arguments. Denoted by a single asterisk prefix (*) attached to a parameter name in the function signature, it instructs the Python interpreter to capture all excess positional arguments provided during invocation and pack them into a single tuple.

By PEP 8 convention, this parameter is typically named *args, though the identifier can be any valid Python variable name (e.g., *values, *items). The asterisk is the syntactic operator; the word following it is the bound variable.

def function_name(standard_param, *args):
    # 'args' evaluates to a tuple of all remaining positional arguments
    pass

Mechanics and Behavior

• Data Type: Within the function’s local scope, the variadic parameter is strictly evaluated as a tuple. It is immutable.
• Empty Resolution: If a function is called without any excess positional arguments, the variadic parameter resolves to an empty tuple (). It does not raise a TypeError for missing arguments.
• Arity Limit: A function signature can contain a maximum of one variadic positional parameter.

def inspect_signature(first, *args):
    print(f"first: {first}")
    print(f"args type: {type(args)}")
    print(f"args value: {args}")


# Invocation with excess arguments
inspect_signature(10, 20, 30, 40)

# first: 10

# args type: <class 'tuple'>

# args value: (20, 30, 40)


# Invocation with exact positional arguments
inspect_signature(10)

# first: 10

# args type: <class 'tuple'>

# args value: ()

Parameter Resolution Order

Python enforces a strict parameter resolution order. The variadic positional parameter must be declared after all standard positional-or-keyword parameters and before any variadic keyword parameters (**kwargs).

Per PEP 3102, any parameter declared after a *args parameter automatically becomes a keyword-only parameter. This is valid syntax regardless of whether the subsequent parameter has a default value. If it lacks a default value, it becomes a required keyword-only parameter, meaning it can only be satisfied via an explicit keyword argument during invocation.

# Valid Signature: 'pos1' is a required keyword-only parameter
def keyword_only_example(*args, pos1):
    pass


# Valid invocation
keyword_only_example(1, 2, 3, pos1=4)


# Invalid invocation: TypeError (missing 1 required keyword-only argument: 'pos1')

# keyword_only_example(1, 2, 3, 4)


# Invalid Signature: SyntaxError

# A function cannot have more than one variadic positional parameter

# def multiple_variadic(*args1, *args2):

#     pass

Caller-Side Unpacking

The inverse of variadic parameter packing is argument unpacking. When invoking a function, the * operator can be applied to any iterable (like a list, tuple, or set) to unpack its elements into discrete positional arguments, which can then be captured by the function’s variadic positional parameter.

def capture(*args):
    print(args)

iterable_data = [1, 2, 3]


# Without unpacking: The entire list is passed as the first positional argument
capture(iterable_data)   # Result: ([1, 2, 3],)


# With unpacking: The list elements are passed as discrete positional arguments
capture(*iterable_data)  # Result: (1, 2, 3)

Master Python with Deep Grasping Methodology!

Learn More