Mettre à jour le dictionnaire imbriqué en Python

En Python, un dictionnaire est une structure de données à usage général qui vous permet de stocker et de récupérer efficacement des paires clé-valeur. En particulier, les dictionnaires imbriqués constituent un moyen pratique d'organiser et de représenter des données complexes. Cependant, la mise à jour des valeurs dans les dictionnaires imbriqués peut parfois s'avérer un peu difficile.

Accéder aux éléments du dictionnaire imbriqués

Pour mettre à jour une valeur dans un dictionnaire imbriqué, nous devons d'abord accéder à une clé spécifique dans la hiérarchie du dictionnaire. Python vous permet d'accéder aux éléments imbriqués en utilisant des clés consécutivement. Par exemple -

nested_dict = {'outer_key': {'inner_key': 'old_value'}}
nested_dict['outer_key']['inner_key'] = 'new_value'

Dans l'extrait de code ci-dessus, nous accédons à l'élément imbriqué "inner_key" en enchaînant les clés consécutivement et mettons à jour sa valeur en "new_value".

Mettre à jour le dictionnaire imbriqué à un seul niveau

Parfois, vous pouvez rencontrer des dictionnaires imbriqués où les clés des différents niveaux n'ont pas de structure fixe. Dans ce cas, une approche plus générale est nécessaire. Python fournit la méthode update(), qui nous permet de fusionner un dictionnaire dans un autre dictionnaire, mettant ainsi à jour ses valeurs. Voici un exemple −

nested_dict = {'outer_key': {'inner_key': 'old_value'}}
update_dict = {'inner_key': 'new_value'}
nested_dict['outer_key'].update(update_dict)

Dans l'extrait de code ci-dessus, nous avons créé un dictionnaire distinct update_dict qui contient les paires clé-valeur que nous souhaitons mettre à jour. En utilisant la méthode update(), nous fusionnons le update_dict dans un dictionnaire imbriqué au niveau de clé spécifié, mettant ainsi à jour efficacement sa valeur.

Mettre à jour le dictionnaire imbriqué à plusieurs niveaux

Si vous devez mettre à jour les valeurs de plusieurs niveaux d'un dictionnaire imbriqué, vous pouvez utiliser une approche récursive. Cette méthode consiste à parcourir récursivement le dictionnaire jusqu'à ce que la clé requise soit trouvée. Voici un exemple −

def update_nested_dict(nested_dict, keys, new_value):
   if len(keys) == 1:
      nested_dict[keys[0]] = new_value
   else:
      key = keys[0]
      if key in nested_dict:
         update_nested_dict(nested_dict[key], keys[1:], new_value)

nested_dict = {'outer_key': {'inner_key': {'deep_key': 'old_value'}}}
keys = ['outer_key', 'inner_key', 'deep_key']
new_value = 'new_value'
update_nested_dict(nested_dict, keys, new_value)

Dans l'extrait de code ci-dessus, nous définissons une fonction récursive update_nested_dict qui prend comme arguments un dictionnaire imbriqué, une liste de clés et une nouvelle valeur. Cette fonction vérifie s'il ne reste qu'une seule clé dans la liste ; si c'est le cas, elle met à jour la valeur dans le dictionnaire imbriqué. Sinon, il parcourt le dictionnaire imbriqué plus profondément jusqu'à ce qu'il trouve la clé requise.

Gérez les clés perdues et créez-en de nouvelles

Lors de la mise à jour des dictionnaires imbriqués, il est important de considérer le cas où la clé spécifiée pourrait ne pas exister. Python propose plusieurs techniques pour gérer de telles situations et créer de nouvelles clés si nécessaire.

Utilisez la méthode Setdefault()

La méthode

setdefault() est un moyen pratique de mettre à jour les valeurs dans un dictionnaire imbriqué lorsqu'il s'agit de clés manquantes. Il permet de spécifier une valeur par défaut si la clé n'existe pas. Si la clé est trouvée, la valeur existante est renvoyée. Sinon, la valeur par défaut sera insérée dans le dictionnaire. Voici un exemple −

nested_dict = {'outer_key': {}}
nested_dict['outer_key'].setdefault('inner_key', 'new_value')

Dans l'extrait de code ci-dessus, nous utilisons la méthode setdefault() pour mettre à jour la valeur de "inner_key" dans la "outer_key" du dictionnaire imbriqué. Si "inner_key" n'existe pas, créez-le avec la valeur "new_value".

Utilisez la classe Defaultdict

La classe defaultdict du module collections fournit un moyen puissant de gérer les clés manquantes dans les dictionnaires imbriqués. Lorsqu’une clé inexistante est accédée, une valeur par défaut lui est automatiquement attribuée. Voici un exemple −

from collections import defaultdict

nested_dict = defaultdict(dict)
nested_dict['outer_key']['inner_key'] = 'new_value'

Dans l'extrait de code ci-dessus, nous avons créé un defaultdict et utilisé le type dict comme usine par défaut. Cela garantit que toute clé qui n'existe pas créera automatiquement un nouveau dictionnaire imbriqué. Nous procédons ensuite à la mise à jour de la "inner_key" à l'intérieur de la "outer_key" avec la valeur "new_value".

Mettre à jour les valeurs dans des dictionnaires profondément imbriqués

L'approche récursive devient plus utile si vous disposez d'un dictionnaire imbriqué avec plusieurs niveaux d'imbrication et que vous devez mettre à jour les valeurs dans le niveau le plus interne. Vous pouvez étendre la fonction récursive pour gérer des dictionnaires profondément imbriqués en modifiant la logique de parcours en conséquence.

def update_deep_nested_dict(nested_dict, keys, new_value):
   if len(keys) == 1:
      nested_dict[keys[0]] = new_value
   else:
      key = keys[0]
      if key in nested_dict:
         update_deep_nested_dict(nested_dict[key], keys[1:], new_value)
      else:
         nested_dict[key] = {}
         update_deep_nested_dict(nested_dict[key], keys[1:], new_value)

nested_dict = {'outer_key': {'inner_key': {'deep_key': 'old_value'}}}
keys = ['outer_key', 'inner_key', 'deep_key']
new_value = 'new_value'
update_deep_nested_dict(nested_dict, keys, new_value)

Dans l'extrait de code ci-dessus, nous avons amélioré la fonction récursive précédente pour gérer les dictionnaires profondément imbriqués. Si une clé est manquante à n'importe quel niveau, un nouveau dictionnaire vide est créé et la fonction continue de parcourir jusqu'à ce que la clé la plus interne soit atteinte.

Dictionnaire imbriqué immuable

Il convient de noter que les dictionnaires en Python sont des objets mutables. Ainsi, lorsque vous mettez à jour un dictionnaire imbriqué, les modifications seront reflétées dans toutes les références au dictionnaire. Si vous devez conserver l'état d'origine d'un dictionnaire imbriqué, vous pouvez en créer une copie complète avant d'effectuer des mises à jour.

import copy

nested_dict = {'outer_key': {'inner_key': 'old_value'}}
updated_dict = copy.deepcopy(nested_dict)
updated_dict['outer_key']['inner_key'] = 'new_value'

Exemple

import copy

nested_dict = {'outer_key': {'inner_key': 'old_value'}}
updated_dict = copy.deepcopy(nested_dict)
updated_dict['outer_key']['inner_key'] = 'new_value'

print("Original nested_dict:")
print(nested_dict)

print("\nUpdated_dict:")
print(updated_dict)

Sortie

Voici le résultat de l'extrait de code mentionné dans la section −

Original nested_dict:
{'outer_key': {'inner_key': 'old_value'}}

Updated_dict:
{'outer_key': {'inner_key': 'new_value'}}

Dans l'extrait de code ci-dessus, la fonction copy.deepcopy() crée une copie complète du dictionnaire imbriqué, y compris tous les niveaux d'imbrication. Cela vous permet de mettre à jour le dictionnaire copié sans affecter le dictionnaire d'origine.

Mettre à jour les valeurs à l'aide de la compréhension du dictionnaire

Pour des mises à jour simples dans un dictionnaire imbriqué, vous pouvez utiliser des compréhensions de dictionnaire. Cette approche convient lorsque vous disposez d'un ensemble connu de clés à mettre à jour.

Exemple

.

nested_dict = {'outer_key': {'inner_key': 'old_value'}}
keys_to_update = ['outer_key']
updated_dict = {key: 'new_value' if key in keys_to_update else value for key, value in nested_dict.items()}

Sortie

Voici le résultat de l'extrait de code ci-dessus−

Original nested_dict:
{'outer_key': {'inner_key': 'old_value'}}

Updated_dict:
{'outer_key': {'inner_key': 'new_value'}}

在代码片段中，我们从包含嵌套结构的nested_dict字典开始。我们使用copy.deepcopy()创建nested_dict的深层副本并将其分配给updated_dict。然后，我们将updated_dict中'outer_key'内的'inner_key'的值更新为'new_value'。

最后，我们打印原始的nested_dict和更新后的updated_dict。从输出中可以看到，原始的nested_dict保持不变，而updated_dict反映了更新后的值。

结论

在 Python 中更新嵌套字典可能涉及访问特定键、合并字典或使用递归技术。通过了解这些不同的方法，您可以根据您的特定要求有效地更新嵌套字典中的值。在选择最合适的方法时，请记住考虑嵌套字典的结构和复杂性。

Python 的灵活性和内置方法（例如 update()、setdefault() 和 defaultdict 类）提供了强大的工具来处理各种情况，包括丢失键和创建新键。

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!