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?
.get(key)
instead of [key]
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")
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. | ...
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.
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.
None
explicitly. It is the default.
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
defaultdict
is that it will grow each time an element that is not yet in there is requested. This is not always desirable.
foo['bar']['test']['sss']
to return None
instead of exception, After one depth it start giving TypeError
instead of KeyError
NoneDicts
. This would help in case the KeyError
would happen in the innermost object. Otherwise the problem is, that once you return a None
object you can't subscribe it anymore. One ugly hack would be to return another object that tests like None
. Beware however that this could lead to horrible bugs.
return dict.get(self, key)
to return super().get(key)
? Then if I decide to use OrderedDict instead of dict, for example, I don't have to worry about changing multiple lines of code.
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'
defaultdict
is that it will keep growing each time a non-existing element is requested.
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.
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
get
method.
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
You can use try-except block
try:
value = dict['keyname']
except IndexError:
value = None
d1={"One":1,"Two":2,"Three":3} 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
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
If you can do it with False
, then, there's also the hasattr built-in funtion:
e=dict()
hasattr(e, 'message'):
>>> False
Success story sharing
None
if the key is explicitly mapped toNone
in the dict. If that's not what you want, you can use something liked.get(key) or "empty"
.[]
,""
,False
,0.0
or indeedNone
), then your solution would always return0
. If you expectNone
s as values, you will have to do theif key in d:
check explicitly."empty"
is returned ifkey
is not a valid key ind
. It has nothing to do with the valuekey
is mapped to.