Python Default Parameters in Functions

In Python programming, functions are one of the most important building blocks of clean, reusable, and efficient code. When creating a function, you can define parameters that accept values when the function is called. But what happens if a parameter is not passed? This is where default parameters come in. In this article, you will learn everything about Python default parameters in functions, why they are useful, and how to use them effectively with clear examples.

What Are Default Parameters in Python?

A default parameter in Python is a parameter that has a default value assigned to it in the function definition. This means that if the caller does not provide a value for that parameter, the function will automatically use the default value. Default parameters make functions more flexible and reduce the need for function overloading.

def greet(name="Guest"):
    print("Hello,", name)

greet()          # Output: Hello, Guest
greet("Alice")   # Output: Hello, Alice

In this example, the parameter name has a default value of "Guest". When the function is called without arguments, it uses that default value.

How Default Parameters Work

When Python defines a function with default parameters, the default value is assigned only once — at the time of function definition, not at the time of function execution. This behavior can lead to unexpected results when the default value is a mutable object like a list or dictionary.

def add_item(item, item_list=[]):
    item_list.append(item)
    return item_list

print(add_item("Apple"))   # ['Apple']
print(add_item("Banana"))  # ['Apple', 'Banana'] - unexpected result

In the example above, both calls to add_item() share the same list object. This happens because the list is created only once, and each function call modifies the same list reference.

To fix this, use None as the default value and create a new list inside the function when needed:

def add_item_fixed(item, item_list=None):
    if item_list is None:
        item_list = []
    item_list.append(item)
    return item_list

print(add_item_fixed("Apple"))   # ['Apple']
print(add_item_fixed("Banana"))  # ['Banana']

This approach ensures that each function call gets its own list object.

Advantages of Using Default Parameters

• Flexibility: Functions can handle both full and partial arguments.
• Cleaner Code: Fewer overloads or conditional checks are needed.
• Improved Readability: The purpose of default behavior is explicitly stated in the function definition.
• Backward Compatibility: You can add new parameters without breaking existing code.

Multiple Default Parameters

You can define multiple default parameters in one function. However, all non-default parameters must appear before any default ones. This is a strict syntax rule in Python.

def make_profile(name, age=18, country="Unknown"):
    print(f"Name: {name}, Age: {age}, Country: {country}")

make_profile("John")                         # Uses both defaults
make_profile("Alice", 25)                    # Overrides age
make_profile("Bob", 30, "Indonesia")         # Overrides both

If you try to put a non-default parameter after a default parameter, Python will raise a SyntaxError.

# ❌ Invalid syntax
def invalid_function(a=10, b):  
    pass

Default Parameters with *args and **kwargs

Default parameters can also be combined with variable-length arguments like *args and **kwargs. This combination allows you to create powerful and flexible functions that can accept both specific and arbitrary arguments.

def show_info(name, *args, city="Unknown", **kwargs):
    print("Name:", name)
    print("City:", city)
    print("Other Info:", args)
    print("Extra Data:", kwargs)

show_info("Rysa", 24, "Developer", city="Jakarta", country="Indonesia", hobby="Coding")

Output:

Name: Rysa
City: Jakarta
Other Info: (24, 'Developer')
Extra Data: {'country': 'Indonesia', 'hobby': 'Coding'}

This example shows that city has a default value but can still be overridden by keyword arguments.

Real-World Example: Logging Function

Default parameters are especially useful in real-world applications. For instance, imagine you are building a logging utility function. You can assign a default log level, message, or output format to make the function easy to use.

import datetime

def log_message(message, level="INFO", timestamp=True):
    if timestamp:
        current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        print(f"[{current_time}] [{level}] {message}")
    else:
        print(f"[{level}] {message}")

log_message("Application started")
log_message("User login failed", level="ERROR")
log_message("Debugging mode active", level="DEBUG", timestamp=False)

Output:

[2025-10-15 18:00:00] [INFO] Application started
[2025-10-15 18:01:22] [ERROR] User login failed
[DEBUG] Debugging mode active

This example demonstrates how default parameters simplify function calls while maintaining flexibility.

Best Practices for Using Default Parameters

• Avoid using mutable objects like lists or dictionaries as default values.
• Use descriptive defaults that make your function intention clear.
• Combine default parameters with keyword arguments for readability.
• Document your default parameters for clarity in larger codebases.

Conclusion

Default parameters in Python are a simple but powerful feature that improves code flexibility and readability. They allow functions to be called with fewer arguments while still providing meaningful defaults. However, always be cautious when using mutable default values, as they can lead to unexpected behavior. By following best practices, you can write cleaner, safer, and more maintainable Python functions.

Now that you understand how Python default parameters in functions work, try implementing them in your own projects to simplify your code and make your functions more adaptable.