Coder Legion - Recent posts tagged hash

Typeerror: 'series' objects are mutable, thus they cannot be hashed

Wed, 09 Sep 2026 11:49:50 +0000

TypeError: 'Series' objects are mutable, thus they cannot be hashed is an error message that can occur when working with pandas, a popular data manipulation library for Python. This error message is raised when trying to use a pandas Series object (a one-dimensional array-like object) as a key in a dictionary or as an element in a set. In this article we are going to look at the idea behind hashing and why a mutable object cannot be hashed which will give raise to the error in consideration.

Brief note on hashing

In Python, a series object is a one-dimensional array-like object that can hold any data type. It is similar to a column in a spreadsheet or a dataframe in pandas. One of the key features of a series object is that it is mutable, meaning that its values can be changed. However, this also means that 'series' objects cannot be hashed.

Hashing is a process of converting an input of any length into a fixed-length output, known as a hash value. The hash value is a unique representation of the input, and it is often used for efficient data searching and indexing. However, since 'series' objects are mutable, they cannot be hashed as their values can change, making it impossible to generate a unique hash value.

One of the most popular uses of hashing is in data structures such as hash tables and hash maps. These data structures use a hash function to convert a key (such as a name or a product ID) into a unique index in an array. This allows for quick and efficient lookup of the corresponding value (such as a price or a product description).

Tip Hashing algorithms come in a variety of forms, such as MD5, SHA-1, and SHA-256, each with their own unique properties and trade-offs. For example, while MD5 is fast and widely supported, it is not considered as secure as the SHA-256 algorithm.

Why the error?

The reason for the error Typeerror: 'series' objects are mutable, thus they cannot be hashed is that in Python, dictionaries and sets use a technique called hashing to quickly look up values based on their keys. Hashing involves taking an input (in this case, the key of a dictionary or set), running it through a mathematical function, and producing a fixed-length output (the "hash value"). The hash value is then used to quickly locate the corresponding value in the dictionary or set.

Here is an example of trying to hash a 'series' object:



import pandas as pd
Creating a 'series' object
s = pd.Series([1, 2, 3])
Attempting to hash the 'series' object
hash(s)

The above code will result in the following error:



TypeError: unhashable type: 'Series'

However, for a data structure to be usable as a key, it must meet certain requirements. One of the most important of these is that the key must be immutable, meaning that its value cannot be changed after it is created. This is because the hash value of a key is calculated based on its value, so if the key's value changes, its hash value would also change. This would make it impossible to locate the key in the dictionary or set.

Pandas Series objects are mutable, meaning that their values can be changed after they are created. This makes them incompatible with dictionaries and sets, as their hash value would change if the values in the Series were modified.

However, if a 'series' object needs to be used in a hash table, it must first be converted to an immutable object such as a tuple or a frozen set.

A walk around

You can convert the Series to an immutable object such as a tuple or a string using the tolist() method or use pd.Index class to create an immutable index.

Here is an example of converting a 'series' object to a tuple:


import pandas as pd

# Creating a 'series' object
s = pd.Series([1, 2, 3])

# Converting the 'series' object to a tuple
s = tuple(s)

# Hashing the tuple
print(hash(s))

The above code will output a hash value for the tuple, allowing it to be used in a hash table.

Note It is important to keep in mind that this conversion may affect the performance of the code, as the conversion process may take a longer time compared to using a mutable object.

Conclusion

In conclusion, the TypeError: 'Series' objects are mutable, thus they cannot be hashed is raised when trying to use a pandas Series object as a key in a dictionary or as an element in a set because they are mutable objects. To fix this error, you can convert the Series to an immutable object such as a tuple or a string or use pd.Index class to create an immutable index.

References

Pandas documentation on Series: https://pandas.pydata.org/pandas-docs/stable/user_guide/dsintro.html#series
Python documentation on dictionaries: https://docs.python.org/3/tutorial/datastructures.html#dictionaries
Python documentation on sets: https://docs.python.org/3/tutorial/datastructures.html#sets
Understanding Hash Tables: https://en.wikipedia.org/wiki/Hash_table
How to convert pandas Series to a NumPy array: https://datatofish.com/convert-pandas-dataframe-to-numpy-array/

Understanding and debugging - TypeError :unhashable type: dict

Sun, 23 Nov 2025 23:58:18 +0000

Introduction

Sometimes while executing a python code, we might run into an error like TypeError: unhashable type: ‘dict’ . For example, if we try to hash a dictionary by trying to use it as a set element or as a dictionary key, we might get this error. A TypeError is raised when an operation or function is applied to an object of inappropriate type. To avoid this, we must ensure that a function is applied on the right type of object. In this article we will understand in detail why this error occurs, as well as ways to avoid it by using alternate datatypes.

Why this error occurs

If we try to use an unhashable datatype in our code where hashing is required the following error will occur. TypeError: unhashable type: name_of_datatype. Before getting any further, let us first understand the meaning of mutable and hashable in the context of Python. Understanding these concepts is crucial to really deep dive into the error and completely understand it.

Mutable and Immutable datatypes:

Mutable: In python, if we can change the value in an object without changing its identity, it is a mutable object. For example, if we create a list and try to change its individual elements, the operation is possible.

my_list = [1,2]
my_list[1] = 3
my_list

Immutable: In python, if we cannot change the value in an object without changing its identity, it is immutable.
For example: Changing the value of individual elements in a tuple is not allowed and would raise an error.

my_tuple = (1,2)
my_tuple[1] = 3

What is a Hashable Object:

An object is hashable if it has a hash value which never changes during its lifetime. Hashing allows for efficient lookup, insertion, and deletion of elements. Some objects in Python are hashed internally.

Hash value: We can view the hash value of objects using the hash() function in Python.

my_tuple = (1,2,3)
hash(my_tuple)

Caution: Not all objects have hash value. If an object does not have a Hash value, TypeError exception will be raised if we try to access its Hash value.

Hashability makes an object usable as a dictionary key and a set member, because these data structures use the hash value internally.
Most of Python’s immutable built-in objects are hashable.

FAQ 1) Numbers and strings are hashable.
2) Tuples and frozenset are hashable if their individual elements are hashable.
3) Mutable datatypes like Lists and Dictionaries are unhashable.

Exploring the error

Let us examine some examples where this error might happen

Case 1: Using a mutable datatype as a Dictionary Key:

student ={"name": "abcd", "age": 22}
new_dict = {student:"highschool"}

In the first example, we are trying to use "student" which is a "dictionary data type" as a dictionary key for another dictionary new_dict.
Dictionary itself is a mutable data type : Hence unhashable
Dictionary keys are Hashed internally by Python, for fast accessibility
The code is trying to hash an unhashable student dictionary so that it can be used as a dictionary key. Hence the error

Case 2: Using a mutable datatype as an element of a Set:

set = {"aa", "bb", "cc", "dd", student}

In the second example, we are trying to use a dictionary data type student as an element of a Set.
As already mentioned above, Dictionary is a mutable data type: Hence unhashable. Elements of a set are hashed, for fast accessibility
This is the reason we get this error

Similar errors like: “TypeError: unhashable type: ‘list’ also occur because of the same reason. Lists are mutable, hence unusable as dictionary keys, or set elements

my_set = {[1,2]}

Solution

The solution is to use Immutable datatypes where we require hashability, i.e. when we want them to be used as elements of sets and keys for dictionary. Let us explore some alternate datatypes that can be used when we have a usecase where hashing is required.

Use Tuple instead of List

Suppose we need to use a group of integers [1,2,3] as a dictionary key.
Instead of using a list [1,2,3] we should convert it into a tuple (1,2,3) . This tuple when used as a dictionary key , would be hashed internally by Python. So, we will not get any error.

my_list = [1,2,3]
my_dict = {tuple(my_list):1}
my_dict

Convert Dictionary to Tuple

Even dictionary can also be converted into tuple and then used as key. Since tuple is hashable, it can definitely be used as dictionary key. Lets consider a simplified example. Here we are converting an unhashable dictionary student to a hashable tuple student_tuple. When we use this student_tuple as a dictionary key python is able to hash it internally and we do not get any error.

student = {"name":"abcd", "age": 22}
student_tuple = tuple(student.items())
new_dict = {student_tuple:1}
new_dict

The items may also be sorted before being converted into a tuple, to ensure consistent hashing as the dictionary elements are inherently unordered collections.

So, a better method would be:

student_tuple = tuple(sorted(student.items()))

Use frozenset instead of set

Instead of a set we may use a frozenset, when hashing is required. In python, frozenset are the immutable version of sets. So, the frozenset can definitely be hashed. Here we are converting an unhashable set my_immutable_object to a frozenset which is hashable. Then when we use it as a dictionary key in my_dict . Python is able to hash it internally. Hence, we would not get any error.

my_immutable_object = frozenset({1,2,3})
my_dict = {my_immutable_object:1}
my_dict

Tips:
1) When using dictionaries, ensure that its keys are immutable datatypes
2) When using sets, ensure that all its elements are immutable datatypes

3) If there is a use case where a mutable datatype like list, set, or dictionary should be used as a dictionary key or set element, first convert it into an immutable datatype like tuple or frozenset

Conclusion

In a nutshell, the understanding of mutability and hashing will help avoid this type of errors. It is important to choose your datatypes carefully and apply appropriate functions to them, considering factors like mutablity and hashability. Hope this article gives sufficient insight into solving this type of error.

Coder Legion - Recent posts tagged hash

Typeerror: 'series' objects are mutable, thus they cannot be hashed

Table of Contents:

Brief note on hashing

Why the error?

A walk around

Conclusion

References

Understanding and debugging - TypeError :unhashable type: dict

Introduction

Why this error occurs

Mutable and Immutable datatypes:

What is a Hashable Object:

Exploring the error

Case 1: Using a mutable datatype as a Dictionary Key:

Case 2: Using a mutable datatype as an element of a Set:

Solution

Use Tuple instead of List

Convert Dictionary to Tuple

Use frozenset instead of set

Conclusion