Tuto Python : Les listes : la méthode COUNT()

Table des matières

Introduction :

Dans ce tutoriel, vous allez découvrir la méthode count () des listes en Python. Vous verrez comment l'utiliser sur des séquences à l'aide d'exemples.

Tout d’abord on va commencer avec la définition de la méthode et syntaxe, la fonctionnalité de la méthode, et la complexité de l’exécution.

Ensuite on va découvrir comment compter les doublons dans une liste, les valeurs et les chaines de caractères uniques, et après on va apprendre comment utiliser la méthode Count() avec des autres méthodes, et faire la comparaison entre Count et Len.

1. Syntaxe de Python Count () :

Une Méthode de comptage des listes

Le module de comptage est une méthode de liste intégrée qui vous permet de compter les occurrences d'un élément particulier dans la séquence.

Sa syntaxe est la suivante :

List_name.count()

Paramètre:

Élément : L'élément que vous voulez trouver le compte.

Valeur de retour :

La méthode count () retournera une valeur entière, c'est-à-dire le nombre d'éléments de la liste donnée. Elle retourne un 0 si la valeur n'est pas trouvée dans la liste donnée.

Exemple :

Cette méthode permet de compter le nombre d'occurrences d'un élément dans une liste. Voir l'exemple ci-dessous.

Syntaxe :

aleatoire_list = ["12", 12, (12, 13), 12, {12, 13}, 'linux', 'osx', 'win7']
aleatoire_list.count(12)

Résultat d’exécution :

Syntaxe :

aleatoire_list.count("12")

Résultat d’exécution :

Vous avez peut-être remarqué que la sortie pour la chaîne 12 était 2 et pour le "12" était 1. C'est parce que la liste ne compte que l'élément qui correspond au type de données et à la valeur du paramètre passé.

2. Comment fonctionne la méthode Count () ?

Cette méthode prend comme entrée un seul argument qui représente l'élément dont l'occurrence doit être déterminée.

Elle itère la liste et compte le nombre d'occurrences qui correspondent et renvoie le nombre total de comptage.

Veuillez noter que la méthode de comptage de la liste renvoie 0 si elle reçoit un paramètre non valide ou inexistant.

Exemple :

Syntaxe :

aleatoire_list.count(-1)

Résultat d’exécution :

Exemple :

Syntaxe :

aleatoire_list.count(0)

Résultat d’exécution :

Exemple :

Syntaxe :

aleatoire_list.count(1000)

Résultat d’exécution :

Exemple :

Syntaxe :

Liste = [123, 'xyz', 'zara', 'abc', 123]
print( "Count for 123 : ", Liste.count(123))
print( "Count for zara : ", Liste.count('zara'))

Résultat d’exécution :

Exemple :

Trouver le nombre d'éléments (doublons) dans une liste donnée

Syntaxe :

liste1 = [2,3,4,3,10,3,5,6,3]
elm_count = liste1.count(3)
print('Le nombre de l’élément : 3 est ', elm_count)

Résultats de l’exécution :

3. Count () Complexité d'exécution :

La complexité temporelle de la méthode de comptage (valeur) est O(n) pour une liste à n éléments. L'implémentation Python standard cPython "touche" tous les éléments de la liste originale pour vérifier s'ils sont égaux à la valeur.

4. Méthode Count() Compter les doublons :

Comment peut-on compter le nombre de doublons dans une liste donnée ?

Problème : Considérons qu'un élément est un double s'il apparaît au moins deux fois dans la liste. Par exemple, la liste [1, 1, 1, 2, 2, 3] comporte deux doublons 1 et 2.

Solution : Vous créez un ensemble vide de doublons. Ensuite, vous itérez sur la liste originale et ajoutez chaque élément à l'ensemble qui a une valeur de comptage d'au moins 2.

Syntaxe :

def trouver_dups(lst):
dups = set()
for el in lst:
if lst.count(el)>1:
dups.add(el)
return dups
print(trouver_dups([1, 1, 1, 2, 2, 3]))
print(trouver_dups(["Alice", "Bob", "Alice"]))
print(trouver_dups([1, 2, 3]))

Résultats de l’exécution :

Notez que cet algorithme a une complexité temporelle quadratique car pour chaque élément de la liste, vous devez compter le nombre de fois qu'il apparaît dans la liste - chacune de ces opérations de comptage a une complexité temporelle linéaire.

5. Compte des valeurs et des chaînes de caractères uniques:

Comment peut-on compter le nombre de valeurs (ou de chaînes) uniques dans une liste donnée ?

Problème :

Une valeur est considérée comme unique si elle n'apparaît qu'une seule fois dans la liste.

Solution :

Une valeur est considérée comme unique si elle n'apparaît qu'une seule fois dans la liste : Vous comptez chaque élément de la liste et vous ne prenez que ceux qui ont list.count(element) == 1.

Syntaxe :

def trouver_uniques(lst):
uniques = set()
for el in lst:
if lst.count(el) == 1:
uniques.add(el)
return uniques
print(trouver_uniques([1, 1, 2, 3, 3]))
print(trouver_uniques(["Alice", "Bob", "Alice"]))

Résultats de l’exécution :

6. Compter tous les éléments (Count_to_Dict):

Comment peut-on compter tous les éléments d'une liste et stocker le résultat dans un dictionnaire ?

Problème :

"Liste "est une liste. Vous voulez compter chaque élément de la liste. Ensuite, vous voulez stocker le résultat dans un dictionnaire en faisant correspondre les éléments à leur fréquence d'apparition (comptages). Par exemple, la liste [1, 1, 2, 2, 3] doit mener au dictionnaire {1:2, 2:2, 3:1}.

Solution :

Vous résolvez ce problème en utilisant la compréhension du dictionnaire. La clé est l'élément de la liste et la valeur est la fréquence de cet élément dans la liste. Pour ce faire, vous utilisez la méthode count ().

Syntaxe :

def count_to_dict(lst):
return {k:lst.count(k) for k in lst}
print(count_to_dict(["Alice", "Bob", "Ann", "Alice", "Charles"]))
print(count_to_dict([1, 1, 1, 2, 2, 3]))

Résultats de l’exécution :

7. Count() avec condition:

que faire si vous voulez compter toutes les valeurs paires dans une liste ? Ou tous les nombres premiers ? Ou toutes les chaînes de caractères qui commencent par un certain caractère ? Il existe plusieurs façons d'y parvenir, discutons-en une par une.

Disons que vous avez une condition pour chaque élément x. Faisons en sorte qu'il s'agisse d'une fonction avec le nom condition(x). Vous pouvez définir n'importe quelle condition que vous voulez - il suffit de la mettre dans votre fonction. Par exemple, cette condition renvoie Vrai pour tous les éléments qui sont supérieurs à l'entier 10 :

Syntaxe :

def condition(x):
return x > 10
print(condition(10))
print(condition(2))
print(condition(11))

Résultats de l’exécution :

Mais vous pouvez aussi définir des conditions plus complexes, comme vérifier s'il s'agit de nombres premiers.

8. Count () IF :

Comment pouvez-vous compter les éléments de la liste IF la condition est remplie ?

La réponse est d'utiliser une simple expression génératrice sum(condition(x) pour x dans lst) :

Syntaxe :

def condition(x):
return x>10
lst = [10, 11, 42, 1, 2, 3]
sum(condition(x) for x in lst)

Résultats de l’exécution :

Le résultat indique qu'il y a deux éléments qui sont supérieurs à 10. Vous avez utilisé une expression génératrice qui renvoie un itérateur de booléens. Notez que le Vrai booléen est représenté par la valeur entière 1 et le Faux booléen est représenté par la valeur entière 0.

9. Compter plus grand / plus petit que :

Si vous voulez déterminer le nombre d'éléments qui sont supérieurs ou inférieurs à une valeur donnée, il suffit de modifier la condition dans cet exemple :

Syntaxe :

def condition(x):
return x>10
lst = [10, 11, 42, 1, 2, 3]
sum(condition(x) for x in lst)

Résultats de l’exécution :

Par exemple, pour trouver le nombre d'éléments inférieur à 5, utilisez la condition x

Syntaxe :

lst = [10, 11, 42, 1, 2, 3]
sum(x

Résultats de l’exécution :

10. Compter Zéro / Non-Zéro :

Pour compter le nombre de zéros dans une liste donnée, utilisez l'appel de la méthode list.count(0).

Pour compter le nombre de non zéros dans une liste donnée, vous devez utiliser le comptage conditionnel comme indiqué précédemment :

Syntaxe :

def condition(x):
return x!=0
lst = [10, 11, 42, 1, 2, 0, 0, 0]
print(sum(condition(x) for x in lst))

Résultats de l’exécution :

11. Count() Lambda + Map:

Syntaxe :

sum(map(lambda x: x%2==0, [1, 2, 3, 4, 5]))

Résultats de l’exécution :

Vous comptez le nombre d'entiers pairs dans la liste.

La fonction lambda renvoie une valeur de vérité pour un élément x donné.
La fonction map transforme chaque élément de la liste en une valeur booléenne (1 ou 0).
La fonction sum additionne les "1".
Le résultat est le nombre d'éléments pour lesquels la condition s'évalue à Vrai.

12. Count() Wildcard (Compteur joker) :

Voulez-vous compter toutes les occurrences d'un préfixe donné (par exemple, le préfixe "Sus" pour les chaînes "Susie", "Susy", "Susi") ?

Solution :

Là encore, vous pouvez utiliser le concept de générateur d'expressions avec l'opérateur ternaire.

Voici le code pour celui-ci qui utilise l'opérateur joker dans un modèle pour compter toutes les occurrences de ce modèle dans la liste.

Syntaxe :

import re
lst=["Susi", "Ann", "Susanne", "Susy"]
modele='Sus.*'
frequence=sum(1 if re.match(modele, x) else 0 for x in lst)
print(frequence)

Résultats de l’exécution :

L'expression génératrice produit un ensemble de 1 et de 0 - le premier si l'élément de liste commence par le préfixe "Sus" et le second si ce n'est pas le cas.

13. Compter les tuples:

Comment peut-on compter le nombre de fois qu'un n-uplet donné apparaît dans une liste ?

Il suffit d'utiliser le tuple comme valeur d'argument d'entrée pour la méthode list.count(value). Voici un exemple :

Syntaxe :

lst = [(1, 2), (1, 1), 99, "Alice", True, (1, 1)]
lst.count((1, 1))

Résultats de l’exécution :

Comment peut-on compter le nombre de tuples dans une liste donnée ?

Utilisez la méthode du type(x) pour vérifier le type d'une variable x donnée. Ensuite, comparez le résultat avec le type de données souhaité (par exemple, un tuple).

Voici un exemple :

Syntaxe :

lst = [(1, 2), (1, 1), 99, "Alice", True, (1, 1)]
lst.count((1, 1))

Résultats de l’exécution :

14. Comptage et tri des listes de pythons:

Voici : liste lst.

Problème :

Vous voulez compter le nombre d'occurrences de toutes les valeurs de la liste et les trier selon leur fréquence.

Exemple :

Pour les éléments de la liste [1, 1, 1, 1, 0, 0, 3, 1, 1, 3, 3, 3], vous voulez obtenir leurs fréquences de manière triée :

6 fois --> élément 1

4 fois --> élément 3

2 fois --> élément 0

Solution :

Utilisez la méthode collections.Counter(lst).most_common() qui fait exactement cela.

Syntaxe :

import collections
lst = [1, 1, 1, 1, 0, 0, 3, 1, 1, 3, 3, 3]
print(collections.Counter(lst).most_common())

Résultats de l’exécution :

15. Python List Count vs Len :

Quelle est la différence ?

La méthode list.count(x) compte le nombre d'occurrences de l'élément x dans la liste.

La méthode len(list) renvoie le nombre total d'éléments dans la liste.

Voici un exemple minimal :

Syntaxe :

lst = [1, 2, 2, 2, 2]
lst.count(2)

Résultats de l’exécution :

En utilisant len :

Syntaxe :

lst = [1, 2, 2, 2, 2]
len(lst)

Résultats de l’exécution :

16. Exercice :

16.1 Exercice 1 :

Dans la liste suivante Trouvez le nombre d'éléments dupliqués :

Liste=[10, 20,10, 30, 10,40 ,60]

Afficher les résultats sous la forme suivante :

« Le nombre de l’élément : 10 est Y »

16.2 Exercice 2 :

Créer une liste dans lequel les composants sont :

["rouge", "vert", "bleu", "orange", "vert", "gris", "vert"]

Ensuite compter le nombre de l’élément dupliqué dans la même liste.

16.3 Exercice 3 :

Dans la liste suivante :

Liste=["jour", "nuit", "matin", "nuit", "weekend", "nuit", "mois"]

Compter le nombre de duplication du mot « nuit ».

16.4 Exercice 4 :

Considérons qu'un élément est un double s'il apparaît au moins deux fois dans la liste. la liste [1, 1, 1, 2, 2, 3] comporte deux doublons 1 et 2.

Comment peut-on compter le nombre de doublons dans la liste donnée ?

17. Solution :

17.1 Exercice 1 :

Syntaxe :

liste=[10, 20,10, 30, 10,40 ,60,10]
elm_count = liste.count(10)
print('Le nombre de l’élément : 10 est ', elm_count)

Résultats de l’affichage :

17.2 Exercice 2 :

Syntaxe :

liste= ["rouge", "vert", "bleu", "orange", "vert", "gris", "vert"]
liste.count("vert")

Résultats de l’affichage :

17.3 Exercice 3 :

Syntaxe :

liste= ["jour", "nuit", "matin", "nuit", "weekend", "nuit", "mois"]
liste.count("nuit")

Résultats de l’affichage :

17.4 Exercice 4 :

Syntaxe :

def trouver_dups(lst):
dups = set()
for el in lst:
if lst.count(el)>1:
dups.add(el)
return dups
print(trouver_dups([1, 1, 1, 2, 2, 3]))
print(trouver_dups([1, 2, 3]))
Résultats de l’exécution :

Résultats de l’exécution :

Conclusion

Count () est une fonction intégrée dans Python. Elle vous renvoie le nombre d'éléments dans une liste ou une chaîne de caractères.

Dans le cas d'une liste, l'élément à compter doit être donné à la fonction count (), et elle retournera le nombre d'éléments.

La méthode count () renvoie une valeur entière.

Article publié le 25 Janvier 2021 par Mouhtat Bilal