Default and Keyword Arguments

Understanding Default Arguments

Default arguments are defined in the function signature by assigning a value to a parameter using the assignment operator. When a function is called, if the caller does not provide an argument for that parameter, the function automatically uses the defined default value. This mechanism is foundational because it reduces the amount of code repetition required when a function is commonly called with the same settings. The key to understanding this is realizing that the default value is calculated and bound at the exact moment the function is defined, not when it is executed. Consequently, if you use a mutable object as a default, that object is shared across all subsequent calls, which often leads to unintended side effects if the object is modified. By providing sensible defaults, you make your utility functions significantly easier to use, as the user only needs to specify non-standard behavior.

def connect_to_database(host='localhost', port=5432):
    # The defaults are set at definition time.
    print(f"Connecting to {host} on port {port}")

connect_to_database() # Uses defaults
connect_to_database('production.db', 8080) # Overrides both

Positional vs Keyword Arguments

In Python, arguments can be passed to functions either positionally or by keyword. Positional arguments are assigned based on the order in which they appear in the function call, which relies heavily on the developer remembering the parameter sequence. Keyword arguments allow you to pass values by explicitly stating the parameter name, such as 'parameter_name=value'. This approach decouples the call from the parameter order, making the code significantly more readable and robust against changes in function signature. When mixing both, positional arguments must always come before keyword arguments. If you rely purely on positional arguments for functions with many parameters, your code becomes fragile, as swapping the order of parameters in the signature will break all existing function calls. Using keyword arguments makes the intent of the caller clear, as the function call itself acts as documentation, mapping inputs to their specific roles.

def process_payment(amount, currency='USD', store='online'):
    # Explicit keywords make logic clear at the call site.
    print(f"Processing {amount} {currency} for {store}")

process_payment(100, store='retail') # Mixing positional and keyword

The Mutable Default Argument Pitfall

A common trap involves using mutable objects, such as lists or dictionaries, as default arguments. Because the default value is assigned once at definition time, the same object instance is reused for every call to the function that lacks a specific argument. If your function modifies this mutable object, those changes persist across subsequent calls, leading to bugs that are notoriously difficult to track down. This behavior occurs because the identifier for the default argument points to a specific memory location initialized when the function was created. To avoid this, developers should follow the standard pattern of using 'None' as the default value and initializing the mutable object inside the function body. This ensures that a brand-new object is instantiated every time the function is called without a specific input, preserving the integrity of the data and preventing state pollution between independent execution cycles.

def add_item(item, basket=None):
    # Never use [] as a default; use None instead.
    if basket is None:
        basket = []
    basket.append(item)
    return basket

print(add_item('apple')) # ['apple']
print(add_item('orange')) # ['orange']

Enforcing Keyword-Only Arguments

Sometimes it is necessary to force a caller to specify arguments by name to avoid confusion, especially when a function takes several boolean flags or similar parameters. You can enforce this by placing an asterisk (*) in the function signature. Any parameters appearing after the asterisk cannot be passed positionally; they must be provided as keyword arguments. This is an advanced technique that improves the clarity of complex API surfaces. When a developer encounters a function with many inputs, keyword-only arguments prevent them from passing values in the wrong sequence, which might cause logic errors that are hard to detect at runtime. By requiring explicit naming, you force the developer to consider what each argument represents, which inherently improves code quality and maintainability in large-scale projects. This effectively creates a self-documenting interface where ambiguity is minimized or eliminated entirely during the interaction with your code.

def configure_server(*, timeout=30, retry=True):
    # The * forces keyword-only usage for security/clarity.
    print(f"Timeout set to {timeout}, Retry: {retry}")

configure_server(timeout=60) # Success
# configure_server(60) # This would raise a TypeError

Advanced Argument Unpacking

Python provides a powerful way to handle dynamic arguments using dictionary unpacking with the double asterisk operator (**). When you define a function with **kwargs, it collects any extra keyword arguments passed by the caller into a dictionary. This allows your functions to accept a variable number of parameters, making them highly versatile when you do not know the exact arguments beforehand. It is essential to combine this with default values correctly to ensure the logic remains predictable. By leveraging dictionary unpacking, you can write wrapper functions that pass settings through to other internal processes or use data structures to construct function calls dynamically. This capability is used extensively in library development to provide extensible APIs that can accommodate future changes without breaking existing calls. It effectively bridges the gap between static function definitions and the dynamic requirements of complex, data-driven applications in production environments.

def setup_system(**settings):
    # Collects arbitrary keyword arguments into a dict.
    defaults = {'theme': 'dark', 'verbose': False}
    defaults.update(settings)
    print(f"System initialized: {defaults}")

setup_system(theme='light', log_level=1) # Dynamic configuration

Interview questions

All Python interview questions →

Check yourself

Take the full Python quiz →