Check if a given key already exists in a dictionary
To get the idea how to do that we first inspect what methods we can call on dictionary.
Here are the methods:
d={'clear':0, 'copy':1, 'fromkeys':2, 'get':3, 'items':4, 'keys':5, 'pop':6, 'popitem':7, 'setdefault':8, 'update':9, 'values':10}
Python Dictionary clear[] Removes all Items
Python Dictionary copy[] Returns Shallow Copy of a Dictionary
Python Dictionary fromkeys[] Creates dictionary from given sequence
Python Dictionary get[] Returns Value of The Key
Python Dictionary items[] Returns view of dictionary [key, value] pair
Python Dictionary keys[] Returns View Object of All Keys
Python Dictionary pop[] Removes and returns element having given key
Python Dictionary popitem[] Returns & Removes Element From Dictionary
Python Dictionary setdefault[] Inserts Key With a Value if Key is not Present
Python Dictionary update[] Updates the Dictionary
Python Dictionary values[] Returns view of all values in dictionary
The brutal method to check if the key already exists may be the get[]
method:
d.get["key"]
The other two interesting methods items[]
and keys[]
sounds like too much of work. So let's examine if get[]
is the right method for us. We
have our dict d
:
d= {'clear':0, 'copy':1, 'fromkeys':2, 'get':3, 'items':4, 'keys':5, 'pop':6, 'popitem':7, 'setdefault':8, 'update':9, 'values':10}
Printing shows the key we don't have will return None
:
print[d.get['key']] #None
print[d.get['clear']] #0
print[d.get['copy']] #1
We use that to get the information if the key is present or no. But consider this if we create a dict with a single key:None
:
d= {'key':None}
print[d.get['key']] #None
print[d.get['key2']] #None
Leading that get[]
method is not reliable in case some values may be None
.
This story should have a happier ending. If we use the in
comparator:
print['key' in d] #True
print['key2' in d] #False
We get the correct results.
We may examine the Python byte code:
import dis
dis.dis["'key' in d"]
# 1 0 LOAD_CONST 0 ['key']
# 2 LOAD_NAME 0 [d]
# 4 COMPARE_OP 6 [in]
# 6 RETURN_VALUE
dis.dis["d.get['key2']"]
# 1 0 LOAD_NAME 0 [d]
# 2 LOAD_METHOD 1 [get]
# 4 LOAD_CONST 0 ['key2']
# 6 CALL_METHOD 1
# 8 RETURN_VALUE
This shows that in
compare operator is not just more reliable, but even faster than get[]
.
In this tutorial, you’ll learn how to use Python to check if a key exists in a dictionary. You’ll also learn how to check if a value exists in a dictionary. You’ll learn how to do this using the in
operator, the .get[]
method, the has_key[]
function, and the .keys[]
and .values[]
methods.
Knowing how to work with Python dictionaries is an important skill. This can be especially helpful when working with web APIs that return JSON data.
While we can easily index a
dictionary, if a key doesn’t exist, a KeyError
will be thrown. This will cause some significant problems in your program, unless these errors are handled.
A much more safe alternative to using dictionary indexing, is to first check if a given key exists in a dictionary. Let’s get started learning!
The Quick Answer: Use in
to see if a key exists
- What is a Python Dictionary?
- The Problem with Indexing a Python Dictionary
- Use Python to Check if a Key Exists: Python keys Method
- Use Python to Check if a Key Exists: Python in Operator
- Use the .get Method to Check if a Key Exists in a Python Dictionary
- Check if a Value Exists in a Python Dictionary Using .values[]
- Conclusion
What is a Python Dictionary?
Dictionaries in Python are one of the main, built-in data structures. They consist of key:value
pairs that make finding an items value easy, if you know their corresponding key. One of the unique attributes of a dictionary is that keys must be unique, but that values can be duplicated.
Let’s take a look at how dictionaries look in Python. They’re
created using {}
curly brackets and the key:value
pairs are separated by commas.
Let’s create a dictionary called ages
, which, well, contains the ages of different people:
ages = { 'Matt': 30, 'Katie': 29, 'Nik': 31, 'Jack': 43, 'Alison': 32, 'Kevin': 38 }
One way that you’re often taught to access a dictionary value is to use indexing via the []
square bracket accessing. In the next section, you’ll see how dictionary indexing works and why it’s not always the best option. Following that, you’ll learn different methods of ensuring that a key
exists.
The Problem with Indexing a Python Dictionary
Indexing a dictionary is an easy way of getting a dictionary key’s value – if the given key exists in the dictionary. Let’s take a look at how dictionary indexing works. We’ll use dictionary indexing to get the value for the key Nik
from our dictionary ages
:
>>> ages = {'Matt': 30, 'Katie': 29, 'Nik': 31, 'Jack': 43, 'Alison': 32, 'Kevin': 38} >>> print[ages['Nik']] 31
We can see here that
this worked beautifully. That being said, let’s see if we try to get the value for the key Jill
, which doesn’t exist in the dictionary:
>>> ages = {'Matt': 30, 'Katie': 29, 'Nik': 31, 'Jack': 43, 'Alison': 32, 'Kevin': 38} >>> print[ages['Jill']] KeyError: 'Jill'
We can see here, that if we try to access a dictionary’s value for a key that doesn’t exist, that a KeyError
is thrown. This has some huge implications for your code. Unless the error is explicitly handled, the program will fail. One way to avoid a KeyError
is to ensure that a key actually exists in a Python dictionary.
That’s exactly what you’ll learn in the next few sections. Let’s get started!
Use Python to Check if a Key Exists: Python keys Method
Python dictionary come with a built-in method that allows us to generate a list-like object that contains all the keys in a dictionary. Conveniently, this is named the .keys[]
method.
Printing out dict.keys[]
looks
like this:
print[ages.keys[]] # Returns: dict_keys[['Matt', 'Katie', 'Nik', 'Jack', 'Alison', 'Kevin']]
We can see how that looks like a little bit like a list. We can now check if a key exists in that list-like object!
Let’s see how we can use the .keys[]
method to see if a key exists in a dictionary. Let’s use this method to see if a key exists:
# Check if a key exists in a Python dictionary by checking all keys ages = {'Matt': 30, 'Katie': 29, 'Nik': 31, 'Jack': 43, 'Alison': 32, 'Kevin': 38} some_key = 'James' if some_key in ages.keys[]: print['Key exists'] else: print['Key doesn\'t exist'] # Returns Key doesn't exist
We can see here that we check whether or not a provided key, some_key
, exists in the keys of our dictionary. In this case, the key didn’t exist and the program printed out Key doesn't exist
.
In the next section, you’ll learn how to simplify this even further!
Use Python to Check if a Key Exists: Python in Operator
The method above works well, but we can simplify checking if a given key exists in a Python dictionary even further. We can actually omit the .keys[]
method entirely, and using the in
operator will scan all keys in a
dictionary.
Let’s see how this works in practise:
ages = {'Matt': 30, 'Katie': 29, 'Nik': 31, 'Jack': 43, 'Alison': 32, 'Kevin': 38} some_key = 'Nik' if some_key in ages: print['Key exists'] else: print['Key doesn\'t exist'] # Returns: Key exists
We can see here that our method actually looks very similar to the above, but we’ve been able to strip out the .keys[]
method entirely! This actually helps the code read a bit more plain-language.
in the next section, you’ll learn how to actually retrieve a key’s value, even if a key doesn’t exist!
Check out some other Python tutorials on datagy, including our complete guide to styling Pandas and our comprehensive overview of Pivot Tables in Pandas!
Use the .get Method to Check if a Key Exists in a Python Dictionary
Working with dictionaries in Python generally involves getting a key’s value – not just checking if it exists. You learned earlier that simply indexing the dictionary will throw a KeyError
if a key doesn’t exist. How can we do this safely, without breaking out program?
The answer to this, is to use the Python .get[]
method. The .get[]
method will simply return None
if a key doesn’t exist. Let’s try this out:
ages = {'Matt': 30, 'Katie': 29, 'Nik': 31, 'Jack': 43, 'Alison': 32, 'Kevin': 38} print[ages.get['Jack']] print[ages.get['Jill']] # Returns: # 43 # None
We can see
here that when the .get[]
method is applied to return a key that exists, that key’s value is correctly returned. When a key doesn’t exist, the program continues to run, but it returns None
.
What is particularly helpful about the Python .get[]
method, is that it allows us to return a value, even if a key doesn’t exist.
Say we wanted our program to notify us that a key didn’t exist. We could ask the .get[]
method to return “Key doesn’t exist!”.
Let’s see how we can do this:
ages = {'Matt': 30, 'Katie': 29, 'Nik': 31, 'Jack': 43, 'Alison': 32, 'Kevin': 38} print[ages.get['Jill', "The key doesn't exist"]] # Returns: "The key doesn't exist!"
The .get[]
method is a great and safe way to see if a key exists in a Python dictionary. Now, let’s learn to see whether or not a given value exists in a Python dictionary.
Similar to the Python dictionary .keys[]
method, dictionaries have a corresponding .values[]
method, which returns a list-like object for all the values in a dictionary.
Let’s see how we can access all of a dictionary’s values:
ages = {'Matt': 30, 'Katie': 29, 'Nik': 31, 'Jack': 43, 'Alison': 32, 'Kevin': 38} print[ages.values[]] #Returns: dict_values[[30, 29, 31, 43, 32, 38]]
We can use this to see whether or not a value exists. Say we wanted to know if the age 27 existed in our dictionary, we could write the following:
ages = {'Matt': 30, 'Katie': 29, 'Nik': 31, 'Jack': 43, 'Alison': 32, 'Kevin': 38} some_age = 27 if some_age in ages.values[]: print['Age exists!'] else: print["Age doesn't exist!"] # Returns: Age doesn't exist!
Now, what if we wanted to return the key or keys for a given value. We can safely do this using a list comprehension, which will have three permutations:
- Be an empty list, if the value doesn’t exist,
- Have one item, if the value exists once
- Have more than one item, if the value exists more than once
Let’s use a slightly modified dictionary to see this in action:
# Getting all keys of a certain value in a Python dictionary ages = {'Matt': 30, 'Katie': 29, 'Nik': 31, 'Jack': 43, 'Jill': 43, 'Alison': 32, 'Kevin': 38} value_43 = [key for key, value in ages.items[] if value == 43] print[value_43] # Returns: ['Jack', 'Jill']
We’ve created a list comprehension that adds each key, if the value of that key is equal to 43.
What are Python List Comprehensions? To learn more about list comprehensions, check out my comprehensive tutorial here and my in-depth video below!
Conclusion
In this post, you learned how to check if a key
exists in a Python dictionary. You learned how to do this with the .keys[]
method, the in
operator, and the .get[]
method. You also learned how to see if a given value exists in a Python dictionary and how to get that values’ key[s].
To learn more about dictionaries in Python, check out the official documentation here.