hm... that's debatable. The implementation could have just as easily chosen to evaluate the default arguments each time the function is invoked and that decision wouldn't have broken any of the existing mental models of variable binding/closures.
One thing Python lacks is the ability to use preceding arguments in defaults, e.g. you cannot do this:
def f(a=3, b=a+1):
return (a + b) / 2
NameError: name 'a' is not defined
Oops. f(b=3)Common Lisp does this right.
def f(a=3, b=None):
b = b or a+1 # or use a more explicit version
return (a + b) / 2- "Let B be one greater than A unless otherwise specified."
- "We have no default value for B. If B has a value, then let B be equal to that value. If B does not have a value, then let B be one greater than A."
I think Python's behaviour is confusing and basically never what anyone actually wants. Regardless of whether or not you can use other params in defaults, the defaults should be evaluated on each call.
My mileage varies.
I'd prefer default parameters to honor referential transparency, whatever hoops the runtime has to jump through to make this happen.
>>> class Evil(object):
def __init__(self):
self.evil = 1
def __add__(self, other):
result = ("%s" % self.evil) + other
self.evil += 1
return result
>>> def referentially_transparent_concat(a, b):
return a + b
>>> e = Evil()
>>> print referentially_transparent_concat(e, "hi")
1hi
>>> print referentially_transparent_concat(e, "hi")
2hi
You can program in a referentially-transparent style with Python, but you'll have to do it by adding your own restrictions to the code you write. Python will not help you with that.
"the mutable default parameter quirk is an ugly corner worth avoiding"
could also be described as:
"a natural outcropping of python's late binding, "names are references" variable model, and closure mechanisms, which provide a consistency to the language that is often crufted up in others"
I do somewhat agree with the author that this particular functionality should be a "use only when needed" feature. I don't think it should be avoided at all costs tho, because there are times where the mutable default allows for a lot of saved code. In fact in a few cases the code to work around using mutable defaults can get into some serious voodoo because frequently the writer is actually trying to work around the bigger mutable/immutable objects and names are references "issues" in python.
This also reminds me of something I was reading on the front page today about the old 'use the whole language' vs 'simplicity is king' holy war.