So lösen Sie den TypeError:unhashable type:'dict'-Fehler in Python

Python „TypeError: unhashable type: ‘dict’“ tritt auf, wenn wir ein Wörterbuch als Schlüssel in einem anderen Wörterbuch oder als Element in einer Sammlung verwenden.

Um diesen Fehler zu beheben, müssen Sie stattdessen frozenset verwenden oder das Wörterbuch in eine JSON-Zeichenfolge konvertieren, bevor Sie es als Schlüssel verwenden. frozenset，或者在将字典用作键之前将其转换为 JSON 字符串。

当我们将字典用作另一个字典中的键时，会发生错误。

# ????️ using dictionary as a key in a dictionary

# ⛔️ TypeError: unhashable type: 'dict'
my_dict = {'name': 'Jiyik', {'country': 'China'}: 'address'}

或者当我们使用字典作为 set 对象中的元素时。

# ????️ 使用字典作为集合中的元素

# ⛔️ TypeError: unhashable type: 'dict'
my_set = {{'name': 'Jiyik'}}

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

将字典转为JSON字符串解决报错

解决该错误的一种方法是在将字典用作键之前将其转换为 JSON 字符串。

import json

# ????️ 将字典转换为 JSON 字符串
my_json = json.dumps({'country': 'China'})

my_dict = {'name': 'Jiyik', my_json: 'address'}
print(my_dict)  # ????️ {'name': 'Jiyik', '{"country": "China"}': 'address'}

# ????️ 当你必须访问字典中的键时
print(my_dict[json.dumps({'country': 'Austria'})]) # ????️ address

json.dumps 方法将 Python 对象转换为 JSON 格式的字符串。 这是有效的，因为字符串是不可变的和可散列的。

相反，json.loads 方法将 JSON 字符串解析为本机 Python 对象，例如 my_dict = json.loads(my_json_str)。

使用 frozenset 解决错误

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

my_key = {'country': 'China'}
key = frozenset(my_key.items())
print(key)  # ????️ frozenset({('country', 'China')})

my_dict = {'name': 'Jiyik', key: 'address'}


# ????️ 当我们必须访问 key 时
print(my_dict[frozenset(my_key.items())])  # ????️ 'address'

dict.items 方法返回字典项（（键，值）对）的新视图。

# ????️ dict_items([('name', 'jiyik'), ('age', 30)])
print({'name': 'jiyik', 'age': 30}.items())

我们使用字典的项目创建了一个 frozenset，我们可以将其用作字典中的键（以及另一个集合中的元素）。

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

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

我们可以将调用 frozenset(my_key.items()) 的结果存储在变量中，并在设置或访问字典中的键时重用 frozenset。

将字典转换为元组以解决错误

解决错误的另一种方法是将字典转换为元组。

dict_key = {'id': 1, 'country': 'China'}

# ✅ 转换为元组
my_tuple = tuple(dict_key)
print(my_tuple)  # ????️ ('id', 'country')

my_dict = {'name': 'Jiyik', my_tuple: 'address'}
print(my_dict)  # ????️ {'name': 'Jiyik', ('id', 'country'): 'address'}

# ????️ 当你必须访问字典中的键时
print(my_dict[my_tuple])  # ????️ address

将字典转换为元组时，元组仅包含字典的键。

元组是不可变的，因此包含字典键的元组可以安全地用作另一个字典中的键。

使用一个字典作为另一个字典中的值

我们不能将一个字典用作另一个字典中的键，但可以将一个字典用作值。

dict_value = {'id': 1, 'country': 'China'}

my_dict = {'name': 'Jiyik', 'data': dict_value}

# ????️ {'name': 'Jiyik', 'data': {'id': 1, 'country': 'China'}}
print(my_dict)

print(my_dict['data'])  # ????️ {'id': 1, 'country': 'China'}

我们将一个字典设置为另一个字典中的值。

这是允许的，因为限制不适用于字典值。

将一个字典的所有键值对添加到另一个字典

如果需要将一个字典的所有键值对添加到另一个字典，则可以使用 for 循环。

another_dict = {'id': 1, 'country': 'China'}

my_dict = {'name': 'Jiyik'}

for key, value in another_dict.items():
    my_dict[key] = value

# ????️ {'name': 'Jiyik', 'id': 1, 'country': 'China'}
print(my_dict)

dict.items 方法返回字典项（（键，值）对）的新视图。

my_dict = {'id': 1,  'name': 'Jiyik'}

# ????️ dict_items([('id', 1), ('name', 'Jiyik')])
print(my_dict.items())

在每次迭代中，我们将键值对设置为另一个字典。

Python 中的可散列对象与不可散列对象

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

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

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

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

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

检查一个对象是否可散列

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

print(hash('jiyik.com'))  # ????️ 4905958875846995527

# ⛔️ TypeError: unhashable type: 'dict'
print(hash({'name': 'Jiyik'}))

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

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

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

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

my_dict = {'name': 'Fql'}

my_dict['name'] = 'Jiyik'

print(my_dict) # ????️ {'name': 'Jiyik'}

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

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

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

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

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

my_dict = {'name': 'Jiyik'}

print(type(my_dict))  # ????️ <class &#39;dict&#39;>
print(isinstance(my_dict, dict))  # ????️ True

my_str = &#39;jiyik.com&#39;

print(type(my_str))  # ????️ <class &#39;str&#39;>
print(isinstance(my_str, str))  # ????️ True

type

Der Fehler tritt auf, wenn wir ein Wörterbuch als Schlüssel in einem anderen Wörterbuch verwenden. 🎜rrreee🎜 Oder wenn wir ein Wörterbuch als Element in einem set-Objekt verwenden. 🎜rrreee

🎜Wir können ein Wörterbuch nicht als Schlüssel in einem Wörterbuch oder als Element in einer Sammlung verwenden, da Wörterbuchobjekte veränderbar und nicht hashbar sind. 🎜

Konvertieren Sie das Wörterbuch in einen JSON-String, um den Fehler zu beheben

🎜Eine Möglichkeit, diesen Fehler zu beheben, besteht darin, das Wörterbuch in einen JSON-String zu konvertieren, bevor Sie es als Schlüssel verwenden. Die Methode 🎜rrreee🎜json.dumps konvertiert ein Python-Objekt in eine JSON-formatierte Zeichenfolge. Dies funktioniert, weil Zeichenfolgen unveränderlich und hashbar sind. 🎜🎜Im Gegensatz dazu analysiert die Methode json.loads einen JSON-String in ein natives Python-Objekt, wie zum Beispiel my_dict = json.loads(my_json_str). 🎜

Verwenden Sie Frozenset, um Fehler zu beheben

🎜Eine andere Möglichkeit, Fehler zu beheben, ist die Verwendung von frozenset. Die Methode 🎜rrreee🎜dict.items gibt eine neue Ansicht von Wörterbuchelementen ((Schlüssel, Wert)-Paare) zurück. 🎜rrreee🎜Wir verwenden die Elemente des Wörterbuchs, um einen eingefrorenen Satz zu erstellen, den wir als Schlüssel im Wörterbuch (sowie als Element in einem anderen Satz) verwenden können. 🎜

🎜frozenset ist eine unveränderliche Version eines Python-Sammlungsobjekts, sodass es als Schlüssel in einem Wörterbuch oder als Element in einer anderen Sammlung verwendet werden kann. 🎜

🎜🎜Bitte beachten Sie🎜, dass wir dieselbe Methode verwenden müssen, um auf die Schlüssel im Wörterbuch zuzugreifen. 🎜

🎜Wir können das Ergebnis des Aufrufs von frozenset(my_key.items()) in einer Variablen speichern und das Frozenset beim Festlegen oder Zugreifen auf Schlüssel im Wörterbuch wiederverwenden. 🎜

Konvertieren Sie das Wörterbuch in ein Tupel, um den Fehler zu beheben

🎜Eine andere Möglichkeit, den Fehler zu beheben, besteht darin, das Wörterbuch in ein Tupel zu konvertieren. 🎜rrreee🎜Beim Konvertieren eines Wörterbuchs in ein Tupel enthält das Tupel nur die Schlüssel des Wörterbuchs. 🎜🎜Tupel sind unveränderlich, sodass ein Tupel, der einen Wörterbuchschlüssel enthält, sicher als Schlüssel in einem anderen Wörterbuch verwendet werden kann. 🎜

Ein Wörterbuch als Wert in einem anderen Wörterbuch verwenden

🎜Wir können ein Wörterbuch nicht als Schlüssel in einem anderen Wörterbuch verwenden, aber wir können ein Wörterbuch als Wert verwenden. 🎜rrreee🎜Wir setzen ein Wörterbuch auf einen Wert in einem anderen Wörterbuch. 🎜🎜Dies ist zulässig, da die Beschränkung nicht für Wörterbuchwerte gilt. 🎜

Alle Schlüssel-Wert-Paare eines Wörterbuchs zu einem anderen Wörterbuch hinzufügen

🎜Wenn Sie alle Schlüssel-Wert-Paare eines Wörterbuchs zu einem anderen Wörterbuch hinzufügen müssen, können Sie eine for-Schleife verwenden. Die Methode 🎜rrreee🎜dict.items gibt eine neue Ansicht von Wörterbuchelementen ((Schlüssel, Wert)-Paare) zurück. 🎜rrreee🎜Bei jeder Iteration setzen wir die Schlüssel-Wert-Paare auf ein anderes Wörterbuch. 🎜

Hashbare vs. nichthashbare Objekte in Python

🎜Die meisten unveränderlichen integrierten Objekte in Python sind hashbar, während veränderliche Objekte nicht hashbar sind. 🎜

🎜Wenn ein Objekt hashbar ist, kann es als Schlüssel in einem Wörterbuch und als Element in einer Sammlung verwendet werden, da diese Datenstrukturen intern Hashwerte verwenden. 🎜

🎜Hashbare Objekte umfassen - 🎜str🎜, 🎜int🎜, 🎜bool🎜, 🎜tuple🎜, 🎜frozenset🎜. 🎜🎜Unhashbare Objekte umfassen - 🎜list🎜, 🎜dict🎜, 🎜set🎜. 🎜

🎜🎜Bitte beachten Sie🎜, dass Tupel und eingefrorene Mengen nur dann hashbar sind, wenn ihre Elemente hashbar sind. 🎜

Überprüfen, ob ein Objekt hashbar ist

🎜Wir können prüfen, ob ein Objekt hashbar ist, indem wir es an die integrierte Funktion hash() übergeben. 🎜rrreee🎜🎜🎜Die Hash-Funktion gibt den Hash-Wert des übergebenen Objekts zurück (falls vorhanden). 🎜🎜Hash-Werte sind Ganzzahlen, die zum Vergleichen von Wörterbuchschlüsseln bei Wörterbuchsuchen verwendet werden. 🎜🎜!> Der Hashwert eines hashbaren Objekts ändert sich während seiner Lebensdauer nie. Aus diesem Grund sind die meisten unveränderlichen Objekte hashbar, während veränderliche Objekte nicht hashbar sind. 🎜🎜Objekte wie Wörterbücher sind veränderbar, da sich der Inhalt des Wörterbuchs ändern kann. 🎜rrreee🎜Andererseits sind fronzenset und Tupelobjekte, die primitive Werte enthalten, unveränderlich (und hashbar). 🎜🎜Wörterbücher werden nach Schlüsseln indiziert, und Schlüssel in einem Wörterbuch können jeden unveränderlichen Typ haben, z. B. Zeichenfolgen oder Zahlen. 🎜

🎜Tupel können nur dann als Schlüssel in einem Wörterbuch verwendet werden, wenn sie Zeichenfolgen, Zahlen oder Tupel enthalten. 🎜

🎜Wenn ein fronzenset oder Tupel ein veränderbares Objekt (z. B. eine Liste) enthält, kann es nicht als Schlüssel in einem Wörterbuch oder als Element in einer Menge verwendet werden. 🎜🎜Wenn wir uns über den Typ des in einer Variablen gespeicherten Objekts nicht sicher sind, verwenden Sie bitte die Funktion type(). 🎜rrreee🎜type Die Funktion gibt den Typ des Objekts zurück. 🎜

Wenn das übergebene Objekt eine Instanz oder Unterklasse der übergebenen Klasse ist, gibt die Funktion isinstance True zurück.

Das obige ist der detaillierte Inhalt vonSo lösen Sie den TypeError:unhashable type:'dict'-Fehler in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!