Variadic Arguments (*args & **kwargs)

**kwargs must strictly be the final parameter in any Python function header. Placing any parameter—positional, default, *args, or keyword-only—after **kwargs causes a compile-time SyntaxError: invalid syntax.

# SyntaxError: invalid syntax
# def bad_func(**kwargs, *args):
#     pass

# Correct: *args precedes **kwargs
def good_func(*args, **kwargs):
    pass

Preceding a dictionary with a single asterisk (*d) unpacks only its KEYS as positional arguments, not its key-value pairs! To unpack a dictionary into keyword arguments, you must use the double asterisk (**d).

def greet(first, last):
    return f'{first} {last}'

names = {'first': 'Grace', 'last': 'Hopper'}
# *names unpacks the keys: greet('first', 'last')!
print('Single *:', greet(*names))

def greet(first, last):
    return f'{first} {last}'

names = {'first': 'Grace', 'last': 'Hopper'}
# **names unpacks keyword arguments: greet(first='Grace', last='Hopper')
print('Double **:', greet(**names))

If a parameter is filled positionally and also included inside an unpacked **kwargs dictionary, Python raises TypeError: function() got multiple values for keyword argument.

def set_point(x, y):
    return x, y

params = {'x': 10, 'y': 20}
try:
    # 5 fills x positionally, then **params attempts to fill x again!
    set_point(5, **params)
except TypeError as e:
    print('Collision error:', e)

def set_point(x, y):
    return x, y

params = {'y': 20}
print('Clean call:', set_point(5, **params))

Because *args packs arguments into a tuple (PyTupleObject), it is strictly immutable. Attempting to call args.append() or args[0] = x raises AttributeError or TypeError. If you need a mutable list, you must explicitly cast it with list(args).

def process_items(*args):
    try:
        args.append('extra')  # Raises AttributeError: 'tuple' object has no attribute 'append'
    except AttributeError as e:
        print('Mutation error:', e)

process_items(1, 2)

def process_items(*args):
    items_list = list(args)
    items_list.append('extra')
    return items_list

print('Result:', process_items(1, 2))

Unpacking a generator expression (*(x*2 for x in range(3))) fully exhausts the generator immediately during the function call, converting its yielded items into arguments.

def show_three(a, b, c):
    return a + b + c

gen = (x * 10 for x in range(1, 4))
print('From generator:', show_three(*gen))

Python keyword arguments must be valid identifier strings. Attempting to unpack a dictionary with non-string keys (such as integers) via **d raises TypeError: keywords must be strings.

def test_kw(**kwargs):
    return kwargs

bad_dict = {100: 'val'}
try:
    test_kw(**bad_dict)
except TypeError as exc:
    print('Key error:', exc)

When unpacking multiple dictionaries in the same call (e.g. f(**d1, **d2)), if both dictionaries contain the same key, the later dictionary overrides the earlier one without error.

def inspect_merged(**kwargs):
    return kwargs

base = {'color': 'red', 'size': 10}
override = {'color': 'blue'}
print('Merged kwargs:', inspect_merged(**base, **override))

Unpacking a 1-element tuple *(x,) passes exactly 1 positional argument. Notice the mandatory trailing comma in (x,).

def echo(val):
    return val

single_tuple = (42,)
print('Unpacked single:', echo(*single_tuple))

Every call to a function with *args allocates a PyTupleObject, and **kwargs allocates a PyDictObject on the heap. In performance-critical micro-benchmarks, explicitly declaring named parameters is faster.

In CPython 3.12, the vectorcall protocol optimizes *args unpacking by populating an existing array buffer when possible, minimizing intermediate object creation.

Using def wrapper(*args, **kwargs): func(*args, **kwargs) introduces slight allocation and argument-parsing latency compared to a direct call, though PyPy and specialized JITs often inline this pattern.

**kwargs dictionary construction hashes every keyword string. For calls with many keyword arguments, this string hashing cost dominates function prologue time.

Web framework middlewares, telemetry monitors, and retry decorators rely on def wrapper(*args, **kwargs) to intercept, time, and log function calls without altering the underlying function's argument signature.

ORM query engines (e.g. Django ORM, SQLAlchemy) accept arbitrary keyword arguments in methods like filter_by(**conditions), dynamically translating keyword names into column filter clauses.

Plugin architectures and UI component factories use *args, **kwargs to pass variable configuration parameters through abstract factories down to concrete class constructors.