En Python, vous pouvez compter le nombre total d’éléments dans une liste ou un tuple avec la fonction intégrée len() et le nombre d’occurrences d’un élément avec la méthode count().
De plus, la classe Counter des collections de bibliothèques standard peut être utilisée pour compter le nombre d’occurrences de chaque élément à la fois.
Cet article décrit le contenu suivant.
- Comptez le nombre total d’éléments :
len() - Comptez le nombre d’occurrences d’un élément :
count() - Comment utiliser collections.Counter
- Obtenez les éléments les plus courants :
most_common() - Compter les éléments uniques
- Compter les éléments qui satisfont aux conditions
- Compter le nombre d’occurrences d’un mot dans une chaîne
- Compter le nombre d’occurrences d’un caractère dans une chaîne
Les listes sont utilisées dans l’exemple de code suivant, mais les tuples peuvent être traités de la même manière.
Comptez le nombre total d’éléments :len()
Vous pouvez compter le nombre total d’éléments dans une liste avec la fonction intégrée len().
l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
print(len(l))
# 7
Comptez le nombre d’occurrences d’un élément :count()
Vous pouvez compter le nombre d’occurrences d’un élément dans une liste avec la méthode count().
Si un élément inexistant est passé, 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
collections.Counter, expliqué ensuite, est utile si vous souhaitez compter le nombre d’occurrences de chaque élément à la fois.
Comment utiliser collections.Counter
La classe Counter est fournie dans les collections de bibliothèques standard.
L’objet compteur est créé en passant une liste à collections.Counter().
Counter est une sous-classe du dictionnaire dict, qui a des éléments comme clés et leurs décomptes 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
En spécifiant un élément, vous pouvez obtenir son nombre. Si un élément inexistant est spécifié, 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 dict telles que keys(), values() et items().
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. Vous pouvez les utiliser telles quelles si vous souhaitez utiliser la boucle for. Si vous voulez le convertir en liste, utilisez list().
Obtenez les éléments les plus courants :most_common()
Counter a une méthode most_common () qui renvoie une liste de tuples de (élément, nombre) triés par nombre.
print(c.most_common())
# [('a', 4), ('c', 2), ('b', 1)]
Vous pouvez obtenir celui avec le plus grand nombre d’occurrences en spécifiant l’index comme [0], celui avec le plus bas comme [-1], et ainsi de suite. Si vous souhaitez obtenir uniquement les éléments ou uniquement le nombre, spécifiez simplement l’index après celui-ci.
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 souhaitez trier par ordre décroissant, utilisez des tranches avec l’incrément défini sur -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 avec le plus d’occurrences sont renvoyés. S’il est omis, tous les éléments sont renvoyés.
print(c.most_common(2))
# [('a', 4), ('c', 2)]
Si vous voulez une liste distincte d’éléments et leurs nombres triés par le nombre d’occurrences, au lieu d’un tuple de (élément, nombre), vous pouvez faire ce qui suit.
values, counts = zip(*c.most_common())
print(values)
# ('a', 'c', 'b')
print(counts)
# (4, 2, 1)
Il utilise la fonction intégrée zip() pour transposer une liste 2D (dans ce cas, une liste de tuples) et la décompresser et l’extraire. Voir les articles suivants pour plus de détails.
Compter les éléments uniques
Si vous souhaitez compter des éléments uniques dans une liste ou un tuple, utilisez Counter ou set().
Le nombre d’éléments dans l’objet Counter est égal au nombre d’éléments uniques dans la liste d’origine. Il 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. Si vous n’avez pas besoin d’objet Counter, il est plus facile d’utiliser set.
set est un type de données qui n’a pas d’éléments en double, et set() renvoie un objet set avec des valeurs uniques lorsqu’une liste est transmise. Vous pouvez obtenir le nombre d’éléments dans set avec len().
print(set(l))
# {'a', 'c', 'b'}
print(len(set(l)))
# 3
Pour plus d’informations sur la vérification, la suppression et l’extraction des éléments en double dans une liste, consultez les articles suivants.
Compter les éléments qui satisfont aux conditions
Pour compter le nombre d’éléments d’une liste ou d’un tuple qui satisfont à une certaine condition, utilisez des compréhensions de liste ou des expressions génératrices.
Par exemple, comptez le nombre d’éléments avec des valeurs négatives pour la liste suivante.
l = list(range(-5, 6))
print(l)
# [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
L’application d’une expression conditionnelle à chaque élément avec des compréhensions de liste renvoie une liste dont les éléments sont de type bool (True, False).
Le type booléen bool est une sous-classe du type entier int. True est traité comme 1 et False comme 0. Vous pouvez compter le nombre de True (le nombre d’éléments qui satisfont la condition) par 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 [] dans la liste des compréhensions est remplacé par (), il devient une expression génératrice. Lorsqu’une expression de générateur est le seul argument, () peut être omis.
print(sum((i < 0 for i in l)))
# 5
print(sum(i < 0 for i in l))
# 5
Utilisez not si vous voulez compter le nombre de False (le nombre d’éléments qui ne satisfont pas la condition).
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, vous pouvez modifier les conditions.
print(sum(i >= 0 for i in l))
# 6
Quelques autres exemples sont présentés ci-dessous.
Compter le 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
Exemples pour une liste de chaînes :
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
Utilisez collections.Counter pour définir le nombre d’occurrences comme condition.
Voici un exemple d’extraction d’éléments avec deux occurrences ou plus, et de comptage du nombre total d’entre eux. Dans cet exemple, il y a quatre a et deux c, donc 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 valeurs d’éléments avec deux occurrences ou plus et de comptage de leur nombre. Dans cet exemple, il y a deux valeurs, 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
Compter le nombre d’occurrences d’un mot dans une chaîne
Comme exemple spécifique, comptons le nombre d’occurrences de mots dans une chaîne.
Tout d’abord, inutile , et . sont remplacés par une chaîne vide à l’aide de la méthode replace() et supprimés. 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 faites une liste, vous pouvez obtenir le nombre d’occurrences, etc. comme dans les exemples précédents.
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
Ce qui précède est un processus très simple, donc pour un traitement du langage naturel plus complexe, il est préférable d’utiliser une bibliothèque telle que NLTK.
Compter le nombre d’occurrences d’un caractère dans une chaîne
Vous pouvez également utiliser la méthode count() pour les chaînes, ou la passer comme argument 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})
Obtenez les cinq personnages 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')