The Principle of Least Astonishment (POLA) refers to the idea that a function or behavior should behave in a way that is least surprising to the user. In Python, a classic violation of POLA is using mutable default arguments in functions.

The Issue with Mutable Default Arguments

In Python, default arguments are evaluated once when the function is defined, not every time the function is called. If a mutable object (e.g., a list, dictionary, or set) is used as a default argument, it can persist changes between function calls. This behavior often astonishes developers who expect a fresh object each time.

Example: Unexpected Behavior

1def append_item(item, my_list=[]):
2    my_list.append(item)
3    return my_list
4
5print(append_item(1))  # Output: [1]
6print(append_item(2))  # Output: [1, 2] (Surprise!)
7print(append_item(3))  # Output: [1, 2, 3] (Still growing!)

Why is this happening?

• The default argument my_list=[] is evaluated only once when the function is defined.
• As a result, the same list is reused across multiple calls to the function.

The Expected Behavior

Most developers would expect the list to be reinitialized (empty) for each call, like this:

print(append_item(1))  # Expected: [1]
print(append_item(2))  # Expected: [2]
print(append_item(3))  # Expected: [3]

The Solution

To avoid this issue, use None as the default argument and initialize the mutable object inside the function.

Corrected Example:

1def append_item(item, my_list=None):
2    if my_list is None:
3        my_list = []  # Initialize a new list each time
4    my_list.append(item)
5    return my_list
6
7print(append_item(1))  # Output: [1]
8print(append_item(2))  # Output: [2]
9print(append_item(3))  # Output: [3]

Why Does This Work?

By setting the default value of my_list to None, you ensure that a new list is created inside the function each time it is called. The condition if my_list is None checks if a new list is needed.

General Rule of Thumb

Always avoid using mutable objects (e.g., lists, dictionaries, sets) as default arguments in Python functions.

• Use None instead.
• Initialize the mutable object inside the function body.

Summary

• POLA Violation: Mutable default arguments persist between calls and lead to surprising behavior.
• Solution: Use None as the default and initialize the mutable object inside the function.

This is one of Python's most commonly misunderstood behaviors, but once you know the fix, it becomes a reliable coding pattern. 🚀