TP : Créer un moteur de censure de texte (3/4)

TP : Créer un moteur de censure de texte (3/4)#

Partie 3 : Censurer un mot entier dans un texte#

Dans cette partie, vous allez écrire une fonction qui parcourt un texte et remplace chaque occurrence du mot interdit par des *, mais seulement si c’est un mot entier (on ne touche pas les mots qui le contiennent).

Exemples

Texte : Bad dog!, mot interdit : bad → *** dog!

Texte : badminton, mot interdit : bad → badminton (pas un mot entier).

Commencez par recopier ci-dessous vos fonctions est_alphabétique(car), en_minuscule(car), et mot_correspond(texte, i, mot) dans les cellules suivantes.

### BEGIN SOLUTION
def est_alphabétique(car):
    return ('a' <= car <= 'z') or ('A' <= car <= 'Z') 
### END SOLUTION

### BEGIN SOLUTION
def en_minuscule(car):
    if 'A' <= car <= 'Z':
        return chr(ord(car) + 32)
    return car
### END SOLUTION

### BEGIN SOLUTION
def mot_correspond(texte, i, mot):
    # Si le mot dépasse la fin du texte, il ne peut pas correspondre
    if i + len(mot) > len(texte):
        return False
    
    for j in range(len(mot)):
        if en_minuscule(texte[i + j]) != en_minuscule(mot[j]):
            return False
    
    return True
### END SOLUTION

Exercice 1 : Déterminer si un mot est “entier” dans le texte#

On dira qu’un mot trouvé à la position i d’un texte est un mot entier si :

  • À gauche : soit le mot est en début de texte (i == 0), soit le caractère précédent n’est pas alphabétique

  • À droite : soit le mot est à la fin du texte (i + longueur_mot == len(texte)), soit le caractère suivant n’est pas alphabétique

Complétez est_mot_entier, qui revoie True si un mot de longueur longueur_mot à la position i dans texte est entier, False sinon.

def est_mot_entier(texte, i, longueur_mot):
    """
    Vérifie que le mot trouvé à l’indice i (de longueur longueur_mot)
    est bien un mot entier (pas collé à d'autres lettres).
      Paramètre texte : une chaîne de caractère, 
      Paramètre i : un entier,
      Paramètre longueur_mot : un entier
      Renvoie True si c’est un mot entier, False sinon.
    """
    ### BEGIN SOLUTION
    # On vérifie le caractère à gauche
    if i > 0 and est_alphabétique(texte[i - 1]):
        return False
    
    # On vérifie le caractère à droite
    j = i + longueur_mot
    if j < len(texte) and est_alphabétique(texte[j]):
        return False

    return True
    ### END SOLUTION

# Tests
assert est_mot_entier("bad!", 0, 3) == True
assert est_mot_entier(" bad ", 1, 3) == True
assert est_mot_entier("unbad mot", 2, 3) == False     
assert est_mot_entier("badminton", 0, 3) == False

Exercice 2 : Censurer un mot#

Nous allons maintenant écrire une fonction qui parcourt le texte et applique une passe de censure en remplaçant un mot mot par des *** .

Indication

À chaque position i :

  • Vérifier si le mot correspond au mot à censurer grâce à mot_correspond

  • Vérifier si c’est un mot entier avec est_mot_entier

  • Si oui ajouter * × longueur du mot, et avancer de cette longueur

  • Sinon recopier le caractère et avancer de 1

Complétez censurer_mot.

def censurer_mot(texte, mot):
    """
    Parcourt le texte et remplace chaque occurrence entière du mot "mot"
    (en ignorant majuscules/minuscules) par des caractères '*'.
      Paramètre texte : une chaîne de caractères 
      Paramètre mot : une chaîne de caractères
      Revoie : le nouveau texte après une passe de censure.
    """
    ### BEGIN SOLUTION
    resultat = ""
    i = 0
    L = len(texte)
    longueur_mot = len(mot)
    caractere_masque='*'

    if longueur_mot == 0:
        return texte

    while i < L:
        if mot_correspond(texte, i, mot) and est_mot_entier(texte, i, longueur_mot):
            resultat += caractere_masque * longueur_mot
            i += longueur_mot
        else:
            resultat += texte[i]
            i += 1

    return resultat
    ### END SOLUTION

# Tests
assert censurer_mot("Bad dog!", "bad") == "*** dog!"
assert censurer_mot("badminton", "bad") == "badminton"
assert censurer_mot("bad bad", "bad") == "*** ***"
assert censurer_mot("!bad?", "bad") == "!***?"
assert censurer_mot("BAd-bAd", "bad") == "***-***"
assert censurer_mot(" bad ", "bad") == " *** "
assert censurer_mot(" bad33", "bad") == " ***33"

Bilan de la partie 3#

Vous avez maintenant une fonction qui censure un mot dans un texte.

Contenu