Nombre d’occurrences d’un élément d’une liste
Recherche du nombre d’occurrences sur des valeurs de type quelconque
Prérequis et Thème
- Prérequis : fonctions, structures conditionnelles, structures itératives (seconde) et notion de liste.
- Objectif : Calculer les fréquences d’apparition des lettres d’un texte donné.
- Notions abordées : structures conditionnelles, structures itératives (for i in...), listes et quelques fonctions associées (len, count ...), parcourir une liste, ajouter un élément à une liste (.append)
- Durée : environ 2 heures.
- Matériel : salle informatique (Python installé ou internet avec repl.it).
Exercice 1. Un exemple qui nous servira à tester nos fonctions
1. On considère l’expression ci dessous qui est une instruction qui demande l’affectation de la valeur ’Bonjour et bienvenue
!’ à la variablechaine. Déterminer à la main sa longueur c’est à dire le nombre de caractères qui la composent.
chaine=’Bonjour et bienvenue !’
2. Vérifier votre résultat en utilisant la fonctionlen(X)de Python qui renvoie la longueur d’une chaine X (ou d’une liste X).
>>> len(chaine) ...
3. Compter (à la main) le nombre d’occurrences des lettres et calculer leurs fréquences (arrondies au millième). Attention, tous les caractères comptent !
B b e i j n o r u v
! (espace)
Occurrences 1 1
Fréquences 0,045 0,045
Exercice 2. Des fonctions qui donnent le nombre d’occurrences d’une lettre dans un texte
Une liste est une suite d’éléments numérotés de même type dont le premier indice est 0. En Python, une liste s’écrit entre crochets [... , ..., ..., ...] avec les éléments séparés par des virgules.
• Le premier élément de la liste est L[0], le 2eest L[1], ...
• Une liste peut être écrite de manière explicite : L = ["Lundi", "Mardi","Mercredi"]
• Sa longueur est donnée parlen(L).
• SI les éléments de la liste sont comparables, le max. est donné parmax(L), le min. parmin(L)
• L=[] permet de définir une liste vide.
• Si L est une liste, l’instructionL.append(x)va ajouter l’élément [x] à la liste L.
Une liste : L
L’objectif ici est de créer des fonctions qui renvoient le nombre d’occurrences d’une lettre dans un texte c’est à dire le nombre de fois où elle est présente dans une chaine de caractères ou une liste.
La chaine de caractèreschainepourrait être écrite sous la forme d’une liste, mais avouez que c’est moins pratique dans notre configuration. Python va gérer les deux écritures.
chaine = ’Bonjour et bienvenue !’
L1 = [’B’ , ’o’ , ’n’ , ’j’ , ’o’ , ’u’ , ’r’ , ’ ’ , ’e’ , ’t’ , ’ ’ , ’b’ , ’i’ , ’e’ , ’n’ , ’v’ , ’e’ , ’n’ , ’u’, ’e’ , ’ ’ , ’ !’]
On peut indifféremment travailler sur la liste L1 ou sur la variable chaine.
Astuce : Vérifier l’action de la fonctionlistsur la variablechaineen tapantlist(chaine)dans la console.
Remarque
1. Méthode 1
L’idée dans un premier temps est de parcourir les caractères du texte donné et de compter le nombre de fois où la lettre apparait à l’aide d’un compteur. Un compteur est une variable initialisée à 0 et que l’on augmente de 1 au fur et à mesure.
Vérifier dans un premier temps que l’on peut accéder à chacune des lettre par leur indice : L1[0] va renvoyer ’B’ ... et L1[50] ?
>>> L1=list(chaine)
>>> L1
['B','o','n','j','o','u','r',' ', 'e','t',' ','b','i','e','n','v','e','n','u', 'e',' ','!']
>>> L1[0]
'B'
>>> L1[1]
'o'
>>> L1[50]
...
Vérifier le fonctionnement de votre fonction sur des exemples, on doit obtenir :
>>> occurrence_lettre1('n',L1) 3
Regarder aussi les résultats de
>>> occurrence_lettre1('b',L1) ...
>>> occurrence_lettre1('B',L1) ...
>>> occurrence_lettre1('K',L1) ...
>>> occurrence_lettre1('B',[]) # [] est une liste vide ...
Est-ce normal ?
2. Méthode 2 : for x in Liste
Il existe avec Python une méthode encore plus simple pour parcourir des listes de caractères.
On peut faire décrire à une variable les éléments d’une liste directement à l’aide d’une boucle sous la forme :for x in texte :
Écrire alors une nouvelle fonction en utilisant cette méthode. Remarquer que l’on n’a plus besoin de connaitre la longueur de la liste (du texte). Vérifier le fonctionnement de votre fonction sur des exemples.
def occurrence_lettre2(lettre,texte):
'''In : un caractère et une liste de caractères
Out : la fréquence d'apparition du caractères dans la liste''' compteur=0
for x in texte:
if ...
...
return ...
3. Méthode 3 : avec .count()
Python est vraiment très sympa car il existe une méthode permettant de calculer directement le nombre d’occurrences d’un caractère d’une liste. C’est la méthode.count(lettre).
Par exemple X.count(’y’) va renvoyer le nombre de caractères ’y’ dans X. Noter que les chaînes de caractères doivent être notée entre apostrophes.
>>> L1.count('e') 4
>>> L1.count('!') 1
>>> L1.count('K') ...
Exercice 3. Une fonction qui donne la fréquence d’une lettre dans un texte
On demande maintenant de créer une fonction qui va renvoyer la fréquence d’une lettre dans un texte.
def frequence_lettre(lettre,texte):
'''In : ...
Out : ...''' ...
Tester votre fonction avec des exemples, par exemple on doit obtenir :
>>> frequence_lettre('B',L1) 0.045454545454545456
>>> frequence_lettre('K',L1) ...
>>> frequence_lettre('B',[]) # [] est une liste vide ...
Exercice 4. Compléments 1 : Une fonction qui donne toutes les fréquences des caractères dans un texte
1. Travail préliminaire: Dans un premier temps, on va découvrir deux façons d’ajouter un élément à une liste.
• LIST.append(x): Ajoute un élément x à la fin de la liste nommée LIST, et la modifie.
• On peut aussi écrire :LIST = LIST + [x]
Par contre cette méthode est plus couteuse. En effet, Python va créer une nouvelle liste conte- nant l’élément x, puis stocker le résultat dans la variable LIST.
List.append(x)
Sur votre console, faites quelques tests, vous pouvez observer par exemple :
>>> List=[1,2,3]
>>> List.append(4)
>>> List [1, 2, 3, 4]
>>> List=List+[5]
>>> List
[1, 2, 3, 4, 5]
>>> List_bis=List+[5]
>>> List ...
>>> List_bis ...
2. Retour au problème: On cherche à écrire une fonctionles_frequence(texte)qui donne la fréquence d’apparition des lettres de l’alphabet dans un texte donné. On va créer une variable alphabet qui contient les lettres à tester et boucler sur ces lettres avec un test sur chaque caractère du texte. La liste renvoyée sera une liste de couples (ou de listes) composés de la lettre et de sa fréquence.
alphabet='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ !,;:'
#
def les_frequences(texte):
'''In : ...
Out : ...''' ...
On devra ici obtenir en écrivant les_frequence(L1) dans la console, un début d’affichage :
>>> les_frequences(L1)
[('a', 0.0), ('b', 0.045454545454545456), ('c', 0.0), ('d', 0.0), ('e', 0.18181818181818182), ('f', 0.0), ('g', 0.0), ('h', 0.0), ('i', 0.045454545454545456), ('j', 0.045454545454545456),
('k', 0.0), ('l', 0.0), ('m', 0.0), ('n', 0.13636363636363635), ('o', 0.09090909090909091), ('p', 0.0), ...
L’idée est de créer une liste vide des résultats au début : liste_resultats=[]
Puis on va lui ajouter successivement chaque couple (lettre,frequence) dans une boucle par exemple avec l’affectation suivante :
liste_resultats = liste_resultats + [(lettre,frequence)]
ou, ce qui est préférable, à l’aide de la fonction.appendqui ajoute un élément à une liste : liste_resultats.append(lettre,frequence)
Aide
Bilan du TD
Une liste est une suite d’éléments numérotés de même type dont le premier indice est 0. En Python, une liste s’écrit entre crochets [... , ..., ..., ...] avec les éléments séparés par des virgules.
• Le premier élément de la liste est L[0], le 2eest L[1], ...
• Une liste peut être écrite de manière explicite : L = ["Lundi", "Mardi","Mercredi"]
• Sa longueur est donnée parlen(L).
• Si les éléments de la liste sont comparables, le max. est donné parmax(L), le min. parmin(L)
• L=[] permet de définir une liste vide.
• Si L est une liste, l’instructionL.append(x)va ajouter l’élément [x] à la liste L.
• Pour parcourir la liste L , deux solutions sont possibles : – un parcours sur les indices :
for i in range(len(L)) : L[i] ...
– un parcours direct sur les éléments : for X in L :
X ...
Une liste : L
• LIST.append(x): Ajoute un élément x à la fin de la liste nommée LIST, et la modifie.
• On peut aussi écrire :LIST = LIST + [x]
Par contre cette méthode est plus couteuse. En effet, Python va créer une nouvelle liste contenant l’élément x, puis stocker le résultat dans la variable LIST.
List.append(x)
Exercice 5. Compléments 2
Reprendre la question 3 en calculant la fréquences des lettres uniquement sur les 26 lettres de l’alphabet (sans les accents), sans distinguer majuscules et minuscules, et sans considérer les signes de ponctuation ou espace.
Dans ce cas par exemple, le nombre de caractères de L1 est 18 et l’occurrence du b est 2 (1 b et 1 B).
Exercice 6. Compléments 3
Écrire une fonction permettant de passer de la chaine de caractère initiale à la liste des caractères et ce sans utiliser la fonction list. C’est à dire ici permettant de passer de :
chaine=’Bonjour et bienvenue !’
Exercice 7. Avec les caractères ASCII
Vous pouvez vous référer au cours associé : lien
On reprend l’exercice 4 mais sans utiliser la variable alphabet. On va utiliser tous les caractères licite parmi les 128 de la table ASCII.
Écrire une fonction (avec son docstring) qui en entrée prend une chaine de caractères parmi les 128 de la table ASCII et qui donne la fréquence d’apparition des caractères dans le texte donné. Cela sous la forme d’une liste de couples (’caractère’, fréquence). Attention, certaines références de la table ASCII ne sont pas des caractères !
# Aide
>>> ord('a') 97
>>>chr(97) 'a'
