Compter des occurrences

Exercice bonus : Compter des occurrences

On souhaite écrire un programme qui compte les occurences de mots dans un texte afin de connaître les mots les plus fréquents.

Question

Écrire une fonction occurrences telle que :

  • L'entrée (sequence) est une séquence (tuple, list, str, ...)

  • La sortie est un dictionnaire tel que :

    • Les clefs sont les valeurs de la séquence

    • Les valeurs sont le nombre d'occurrence de ces clefs dans la séquence

Solution

1
def occurrences(sequence):
2
    """
3
    Compte les occurences dans une liste
4
    :param sequence: Une séquence (tuple, list ou str)
5
    :return: dictionnaire tel que :
6
            - les clefs sont les valeurs de la séquence
7
            - les valeurs sont les occurrences de ces clefs dans la séquence
8
    >>> occurrences([4, 2, 3, 4, 1, 4, 3, 4])
9
    {4: 4, 2: 1, 3: 2, 1: 1}
10
    >>> occurrences("abracadrabra")
11
    {'a': 5, 'b': 2, 'r': 3, 'c': 1, 'd': 1}
12
    """
13
    dico = {}
14
    for valeur in sequence:
15
        if valeur in dico:
16
            # Si la valeur est déjà dans le dico, on incrémente
17
            dico[valeur] += 1
18
        else:
19
            # Sinon on l'ajoute
20
            dico[valeur] = 1
21
    return dico

Question

Écrire une fonction compte_mots telle que :

  • L'entrée (phrase) est une chaîne de caractères comportant des espaces

  • La sortie est un dictionnaire tel que :

    • Les clefs sont les mots de la phrase

    • Les valeurs sont le nombre d'occurrence des mots dans la phrase

Indice

La méthode .split() pourrait vous aider.

Cf cette page pour plus de détails...

Solution

1
def compte_mots(phrase: str):
2
    """
3
    Compte les occurences de mots dans une chaîne de caractères
4
    :param phrase: une chaîne de caractère comportant des espaces
5
    :return: dict – dictionnaire tel que :
6
            - les clés sont les mots de la chaine
7
            - les valeurs sont les occurrences des mots
8
    >>> compte_mots("a b a c ab")
9
    {'a': 2, 'b': 1, 'c': 1, 'ab': 1}
10
    """
11
    # On découpe la phrase à chaque espace (méthode split)
12
    liste = phrase.split()
13
    # On se sert de la fonction précédente
14
    return occurrences(liste)

Le « Petit Chaperon Rouge »

Pour pouvoir réaliser des tests, on va utiliser le texte du « Petit Chaperon Rouge ».

On veillera donc à télécharger le fichier suivant.

Télécharger ce fichier dans le même dossier que votre code Python.

Petit_Chaperon_Rouge_Sans_Ponctuation.txt [txt]

Question

Dans le programme principal, importer ce texte puis écrire les instructions nécessaires pour afficher, dans la console, chaque mot de ce texte suivi de son nombre d'occurrences dans le texte.

Indice

La fonction open, permet d'ouvrir un fichier.

Ainsi le code suivant ouvre le fichier (fichier.txt) en lecture et obtient un référence (f).

1
with open("fichier.txt", 'r') as f:
2
    # Faire quelque chose

Indice

Si f est le nom d'une variable faisant référence à un fichier texte, alors f.read() renvoie le contenu de ce fichier texte sous la forme d'une unique chaîne de caractères.

Solution

1
with open("Petit_Chaperon_Rouge_Sans_Ponctuation.txt", 'r') as f:
2
    texte = f.read()

Question

Écrire une fonction compte_mots_par_longueur telle que :

  • L'entrée (phrase) est une chaîne de caractères comportant des espaces

  • La sortie est un dictionnaire tel que :

    • Les clefs sont la longueur des mots de l'entrée

    • Les valeurs sont le nombre de mots dans la phrase qui ont cette longueur

Appliquer ensuite, dans le programme principal, cette fonction au texte du « Petit Chaperon Rouge ».

Solution

1
def compte_mots_par_longueur(phrase):
2
    """
3
    Compte le nombre de mots selon la taille dans une chaîne de caractères
4
    :param phrase: une chaîne de caractère comportant des espaces
5
    :return: dict – dictionnaire tel que :
6
            - les clés sont des entiers (longueurs possibles pour un mot)
7
            - les valeurs sont les occurrences des mots ayant cette longueur
8
    >>> compte_tous_mots("a b a c ab")
9
    {1: 4, 2: 1}
10
    """
11
    dico_mots = compte_mots(phrase)
12
    dico_taille = {}
13
14
    for mot, nombre in dico_mots.items():
15
        taille = len(mot)
16
        if taille in dico_taille:
17
            # Si la taille du mot est déjà dans le dico, on ajoute son nombre d'occurences
18
            dico_taille[taille] += nombre
19
        else:
20
            # Sinon on le rajoute
21
            dico_taille[taille] = nombre
22
23
    return dico_taille
24
Question
Écrire une fonction plus_frequent telle que :
  • Les entrées :
    • Un dictionnaire (dico) tel que :
      • Les clefs sont des mots
      • Les valeurs sont le nombre d'occurrence de ces mots dans un texte
    • Un entier (longueur), la longueur des mots que l'on considére
  • La sortie est un tableau constitués des chaînes de caractères de la longueur spécifiée et associées à la plus grande valeur dans le dictionnaire.
Indice
C'est un algorithme de recherche du maximum légèrement modifié :
  • lorsqu'on rencontre un nouveau maximum, on ré-initialise le tableau ;
  • lorsqu'on rencontre un mot de même « valeur », on l'incorpore au tableau.
Solution
1
def plus_frequent(dico, longueur):
2
    """
3
    Renvoie les mots les plus fréquents de la longueur donnée. En cas d'égalité en fréquence, on renverra tous les mots
4
    de cette égalité.
5
    :param dico: dictionnaire de chaines avec leur occurence
6
    :param longueur: longueur à regarder pour trouver les mots
7
    :return: string – chaine de taille longueur ayant
8
             l'occurence la plus grande.
9
    >>> plus_frequent({'a': 3, 'b': 2, 'c': 3, 'ab': 5}, 1)
10
    ['a', 'c']
11
    """
12
    # Intitialisation à une liste vide et une fréquence nulle
13
    maximum = []
14
    frequence_maximum = 0
15
16
    for mot in dico:
17
        # Vérification de la contrainte de longueur
18
        if len(mot) == longueur:
19
            # Vérification de la fréquence du mot
20
            if dico[mot] > frequence_maximum:
21
                # Si plus grand, on remet à zéro
22
                maximum = [mot]
23
                frequence_maximum = dico[mot]
24
            elif dico[mot] == frequence_maximum:
25
                # Si égalité, on ajoute dans notre liste de maximums
26
                maximum.append(mot)
27
            # Sinon, on ne fait rien
28
29
    return maximum