Python Dictionary contains (6+ Example)

In this Python Tutorial, I will explain what the Python Dictionary contains means and how we can check what the dictionary contains in Python using different methods with examples.

What does the Python Dictionary contains mean?

In Python, dictionaries are a flexible way to store and manipulate data. We use the term “Python Dictionary Contains” to describe the action of checking whether a specific key or value is present within a dictionary Python. In this article, we will go over various ways to determine if a dictionary contains a certain element, key, or value, with relevant examples.

Python Dictionary Contains Key

To check if a Python dict contains a specific key, you can use the in keyword. This is an essential task because attempting to access a key that does not exist will result in a KeyError.

For instance: Consider a program that needs to find the capital of a U.S. state. We have a dictionary of states and their capitals.

states_capitals = {
    'California': 'Sacramento',
    'Texas': 'Austin',
    'Florida': 'Tallahassee',
}

print('California' in states_capitals)

Output: In this example, ‘California’ in states_capitals returns True, confirming that the dictionary contains the key ‘California‘.

True

Python Dictionary Contains Value

To verify if a Python dictionary contains the value, use the values() method followed by the in keyword.

For example: Now, imagine you want to check if a specific city is the capital of any U.S. state in the above states_capitals dictionary in Python.

states_capitals = {
    'California': 'Sacramento',
    'Texas': 'Austin',
    'Florida': 'Tallahassee',
}

print('Austin' in states_capitals.values())

Output: Here, ‘Austin‘ in states_capitals.values() returns True, indicating that ‘Austin‘ is a capital in the states_capitals dictionary in Python.

True

Python Dictionary Contains List as Value

Sometimes, a dictionary contains a list of values where the key is associated with a list of values.

For instance, In a program keeping track of major cities in each state, you want to check if a particular city is in the list of major cities for a specific state.

states_cities = {
    'California': ['Los Angeles', 'San Francisco', 'San Diego'],
    'Texas': ['Houston', 'Dallas', 'San Antonio'],
}

print('San Francisco' in states_cities['California'])

Output: In this code of Python, ‘San Francisco‘ in states_cities[‘California’] returns True, confirming that ‘San Francisco‘ is one of the major cities in California.

True

Python Dictionary Contains Another Dictionary

In some scenarios, a Python dictionary contains another dictionary as its value. They are called nested dictionary in Python.

For instance, Consider you are managing a database of U.S. states, with each state having a nested Python dictionary of additional information, and you need to check for a specific key in the nested dictionary.

states_details = {
    'California': {
        'Capital': 'Sacramento',
        'Population': 39538223,
    },
    'Texas': {
        'Capital': 'Austin',
        'Population': 29145505,
    },
}

print('Capital' in states_details['California'])

Output: In this case, ‘Capital‘ in states_details[‘California’] returns True, indicating that the nested dictionary contains the key ‘Capital‘.

True

Python Dictionary Contains Duplicate Keys

A Python dictionary contains multiple keys but cannot have duplicate keys. Each key must be unique. If a duplicate key is found, the last occurrence will override the previous values.

For example, In case you accidentally define a dictionary with duplicate keys, Python will retain the last occurrence.

duplicate_keys = {
    'a': 1,
    'b': 2,
    'a': 3,
}

print(duplicate_keys)

Output: Here, even though the dictionary is defined with duplicate keys, the output is {‘a’: 3, ‘b’: 2}, retaining the last occurrence of ‘a‘.

{'a': 3, 'b': 2}

Python dictionary contains multiple keys

Python dictionary contains key value pair

For checking Python dictionary contains a key-value pair, utilize items() alongside the in keyword.

For example, Let’s take a record of the participants and their selected subjects for the quiz and check for one of them with their selected subject,

Name_with_subject = {'John': ['Math', 'Science'], 'Emily': ['English', 'History']}
if ('John', ['Math', 'Science']) in Name_with_subject.items():
    print("Yes")

Output: Here, as the name is in the dictionary so, the if condition holds True and gives the desired output.

Yes

Python dictionary contains key value pair

Methods to check what the Python Dictionary contains

There are many different methods to prevent if the Python Dictionary includes a key, values, or pair.

Name	Description
The in Keyword	The in keyword in Python is used to check if a specified key exists within a dictionary.
The get() Method	The get() method in Python is used to retrieve the value for a specified key from the dictionary.
The keys() Method	The keys() method returns a view object that displays a list of all the keys in the dictionary.
The values() Method	The values() method is used to check if a specific value exists in the dictionary.
The items() Method	The items() method returns a view object that displays a list of dictionary’s (key, value) tuple pairs.
The all() Function	The all() function returns True if all items in an iterable are true.

List of methods present in Python to check whether the dictionary has the specified key, value, or pair.

Let’s see them one by one using demonstrative examples:

Method 1: Using the in Keyword to Check for a Key

The in keyword in Python is used to check if a specified key exists within a dictionary. This method returns True if the key is found in the dictionary, and False otherwise. It is a fast and straightforward way to check for the existence of a key.

Scenario: Checking if a state is in a dictionary of U.S. states and their populations.

state_populations = {'California': 39538223, 'Texas': 29145505, 'Florida': 21538187}
# Checking if 'Texas' is a key in the state_populations dictionary.
if 'Texas' in state_populations:
    print(f"Texas has a population of {state_populations['Texas']}.")

Output: In this case, ‘Texas‘ is found in the state_populations Python dictionary, and the population is printed out.

Texas has a population of 29145505.

Method 2: Using the get() Method to Check for a Key:

The get() method in Python is used to retrieve the value for a specified key from the dictionary. It returns None if the key does not exist (unless a default value is specified). By checking the returned value, we can determine whether a key exists in the dictionary in Python.

Scenario: In a dictionary of national parks and their respective states, you want to find out in which state “Yosemite National Park” is located.

national_parks = {'Yosemite': 'California', 'Grand Canyon': 'Arizona', 'Everglades': 'Florida'}
park = national_parks.get('Yosemite')
if park:
    print(f"Yosemite National Park is in {park}.")
else:
    print("This national park isn't in the dictionary.")

Output: Here, the get() method returns California as ‘Yosemite‘ was in the national_park Python dictionary.

Yosemite National Park is in California.

Method 3: Using the keys() Method to Check for a Key

The keys() method returns a view object that displays a list of all the keys in the dictionary. You can use the in keyword to check if a specific key exists within the keys.

Scenario: You’re organizing a road trip and have a list of states you’ll visit. You want to confirm if “Nevada” is one of your destinations.

road_trip_states = {'California': 'Los Angeles', 'Arizona': 'Phoenix', 'Utah': 'Salt Lake City'}
if 'Nevada' in road_trip_states.keys():
    print("Nevada is one of the destinations!")
else:
    print("Nevada isn't on the list.")

Output: Here, the key() method returns False as ‘Nevada‘ is not in the road_trip_states dictionary in Python.

Nevada isn't on the list.

Method 4: Using the values() Method to Check for a Value

The values() method is used to check if a specific value exists in the dictionary. It returns a view object that displays a list of all the values in the dictionary Python. You can use the in keyword to check if a particular value is present among the values.

Scenario: Within a Python dictionary of U.S. states and their famous foods, you want to see if any state is famous for “Burgers“.

state_foods = {'New York': 'Pizza', 'Maine': 'Lobster', 'Texas': 'BBQ'}
if 'Burgers' in state_foods.values():
    print("One of the states is famous for Burgers!")
else:
    print("No state in the list is particularly famous for Burgers.")

Output: In this example, the value() method returns False as ‘Burgers‘ is not in the state_foods dictionary in Python.

No state in the list is particularly famous for Burgers.

Method 5: Using the items() Method to Check for a Key-Value Pair

The items() method returns a view object that displays a list of dictionary’s (key, value) tuple pairs. You can use the in keyword to check if a particular key-value pair is present in the dictionary.

Scenario: You have a dictionary of U.S. cities and their nicknames in Python. You want to confirm that Chicago is indeed called “The Windy City“.

city_nicknames = {
    'New York': 'The Big Apple',
    'Los Angeles': 'City of Angels',
    'Chicago': 'The Windy City'
}
if ('Chicago', 'The Windy City') in city_nicknames.items():
    print("Yes, Chicago is called 'The Windy City'.")
else:
    print("This nickname doesn't match the city.")

Output: In this example, the conditional statements return True as (‘Chicago’, ‘The Windy City’) is in the city_nicknames in dictionary Python.

Yes, Chicago is called 'The Windy City'.

Method 6: Using the all() Function to Check for Multiple Keys or Values

The all() function returns True if all items in an iterable are true. It can be used to check if multiple keys or values exist in a Python dictionary by iterating over each item and checking their existence.

Scenario for Multiple Keys: You’re studying famous U.S. landmarks and have a list in your dictionary. You want to ensure that both “Statue of Liberty” and “Mount Rushmore” are on your list.

landmarks = {
    'Statue of Liberty': 'New York',
    'Golden Gate Bridge': 'California',
    'Mount Rushmore': 'South Dakota'
}
landmarks_to_check = ['Statue of Liberty', 'Mount Rushmore']
if all(landmark in landmarks for landmark in landmarks_to_check):
    print(f"All landmarks, {', '.join(landmarks_to_check)}, are in the list.")

Output: Here, the all() function returns True as all keys present in the list.

All landmarks, Statue of Liberty, Mount Rushmore, are in the list.

Scenario for Multiple Values: In a dictionary of car manufacturers and their country of origin, you want to verify if the USA and Japan are both represented.

car_manufacturers = {'Ford': 'USA', 'Toyota': 'Japan', 'BMW': 'Germany'}
countries_to_check = ['USA', 'Japan']
if all(country in car_manufacturers.values() for country in countries_to_check):
    print(f"Both countries, {', '.join(countries_to_check)}, are present.")

Output: Here, the all() function returns True as all values present in the list.

Both countries, USA, Japan, are present.

Conclusion

In summary, understanding what the Python Dictionary contains means, like various elements such as keys, values, pairs of both, or other dictionaries, and how we can check what the dictionary contains in Python using different six methods like the ‘in‘ keyword, get() method, keys() method, values() method, items() method or all() method with illustrative examples.

Recognizing the scenarios and applying the appropriate syntax to verify the existence of elements in a Python dictionary effectively can lead to error-free coding.