Comptez le nombre de fois que deux valeurs apparaissent simultanément dans un élément de type itérateur Python 3

Code qui compte le nombre de fois où deux éléments d'un élément de type itérateur (liste ou tapple) apparaissent en même temps. C'est aussi un exemple de code de sorted avec une combinaison d'éléments de type itérateur (ʻitertools.combination), un ensemble immuable ( frozenset`) et une clé.

code

count_colocation2.py

import itertools
import typing
from itertools import chain


def count_colocation2(
        iteriter: typing.Iterable
        ) -> typing.Dict[frozenset, int]:
    """
Comptez le nombre de fois où deux éléments d'un élément de type itérateur (liste ou tapple) apparaissent en même temps.
    """
    if not isinstance(iteriter, typing.Iterable):
        raise TypeError()
    #Préparez la combinaison
    comb = itertools.combinations(frozenset(chain.from_iterable(iteriter)), 2)
    comb = [frozenset(item) for item in comb]
    #Vérifier dans l'ordre et ajouter le nombre de combinaisons
    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)
#Trier les valeurs par ordre décroissant
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)]
"""

Remarques

frozenset frozenset est une version immuable de set. Vous pouvez changer le contenu de set avec ʻadd ou ʻupdate, mais vous ne pouvez pas changer le contenu de ensemble gelé. D'autre part, frozenset peut être utilisé comme clé de dictionnaire car il peut obtenir le hachage.

#Ne pas commenter la ligne suivante entraînera une erreur.
# print(hash(set(["a", "b", "c"])))
# TypeError: unhashable type: 'set'

#Il se termine normalement.
print(hash(frozenset(["a", "b", "c"])))

Il y a «tuple» dans le type immuable qui peut être la clé du même dictionnaire. «tuple» distingue l'ordre des éléments, mais «frozenset» ne le fait pas.

typing.Sequence、typing.Iterable Python a des classes comme «list», «tuple», «set» et «frozenset», mais celles-ci peuvent être catégorisées par des fonctionnalités communes. list et tuple sont classés comme type de séquence ( typing.Sequence) car ils sont accessibles par index. De plus, «list», «tuple», «set» et «frozenset» sont classés comme «typing.Iterable» car ils fournissent des itérateurs.

typing.Sequence et typing.Iterable sont définis comme des types et peuvent être utilisés dans les indices de type, ainsi que dans ʻis instance et ʻis sous-classe.

Liste des tapples combinés de type itérateur

ʻItertools.combinations vous permet de créer une liste de n'importe quel nombre de combinaisons à partir d'éléments de type (typing.Iterable`).

Accès aux éléments de set / fixed set

set / frozenset n'est pas accessible à l'index [index]. Vous pouvez y accéder en le convertissant une fois en list ou tuple aveclist ()outuple (). Puisqu'il s'agit d'un type itérateur, «for» peut être utilisé.

Tri non destructif des dictionnaires

Vous pouvez spécifier une expression lambda pour key = ... dans sorted () pour trier le dictionnaire de manière non destructive. Notez que les paires clé / valeur du dictionnaire sont récupérées avec dict.items (). Si vous passez dict lui-même à sorted, le nom de la clé sera la cible desorted ().

Trier par clé

sorted(dict.items(), key=lambda item: item[0])                #ordre croissant
sorted(dict.items(), key=lambda item: item[0], reverse=True)  #Ordre décroissant

Trier par valeur

sorted(dict.items(), key=lambda item: item[1])                #ordre croissant
sorted(dict.items(), key=lambda item: item[1], reverse=True)  #Ordre décroissant