You think so but then you write a function with a default argument pointing to some variable that is a list and now suddenly the semantics of that are... what?
b = ComplexObject (...)
# do things with b
def foo (self, arg=b):
# use b
return foo
Should the semantic of this be any different? :
def foo (self, arg=ComplexObject (...)):
ComplexObject = listdef foo(self, arg=expression):
could, and should work as if it was written like this (pseudocode)
def foo(self, arg?): if is_not_given(arg): arg=expression
if "expression" is a literal or a constructor, it'd be called right there and produce new object, if "expression" is a reference to an object in outer scope, it'd be still the same object.
it's a simple code transformation, very, very predictable behavior, and most languages with closures and default values for arguments do it this way. Except python.
def foo (self, arg=lambda : expression):
> most languages with closures and default values for arguments do it this way.
Do these also evaluate function definitions at runtime?