Programmation Python : Une autre façon d'utiliser le mappage de chaînes de dictionnaires (ChainMap), jouez avec !

Avant-propos

Une collection est un type de données de conteneur spécialisé (Container Datatype) qui peut remplacer les conteneurs généraux intégrés de Python, tels que dict, list, set et tuple. Un conteneur est un objet spécial qui peut être utilisé pour stocker différents objets. Il fournit un moyen d'accéder aux objets contenus et de les parcourir.

Python fournit le module de collections qui implémente les types de données de conteneur. Dans cette série de chapitres, nous découvrirons les différents types de collections dans le module Collections, notamment :

• ChainMap
• Counter
• Deque
• DefaultDict
• NamedTuple
• OrderedDict
• UserDict
• UserList
• ChaîneUtilisateur

Présentons chacun de ces types de conteneurs - ChainMap.

Découvrez ChainMap

La classe ChainMap (appelée classe de mappage de chaîne) fournie par Python est une classe de type dictionnaire qui est utilisée pour relier rapidement de nombreux mappages afin qu'ils puissent être traités comme une seule unité. C'est généralement beaucoup plus rapide que de créer un nouveau dictionnaire et d'exécuter plusieurs appels update().

Le format de syntaxe est le suivant :

xchainMap = collections.ChainMap(*maps)

Explication : les collections au format syntaxique sont le nom du module de complétion importé. Si vous importez le module comme ceci : importez des collections en tant que cts, la syntaxe peut être modifiée en : class cts.ChainMap(*maps), ou importation floue : à partir des collections, importez ChainMap, qui peut être modifié en : ChainMap(*maps).

ChainMap combine plusieurs dictionnaires ou autres mappages pour créer une vue unique et actualisable (une liste de dictionnaires). Si aucun mappage n'est spécifié, un dictionnaire vide est fourni afin que les nouvelles mappages de chaîne (ChainMap) aient toujours au moins un mappage disponible.

Le mappage sous-jacent d'une carte de chaîne est stocké dans une liste. La liste est publique et peut être consultée ou mise à jour à l'aide de la propriété maps. Hormis l'attribut maps, le mappage en chaîne n'a pas d'autre nouvel état étendu.

ChainMap fusionne le mappage sous-jacent par référence. Ainsi, si l’une des cartes sous-jacentes est mise à jour, ces modifications seront également reflétées dans ChainMap.

Le mappage de chaîne prend en charge toutes les méthodes courantes de dictionnaire (dict). De plus, il existe un attribut maps pour les méthodes qui créent de nouveaux sous-contextes, et l'attribut maps peut être utilisé pour accéder à toutes les maps sauf la première map - maps est une liste.

correspond à une liste de cartographie pouvant être mise à jour par l'utilisateur et classée de la première recherche à la dernière recherche. C'est le seul état stocké qui peut être modifié pour changer le mappage à rechercher. Une telle liste doit toujours contenir au moins un mappage.

Regardez l'exemple simple ci-dessous. La liste de codes est la suivante :

Le résultat de l'exécution du programme est le suivant :

ChainMap({'one': 1, 'two': 2}, {'a': 'A', 'b': 'B'})
[{'one': 1, 'two': 2}, {'a': 'A', 'b': 'B'}]

Dans la liste ci-dessus, nous utilisons deux dictionnaires pour définir un objet ChainMap ( chain_map). Ensuite, nous imprimons l'objet ChainMap et la propriété maps. Comme vous pouvez le voir dans le résultat, le résultat est une vue de la composition de ces dictionnaires.

Accès aux valeurs des clés ChainMap

Nous pouvons accéder aux clés et aux valeurs ChainMap en utilisant les méthodes key() etvalues(). L'exemple de code est le suivant :

Le résultat de sortie du code ci-dessus est :

KeysView(ChainMap({'one': 1, 'two': 2}, {'a': 'A', 'b': 'B'}))
ValuesView(ChainMap({'one': 1, 'two': 2}, {'a': 'A', 'b': 'B'}))

Comme le montre le résultat de sortie du programme, le résultat de chain_map.keys() est un KeysView (vue clé), et le le résultat de chain_map.values() est un ValuesView (vue de valeur). Ces deux classes intégrées de type vue sont des objets itérables qui peuvent respectivement parcourir les noms de clé et les objets de valeur correspondants. Par exemple :

Le résultat de sortie est :

key = a,value=A
key = b,value=B
key = one,value=1
key = two,value=2
链映射包含的值为：
A;B;1;2;

En combinant le code et les résultats de sortie, il est facile à comprendre, c'est-à-dire que le mappage en chaîne consiste à regrouper plusieurs mappages (la carte a de nombreuses implémentations et le dictionnaire est l'une des eux) en un seul mappage, c'est-à-dire un mappage en chaîne, auquel on peut ensuite accéder comme un dictionnaire. Par exemple, accédez à la valeur d'une certaine clé comme un dictionnaire :

print(chain_map['b'] )

Autrement dit, utilisez le nom de la clé : chain_map[' one '] pour accéder à la valeur d'un seul élément dans le dictionnaire sous-jacent de ChainMap.

Ajouter un nouveau mappage à ChainMap

ChainMap peut contenir n'importe quel nombre de dictionnaires. Nous ajoutons un nouveau dictionnaire au ChainMap en utilisant la méthode intégrée new_child(). La méthode new_child() renvoie un nouveau ChainMap contenant le nouveau mappage, suivi de tous les mappages de l'instance actuelle. Une chose à noter ici est que le dictionnaire nouvellement ajouté sera placé au début du ChainMap. Regardons l'exemple :

Exécutez le programme et le résultat d'entrée est le suivant :

Old: ChainMap({'one': 1, 'two': 2}, {'a': 'A', 'b': 'B'})
New: ChainMap({'x': 0, 'y': 1}, {'one': 1, 'two': 2}, {'a': 'A', 'b': 'B'})

这里需要注意的是，用链式映射的new_child()方法添加新字典后，不改变原来的链映射，会返回一个新的ChainMap对象。另外，如果你修改链式映射所包含的映射或字典，变化也将体现在链式映射对象中。

另外，实践中要当心：如果你按照字典操作来添加新的键值对，则该键值对会添加到链式映射所包含的第一个映射中，如：new_chain_map['X'] = 'Unkown' 。自己动手试试看。

所含映射有相同键怎么办？

底层上，链式映射主要是为把多个字典或映射打包成一个映射，以便集中操作。如果所办函的字典中有相同的键会怎样呢？来看示例：

运行程序输出结果如下：

ChainMap({'id': 21001, 'country': '大秦', 'emperor': '嬴政'}, {'name': '李靖', 'country': '大唐', 'title': '元帅'})
大秦
('name', '李靖')
('country', '大秦')
('title', '元帅')
('id', 21001)
('emperor', '嬴政')

很显然，链接的映射中出现相同字典项时，只读取第一个，以第一个为准，而且当你更新一个键的值时，它也只是更新第一个映射内容的键值。

如果你想一次更新所有映射中的相同键的值怎么办呢？你可以自定义一个ChainMap子类来实现，或定义更新方法。因为ChainMap中有个属性maps持有完整的各个映射，可以基于此属性来完成相同键的一次性更新。这里简单给个通过方法的方式实现多映射相同键的一次更新。示例代码如下：

当然，你可以写得更复杂一点，以完成更多的需要，也可实现一次多个映射中的相同键的值。自己动手试试吧。

本文小结

本文主要介绍了Python集合模块中的链式映射容器——ChainMap的使用，可以把多个字典打包成一个对象来操作。同时需要注意的是，该映射只是对原字典的引用，当你修改原字典时，相应的变化也为体现在链式映射中。同时，在为ChainMap新增新的键值对时，它会添加到所包含的第一个映射对象中。

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!