TypeError: unhashable type: 'set' in Python [Solved]

# TypeError: unhashable type: 'set' in Python [Solved]

The Python "TypeError: unhashable type: 'set'" occurs when we use a set as a key in a dictionary or an element in another set.

To solve the error, use a frozenset instead because set objects are mutable and unhashable.

Here is an example of how the error occurs when using a set as an element in another set.

Copied!
my_set = {'apple', 'banana'}

# 👇️ using a set as an element in another set

# ⛔️ TypeError: unhashable type: 'set'
another_set = {'Alice', 'Bobby', my_set}

And here is another example of how the error occurs when using a set as a key in a dictionary.

Copied!
my_set = {'apple', 'banana'}

# 👇️ using a set as a key in a dictionary

# ⛔️ TypeError: unhashable type: 'set'
my_dict = {my_set: 'fruits'}

# Use a frozenset instead of a regular set

One way to solve the error is to use a frozenset.

Copied!
my_set = frozenset({'apple', 'banana'})


another_set = {'Alice', 'Bobby', my_set}
print(another_set)  # 👉️ {'Bobby', frozenset({'banana', 'apple'}), 'Alice'}

# checking if an element is in a set
print(frozenset({'apple', 'banana'}) in another_set)  # 👉️ True

# ---------------------------------------------------------------

my_dict = {my_set: 'fruits'}
print(my_dict)  # 👉️ {'Bob', frozenset({'banana', 'apple'}), 'Alice'}


# 👇️ accessing a key in the dictionary
print(my_dict[frozenset({'apple', 'banana'})])  # 👉️ fruits

We used a frozenset instead of a set. The frozenset class takes an iterable as an argument.

Notice that you have to use the same approach to access the key in the dictionary.

# Use a tuple instead of a set object

Alternatively, you can use another immutable type such as a tuple if that suits your use case.

Copied!
my_tuple = tuple({'apple', 'banana'})

my_set = {'Alice', 'Bobby', my_tuple}
print(my_set)  # 👉️ {'Alice', 'Bobby', ('banana', 'apple')}

print(tuple({'apple', 'banana'}) in my_set)  # 👉️ True

# -----------------------------------------------------

my_dict = {my_tuple: 'fruits'}
print(my_dict)  # 👉️ {('banana', 'apple'): 'fruits'}


print(my_dict[tuple({'apple', 'banana'})])  # 👉️ 'fruits'

Tuple objects are immutable and are hashable.

You can also declare a tuple directly by wrapping the items in parentheses and not square brackets.

Copied!
my_tuple = ('a', 'b', 'c')

print(my_tuple)  # 👉️ ('a', 'b', 'c')
print(type(my_tuple))  # 👉️ <class 'tuple'>

# Hashable objects vs Unhashable objects

Most of the immutable built-in objects in Python are hashable, whereas mutable objects are unhashable.

Hashable objects include - str, int, bool, tuple, frozenset.

Unhashable objects include - list, dict, set.

Note that tuples and frozensets are only hashable if their elements are hashable.

You can check if an object is hashable by passing it to the built-in hash() function.

Copied!
print(hash('bobybhadz'))  # 👉️ -5394383801093474825

# ⛔️ TypeError: unhashable type: 'set'
print(hash({'bobby', 'hadz', 'com'}))

The hash() function returns the hash value of the passed-in object (if it has one).

Hash values are integers and are used to compare dictionary keys during a dictionary lookup.

Objects like sets are mutable because the contents of a set can be changed.

Copied!
my_set = {'a', 'b'}

my_set.add('c')

print(my_set)  # 👉️ {'c', 'a', 'b'}

On the other hand, frozenset objects and tuples that contain primitive values are immutable (and hashable).

Dictionaries are indexed by keys and the keys in a dictionary can be any immutable type, e.g. strings or numbers.

If a frozenset or a tuple contains mutable objects such as lists, it cannot be used as a key in a dictionary or an element in a set.

If you aren't sure what type of object a variable stores, use the type() class.

Copied!
my_set = {'a', 'b'}
print(type(my_set))  # 👉️ <class 'set'>
print(isinstance(my_set, set))  # 👉️ True

my_tuple = ('a', 'b')
print(type(my_tuple))  # 👉️ <class 'tuple'>
print(isinstance(my_tuple, tuple))  # 👉️ True

The type class returns the type of an object.

The isinstance() function returns True if the passed-in object is an instance or a subclass of the passed in class.

# Additional Resources

You can learn more about the related topics by checking out the following tutorials:

• TypeError: unhashable type: 'dict' in Python [Solved]
• TypeError: unhashable type 'slice' in Python [Solved]
• Creating a Tuple or a Set from user Input in Python
• AttributeError: 'set' object has no attribute 'items'
• TypeError: 'set' object is not subscriptable in Python