Understanding and Resolving "TypeError: unhashable type: 'dict'" in Python

Introduction

In Python, dictionaries are powerful data structures used to store key-value pairs. However, when working with dictionaries as keys for other dictionaries or elements within sets, developers may encounter the TypeError: unhashable type: 'dict'. This error arises because dictionaries, being mutable, cannot be hashed and therefore can’t be used directly in these contexts.

This tutorial explores why this error occurs and presents several strategies to resolve it by converting dictionaries into hashable forms. By understanding these techniques, you’ll enhance your ability to manipulate complex data structures effectively in Python.

Understanding Hashability

In Python, objects that are immutable—such as strings, integers, floats, tuples of immutables, frozensets—are considered "hashable." Hashable objects have a hash value that remains constant during their lifetime. This property allows them to be used as keys in dictionaries or elements in sets.

Dictionaries themselves are mutable; they can change after creation (keys and values can be added or removed), making them inherently unhashable. Consequently, using a dictionary directly as a key for another dictionary or adding it to a set will raise the TypeError: unhashable type: 'dict'.

Strategies to Resolve Unhashability

Below are several strategies that demonstrate how to convert dictionaries into hashable forms:

1. Convert Dictionary to Tuple of Items

   Transforming a dictionary’s items (key-value pairs) into tuples allows it to be used as a key in another dictionary or an element in a set since tuples are immutable.

   d1 = {'a': 1, 'b': 2}
   d2 = {tuple(d1.items()): 3}  # Works as tuple is hashable
   
   # Checking membership
   print(tuple(d1.items()) in d2)  # True
   

2. Convert Dictionary to a String Representation

   Converting dictionaries into strings can also make them suitable for use as keys or set elements, particularly when you need to preserve the content.

   import ast
   
   d1 = {'a': 1, 'b': 2}
   str_d1 = str(d1)
   d3 = {str_d1: 3}
   
   # Recovering original dictionary from string key
   recovered_dict = ast.literal_eval(str_d1)
   print(recovered_dict)  # Output: {'a': 1, 'b': 2}
   

3. Convert Dictionary to a Frozenset of Items

   Using frozenset is another technique, especially useful for deduplication purposes since frozensets are immutable.

   lst = [{1: 3, 2: 0}, {2: 0, 1: 3}]
   unique_frozensets = {frozenset(d.items()) for d in lst}
   
   # Convert back to list of dictionaries
   unique_dicts = [dict(f) for f in unique_frozensets]
   print(unique_dicts)  # Output: [{2: 0, 1: 3}, {2: 3}]
   

4. Serialize Dictionary Using JSON

   When dealing with JSON-serializable dictionaries, converting them to JSON strings can help achieve hashability.

   import json
   
   lst = [{'a': 1}, {'b': 2}]
   unique_jsons = {json.dumps(d, sort_keys=True) for d in lst}
   
   # Convert back to list of dictionaries
   recovered_dicts = [json.loads(j) for j in unique_jsons]
   print(recovered_dicts)  # Output: [{'a': 1}, {'b': 2}]
   

5. Custom Hashing with Dict of Dictionaries

   For more control, especially when needing a unique representation, using a custom hash function or a dictionary to store dictionaries indexed by their hashes can be effective.

   from typing import Dict
   
   mydict: Dict[int, dict] = {}
   d1 = {'a': 1, 'b': 2}
   mydict[hash(str(d1))] = d1
   
   print(mydict)  # Output: {hash_value: {'a': 1, 'b': 2}}
   

Conclusion

Handling unhashable types in Python requires understanding immutability and hashability. By converting dictionaries into immutable forms—such as tuples, strings, frozensets, or JSON strings—you can effectively use them in scenarios requiring hashable keys. Each method has its applications and trade-offs, so choose the one that best fits your specific needs.