TypeError: Unhashable Type ‘dict’ In Python Code

In the world of programming, errors are inevitable but solvable. One common hurdle developers face is the “TypeError: Unhashable type ‘dict’,” which can be encountered in different contexts. This error can be puzzling, but fear not! In this comprehensive guide, we will delve into various scenarios where this error might occur and provide practical solutions with accompanying Python code snippets.

TypeError: Unhashable Type 'dict'

Keyword Explanation

Before we dive into solutions, let’s clarify the keywords that will be central to our discussion.

  1. TypeError: A built-in Python exception raised when an operation is performed on an object of an inappropriate type.
  2. Unhashable: Refers to an object that cannot be hashed, meaning it cannot be used as a key in a dictionary or an element in a set.
  3. dict: Short for “dictionary,” it is a mutable data structure that stores key-value pairs.
  4. dict_keys, dict_items: Views into a dictionary that provide access to its keys and key-value pairs, respectively.
  5. JSON: Stands for JavaScript Object Notation, a lightweight data interchange format.
  6. drop duplicates: A data manipulation operation involving removing duplicate elements from a collection.
  7. MongoDB: A popular NoSQL database system, often used to store and manage large volumes of data.
  8. FastAPI: A modern, fast web framework for building APIs with Python.
  9. Django: A high-level Python web framework that encourages rapid development and clean, pragmatic design.

Scenarios and Solutions

TypeError: Unhashable type ‘dict’ in General Context

This error can occur when trying to use a dictionary containing dictionaries as keys in another dictionary or set. To resolve this, convert the inner dictionary into a hashable type (e.g., a frozenset).

   unhashable_dict = {'inner_dict': {'key': 'value'}}
   hashable_key = frozenset(unhashable_dict['inner_dict'].items())
   hashable_dict = {hashable_key: 'data'}

TypeError: Unhashable type ‘dict_keys’ or ‘dict_items’

These errors stem from attempting to use dictionary views as keys. To address this, convert the view into a list or tuple before using it as a key.

   dict_data = {'key': 'value'}
   keys_view = dict_data.keys()
   keys_as_list = list(keys_view)
   new_dict = {tuple(keys_as_list): 'data'}

TypeError: Unhashable type ‘dict’ with JSON Data

If you encounter this error while working with JSON data, ensure that the dictionary keys are of hashable types. Use json.loads to parse JSON strings into Python objects.

   import json
   json_string = '{"key": "value"}'
   json_data = json.loads(json_string)

TypeError: Unhashable type ‘dict’ – Dropping Duplicates

When removing duplicates from a list of dictionaries, use the frozenset approach or convert the dictionaries to hashable types.

   data_list = [{'key': 'value'}, {'key': 'value'}]
   unique_data = list({frozenset(item.items()) for item in data_list})

TypeError: Unhashable type ‘dict’ in MongoDB

This error can occur when trying to use a dictionary as a key in a MongoDB operation. Convert the dictionary to a hashable type before using it as a key.

   from bson import json_util

   dict_data = {'key': 'value'}
   hashable_key = frozenset(dict_data.items())
   db.collection.update_one({'_id': hash(hashable_key)}, {'$set': dict_data})

TypeError: Unhashable type ‘dict’ in FastAPI

If you encounter this error while handling FastAPI requests, ensure that the data being processed doesn’t include dictionaries as keys.

   from fastapi import FastAPI

   app = FastAPI()

   async def process_data(data: dict):
       # Process the data
       return {'message': 'Data processed successfully'}

TypeError: Unhashable type ‘dict’ in Django

When using dictionaries as keys in Django-related operations, consider alternatives like using string representations of the dictionary keys.

   from django.http import JsonResponse

   def get_data(request, key):
       data_dict = {'key': 'value'}
       result = data_dict.get(key, None)
       return JsonResponse({'result': result})

Benefits of Resolving TypeError: Unhashable Type ‘dict’

  • Enhanced Data Management: Solving this error ensures smoother data handling and manipulation across different scenarios.
  • Efficient Database Operations: Resolving this issue in MongoDB leads to optimized database operations, enhancing overall performance.
  • Seamless API Development: In FastAPI and Django, overcoming this error streamlines API development and ensures a smooth user experience.
ScenarioSolution Code
General ‘dict’ as Keyhashable_key = frozenset(unhashable_dict[‘inner_dict’].items())
‘dict_keys’ as Keykeys_as_list = list(keys_view)
‘dict_items’ as Keykeys_as_tuple = tuple(keys_view)
JSON Data with ‘dict’json_data = json.loads(json_string)
Dropping Duplicatesunique_data = list({frozenset(item.items()) for item in data_list})
MongoDB Operationdb.collection.update_one({‘_id’: hash(hashable_key)}, {‘$set’: dict_data})
FastAPI Handlingasync def process_data(data: dict):
Django Operationresult = data_dict.get(key, None)


Navigating the intricate terrain of programming errors like “TypeError: Unhashable type ‘dict'” might seem daunting, but armed with the right knowledge and solutions, you’re well-prepared to conquer it. By understanding each scenario and applying the appropriate solutions with the provided Python code snippets, you can enjoy error-free coding experiences. Happy coding!

Remember, coding is an art of problem-solving, and mastering these nuances elevates your skills to new heights.

Stay in the Loop

Receive the daily email from Techlitistic and transform your knowledge and experience into an enjoyable one. To remain well-informed, we recommend subscribing to our mailing list, which is free of charge.

Latest stories

You might also like...