“Least Astonishment” is a principle in software design which states that the behavior of a software component should not surprise its users, and should be consistent with their expectations. This means that when designing software, developers should strive to make the software’s behavior as predictable and intuitive as possible.
In Python, one area where the principle of Least Astonishment is sometimes violated is with mutable default arguments. Consider the following function:
This function appends an item to a list and returns the updated list. If the
my_list argument is not provided, the function uses a default value of
. However, because default arguments are evaluated only once, the same mutable list object is reused across multiple calls to the function. This can lead to unexpected behavior:
[1, 2] # expected , but got [1, 2]
In this example, we expect that the second call to
append_to_list will return a list containing only the second item, since we didn’t explicitly pass a value for
my_list. However, because the same list object is being reused across both calls, the first item is still present in the list on the second call.
To avoid this issue, a common practice in Python is to use immutable objects (such as
None) as default arguments, and then create the mutable object inside the function:
if my_list is None:
my_list = 
my_list is not provided as an argument, a new empty list is created each time the function is called, avoiding the issue with mutable default arguments.
- sunny asked 1 month ago
- You must login to post comments