In the past few months I’ve been helping some people who are new to Python to get to know the language. I found that there are some pitfalls that almost everyone meet when they’re new to the language, so I decided to share my advice with you. Each part of this
series will focus on a different common mistake, describe what causes it and offer a solution.

Using a Mutable Value as a Default Value

This one definitely deserves its place at the top of the list. Not only is the reason for this “bug” subtle, it’s also very hard to debug. Consider the following snippet¹:

1
2
3

def foo(numbers=[]):
    numbers.append(9)
    print numbers

So we take a list (defaults to an empty list), add 9 to it and print it.

1
2
3
4
5
6

>>> foo()
[9]
>>> foo(numbers=[1,2])
[1, 2, 9]
>>> foo(numbers=[1,2,3])
[1, 2, 3, 9]

Seems good, right? Except this is what happens when we call foo without
numbers:

1
2
3
4
5
6
7
8

>>> foo() # first time, like before
[9]
>>> foo() # second time
[9, 9]
>>> foo() # third time...
[9, 9, 9]
>>> foo() # WHAT IS THIS BLACK MAGIC?!
[9, 9, 9, 9]

So what’s happening here? Our instincts tell us that whenever we call foo without numbers,
then numbers will be assigned with
an empty list. This is wrong. Default values for functions in Python are instantiated when the function is defined, not when it’s called.

Still, you’d ask, why isn’t the same pre-calculated value reassigned every time I call the function? Well, every time you specify a default value for a function, Python stores that value. If you call the function and override that default, the stored value
is not used. When you don’t override it (like in our example), Python makes the name you defined (numbers,
in our case) reference the stored value. It does not copy the stored value to your variable. This may be a difficult concept for beginners, so imagine that instead of two distinct variables (one – the internal, initial default value and the other – the current,
local variable), what we have in fact is two names that allow us to interact with the same value. So whenever numbers changes,
it also changes Python’s memory of what the initial value is.

The solution here is this²:

1
2
3
4
5

def foo(numbers=None):
    if numbers is None:
        numbers = []
    numbers.append(9)
    print numbers

More often than not, when people hear about this, they ask how come other default values do work as expected. Consider this:

1
2
3

def foo(count=0):
    count += 1
    print count

When we run it, it works percisely as expected:

1
2
3
4
5
6
7
8
9
10

>>> foo()
1
>>> foo()
1
>>> foo(2)
3
>>> foo(3)
4
>>> foo()
1

Why is that? The “secret” here is not in the default value assignment, but in the value itself. An integer is an immutable type. While, like the empty list, it is executed in the definition of the function, it cannot be changed. When we do count
+= 1 we do not change the original value of count. We simply make the name count point
to a different value. However, when we donumbers.append(9) we
do change the original list. Hence, the confusion.

There is another variety of this same problem when you try to call a function as the default value:

1
2

def print_now(now=time.time()):
    print now

As before, while the value of time.time() is
immutable, it is calculated only when the function is defined, so it’ll always return the same time – the time when the function code was parsed by Python:

1
2
3
4
5
6

>>> print_now()
1373121487.91
>>> print_now()
1373121487.91
>>> print_now()
1373121487.91

def foo(numbers=[]): 
    numbers.append(9) 
    print numbers 

>>> foo() 
[9] 
>>> foo(numbers=[1,2]) 
[1, 2, 9] 
>>> foo(numbers=[1,2,3]) 
[1, 2, 3, 9] 

>>> foo() # first time, like before 
[9] 
>>> foo() # second time 
[9, 9] 
>>> foo() # third time... 
[9, 9, 9] 
>>> foo() # WHAT IS THIS BLACK MAGIC?! 
[9, 9, 9, 9] 

def foo(numbers=None): 
    if numbers is None: 
        numbers = [] 
    numbers.append(9) 
    print numbers 

def foo(count=0): 
    count += 1 
    print count 

>>> foo() 
1 
>>> foo() 
1 
>>> foo(2) 
3 
>>> foo(3) 
4 
>>> foo() 
1 

def print_now(now=time.time()): 
    print now 

>>> print_now() 
1373121487.91 
>>> print_now() 
1373121487.91 
>>> print_now() 
1373121487.91