file = None

try:
file = open(’/tmp/somefile’)
finally:
file and file.close()

why putting ‘open’ into the try-finally block?
If it fails there is nothing to close anyway.
I was repeating such construction many times until I realized it’s a bit illogical.

def report(when=time.time):
… if hasattr(when, “__call__”):
… print when()
… else:
… print when

>>> report()
1210613185.87
>>> report(”Now”)
Now

Though regarding your second example — yowza! I can see a sleepless night worrying about that one!

def report(when=None):
when = when or time.time()
print when

Note that no parenthesis are used in the default parameter.

def load_file(filename,cache={}):
if filename not in cache:
cache[filename] = open(filename)
return cache[filename]

Still, this does cause more bugs than I would like. Knowing a little bit of how python works I can’t think of a different way to do this to keep this from happening. Another idiom perhaps is this:

def getval(f):
if callable(f):
return f()
return f
def report(when=time.time):
print getval(when)

The only case where this doesn’t work of course, is if the arg is meant to hold a function and not a value, but this is rare (and doesn’t suffer from the default problem). I like this better than having a bunch of None default values in my constructors.

I tried to think of a decorator solution, but it seems like you will still have the early execution thing, and what we are after is lazy execution. But it can’t happen every time, because you do want to be able to set a default value based on the output of a function in some situations.

Do we need a function that evaluates to itself the first time, and then generates values after that? Maybe a generator solution?

Mutables are an even harder issue though, and I think that is a much more common bug as well than the functional one. I wouldn’t mind warnings for assigning mutables to default arguments.

x = expression

and then evaluate “x” some time in the future, Python would by some reason evaluate the expression again. I’m sure he knows that things doesn’t work this way, and that it was just the unusual context (defining models by setting class attributes) that was confusing him.