Zählen Sie, wie oft zwei Werte gleichzeitig in einem Element vom Typ Python 3-Iterator angezeigt werden

Code, der zählt, wie oft zwei Elemente in einem Element vom Typ Iterator (Liste oder Tapple) gleichzeitig angezeigt werden. Es ist auch ein Beispielcode von "sortiert" mit einer Kombination von Elementen vom Typ Iterator ("itertools.combination"), einer unveränderlichen Menge ("frozenset") und einem Schlüssel.

Code

count_colocation2.py

import itertools
import typing
from itertools import chain


def count_colocation2(
        iteriter: typing.Iterable
        ) -> typing.Dict[frozenset, int]:
    """
Zählen Sie, wie oft zwei Elemente in einem Element vom Typ Iterator (Liste oder Tapple) gleichzeitig angezeigt werden.
    """
    if not isinstance(iteriter, typing.Iterable):
        raise TypeError()
    #Bereiten Sie die Kombination vor
    comb = itertools.combinations(frozenset(chain.from_iterable(iteriter)), 2)
    comb = [frozenset(item) for item in comb]
    #Überprüfen Sie die Reihenfolge und fügen Sie die Anzahl der Kombinationen hinzu
    d = {key: 0 for key in comb}
    for entry in iteriter:
        for pair in comb:
            t = tuple(pair)
            if t[0] in entry and t[1] in entry:
                d[pair] += 1
    return d

1.py

from pprint import pp

from count_colocation2 import count_colocation2

ll = [
        ["a", "b", "c"],
        ["d", "e", "f"],
        ["a", "d", "f"],
        ["b", "d", "f"],
    ]

coloc2 = count_colocation2(ll)
#Sortieren Sie die Werte in absteigender Reihenfolge
pp(sorted(coloc2.items(), key=lambda item: item[1], reverse=True))

"""
[(frozenset({'f', 'd'}), 3),
 (frozenset({'f', 'e'}), 1),
 (frozenset({'f', 'b'}), 1),
 (frozenset({'f', 'a'}), 1),
 (frozenset({'d', 'e'}), 1),
 (frozenset({'d', 'b'}), 1),
 (frozenset({'d', 'a'}), 1),
 (frozenset({'b', 'a'}), 1),
 (frozenset({'b', 'c'}), 1),
 (frozenset({'a', 'c'}), 1),
 (frozenset({'f', 'c'}), 0),
 (frozenset({'b', 'e'}), 0),
 (frozenset({'e', 'a'}), 0),
 (frozenset({'e', 'c'}), 0),
 (frozenset({'d', 'c'}), 0)]
"""

Bemerkungen

frozenset frozenset ist eine unveränderliche Version von set. Sie können den Inhalt von "set" mit "add" und "update" ändern, aber Sie können den Inhalt von "gefrorenem Set" nicht ändern. Andererseits kann "frozenset" als Wörterbuchschlüssel verwendet werden, da es den Hash erhalten kann.

#Das Kommentieren der nächsten Zeile führt zu einem Fehler.
# print(hash(set(["a", "b", "c"])))
# TypeError: unhashable type: 'set'

#Es wird normal abgeschlossen.
print(hash(frozenset(["a", "b", "c"])))

Der unveränderliche Typ enthält ein Tupel, das der Schlüssel desselben Wörterbuchs sein kann. tuple unterscheidet die Reihenfolge der Elemente , frozenset jedoch nicht.

typing.Sequence、typing.Iterable Python hat Klassen wie "list", "tuple", "set" und "frozenset", aber diese können nach allgemeinen Funktionen kategorisiert werden. list und tuple werden als Sequenztyp ( typing.Sequence) klassifiziert, da über den Index auf sie zugegriffen werden kann. Außerdem werden "list", "tuple", "set" und "frozenset" als "typing.Iterable" klassifiziert, da sie Iteratoren bereitstellen.

typing.Sequence und typing.Iterable sind als Typen definiert und können in Typhinweisen sowie in isinstance und issubclass verwendet werden.

Liste der Kombinations-Tapples vom Typ Iterator

Mit itertools.combinations können Sie eine Liste mit einer beliebigen Anzahl von Kombinations-Tapples aus Elementen des Typs ( typing.Iterable) erstellen.

Zugriff auf die Elemente von "Set" / "Frozen Set"

set / frozenset ist unter index[index]nicht zugänglich. Sie können darauf zugreifen, indem Sie es einmal mit "list ()" oder "tuple ()" in "list" oder "tuple" konvertieren. Da es sich um einen Iteratortyp handelt, kann "for" verwendet werden.

Zerstörungsfreie Sortierung von Wörterbüchern

Sie können einen Lambda-Ausdruck in "key = ..." von "sortiert ()" angeben, um das Wörterbuch zerstörungsfrei zu sortieren. Beachten Sie, dass die Wörterbuchschlüssel / Wert-Paare mit "dict.items ()" abgerufen werden. Wenn Sie "dict" selbst an "sorted" übergeben, ist der Schlüsselname das Ziel von "sorted ()".

Nach Schlüssel sortieren

sorted(dict.items(), key=lambda item: item[0])                #aufsteigende Reihenfolge
sorted(dict.items(), key=lambda item: item[0], reverse=True)  #absteigende Reihenfolge

Nach Wert sortieren

sorted(dict.items(), key=lambda item: item[1])                #aufsteigende Reihenfolge
sorted(dict.items(), key=lambda item: item[1], reverse=True)  #absteigende Reihenfolge