> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Python 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. ```python theme={"dark"} 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. ```python theme={"dark"} 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: # args value: (20, 30, 40) # Invocation with exact positional arguments inspect_signature(10) # first: 10 # args type: # 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. ```python theme={"dark"} # 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. ```python theme={"dark"} 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) ```

Tired of Poor Python Skills? Fix That With Deep Grasping! Learn More