Positional & Keyword Arguments

Default parameter values are evaluated once when the function is defined, not on each function call. Using a mutable object like a list or dictionary as a default causes that object to be shared across all calls that omit the argument, leaking state across calls.

def record_event(event_id, event_log=[]):
    event_log.append(event_id)
    return event_log

print(record_event(1))  # [1]
print(record_event(2))  # [1, 2] (Shared state bug!)

def record_event(event_id, event_log=None):
    if event_log is None:
        event_log = []
    event_log.append(event_id)
    return event_log

print(record_event(1))  # [1]
print(record_event(2))  # [2] (Cleanly isolated!)

At the call site, all positional arguments must precede any keyword arguments. Placing a positional argument after a keyword argument is a compile-time SyntaxError: positional argument follows keyword argument.

def send_email(to, subject, body):
    return f'{to}: {subject}'

# SyntaxError: positional argument follows keyword argument
# send_email(to='user@corp.io', 'Urgent', 'Meeting at 2pm')

def send_email(to, subject, body):
    return f'{to}: {subject}'

# Correct: all positional first, or all keyword
send_email('user@corp.io', 'Urgent', body='Meeting at 2pm')

If you provide a value positionally for a parameter, and also provide an explicit keyword argument for the same parameter name, Python raises TypeError: function() got multiple values for argument.

def greet(name, greeting='Hello'):
    return f'{greeting}, {name}'

try:
    # 'Alice' fills name positionally; name='Bob' attempts to fill it again!
    greet('Alice', name='Bob')
except TypeError as e:
    print('Multiple values error:', e)

def greet(name, greeting='Hello'):
    return f'{greeting}, {name}'

print(greet('Alice', greeting='Hi'))  # Distinct parameters

In a function definition, non-default parameters cannot follow default parameters. If a parameter with a default value were defined before a required parameter, Python would not know how to match positional arguments.

# SyntaxError: non-default argument follows default argument
# def query(timeout=30, sql):
#     pass

# Correct: required non-default parameters come first
def query(sql, timeout=30):
    pass

When no surplus positional or keyword arguments are supplied, *args evaluates to an empty tuple () and **kwargs evaluates to an empty dictionary {}. They are never None.

def inspect_variadic(*args, **kwargs):
    print('args is tuple?', isinstance(args, tuple), 'len:', len(args))
    print('kwargs is dict?', isinstance(kwargs, dict), 'len:', len(kwargs))

inspect_variadic()

When unpacking a dictionary with **kwargs, all dictionary keys must be strings. If any dictionary key is an integer or non-string, Python raises TypeError: function() keywords must be strings.

def test_func(**kwargs):
    pass

invalid_dict = {1: 'one', 2: 'two'}
try:
    test_func(**invalid_dict)
except TypeError as exc:
    print('Kwargs error:', exc)

When building wrapper functions or decorators, forwarding *args and **kwargs transparently preserves all positional and keyword arguments to the wrapped function.

def target(x, y, multiplier=1):
    return (x + y) * multiplier

def wrapper(*args, **kwargs):
    print('Wrapper intercepted call')
    return target(*args, **kwargs)

print('Result:', wrapper(3, 4, multiplier=2))

A bare asterisk (*) in the parameter list does not bind to a variable; it acts as a delimiter indicating that all following parameters MUST be passed as keyword arguments.

def create_table(name, *, primary_key='id', auto_increment=True):
    return f'Table {name} (PK: {primary_key})'

print(create_table('users', primary_key='uuid'))

Positional arguments map directly to fastlocals array offsets in O(1) time without name resolution. Keyword arguments require hashing and comparing parameter names, incurring slight overhead in high-frequency loops.

*args allocates a new tuple and **kwargs allocates a new dictionary on each call. If performance is paramount in tight inner loops, explicit named parameters avoid these heap allocations.

Function default values reside in a single tuple (__defaults__) allocated once per function definition, consuming negligible memory regardless of how many times the function is invoked.

Positional-only parameters (marked with /) allow Python's internal C vectorcall protocol to bypass keyword dictionary inspection completely, yielding fastest possible invocation throughput.

Modern HTTP client libraries define signatures like get(url, params=None, headers=None, **kwargs). Surplus keyword arguments (**kwargs) are passed through to underlying connection and timeout handlers transparently.

Event tracking SDKs (e.g. telemetry trackers) define track(event_name, *tags, **metadata), allowing callers to record arbitrary metric tags and contextual payload properties without changing SDK method signatures.

Scientific and financial computation engines combine zip() and map() to stream multi-feature vectors into model scoring functions with zero-overhead argument unpacking.