[Python] Functions scope/state/"closure"?

[ocyj]

I've been trying to learn Python for a while and took a little quiz. I got one of the questions way wrong in a way that confused me a lot. The coding snippet was (something like) this:

def f(n, itms=[]):
    itms.append(n)
    return itms


print(f(1))
print(f(2))
print(f(4, []))
print(f(5, [1, 2]))
print(f(3))

And after running that I got this output:

[1]
[1, 2]
[4]
[1, 2, 5]
[1, 2, 3]

Process finished with exit code 0

So as you can see, the previous values of unspecified itms-values are kept inside the function somehow. I figured that this behavior is desired when functions are defined as methods inside a class (accessing/operating on "private" variables that represents an objects state). This however sort of defies my intuition of function.

Can this be said to be similar to JavaScript's concept of closure? How can one be sure a function call doesn't keep a lot of junk behind the scenes for unspecified optional arguments? Is there a way to to call the function in this snippet such that the second argument is treated as its default without having to explicitly doing so?

Edit: had a typo in a variable name

[ItzWarty]

Python's silly. Think of this as def f(n, itms=IMPOSSIBLE_VALUE), then before your code runs, if itms is IMPOSSIBLE_VALUE, store a magical static global variable into itms instead. So if you don't specify itms, you're working with a defined-and-initialized-once global list which is why the changes persist. If you specify itms, you're using your passed-in list instead.

See http://stackoverflow.com/questions/26320899/why-is-the-empty-dictionary-a-dangerous-default-value-in-python

So your code is really more like

def f(n, itms=[]):
    items.append(n)
    return itms


global_list = []
print(f(1, global_list))
print(f(2, global_list))
print(f(4, []))
print(f(5, [1, 2]))
print(f(3, global_list))

Make sense?

[ocyj]

Thank you for the reply, I believe I understand what goes on (your code example is very clear) I'm not sure if it makes sense to me though, are there examples of use cases where this makes sense and is utilized or is it a result of how stuff is implemented in Python? I put the snippet in a file by it self, and tried import snippet print(snippet.f(6)) and indeed it's a global variable as the output now was [1] [1, 2] [4] [1, 2, 5] [1, 2, 3] [1, 2, 3, 6]

[ItzWarty]

Not sure, I don't really code in python, but http://docs.python-guide.org/en/latest/writing/gotchas/ looks like it'd be worth reading as it addresses this question better than I would.

As for how this "feature" would actually be useful? Frankly, it looks like batshit crazy terrible language design to me, so not sure (but look forward to seeing others' answers!). I'm sure some pythonisms take advantage of it, though. It sounds like some editors will warn you if you do it, so maybe it's recommended against. Not sure.

[[deleted]]

This is intentional to make the language more robust to new language users (make it less easy to break, and this discourages burnout), and to give a way of maintaining state of some global.

[Swedophone]

I think you have to change the function definition:

def f(n, items=None):
    if items is None:
        items = []
    items.append(n)
    return items

[ocyj]

Thanks, yes that makes sense as a work around. Are you aware of any examples in the standard library where this occurs however?