How to Check If a Dictionary’s Values Are of the Same Type in Python

Introduction

In this lab, you will learn how to check if all values in a Python dictionary are of the same type. The lab explores the concept of type uniformity and demonstrates how to use the all() function with type() to verify that all values in a dictionary share the same data type.

The lab guides you through creating Python scripts to explore type uniformity by first creating lists with elements of the same type and then lists with mixed data types. You will then learn how to apply this knowledge to dictionaries, including handling empty dictionaries, to determine if their values are of the same type.

Skills Graph

Explore Type Uniformity

In this step, you will learn about type uniformity in Python. Type uniformity refers to the concept of ensuring that all elements within a collection, such as a list or dictionary, are of the same data type. This is important for maintaining consistency and avoiding unexpected errors in your code.

Let's start by creating a Python script to explore this concept.

1. Open the VS Code editor in the LabEx environment.

2. Create a new file named type_uniformity.py in the ~/project directory.

   touch ~/project/type_uniformity.py

3. Open the type_uniformity.py file in the editor.

Now, let's add some code to the type_uniformity.py file to create a list with elements of the same type.

## Create a list of integers
int_list = [1, 2, 3, 4, 5]

## Print the list
print("List of integers:", int_list)

## Verify the type of each element
for item in int_list:
    print("Type of", item, "is", type(item))

In this code, we create a list named int_list containing only integer values. We then iterate through the list and print the type of each element using the type() function.

Next, let's create a list with elements of different types.

## Create a list of mixed data types
mixed_list = [1, "hello", 3.14, True]

## Print the list
print("\nList of mixed data types:", mixed_list)

## Verify the type of each element
for item in mixed_list:
    print("Type of", item, "is", type(item))

In this code, we create a list named mixed_list containing integers, strings, floats, and booleans. We then iterate through the list and print the type of each element.

Now, let's run the script to see the output.

1. Open the terminal in the VS Code environment.

2. Navigate to the ~/project directory.

   cd ~/project

3. Run the type_uniformity.py script using the python command.

   python type_uniformity.py

You should see output similar to the following:

List of integers: [1, 2, 3, 4, 5]
Type of 1 is <class 'int'>
Type of 2 is <class 'int'>
Type of 3 is <class 'int'>
Type of 4 is <class 'int'>
Type of 5 is <class 'int'>

List of mixed data types: [1, 'hello', 3.14, True]
Type of 1 is <class 'int'>
Type of hello is <class 'str'>
Type of 3.14 is <class 'float'>
Type of True is <class 'bool'>

As you can see, the int_list contains elements of the same type (int), while the mixed_list contains elements of different types (int, str, float, bool).

Understanding type uniformity is crucial for writing robust and maintainable Python code. In the following steps, you will learn how to use the all() function in conjunction with the type() function to check for type uniformity in collections.

Use all() with type() on Values

In this step, you will learn how to use the all() function in combination with the type() function to check if all elements in a list have the same data type. This is a powerful technique for ensuring type uniformity in your Python code.

The all() function returns True if all elements in an iterable are true. We can use this function to check if a condition is true for all elements in a list.

Let's continue working with the type_uniformity.py file you created in the previous step.

1. Open the type_uniformity.py file in the VS Code editor.

Now, let's add some code to check if all elements in a list are integers using the all() and type() functions.

## List of integers
int_list = [1, 2, 3, 4, 5]

## Check if all elements are integers
all_integers = all(type(item) is int for item in int_list)

## Print the result
print("\nAre all elements in int_list integers?", all_integers)

In this code, we use a generator expression (type(item) is int for item in int_list) to create a sequence of boolean values. Each boolean value indicates whether the corresponding element in int_list is an integer. The all() function then checks if all the boolean values in the sequence are True.

Next, let's check if all elements in a list of mixed data types are integers.

## List of mixed data types
mixed_list = [1, "hello", 3.14, True]

## Check if all elements are integers
all_integers = all(type(item) is int for item in mixed_list)

## Print the result
print("Are all elements in mixed_list integers?", all_integers)

Now, let's run the script to see the output.

1. Open the terminal in the VS Code environment.

2. Navigate to the ~/project directory.

   cd ~/project

3. Run the type_uniformity.py script using the python command.

   python type_uniformity.py

You should see output similar to the following:

List of integers: [1, 2, 3, 4, 5]
Type of 1 is <class 'int'>
Type of 2 is <class 'int'>
Type of 3 is <class 'int'>
Type of 4 is <class 'int'>
Type of 5 is <class 'int'>

List of mixed data types: [1, 'hello', 3.14, True]
Type of 1 is <class 'int'>
Type of hello is <class 'str'>
Type of 3.14 is <class 'float'>
Type of True is <class 'bool'>

Are all elements in int_list integers? True
Are all elements in mixed_list integers? False

As you can see, the all() function correctly identifies that all elements in int_list are integers, while not all elements in mixed_list are integers.

This technique can be used to check for type uniformity in any list, regardless of the data types it contains. In the next step, you will learn how to handle empty dictionaries when checking for type uniformity.

Handle Empty Dictionaries

In this step, you will learn how to handle empty dictionaries when checking for type uniformity. An empty dictionary is a dictionary with no key-value pairs. When checking for type uniformity in an empty dictionary, it's important to handle this case gracefully to avoid errors.

Let's continue working with the type_uniformity.py file you created in the previous steps.

1. Open the type_uniformity.py file in the VS Code editor.

Now, let's add some code to check for type uniformity in an empty dictionary.

## Empty dictionary
empty_dict = {}

## Check if the dictionary is empty
if not empty_dict:
    print("\nThe dictionary is empty.")
else:
    ## Check if all values have the same type (this will not be executed for an empty dictionary)
    first_type = type(next(iter(empty_dict.values())))
    all_same_type = all(type(value) is first_type for value in empty_dict.values())
    print("Are all values in the dictionary of the same type?", all_same_type)

In this code, we first check if the dictionary empty_dict is empty using the if not empty_dict: condition. If the dictionary is empty, we print a message indicating that the dictionary is empty. Otherwise, we proceed to check if all values in the dictionary have the same type.

Explanation:

• if not empty_dict:: This condition checks if the dictionary is empty. An empty dictionary evaluates to False in a boolean context, so not empty_dict will be True if the dictionary is empty.
• print("\nThe dictionary is empty."): This line prints a message indicating that the dictionary is empty.
• The else block is not executed when the dictionary is empty.

Now, let's add some code to check for type uniformity in a non-empty dictionary.

## Dictionary with integer values
int_dict = {"a": 1, "b": 2, "c": 3}

## Check if the dictionary is empty
if not int_dict:
    print("\nThe dictionary is empty.")
else:
    ## Check if all values have the same type
    first_type = type(next(iter(int_dict.values())))
    all_same_type = all(type(value) is first_type for value in int_dict.values())
    print("Are all values in the dictionary of the same type?", all_same_type)

In this code, we create a dictionary named int_dict with integer values. We then check if the dictionary is empty. If it's not empty, we get the type of the first value in the dictionary and check if all other values have the same type.

Now, let's run the script to see the output.

1. Open the terminal in the VS Code environment.

2. Navigate to the ~/project directory.

   cd ~/project

3. Run the type_uniformity.py script using the python command.

   python type_uniformity.py

You should see output similar to the following:

List of integers: [1, 2, 3, 4, 5]
Type of 1 is <class 'int'>
Type of 2 is <class 'int'>
Type of 3 is <class 'int'>
Type of 4 is <class 'int'>
Type of 5 is <class 'int'>

List of mixed data types: [1, 'hello', 3.14, True]
Type of 1 is <class 'int'>
Type of hello is <class 'str'>
Type of 3.14 is <class 'float'>
Type of True is <class 'bool'>

Are all elements in int_list integers? True
Are all elements in mixed_list integers? False

The dictionary is empty.
Are all values in the dictionary of the same type? True

As you can see, the code correctly handles the empty dictionary and prints the appropriate message. For the non-empty dictionary, it checks if all values have the same type and prints the result.

This completes the lab on exploring type uniformity in Python. You have learned how to check for type uniformity in lists and dictionaries, and how to handle empty dictionaries gracefully.

Summary

In this lab, you explored the concept of type uniformity in Python, which involves ensuring that all elements within a collection are of the same data type. You created a Python script to demonstrate this concept by creating a list of integers and a list of mixed data types, then printing the type of each element using the type() function.

The lab highlighted the importance of type uniformity for maintaining consistency and avoiding unexpected errors in code, showcasing how different data types can coexist within a single list and how to identify the type of each element.