Adventures in Machine Learning

Overcoming ‘TypeError: unhashable type: ‘dict” in Python

Handling “TypeError: unhashable type: ‘dict'” in Python

Python is a popular programming language used by developers to create various applications such as web development, data analysis, and machine learning. Its fast execution, simple syntax, and portability make it a favorite among programmers.

However, it is not without its challenges. One such problem that programmers often encounter is a TypeError with unhashable types, particularly a ‘dict’.

This error is thrown when we try to use an unhashable object as a dictionary key. In this article, we will discuss the various ways to handle this error so that you can overcome the challenges it presents.

Resolving the “TypeError: unhashable type: ‘dict'”

1. Converting dictionary to JSON string

One way to resolve this issue is by converting the dictionary to a JSON string. JSON stands for JavaScript Object Notation, and it is a lightweight data-interchange format that is easy to read and write.

It is also language-independent, which means it can be used with Python and other programming languages. Converting the dictionary to a JSON string can be done using the json.dumps() function.

This function converts Python objects into a JSON string.

2. Using frozenset instead of dictionary

Another way to resolve this error is by using a frozenset instead of a dictionary. A frozenset is an immutable set and hence can be used as a key in a dictionary.

It is created using the frozenset() function and can only hold immutable objects such as strings, integers, and tuples. Since frozensets are immutable, they can be used as dictionary keys.

3. Converting dictionary to tuple

Yet another way to resolve this error is by converting the dictionary to a tuple. Tuples are immutable and can be used as keys in a dictionary.

Converting the dictionary to a tuple can be done using the items() function, which returns a list of tuples, each containing a key-value pair.

4. Using dictionary as a value in another dictionary

If you need to use a dictionary as a value in another dictionary, you can wrap it inside a frozenset or convert it into a tuple. For example, the following code will result in a TypeError:

d1 = {'key1': {'key2': 'value2'}}
d2 = {d1: 'value'}

To resolve this error, we can convert the dictionary ‘d1’ into a tuple:

d1 = {'key1': {'key2': 'value2'}}
d2 = {(tuple(d1.items())): 'value'}

5. Adding key-value pairs of one dictionary to another

In some cases, you may want to add the key-value pairs of one dictionary to another. One way to do this is by using a for loop to iterate over the dictionary and adding each key-value pair to the new dictionary.

The following code demonstrates this:

dict1 = {'key1': 'value1', 'key2': 'value2'}
dict2 = {}
for key, value in dict1.items():
    dict2[key] = value

Now, dict2 will contain the key-value pairs of dict1.

Hashable vs Unhashable objects in Python

In Python, hashable objects are objects that have a unique hash value that does not change throughout its lifetime. Examples of hashable types are strings, integers, and tuples.

Unhashable objects do not have a unique hash value and cannot be used as keys in a dictionary. Examples of unhashable types are dictionaries and lists.

Checking if an object is hashable

To check if an object is hashable, we can use the hash() function. This function returns the hash value of an object if it is hashable, and it raises a TypeError if the object is unhashable.

For example:

a = 1
print(hash(a)) #prints the hash value of 1
b = {'key1': 'value1'}
print(hash(b)) #raises a TypeError since dictionaries are unhashable

Additional Resources

It is important to keep learning about Python and other programming languages to keep up with the ever-evolving technology industry. To learn more about handling different types of errors in Python and other related topics, here are some additional resources:


In summary, “Handling ‘TypeError: unhashable type: ‘dict” in Python” is an important topic for programmers who encounter errors while developing Python applications.

This article has covered various ways to handle the TypeError, including converting dictionaries to JSON strings, using frozensets or tuples, and adding key-value pairs of one dictionary to another. It is critical to understand the difference between hashable and unhashable objects in Python, and to check whether an object is hashable using the hash() function.

In conclusion, mastering these techniques will make Python programming more efficient and less frustrating.

Popular Posts