Comments on: Is get lazily evaluated?

By: Tiho

Tiho — Sun, 07 Jun 2009 12:13:26 +0000

I don’t know but I think that you wrong.I am notcompetent in this but I think so.

By: nes

nes — Mon, 26 Jan 2009 20:23:57 +0000

There must be something wrong with Christian’s timing. I’ve seen posts on the internet where the last example has been found to be pretty slow.

By: John

John — Mon, 26 Jan 2009 07:43:12 +0000

Just to expand on Robert Lehmann’s example, you can go one step further and define a subclass that allows functions (or any object with a __call__ method really) or values:

>>> class newdict(dict):
… def get(self, key, default_value_or_func):
… if key in self:
… return self[key]
… if hasattr(default_value_or_func, “__call__”):
… return default_value_or_func()
… return default_value_or_func
…
>>> def f():
… print “f was called”
… return 7
…
>>> d = newdict({1:2, 3:4})
>>> d.get(1, f)
2
>>> d.get(42, f)
f was called
7
>>> d.get(“heinz”, 57)
57
>>>

By: bookstack

bookstack — Mon, 26 Jan 2009 05:16:29 +0000

Thanks for all the comments first.

I think Robert Lehmann’s proposal is exactly I try to approach.

And also Christian Wyglendowski’s experiment is quite interesting. At least in C++, try/catch is quite expensive, the compiler needs to generate quite little bit code to guarantee the order of exceptions and that constrains the out-of-order optimization.

And personally, I think the try/except is abused if the condition is not really exceptional.

By: Eric Larson

Eric Larson — Sun, 25 Jan 2009 23:15:20 +0000

In your example, wouldn’t passing in f() call the function immediately? I was under the impression the () effectively calls the function in place.

It is an interesting idea though to create a dict type that does lazy evaluation on the get function. You could make the fallbacks pretty complex if there was an option to take a callable.

By: Christian Wyglendowski

Christian Wyglendowski — Sun, 25 Jan 2009 20:15:16 +0000

I don’t think that try/except is as expensive as you think. Some testing in ipython with timeit confirms it:

In [2]: d = {‘a’:1}

In [3]: timeit d.get(‘a’)
1000000 loops, best of 3: 353 ns per loop

In [4]: timeit “try: d['a']\nexcept: 1″
10000000 loops, best of 3: 42.3 ns per loop

In [5]: timeit d.get(‘b’, 1)
1000000 loops, best of 3: 377 ns per loop

In [6]: timeit “try: d['b']\nexcept: 1″
10000000 loops, best of 3: 42.5 ns per loop

So .get(key, fallback) is more expensive in both cases – where a value for the key exists and where the fallback is used.

By: Toothy

Toothy — Sun, 25 Jan 2009 19:44:07 +0000

You don’t understand how the language works in general

When you write f() you are evaluating the f function right there and you will pass the value of it into the get function. This has nothing to do with the get function, you cannot write a function at all where
writing f() in the parameter list would postpone executing f().

Your analogy is incorrect too.

What you need to do is write a function that allows you to pass other functions into it, not default values.