Comment résoudre l'erreur TypeError:unhashable type:'dict' en Python

Python « TypeError : unhashable type : ‘dict’ » se produit lorsque nous utilisons un dictionnaire comme clé dans un autre dictionnaire ou comme élément dans une collection.

Pour résoudre cette erreur, vous devez utiliser frozenset à la place, ou convertir le dictionnaire en chaîne JSON avant de l'utiliser comme clé. 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

L'erreur se produit lorsque nous utilisons un dictionnaire comme clé dans un autre dictionnaire. 🎜rrreee🎜 Ou lorsque nous utilisons un dictionnaire comme élément dans un objet set. 🎜rrreee

🎜Nous ne pouvons pas utiliser un dictionnaire comme clé dans un dictionnaire ou comme élément dans une collection car les objets du dictionnaire sont mutables et ne peuvent pas être hachés. 🎜

Convertir le dictionnaire en chaîne JSON pour résoudre l'erreur

🎜Une façon de résoudre cette erreur consiste à convertir le dictionnaire en chaîne JSON avant de l'utiliser comme clé. La méthode 🎜rrreee🎜json.dumps convertit un objet Python en une chaîne au format JSON. Cela fonctionne car les chaînes sont immuables et hachables. 🎜🎜En revanche, la méthode json.loads analyse une chaîne JSON en un objet Python natif, tel que my_dict = json.loads(my_json_str). 🎜

Utilisez Frozenset pour résoudre les erreurs

🎜Une autre façon de résoudre les erreurs est d'utiliser frozenset. La méthode 🎜rrreee🎜dict.items renvoie une nouvelle vue des éléments du dictionnaire (paires (clé, valeur)). 🎜rrreee🎜Nous utilisons les éléments du dictionnaire pour créer un frozenset que nous pouvons utiliser comme clé dans le dictionnaire (ainsi que comme élément dans un autre ensemble). 🎜

🎜frozenset est une version immuable d'un objet de collection Python, il peut donc être utilisé comme clé dans un dictionnaire ou comme élément dans une autre collection. 🎜

🎜🎜Veuillez noter🎜 que nous devons utiliser la même méthode pour accéder aux clés du dictionnaire. 🎜

🎜Nous pouvons stocker le résultat de l'appel de frozenset(my_key.items()) dans une variable et réutiliser le Frozenset lors de la définition ou de l'accès aux clés du dictionnaire. 🎜

Convertir le dictionnaire en tuple pour résoudre l'erreur

🎜Une autre façon de résoudre l'erreur consiste à convertir le dictionnaire en tuple. 🎜rrreee🎜Lors de la conversion d'un dictionnaire en tuple, le tuple ne contient que les clés du dictionnaire. 🎜🎜Les tuples sont immuables, donc un tuple contenant une clé de dictionnaire peut être utilisé en toute sécurité comme clé dans un autre dictionnaire. 🎜

Utiliser un dictionnaire comme valeur dans un autre dictionnaire

🎜Nous ne pouvons pas utiliser un dictionnaire comme clé dans un autre dictionnaire, mais nous pouvons utiliser un dictionnaire comme valeur. 🎜rrreee🎜Nous définissons un dictionnaire sur une valeur dans un autre dictionnaire. 🎜🎜 Ceci est autorisé car la limite ne s'applique pas aux valeurs du dictionnaire. 🎜

Ajouter toutes les paires clé-valeur d'un dictionnaire à un autre dictionnaire

🎜Si vous devez ajouter toutes les paires clé-valeur d'un dictionnaire à un autre dictionnaire, vous pouvez utiliser une boucle for. La méthode 🎜rrreee🎜dict.items renvoie une nouvelle vue des éléments du dictionnaire (paires (clé, valeur)). 🎜rrreee🎜À chaque itération, nous définissons les paires clé-valeur dans un autre dictionnaire. 🎜

Objets hachables et non hachables en Python

🎜La plupart des objets immuables intégrés dans Python sont hachables, tandis que les objets mutables ne le sont pas. 🎜

🎜Si un objet est hachable, alors il peut être utilisé comme clé dans un dictionnaire et comme élément dans une collection, car ces structures de données utilisent des valeurs de hachage en interne. 🎜

🎜Les objets hachables incluent - 🎜str🎜 , 🎜int🎜 , 🎜bool🎜 , 🎜tuple🎜 , 🎜frozenset🎜. 🎜🎜Les objets non hachables incluent - 🎜list🎜, 🎜dict🎜, 🎜set🎜. 🎜

🎜🎜Veuillez noter🎜 que les tuples et les ensembles gelés ne peuvent être hachés que si leurs éléments le sont. 🎜

Vérifier si un objet est hachable

🎜Nous pouvons vérifier si un objet est hachable en le passant à la fonction intégrée hash(). 🎜rrreee🎜🎜🎜La fonction de hachage renvoie la valeur de hachage de l'objet transmis (le cas échéant). 🎜🎜Les valeurs de hachage sont des entiers utilisés pour comparer les clés du dictionnaire lors des recherches dans le dictionnaire. 🎜🎜!> La valeur de hachage d'un objet hachable ne change jamais au cours de sa durée de vie. C'est pourquoi la plupart des objets immuables sont hachables, alors que les objets mutables ne le sont pas. 🎜🎜Les objets comme les dictionnaires sont modifiables car le contenu du dictionnaire peut changer. 🎜rrreee🎜D'un autre côté, les fronzenset et les objets tuple contenant des valeurs primitives sont immuables (et hachables). 🎜🎜Les dictionnaires sont indexés par clés, et les clés d'un dictionnaire peuvent être de n'importe quel type immuable, tel que des chaînes ou des nombres. 🎜

🎜Les tuples ne peuvent être utilisés comme clés dans un dictionnaire que s'ils contiennent des chaînes, des nombres ou des tuples. 🎜

🎜Si un fronzenset ou un tuple contient un objet mutable (comme une liste), il ne peut pas être utilisé comme clé dans un dictionnaire ou comme élément dans un ensemble. 🎜🎜Si nous ne sommes pas sûrs du type d'objet stocké dans une variable, veuillez utiliser la fonction type(). La fonction 🎜rrreee🎜type renvoie le type d'objet. 🎜

Si l'objet transmis est une instance ou une sous-classe de la classe transmise, la fonction isinstance renvoie True.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!