Compter le nombre d’occurrences de chaque élément dans une liste avec Counter de Python

Affaires

En Python, le nombre de tous les éléments d'une liste ou d'un tuple peut être obtenu à l'aide de la fonction intégrée len(), et le nombre de chaque élément (le nombre d'occurrences de chaque élément) peut être obtenu à l'aide de la méthode count().

En outre, la classe Counter des collections de la bibliothèque standard de Python peut être utilisée pour obtenir les éléments dans l'ordre du nombre d'occurrences.

Dans cette section, nous aborderons les points suivants

  • Comptez le nombre total d'éléments :len()
  • Compter le nombre de chaque élément (le nombre d'occurrences de chaque élément) :count()
  • Utilisation.collections.Counter
  • Les éléments sont récupérés par ordre de fréquence d'apparition :most_common()
  • Comptez le nombre (type) d'éléments qui ne se chevauchent pas (éléments uniques).
  • Comptez le nombre d'éléments qui satisfont à la condition.

En outre, à titre d'exemple concret, ce qui suit est expliqué avec un exemple de code.

  • Compte le nombre d'occurrences d'un mot dans une chaîne de caractères.
  • Compte le nombre d'occurrences d'un caractère dans une chaîne de caractères.

L'échantillon est une liste, mais le même traitement peut être effectué avec des tuples.

Compter le nombre total d'éléments : len()

Pour compter le nombre total d'éléments dans une liste ou un tuple, utilisez la fonction intégrée len().

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']

print(len(l))
# 7

Compter le nombre de chaque élément (le nombre d'occurrences de chaque élément) : méthode count()

Pour compter le nombre de chaque élément (le nombre d'occurrences de chaque élément), utilisez la méthode count() pour les listes, les tuples, etc.

Si une valeur qui n'existe pas en tant qu'élément est passée comme argument, 0 est renvoyé.

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']

print(l.count('a'))
# 4

print(l.count('b'))
# 1

print(l.count('c'))
# 2

print(l.count('d'))
# 0

Si vous voulez obtenir le nombre d'occurrences de chaque élément en une seule fois, la collection.Counter suivante est utile.

Comment utiliser collections.Counter

Les collections de la bibliothèque standard Python possèdent une classe Counter.

Counter() est une sous-classe du type dictionnaire dict, qui possède des données sous forme d'éléments comme clés et d'occurrences comme valeurs.

import collections

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']

c = collections.Counter(l)
print(c)
# Counter({'a': 4, 'c': 2, 'b': 1})

print(type(c))
# <class 'collections.Counter'>

print(issubclass(type(c), dict))
# True

Si un élément est spécifié comme clé, le nombre d'éléments peut être obtenu. Si une valeur qui n'existe pas en tant qu'élément est spécifiée, 0 est renvoyé.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

Vous pouvez également utiliser des méthodes de type dictionnaire telles que keys(), values(), items(), etc.

print(c.keys())
# dict_keys(['a', 'b', 'c'])

print(c.values())
# dict_values([4, 1, 2])

print(c.items())
# dict_items([('a', 4), ('b', 1), ('c', 2)])

Ces méthodes renvoient des objets de type dict_keys, etc. Elles peuvent être utilisées telles quelles si vous voulez exécuter une instruction for. Si vous voulez les convertir en liste, utilisez list().

Obtention des éléments par ordre de fréquence d'apparition : méthode most_common()

Counter possède la méthode most_common(), qui renvoie une liste de tuples de la forme (élément, nombre d'occurrences) triés par le nombre d'occurrences.

print(c.most_common())
# [('a', 4), ('c', 2), ('b', 1)]

L'élément ayant le plus grand nombre d'occurrences peut être obtenu en spécifiant un index, tel que [0] pour le plus grand nombre d'occurrences et [-1] pour le plus petit nombre d'occurrences. Si vous voulez obtenir seulement les éléments ou seulement le nombre d'occurrences, vous pouvez spécifier l'indice plus loin.

print(c.most_common()[0])
# ('a', 4)

print(c.most_common()[-1])
# ('b', 1)

print(c.most_common()[0][0])
# a

print(c.most_common()[0][1])
# 4

Si vous voulez les trier par ordre décroissant de nombre d'occurrences, utilisez la tranche avec l'incrément fixé à -1.

print(c.most_common()[::-1])
# [('b', 1), ('c', 2), ('a', 4)]

Si l'argument n est spécifié pour la méthode most_common(), seuls les n éléments ayant le plus grand nombre d'occurrences sont renvoyés. S'il est omis, tous les éléments.

print(c.most_common(2))
# [('a', 4), ('c', 2)]

Si vous voulez une liste séparée d'éléments\occurrences ordonnée par le nombre d'occurrences, plutôt qu'un tuple de (élément, nombre d'occurrences), vous pouvez la décomposer comme suit

values, counts = zip(*c.most_common())

print(values)
# ('a', 'c', 'b')

print(counts)
# (4, 2, 1)

La fonction intégrée zip() est utilisée pour transposer une liste bidimensionnelle (dans ce cas, une liste de tuples), puis la décompresser et l'extraire.

Comptez le nombre (type) d'éléments qui ne se chevauchent pas (éléments uniques).

Pour compter combien d'éléments non superposés (éléments uniques) il y a dans une liste ou un tuple (combien de types il y a), utilisez Counter ou set() comme décrit ci-dessus.

Le nombre d'éléments dans l'objet Counter est égal au nombre d'éléments non chevauchants dans la liste originale, qui peut être obtenu avec len().

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)

print(len(c))
# 3

Vous pouvez également utiliser set(), le constructeur du type set, ce qui est plus facile si vous n'avez pas besoin d'un objet Counter.

Le type set est un type de données qui ne possède pas d'éléments dupliqués. Le passage d'une liste à set() ignore les valeurs en double et renvoie un objet de type set avec pour seuls éléments des valeurs uniques. Le nombre d'éléments de ce type est obtenu par len().

print(set(l))
# {'a', 'c', 'b'}

print(len(set(l)))
# 3

Comptez le nombre d'éléments qui satisfont à la condition.

Pour compter le nombre d'éléments d'une liste ou d'un tuple qui satisfont à une certaine condition, utilisez la notation de compréhension de liste ou les expressions de générateur.

À titre d'exemple, comptez le nombre d'éléments ayant une valeur négative pour la liste de nombres suivante

l = list(range(-5, 6))
print(l)
# [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]

En appliquant une expression conditionnelle à chaque élément dans la notation de compréhension de liste, on obtient une liste dont les éléments sont des booléens (true, false). Le type booléen bool est une sous-classe du type entier int, où true est traité comme 1 et false comme 0. Par conséquent, le nombre de valeurs vraies (le nombre d'éléments qui satisfont à la condition) peut être compté en calculant la somme à l'aide de sum().

print([i < 0 for i in l])
# [True, True, True, True, True, False, False, False, False, False, False]

print(sum([i < 0 for i in l]))
# 5

Si nous remplaçons [] dans la notation de compréhension de liste par (), nous obtenons une expression génératrice. La notation de compréhension de liste génère une liste de tous les éléments traités, tandis que l'expression du générateur traite les éléments de manière séquentielle et est donc plus efficace en termes de mémoire.

Lorsque l'expression du générateur est le seul argument, () peut être omis, ce qui permet de l'écrire comme dans le dernier cas.

print(sum((i < 0 for i in l)))
# 5

print(sum(i < 0 for i in l))
# 5

Si vous voulez compter le nombre de valeurs fausses (le nombre d'éléments qui ne satisfont pas la condition), utilisez not. Notez que > a une plus grande priorité que not (il est calculé en premier), de sorte que les parenthèses () dans (i < 0) dans l'exemple suivant ne sont pas nécessaires.

print([not (i < 0) for i in l])
# [False, False, False, False, False, True, True, True, True, True, True]

print(sum(not (i < 0) for i in l))
# 6

Bien sûr, les conditions elles-mêmes peuvent être modifiées.

print(sum(i >= 0 for i in l))
# 6

D'autres exemples sont présentés ci-dessous.

Exemple d'obtention du nombre d'éléments impairs pour une liste de nombres.

print([i % 2 == 1 for i in l])
# [True, False, True, False, True, False, True, False, True, False, True]

print(sum(i % 2 == 1 for i in l))
# 6

Exemple de condition pour une liste de chaînes de caractères.

l = ['apple', 'orange', 'banana']

print([s.endswith('e') for s in l])
# [True, True, False]

print(sum(s.endswith('e') for s in l))
# 2

Counter est utilisé pour compter en fonction du nombre d'occurrences. items() récupère un tuple de (élément, nombre d'occurrences), et le nombre d'occurrences spécifie la condition.

Voici un exemple d'extraction d'éléments ayant deux occurrences ou plus et de comptage du nombre total d'occurrences. Dans cet exemple, il y a quatre a et deux c, soit un total de six.

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)

print(c.items())
# dict_items([('a', 4), ('b', 1), ('c', 2)])

print([i for i in l if c[i] >= 2])
# ['a', 'a', 'a', 'a', 'c', 'c']

print([i[1] for i in c.items() if i[1] >= 2])
# [4, 2]

print(sum(i[1] for i in c.items() if i[1] >= 2))
# 6

Voici un exemple d'extraction des types d'éléments ayant deux occurrences ou plus et de comptage du nombre d'occurrences. Dans cet exemple, il y a deux types, a et c.

print([i[0] for i in c.items() if i[1] >= 2])
# ['a', 'c']

print([i[1] >= 2 for i in c.items()])
# [True, False, True]

print(sum(i[1] >= 2 for i in c.items()))
# 2

Compte le nombre d'occurrences d'un mot dans une chaîne de caractères.

À titre d'exemple concret, comptons le nombre d'occurrences d'un mot dans une chaîne de caractères.

Tout d'abord, remplacez les virgules et les points inutiles par une chaîne vide à l'aide de la méthode replace(), puis supprimez-les. Ensuite, utilisez la méthode split() pour créer une liste séparée par des espaces.

s = 'government of the people, by the people, for the people.'

s_remove = s.replace(',', '').replace('.', '')

print(s_remove)
# government of the people by the people for the people

word_list = s_remove.split()

print(word_list)
# ['government', 'of', 'the', 'people', 'by', 'the', 'people', 'for', 'the', 'people']

Si vous pouvez faire une liste, vous pouvez obtenir le nombre de fois où chaque mot apparaît, les types de mots qui apparaissent, et la fonction most_common() de collections.Counter pour obtenir le mot qui apparaît le plus souvent.

print(word_list.count('people'))
# 3

print(len(set(word_list)))
# 6

c = collections.Counter(word_list)

print(c)
# Counter({'the': 3, 'people': 3, 'government': 1, 'of': 1, 'by': 1, 'for': 1})

print(c.most_common()[0][0])
# the

Le processus ci-dessus est très simple, il est donc préférable d'utiliser des bibliothèques telles que NLTK pour le traitement plus complexe du langage naturel.

De plus, dans le cas d'un texte japonais, split() ne peut pas être utilisé pour diviser le texte car il n'y a pas de séparation claire des mots. Vous pouvez par exemple utiliser la bibliothèque Janome pour y parvenir.

Compte le nombre d'occurrences d'un caractère dans une chaîne de caractères.

Les chaînes de caractères étant également un type de séquence, elles peuvent être utilisées avec la méthode count() ou passées comme argument au constructeur de collections.Counter().

s = 'supercalifragilisticexpialidocious'

print(s.count('p'))
# 2

c = collections.Counter(s)

print(c)
# Counter({'i': 7, 's': 3, 'c': 3, 'a': 3, 'l': 3, 'u': 2, 'p': 2, 'e': 2, 'r': 2, 'o': 2, 'f': 1, 'g': 1, 't': 1, 'x': 1, 'd': 1})

Exemple de récupération des 5 caractères les plus fréquents.

print(c.most_common(5))
# [('i', 7), ('s', 3), ('c', 3), ('a', 3), ('l', 3)]

values, counts = zip(*c.most_common(5))

print(values)
# ('i', 's', 'c', 'a', 'l')
Copied title and URL