Question

I wonder what is better to do:

d = {
           'a': 1, 'b': 2}'a' in dTrue

or:

d = {
           'a': 1, 'b': 2}d.has_key('a')True

8,326 11 66 109 · Accepted Answer · 2009-08-24 16:33:18Z

546

accepted

in is definitely more pythonic.

In fact .

8,326

11

66

109

answered

Aug 24 '09 at 16:33

11.8k

1

24

33

2

As an addition, in Python 3, to check for the existence in values, instead of the keys, try >>> 1 in d.values() –

76

One semi-gotcha to avoid though is to make sure you do: "key in some_dict" rather than "key in some_dict.keys()". Both are equivalent semantically, but performance-wise the latter is much slower (O(n) vs O(1)). I've seen people do the "in dict.keys()" thinking it's more explicit & therefore better. –

1

in works with 2.6 too right? –

@Logan yes it does –

1

@BenjaminSchollnick what's the result? –

440k 75 813 1119 · Answer 2 · 2009-08-24 18:12:28Z

179

in wins hands-down, not just in elegance (and not being deprecated;-) but also in performance, e.g.:

$ python -mtimeit -s'd=dict.fromkeys(range(99))' '12 in d'10000000 loops, best of 3: 0.0983 usec per loop$ python -mtimeit -s'd=dict.fromkeys(range(99))' 'd.has_key(12)'1000000 loops, best of 3: 0.21 usec per loop

While the following observation is not always true, you'll notice that usually, in Python, the faster solution is more elegant and Pythonic; that's why -mtimeit is SO helpful -- it's not just about saving a hundred nanoseconds here and there!-)

answered

Aug 24 '09 at 18:12

440k

75

813

1119

2

thanks a lot, good to know, now I'm changing my code to use 'in' instead of has_key() ;) –

3

Thanks for this, made verifying that "in some_dict" is in fact O(1) much easier (try increasing the 99 to say 1999, and you'll find the runtime is about the same). –

has_key appears to be O(1) too. –

51.1k 9 116 151 · Answer 3 · 2009-08-24 16:33:51Z

43

According to python :

has_key() is deprecated in favor of key in d.

51.1k

9

116

151

answered

Aug 24 '09 at 16:33

53k

12

128

139

thanks a lot, it really helped! –

69.7k 16 127 172 · Answer 4 · 2009-08-24 22:11:34Z

28

Use dict.has_key() if (and only if) your code is required to be runnable by Python versions earlier than 2.3 (when key in dict was introduced).

69.7k

16

127

172

answered

Aug 24 '09 at 22:11

48.3k

3

59

123

6

While one would hope no one is using a Python earlier than 2.3 (released in 2003), I'm quite confident there are still some holdouts. So this answer is a valuable footnote to all the "use in of course, duh" answers. –

2

@JohnY This really comes into play with the embedded linux variants. I'm currently stuck using 2.3 on two projects :( –

1

The WebSphere update in 2013 uses Jython 2.1 as its main scripting language. So this is unfortunately still a useful thing to note, five years after you noted it. –

4,659 11 19 · Answer 5 · 2012-01-18 16:45:39Z

There is one example where in actually kills your performance.

If you use in on a O(1) container that only implements __getitem__ and has_key() but not __contains__ you will turn an O(1) search into an O(N) search (as in falls back to a linear search via __getitem__).

Fix is obviously trivial:

def __contains__(self, x):    return self.has_key(x)

score 8 · Answer 6

has_key is a dictionary method, but in will work on any collection, and even when __contains__ is missing, in will use any other method to iterate the collection to find out.

11 Answers