TD n°1 - Algorithmes

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 bien-
venue !’ à la variable chaine. 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 fonction len(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). Atten-
tion, 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
 TD n°1 - Algorithmes - Nombre d’occurrences d’un élément d’une liste

Exercice 2. Des fonctions qui donnent le nombre d’occurrences d’une lettre dans un texte

Une liste : L
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 2e est L[1], ...

• Une liste peut être écrite de manière explicite : L = ["Lundi", "Mardi","Mercredi"]

• Sa longueur est donnée par len(L).

• SI les éléments de la liste sont comparables, le max. est donné par max(L), le min. par min(L)

• L=[] permet de définir une liste vide.

• Si L est une liste, l’instruction L.append(x) va ajouter l’élément [x] à la 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.

Remarque
La chaine de caractères chai ne pourrait ê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 fonction list sur la variable chaine en tapant list(chaine) dans la console.

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]
...

Compléter ensuite le code suivant qui précise le docstring de la fonction, c’est à dire la description des paramètres
(ou arguments) en entrée (IN) et des valeurs en sortie (OUT)

L1='Bonjour et bienvenue !'

# Question 2.1
def occurrence_lettre1(lettre,texte):
'''In : un caractère et une liste de caractères
Out : le nombre d'occurrences du caractères dans la liste'''
compteur=0
n=len(texte) # n est donc la longueur du texte (ou de la liste)
for i in range(n):
if ...
...
return compteur

www.math93.com / M. Duffaud 2/7

 TD n°1 - Algorithmes - Nombre d’occurrences d’un élément d’une liste

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’occur-
rences 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')
...

www.math93.com / M. Duffaud 3/7

 TD n°1 - Algorithmes - Nombre d’occurrences d’un élément d’une liste

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)
• 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.

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
...

www.math93.com / M. Duffaud 4/7

 TD n°1 - Algorithmes - Nombre d’occurrences d’un élément d’une liste

2. Retour au problème : On cherche à écrire une fonction les_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), ...

Aide
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 .append qui ajoute un élément à une liste :

liste_resultats.append(lettre,frequence)

www.math93.com / M. Duffaud 5/7

 TD n°1 - Algorithmes - Nombre d’occurrences d’un élément d’une liste

Bilan du TD

Une liste : L
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 2e est L[1], ...

• Une liste peut être écrite de manière explicite : L = ["Lundi", "Mardi","Mercredi"]

• Sa longueur est donnée par len(L).

• Si les éléments de la liste sont comparables, le max. est donné par max(L), le min. par min(L)

• L=[] permet de définir une liste vide.

• Si L est une liste, l’instruction L.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 ...

List.append(x)
• 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.

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 !’

L1 = [’B’ , ’o’ , ’n’ , ’j’ , ’o’ , ’u’ , ’r’ , ’ ’ , ’e’ , ’t’,’ ’ , ’b’ , ’i’ , ’e’ , ’n’ , ’v’ , ’e’ , ’n’ , ’u’ , ’e’ , ’ ’ , ’ !’ ]

www.math93.com / M. Duffaud 6/7

 TD n°1 - Algorithmes - Nombre d’occurrences d’un élément d’une liste

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'

[ Fin du devoir \

www.math93.com / M. Duffaud 7/7