How to Check If a Dictionary Contains Only Specific Types in Python

Introduction

In this lab, you will learn how to check if a Python dictionary contains only specific types for its keys and values. The lab focuses on understanding the importance of type checking within dictionaries to ensure data integrity.

You'll start by creating a sample dictionary and exploring the concept of type checking. Then, you'll learn how to use the isinstance() function in conjunction with the all() function to verify that all keys and values in a dictionary conform to the expected data types. This hands-on experience will equip you with the skills to validate dictionary contents and maintain code reliability.

Skills Graph

Understand Type Checking in Dictionaries

In this step, we'll explore the importance of type checking within dictionaries in Python. Dictionaries are versatile data structures that can store key-value pairs. However, to ensure the integrity and reliability of your code, it's crucial to understand how to check the types of keys and values stored in a dictionary.

Dictionaries in Python are defined using curly braces {}. Each element in a dictionary consists of a key and a corresponding value, separated by a colon :.

Let's start by creating a simple dictionary:

## Create a dictionary
my_dict = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

print(my_dict)

Save the above code in a file named type_checking.py within your ~/project directory. You can use the VS Code editor to create and edit this file.

Now, execute the script using the following command in the terminal:

python ~/project/type_checking.py

You should see the following output:

{'name': 'Alice', 'age': 30, 'city': 'New York'}

In this dictionary, the keys are strings ("name", "age", "city") and the values are a string ("Alice"), an integer (30), and another string ("New York").

Type checking becomes important when you want to ensure that the data stored in your dictionary conforms to your expectations. For example, you might want to verify that the age is always an integer or that the name is always a string.

Let's consider a scenario where you want to add a new key-value pair to the dictionary, but you want to ensure that the value is of a specific type.

Open the type_checking.py file in VS Code and modify it as follows:

## Create a dictionary
my_dict = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

## Function to add a key-value pair with type checking
def add_item(dictionary, key, value, expected_type):
    if isinstance(value, expected_type):
        dictionary[key] = value
        print(f"Added {key}: {value} to the dictionary.")
    else:
        print(f"Error: {key} must be of type {expected_type.__name__}.")

## Example usage
add_item(my_dict, "occupation", "Engineer", str)
add_item(my_dict, "salary", 75000, int)
add_item(my_dict, "is_active", True, bool)
add_item(my_dict, "height", "5.8", float) ## Intentionally incorrect type

print(my_dict)

In this code, we define a function add_item that takes a dictionary, a key, a value, and an expected type as input. The function uses the isinstance() function to check if the value is of the expected type. If it is, the key-value pair is added to the dictionary. Otherwise, an error message is printed.

Execute the script again:

python ~/project/type_checking.py

You should see the following output:

Added occupation: Engineer to the dictionary.
Added salary: 75000 to the dictionary.
Added is_active: True to the dictionary.
Error: height must be of type float.
{'name': 'Alice', 'age': 30, 'city': 'New York', 'occupation': 'Engineer', 'salary': 75000, 'is_active': True}

As you can see, the add_item function successfully added the "occupation", "salary", and "is_active" key-value pairs to the dictionary because their values matched the expected types. However, it printed an error message for "height" because the provided value ("5.8") is a string, while the expected type was float.

This example demonstrates the basic concept of type checking in dictionaries. In the following steps, we will explore more advanced techniques for ensuring type safety in your Python code.

Check Types of Keys and Values

In the previous step, we learned how to check the type of values when adding them to a dictionary. Now, let's delve deeper and explore how to check the types of both keys and values within a dictionary.

It's essential to ensure that keys in a dictionary are immutable types like strings, numbers, or tuples. Values, on the other hand, can be of any type. Let's modify our type_checking.py file to include key type checking.

Open the type_checking.py file in VS Code and modify it as follows:

## Create a dictionary
my_dict = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

## Function to add a key-value pair with type checking for both key and value
def add_item(dictionary, key, value, expected_key_type, expected_value_type):
    if not isinstance(key, expected_key_type):
        print(f"Error: Key must be of type {expected_key_type.__name__}.")
        return
    if not isinstance(value, expected_value_type):
        print(f"Error: Value must be of type {expected_value_type.__name__}.")
        return
    dictionary[key] = value
    print(f"Added {key}: {value} to the dictionary.")

## Example usage
add_item(my_dict, "occupation", "Engineer", str, str)
add_item(my_dict, "salary", 75000, str, int)
add_item(my_dict, 123, "Some Value", str, str) ## Intentionally incorrect key type

print(my_dict)

In this updated code, the add_item function now takes expected_key_type and expected_value_type as arguments. It checks if the provided key and value are of the expected types using isinstance(). If either the key or the value has an incorrect type, an error message is printed, and the function returns without adding the item to the dictionary.

Now, execute the script:

python ~/project/type_checking.py

You should see the following output:

Added occupation: Engineer to the dictionary.
Added salary: 75000 to the dictionary.
Error: Key must be of type str.
{'name': 'Alice', 'age': 30, 'city': 'New York', 'occupation': 'Engineer', 'salary': 75000}

The output shows that the "occupation" and "salary" key-value pairs were successfully added to the dictionary because both their keys and values matched the expected types. However, when we tried to add a key-value pair with an integer key (123), the function printed an error message because the expected key type was str.

Checking the types of both keys and values helps maintain the consistency and correctness of your data. It prevents unexpected errors and ensures that your dictionary behaves as expected.

Use all() with isinstance()

In this step, we'll explore how to use the all() function in combination with isinstance() to efficiently check the types of all keys and values in a dictionary. This approach is particularly useful when you need to validate the entire dictionary against a set of expected types.

The all() function in Python returns True if all elements in an iterable are true. We can use this function to iterate through the dictionary and check if all keys and values match the expected types.

Let's modify our type_checking.py file to incorporate this approach.

Open the type_checking.py file in VS Code and modify it as follows:

## Create a dictionary
my_dict = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

## Function to check types of all keys and values in a dictionary
def check_dictionary_types(dictionary, expected_key_type, expected_value_type):
    key_types_correct = all(isinstance(key, expected_key_type) for key in dictionary)
    value_types_correct = all(isinstance(value, expected_value_type) for value in dictionary.values())

    if key_types_correct and value_types_correct:
        print("All keys and values have the correct types.")
        return True
    else:
        print("Not all keys and values have the correct types.")
        return False

## Example usage
check_dictionary_types(my_dict, str, (str, int)) ## Expecting keys to be strings and values to be either strings or integers

my_dict["zip"] = "10001"
check_dictionary_types(my_dict, str, (str, int))

my_dict["country"] = 123
check_dictionary_types(my_dict, str, (str, int))

In this code, the check_dictionary_types function takes a dictionary, an expected key type, and an expected value type as input. It uses the all() function with a generator expression to check if all keys are of the expected type and if all values are of the expected type. If both conditions are true, it prints a success message and returns True. Otherwise, it prints an error message and returns False.

Execute the script:

python ~/project/type_checking.py

You should see the following output:

All keys and values have the correct types.
All keys and values have the correct types.
Not all keys and values have the correct types.

The first call to check_dictionary_types returns True because all keys are strings and all values are either strings or integers. The second call also returns True after adding the "zip" key. However, the third call returns False after adding the "country" key with an integer value, because now one of the keys is an integer, violating the expected key type.

Using all() with isinstance() provides a concise and efficient way to validate the types of all elements in a dictionary, ensuring data integrity and preventing unexpected errors in your Python code.

Summary

In this lab, we began by understanding the importance of type checking within Python dictionaries, which are versatile data structures storing key-value pairs. We created a sample dictionary with string keys and mixed-type values (string and integer) and emphasized the need to ensure data integrity by verifying the types of keys and values.

The initial step highlighted the significance of type checking to ensure that the data stored in a dictionary conforms to expected types, such as verifying that an age is always an integer or a name is always a string. The lab setup involved creating a type_checking.py file and executing it to display the dictionary's contents.