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 字符串。
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'})]) # ????️ addressjson.dumps 方法将 Python 对象转换为 JSON 格式的字符串。 这是有效的，因为字符串是不可变的和可散列的。
相反，json.loads 方法将 JSON 字符串解析为本机 Python 对象，例如 my_dict = json.loads(my_json_str)。
解决错误的另一种方法是使用 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 中的大多数不可变内置对象都是可散列的，而可变对象是不可散列的。
如果一个对象是可散列的，那么它可以用作字典中的键和集合中的元素，因为这些数据结构在内部使用散列值。
可哈希对象包括 - 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 'dict'>
print(isinstance(my_dict, dict)) # ????️ True
my_str = 'jiyik.com'
print(type(my_str)) # ????️ <class 'str'>
print(isinstance(my_str, str)) # ????️ Truetype
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. 🎜
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). 🎜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. 🎜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. 🎜🎜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. 🎜
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!
