Return a default value if a dictionary key is not available

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.
     |  
    ...

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.

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.

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'

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]
'asdf'
>>> foo[2]
'qwerty'
>>> foo[3] is None
True

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:

eg.

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

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
    pass

else:

    # d['keyname'] does not exist
    pass

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:

try:
   <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.

As mentioned elsewhere a possible issue with dct.get(key, default) is that, if key in dct but dct[key] is None, you get None not your default:

>>> dct = dict(foo=123, baz=None)
>>> dct.get("foo", 0)
123
>>> dct.get("bar", 0)
0
>>> dct.get("baz", 0)
>>> # where'd the value go?

Since Python 3.8, using the "walrus operator" to create an assignment expression, you can handle this like:

>>> value if (value := dct.get("baz")) is not None else 0
0

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.

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

If you have a more complex requirement that equates to a cache, this class might come in handy:

class Cache(dict):
    """ Provide a dictionary based cache

        Pass a function to the constructor that accepts a key and returns
        a value.  This function will be called exactly once for any key
        required of the cache.
    """

    def __init__(self, fn):
        super()
        self._fn = fn

    def __getitem__(self, key):
        try:
            return super().__getitem__(key)
        except KeyError:
            value = self[key] = self._fn(key)
            return value

The constructor takes a function that is called with the key and should return the value for the dictionary. This value is then stored and retrieved from the dictionary next time. Use it like this...

def get_from_database(name):
    # Do expensive thing to retrieve the value from somewhere
    return value

answer = Cache(get_from_database)
x = answer(42)   # Gets the value from the database
x = answer(42)   # Gets the value directly from the dictionary

As mentioned an issue with dct.get(key, default) is that, if key exists but is mapped to a falsy value (e.g. None), you will get that value, not default.

If you want to return a default value even when key exists but is mapped to None, you can use this implementation:

class MyDict(dict):
    def myget(self, key, default=None):
        """Get value by key, return default if key is missing or is mapped to a falsy value."""
        val  = self.get(key, default)
        if val is None:
            val = default
        if isinstance(val, dict):
            val = MyDict(val)
        return val

Let's see an use case.

Suppose you get external data from a third-party that looks like this:

d1 = {"name":"Mark", "belongings":{"bycicles":2, "cars":5, "trucks":2}}
d2 = {"name":"Peter"}
d3 = {"name":"John", "belongings":None}

To get the number of cars that belongs to Mark, you would do:

d1.get("belongings").get("cars") # 5

and this would correctly return 5.

But if you use this to get the number of Peter's cars:

d2.get("belongings").get("cars") # throws AttributeError: 'NoneType' object has no attribute 'get'

you would get an Exception because d2 does not have a belongings key, so the first gest returns None.

To fix this, you would do:

d2.get("belongings", {}).get("cars", 0) # returns 0

This owuld correctly returns 0.

Now let's get the number of John's cars:

d3.get("belongings", {}).get("cars", 0) # throws AttributeError: 'NoneType' object has no attribute 'get'

This would throw an error because in d3 the key belongings is mapped to a None value, which is then returned.

Now let's use our implementation:

MyDict(d3).myget("belongings", {}).myget("cars", 0) # 0

1. d1={"One":1,"Two":2,"Three":3}

2. d1.get("Four")

If you will run this code there will be no 'Keyerror' which means you can use 'dict.get()' to avoid error and execute your code