Many modern languages allow for default function arguments. Default arguments can be a great thing - they allow you to use sensible defaults for the common cases, without taking away the power to add more functionality as needed. You can arbitrarily expand a function definition without breaking existing code by providing sensible defaults for the new parameters.

Here is a fun example of how Python will bite you if you try to use a mutable object (like a list, dict, or object instance) as a default argument. The following is an example function I'm trying to write ...



At first glance this appears to do what is intended. If the user doesn't pass a list to append items to, then a new list is started. Or at least that appears to be what will happen. Lets try running it:



When you run this, you will get the following output:



Whoa! That was unexpected. When you use a mutable object as a default arg, Python creates a single object, and reuses that same object on every call. I find this non-intuitive, personally, but that's the way Python works. I think it has something to do with passing args to lambda functions, but I could be completely wrong.

Anyways, here is the correct way to code the function to acheive the result I want:



Now when you run the program you will get the expected result:



Note that not every instance of using a mutable type as a default arg will cause problems. In fact, you'll probably be OK most of the time. The danger is in those times that you aren't expecting trouble, and can't figure out why your code isn't working. I find it tends to happen more with recursive functions.

At any rate, my personal rule of thumb is to never use a mutable type as a default arg, and instead to always us None as shown above, and then set the variable inside the function body (where a new empty object will always be created).

It's simple, neat, takes one line, and can save you a marathon debugging session trying to figure out what is wrong (speaking from painful experience!)