python – Return None if Dictionary key is not available

The Question :

532 people think this question is useful

I need a way to get a dictionary value if its key exists, or simply return None, if it does not.

However, Python raises a KeyError exception if you search for a key that does not exist. I know that I can check for the key, but I am looking for something more explicit. Is there a way to just return None if the key does not exist?

The Question Comments :
  • Just use .get(key) instead of [key]
  • A dict raises a KeyError exception. It does not “return key_error”.
  • Accessing the key and catching the exception is perfectly okay in Python. It is even a well known and oft-used design pattern. If you return None instead, it becomes impossible to store None as a value, which may be relevant in some cases.
  • Sometimes you want to treat “None” entries in the dictionary and missing entries the same, in that case the accepted answer seems to do the job just fine.
  • @Ber I have edited the question to clarify. You could have done so as well.

The Answer 1

876 people think this answer is useful

You can use dict.get()

value = d.get(key)

which will return None if key is not in d. You can also provide a different default value that will be returned instead of None:

value = d.get(key, "empty")

The Answer 2

65 people think this answer is useful

Wonder no more. It’s built into the language.

    >>> help(dict)

    Help on class dict in module builtins:

    class dict(object)
     |  dict() -> new empty dictionary
     |  dict(mapping) -> new dictionary initialized from a mapping object's
     |      (key, value) pairs
     |  get(...)
     |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.

The Answer 3

24 people think this answer is useful

Use dict.get

Returns the value for key if key is in the dictionary, else default. If default is not given, it defaults to None, so that this method never raises a KeyError.

The Answer 4

20 people think this answer is useful

You should use the get() method from the dict class

d = {}
r = d.get('missing_key', None)

This will result in r == None. If the key isn’t found in the dictionary, the get function returns the second argument.

The Answer 5

18 people think this answer is useful

If you want a more transparent solution, you can subclass dict to get this behavior:

class NoneDict(dict):
    def __getitem__(self, key):
        return dict.get(self, key)

>>> foo = NoneDict([(1,"asdf"), (2,"qwerty")])
>>> foo[1]
>>> foo[2]
>>> foo[3] is None

The Answer 6

14 people think this answer is useful

I usually use a defaultdict for situations like this. You supply a factory method that takes no arguments and creates a value when it sees a new key. It’s more useful when you want to return something like an empty list on new keys (see the examples).

from collections import defaultdict
d = defaultdict(lambda: None)
print d['new_key']  # prints 'None'

The Answer 7

9 people think this answer is useful

You could use a dict object’s get() method, as others have already suggested. Alternatively, depending on exactly what you’re doing, you might be able use a try/except suite like this:

   <to do something with d[key]>
except KeyError:
   <deal with it not being there>

Which is considered to be a very “Pythonic” approach to handling the case.

The Answer 8

8 people think this answer is useful

A one line solution would be:

item['key'] if 'key' in item else None

This is useful when trying to add dictionary values to a new list and want to provide a default:


row = [item['key'] if 'key' in item else 'default_value']

The Answer 9

6 people think this answer is useful

As others have said above, you can use get().

But to check for a key, you can also do:

d = {}
if 'keyname' in d:

    # d['keyname'] exists


    # d['keyname'] does not exist

The Answer 10

1 people think this answer is useful

For those using the dict.get technique for nested dictionaries, instead of explicitly checking for every level of the dictionary, or extending the dict class, you can set the default return value to an empty dictionary except for the out-most level. Here’s an example:

my_dict = {'level_1': {
             'level_2': {
                  'level_3': 'more_data'
result = my_dict.get('level_1', {}).get('level_2', {}).get('level_3')
# result -> 'more_data'
none_result = my_dict.get('level_1', {}).get('what_level', {}).get('level_3')
# none_result -> None

WARNING: Please note that this technique only works if the expected key’s value is a dictionary. If the key what_level did exist in the dictionary but its value was a string or integer etc., then it would’ve raised an AttributeError.

The Answer 11

0 people think this answer is useful

I was thrown aback by what was possible in python2 vs python3. I will answer it based on what I ended up doing for python3. My objective was simple: check if a json response in dictionary format gave an error or not. My dictionary is called “token” and my key that I am looking for is “error”. I am looking for key “error” and if it was not there setting it to value of None, then checking is the value is None, if so proceed with my code. An else statement would handle if I do have the key “error”.

if ((token.get('error', None)) is None):
    do something

The Answer 12

-2 people think this answer is useful

If you can do it with False, then, there’s also the hasattr built-in funtion:

hasattr(e, 'message'):
>>> False

Add a Comment