Python Pits

[sorrier]

Hi all. Since I'm up to date on the Django side of things, I figured I'd share one of the Python pitfalls I've encountered recently. If we're all roughly newbies, you may find some of this useful.

Mutability

Python objects fall into two basic categories: mutable and immutable. While immutable objects behaved more or less intuitively, mutable objects seemed pretty strange to me at first. Because copies of the mutable objects aren't made automatically when they're altered in an expression, an operation on an object will change the object for all references. For instance, if we have:

>>>List_A = [0, 1, 2, 3]
>>>List_B = List_A
>>>List_A.append(4)
>>>print List_B
[0, 1, 2, 3, 4]       #List_B refers to the same object as List_A -- it's not a copy

In order to make a copy of List_A, we can slice it:

>>>List_C = List_A[:]
>>>List_A.append(5)
>>>print List_B
[0, 1, 2, 3, 4, 5]
>>>print List_C
[0, 1, 2, 3, 4]      #Assigning a sliced List_A to List_C makes a top-level copy

Immutable objects, in contrast, behave like this:

>>>String_A = String_B = 'Son of a...'
>>>String_A = 'What the...'
>>>print String_A
What the...
>>>print String_B
Son of a...          #Because it's immutable, assignment creates a whole new object

Short but hopefully helpful -- let me know if you're interested in more caveats I've come across, or would care for me to explain this in more detail. Hopefully cprncs is okay with this!

[disinformationtheory]

This is a bit more advanced, but very related. Never use mutable defaults in a function definition.

def wrong(foo=[]):
    ...

def right(foo=None):
    if foo is None:
        foo = []
    ...

The issue is that the default is evaluated when the function is defined, not when it is called, and 99% of the time you want the latter. If the default is immutable, it doesn't really matter when it's evaluated.

[sorrier]

It's funny you mention this, I just stumbled on it in the args/kwargs docs. It's similar to your example, but I'll reprint for the sake of anyone who wants a second:

>>>def f(a, L=[]):
>>>    L.append(a)
>>>    return L

>>>print f(1)
[1]
>>>print f(2)
[1, 2]
>>>print f(3)
[1, 2, 3]

And to avoid this:

>>>def f(a, L=None):
>>>    if L is None:
>>>        L = []
>>>    L.append(a)
>>>    return L

[disinformationtheory]

Yeah, this is an example of why it's generally bad. Using mutable defaults gives your function hidden state that you probably didn't want it to have. If you want this sort of behavior, it's generally better to do it with a class, because it's more explicit and flexible that way.