Python dictionary lookup performance, get vs in

Question

This isn't premature optimization. My use case has the double-checking of dict's right in the inner-most of inner loops, running all the time. Also, it's intellectually irksome (see results). Which of these approaches is faster? ``` mydict = { 'hello': 'yes', 'goodbye': 'no' } key = 'hello' # (A) if key in mydict: a = mydict[key] do_things(a) else: handle_an_error() # vs (B) a = mydict.get(key,None) if a is not None: do_things(a) else: handle_an_error() ``` Edit: these are the same speed. Common sense tells me that (B) should be noticeably faster since it's only one dict lookup vs. 2, but the results are different. I'm scratching my head. Results of a benchmark averaged over 12 runs, 1/2 of which are hits, the other half are misses: ``` doing in switching to get total time for IN: 0.532250006994 total time for GET: 0.480916659037 times found: 12000000 times not found: 12000000 ``` And when a similar one is run (*10 more loops) without ever finding the key, ``` doing in switching to ge…

Accepted Answer

We can do some better timings:

```
import timeit

d = dict.fromkeys(range(10000))

def d_get_has(d):
    return d.get(1)

def d_get_not_has(d):
    return d.get(-1)

def d_in_has(d):
    if 1 in d:
        return d[1]

def d_in_not_has(d):
    if -1 in d:
        return d[-1]

print timeit.timeit('d_get_has(d)', 'from __main__ import d, d_get_has')
print timeit.timeit('d_get_not_has(d)', 'from __main__ import d, d_get_not_has')
print timeit.timeit('d_in_has(d)', 'from __main__ import d, d_in_has')
print timeit.timeit('d_in_not_has(d)', 'from __main__ import d, d_in_not_has')
```

On my computer, the "in" variants are faster than the `.get` variants. This is probably because `.get` is an attribute lookup on the dict and an attribute lookup is likely to be as expensive as a membership test on the dict. Note that `in` and item lookup using `dict[x]` can be done directly in bytecode so the normal method lookups can be bypassed...

It also might be worth pointing out that I get a HUGE optimization if I just use pypy :-):

```
$ python ~/sandbox/test.py
0.169840812683
0.1732609272
0.122044086456
0.0991759300232

$ pypy ~/sandbox/test.py
0.00974893569946
0.00752687454224
0.00812077522278
0.00686597824097
```

Python dictionary lookup performance, get vs in

Solution

Problem