Python-Programmierung: Eine andere Möglichkeit, die Wörterbuchkettenzuordnung (ChainMap) zu verwenden, probieren Sie es aus!

Vorwort

Eine Sammlung ist ein spezieller Container-Datentyp (Container-Datentyp), der die allgemeinen integrierten Container von Python wie Diktat, Liste, Menge und Tupel ersetzen kann. Ein Container ist ein Spezialobjekt, das zum Speichern verschiedener Objekte verwendet werden kann. Es bietet eine Möglichkeit, auf die enthaltenen Objekte zuzugreifen und diese zu durchlaufen.

Python stellt das Sammlungsmodul bereit, das Containerdatentypen implementiert. In dieser Kapitelreihe lernen wir die verschiedenen Arten von Sammlungen im Sammlungsmodul kennen, darunter:

• ChainMap
• Counter
• Deque
• DefaultDict
• NamedTuple
• OrderedDict
• UserDict
• UserList
• UserString

Lassen Sie uns jeden dieser Containertypen vorstellen – ChainMap.

Lernen Sie ChainMap kennen

Die von Python bereitgestellte ChainMap-Klasse (Chain-Mapping-Klasse genannt) ist eine wörterbuchähnliche Klasse, die zum schnellen Verknüpfen vieler Zuordnungen verwendet wird, sodass sie als eine einzige Einheit verarbeitet werden können. Dies ist normalerweise viel schneller, als ein neues Wörterbuch zu erstellen und mehrere update()-Aufrufe auszuführen.

Das Syntaxformat ist wie folgt:

xchainMap =collections.ChainMap(*maps)

Erklärung: Sammlungen im Syntaxformat ist der Name des importierten Vervollständigungsmoduls. Wenn Sie das Modul wie folgt importieren: Sammlungen als cts importieren, kann die Syntax geändert werden in: class cts.ChainMap(*maps) oder Fuzzy-Import: aus Sammlungen importieren ChainMap, was geändert werden kann in: ChainMap(*maps).

ChainMap kombiniert mehrere Wörterbücher oder andere Zuordnungen, um eine einzige, aktualisierbare Ansicht (eine Liste von Wörterbüchern) zu erstellen. Wenn keine Zuordnung angegeben ist, wird ein leeres Wörterbuch bereitgestellt, sodass für neue Kettenzuordnungen (ChainMap) immer mindestens eine Zuordnung verfügbar ist.

Die zugrunde liegende Zuordnung einer Kettenzuordnung wird in einer Liste gespeichert. Die Liste ist öffentlich und kann über die Eigenschaft „maps“ aufgerufen oder aktualisiert werden. Abgesehen vom Attribut „maps“ hat die Kettenzuordnung keinen weiteren neuen erweiterten Status.

ChainMap führt die zugrunde liegende Zuordnung per Referenz zusammen. Wenn also eine der zugrunde liegenden Karten aktualisiert wird, werden diese Änderungen auch in der ChainMap widergespiegelt.

Chain Mapping unterstützt alle gängigen Wörterbuch-(Dikt-)Methoden. Darüber hinaus gibt es ein Maps-Attribut für Methoden, die neue Unterkontexte erstellen, und das Maps-Attribut kann verwendet werden, um auf alle Maps außer der ersten zuzugreifen – Maps ist eine Liste.

entspricht einer vom Benutzer aktualisierbaren Zuordnungsliste, die von der ersten Suche bis zur letzten Suche geordnet ist. Es ist der einzige gespeicherte Zustand, der geändert werden kann, um die zu durchsuchende Zuordnung zu ändern. Eine solche Liste sollte immer mindestens eine Zuordnung enthalten.

Sehen Sie sich das einfache Beispiel unten an. Die Codeliste lautet wie folgt:

Das Ausgabeergebnis der Ausführung des Programms lautet wie folgt:

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

In der obigen Liste verwenden wir zwei Wörterbücher, um ein ChainMap-Objekt zu definieren ( chain_map). Dann drucken wir das ChainMap-Objekt und die Maps-Eigenschaft aus. Wie Sie in der Ausgabe sehen können, ist das Ergebnis eine Ansicht der Zusammensetzung dieser Wörterbücher.

Zugriff auf ChainMap-Schlüsselwerte

Wir können auf ChainMap-Schlüssel und -Werte zugreifen, indem wir die Methoden „keys()“ und „values()“ verwenden. Das Codebeispiel lautet wie folgt:

Das Ausgabeergebnis des obigen Codes lautet:

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

Wie im Programmausgabeergebnis gezeigt, ist das Ergebnis von chain_map.keys() eine KeysView (Schlüsselansicht) und die Ergebnis von chain_map.values() ist eine ValuesView (Wertansicht). Diese beiden integrierten Klassen vom Ansichtstyp sind iterierbare Objekte, die die entsprechenden Schlüsselnamen bzw. Wertobjekte durchlaufen können. Zum Beispiel:

Das Ausgabeergebnis lautet:

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

Durch die Kombination des Codes und des Ausgabeergebnisses ist es leicht zu verstehen, dass die Kettenzuordnung darin besteht, mehrere Zuordnungen zu packen (die Karte hat viele Implementierungen und das Wörterbuch ist eine). von ihnen) in eine Zuordnung, also eine Kettenzuordnung, umgewandelt werden, auf die dann wie auf ein Wörterbuch zugegriffen werden kann. Greifen Sie beispielsweise wie ein Wörterbuch auf den Wert eines bestimmten Schlüssels zu:

print(chain_map['b'] )

Das heißt, Sie verwenden den Schlüsselnamen: chain_map['one'], um auf den Wert eines einzelnen Elements im zugrunde liegenden Wörterbuch von ChainMap zuzugreifen.

Neue Zuordnung zu ChainMap hinzufügen

ChainMap kann eine beliebige Anzahl von Wörterbüchern enthalten. Wir fügen der ChainMap ein neues Wörterbuch hinzu, indem wir die integrierte Methode new_child() verwenden. Die Methode new_child() gibt eine neue ChainMap zurück, die die neue Zuordnung enthält, gefolgt von allen Zuordnungen in der aktuellen Instanz. Hierbei ist zu beachten, dass das neu hinzugefügte Wörterbuch am Anfang der ChainMap platziert wird. Schauen wir uns das Beispiel an:

Führen Sie das Programm aus und das Eingabeergebnis ist wie folgt:

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新增新的键值对时，它会添加到所包含的第一个映射对象中。

Das obige ist der detaillierte Inhalt vonPython-Programmierung: Eine andere Möglichkeit, die Wörterbuchkettenzuordnung (ChainMap) zu verwenden, probieren Sie es aus!. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!