迹忆客 专注技术分享

当我们将一个集合用作字典中的键或另一个集合中的元素时，会出现 Python“TypeError: unhashable type: 'set' ”。 要解决该错误，请改用 frozenset，因为 set 对象是可变的且不可散列的。

下面是一个产生上述错误的示例

my_set = {'apple', 'banana'}

# 👇️ using set as an element in another set
# ⛔️ TypeError: unhashable type: 'set'
another_set = {'Alice', 'Bob', my_set}

# 👇️ using set as a key in a dictionary
# ⛔️ TypeError: unhashable type: 'set'
my_dict = {my_set: 'fruits'}

我们不能将集合用作字典中的键或另一个集合中的元素，因为集合对象是可变的和不可散列的。

解决错误的一种方法是使用 frozenset。

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


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

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

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

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


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

我们使用 frozenset 而不是 set。 frozenset 类接受一个可迭代对象作为参数。

frozenset 是 Python 集合对象的不可变版本，因此它可以用作字典中的键或另一个集合中的元素。

请注意 ，我们必须使用相同的方法来访问字典中的键。

或者，如果适合我们的用例，我们可以使用另一种不可变类型，例如元组。

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

my_set = {'Alice', 'Bob', my_tuple}
print(my_set)  # 👉️ {'Alice', 'Bob', ('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'

元组对象是不可变的并且是可散列的。

我们还可以通过将项目包装在圆括号而不是方括号中来直接声明元组。

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

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

Python 中的大多数不可变内置对象都是可散列的，而可变对象是不可散列的。

如果一个对象是可散列的，那么它可以用作字典中的键和集合中的元素，因为这些数据结构在内部使用散列值。

可哈希对象包括 - str、int、bool、tuple、frozenset。

不可散列的对象包括 - list、dict、set。

请注意 ，元组和 frozensets 仅在其元素可哈希时才可哈希。

我们可以通过将对象传递给内置的 hash() 函数来检查对象是否可散列。

print(hash('hello'))  # 👉️ -1210368392134373610

# ⛔️ TypeError: unhashable type: 'set'
print(hash({'a', 'b', 'c'}))

散列函数返回传入对象的散列值（如果有的话）。

哈希值是整数，用于在字典查找期间比较字典键。

可散列对象的散列值在其生命周期内永远不会改变。 这就是为什么大多数不可变对象是可哈希的，而可变对象是不可哈希的。

像集合这样的对象是可变的，因为集合的内容可以改变。

my_set = {'a', 'b'}

my_set.add('c')

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

另一方面，包含原始值的 frozensets 和元组是不可变的（和可散列的）。

字典由键索引，字典中的键可以是任何不可变类型，例如 字符串或数字。

如果元组包含字符串、数字或元组，则它们只能用作字典中的键。

如果 frozensets 或元组包含可变对象（例如列表），则不能将其用作字典中的键或集合中的元素。

如果我们不确定变量存储的对象类型，请使用 type() 函数。

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

类型类返回对象的类型。

如果传入的对象是传入类的实例或子类，则 isinstance 函数返回 True。