Why is the empty dictionary a dangerous default value in Python?

Question

I put a dict as the default value for an optional argument to a Python function, and pylint (using Sublime package) told me it was dangerous. Can someone explain why this is the case? And is a better alternative to use None instead?

Solution 1

It's dangerous only if your function will modify the argument. If you modify a default argument, it will persist until the next call, so your "empty" dict will start to contain values on calls other than the first one.

Yes, using None is both safe and conventional in such cases.

Solution 2

Let's look at an example:

def f(value, key, hash={}):
    hash[value] = key
    return hash

print(f('a', 1))
print(f('b', 2))

Which you probably expect to output:

{'a': 1}
{'b': 2}

But actually outputs:

{'a': 1}
{'a': 1, 'b': 2}

Comments

[hamed]

The problem with pasing empty list as a default argument is that it will be shared between all invocations of the function -- see the "important warning" in docs.python.org/3/tutorial/…

[NightFurry]

if function is not modifying the argument, should we still use None as default in the name of best practice?

[John Zwinck]

@NightFurry: I hesitate to prescribe anything here--None is often the best choice, but perhaps not 100% of the time. Use your judgement, but if you can't decide, None is a safe bet.

[Ricky Levi]

so how we can still achieve a default value that matches afterwards code, vs saying "if h is None: h = {}" and then continue the code ?

[limeri]

@RickyLevi, yes.

[Mandemon]

I am kinda late, but I wanted to say thanks for this example. This was not something I was aware of with Python, so I was wondering why having empty list/dict was considered "dangerous". This helped a lot.

[Inarus Lynx]

In case anyone else stumbles across this question, please look at this answer on optional dictionaries in function arguments. I feel it's a much better discussion on how this issue should be addressed. Basically, today one should type-hint an optional mapping of {key: value}. ie arg: Optional[Mapping[str, str]] = None

[alper]

so hash becomes a global variable?

[marxus]

@alper it's not global variable, you can access it only in the scope of the function, but the default value, if not supplied is referenced to the dict you defined as literal. one way to avoid it is to def func(hash=None): if hash == None: hash = {} ...

[kaya3]

If the function does not modify the argument but leaks a reference to it (by returning it, yielding it, calling some other function with it as an argument, or so on), then the same problem can occur. I would recommend always using None, even if the function is written carefully to avoid such bugs, purely so that seemingly-innocuous changes to the function cannot break it.

[Timmmm]

I just want to say this is a real Python WTF. Who thought this could possibly be sane behaviour?

[hum3]

Just bitten me as well. Tests run individually work but as a collection prior calls contaminate later ones.

[27px]

That sounds like a bug in python, as far I know other dynamic programming languages will not behave that way

[Mike Pennington]

This is a nice example, but AFAICT hash shouldn't be in the list of parameters when you only want the "expected output", above.

[Ratul Hasan]

@RickyLevi you can achieve such possiblity by replacing the arg using list or dict .copy() or copy.deepcopy(obj) before using the arg in the the function. So original list or dict stay safe since you're messing with a copy of it, not the original one.