1. TP - Travail sur les chaînes



1.1. Introduction

Dans ce TP, on s'intéresse aux chaînes de caractères. Nous allons mettre en place l'organisation d'un programme Python ainsi que les traitements nécessaires pour répondre aux exercices posés.

1.2. Organisation d'un programme

Un programme sera composé de cinq parties :

Voici donc le squelette d'un programme assez évolué :

  1. """
  2.    Description du programme : que fait-il et comment le fait-il
  3. """
  4.  
  5. # ===================================================================
  6. # IMPORTS
  7. # ===================================================================
  8.  
  9. import sys
  10.  
  11. # ===================================================================
  12. # VARIABLES GLOBALES
  13. # ===================================================================
  14.  
  15. # Exemple :
  16. # nombre de tests effectués
  17. nbr_tests = 0
  18. # nombre de tests validés
  19. nbr_tests_valides = 0
  20.  
  21. # ===================================================================
  22. # SOUS-PROGRAMMES
  23. # ===================================================================
  24.  
  25. # Exemple
  26. def diviser(a, b) -> int:
  27.     """
  28.        Que fait le sous-programme, comment le fait-il, quels
  29.        sont les particularités des paramètres. Par exemple :
  30.  
  31.        Calcul de la division entière de deux entiers
  32.        - a, b : entiers à diviser, b peut être nul
  33.  
  34.        Retourne a/b sauf si b==0 auquel cas on affiche on lève une
  35.        exception
  36.        
  37.        !!! Attention !!!
  38.        Les commentaires de sous-programmes en Python doivent être à
  39.        l'intérieur du sous-programme
  40.    """
  41.    
  42.     if b == 0:
  43.         raise Exception("division par zéro")
  44.        
  45.  
  46.     # utilisation de la division entière '//'
  47.     return a // b
  48.  
  49.  
  50.  
  51. # ===================================================================
  52. # PROGRAMME PRINCIPAL
  53. # ===================================================================
  54.  
  55. def main():
  56.     """
  57.    Fonction princiale
  58.    """
  59.  
  60.     # on indique que ces variables sont globales au programme
  61.     global nbr_tests, nbr_tests_valides
  62.  
  63.     try:
  64.         print("==== PREMIER TRAITEMENT ====")
  65.         nbr_tests += 1
  66.         a = 14
  67.         b = 2
  68.         c = diviser(a, b)
  69.         print(f"{a} / {b} = {c}")
  70.         nbr_tests_valides += 1
  71.  
  72.         print("==== SECOND TRAITEMENT ====")
  73.         nbr_tests += 1
  74.         a = 14
  75.         b = 0
  76.         c = diviser(a, b)
  77.         print(f"{a} / {b} = {c}")
  78.         nbr_tests_valides += 1
  79.     except Exception as e:
  80.          print(e)
  81.  
  82.     print(f"nombre de tests effectués={nbr_tests}")
  83.     print(f"nombre de tests validés  ={nbr_tests_valides}")
  84.  
  85.  
  86. # ===================================================================
  87. # APPEL DE main()
  88. # ===================================================================
  89.  
  90. if __name__ == '__main__':
  91.     main()
  92.  

Vous pouvez reprendre ce squelette et l'adapter à vos besoins.

1.2.1. Première fonction lire_fichier

Exercice 1.1

Créez un programme traitement_fichier.py à partir du squelette de programme Python ci-dessus et faire un import du package string.

Ecrire une fonction lire_fichier qui prend en paramètre un nom de fichier et retourne le contenu du fichier sous forme d'une seule chaîne de caractères. Cherchez sur Google comment faire.

Dans la fonction main(), appelez cette fonction pour lire le fichier texte.txt et stockez son contenu dans la variable locale texte; puis affichez le contenu de cette variable.

Pour tester votre programme, sous le shell, saisir (suivant les systèmes) :

> python traitement_fichier.py
# ou
> python3 traitement_fichier.py

1.2.2. Décomposition sous forme de lignes

Exercice 1.2

Décomposez le contenu de texte sous forme d'une liste de lignes dans la variable locale lignes. On pensera à utiliser la fonction split (cf doc split) associée aux chaînes de caractères. Affichez ensuite le contenu de lignes afin de vérifier qu'on a bien une liste de lignes.

1.2.3. Suppression des espaces en début et fin de chaîne

Exercice 1.3

Le fichier texte.txt contient beaucoup d'espaces en début et fin de chaîne et on désire les supprimer. Créez une nouvelle liste de chaînes de caractètres appelée lignes_sans_espaces qui à partir de lignes supprime les espaces en utilisant la fonction strip (cf doc strip) associée aux chaînes de caractères. On pensera à utiliser la compréhension de listes.

Affichez ensuite le contenu de lignes_sans_espaces afin de vérifier que les espaces ont bien été supprimés.

1.2.4. Affichage informatif

On désire obtenir l'affichage suivant concernant les lignes sans espaces :

<==== AFFICHAGE INFORMTATIF ====>
Ligne 001 :  37 Travail sur les chaînes de caractères
Ligne 002 :  35 On considère, un fichier, non vide.
Ligne 003 :  12 On le charge
Ligne 004 :  55 et on le décompose suivant les lignes qui le composent.
Ligne 005 :   0 
Ligne 006 :   0 
Ligne 007 :   0 
Ligne 008 :  52 Attention, le fichier peut contenir des lignes vides
Ligne 009 :  35 ou alors des lignes qui contiennent
Ligne 010 :  33 des espaces en début ou en fin de
Ligne 011 :   6 ligne.
Ligne 012 :   0 
Ligne 013 :   0 
Ligne 014 :   0 
Ligne 015 :   0

On commence à afficher le numéro de ligne sur 3 caractères (complété avec des '0'), puis la longueur de chaque ligne sur 3 caractères et enfin le contenu de la ligne.

Voir ce site pour le formatage avec des f-string.

On pensera à utiliser une boucle for avec enumerate() :

  1. for numero, ligne in enumerate(lignes_sans_espaces):
  2.     longueur = len(ligne)
  3.     # ...

Exercice 1.4

Ajoutez le traitement nécessaire dans la fonction main().

1.2.5. Suppression des caractères de ponctuation

On désire supprimer les caractères de ponctuation de chacune des lignes de lignes_sans_espaces.

Exercice 1.5

Ajoutez le traitement adéquat et stockez le résultat dans la liste lignes_sans_ponctuation.

On procédera en parcourant les chaînes et en créant une nouvelle chaîne qui ne contient pas de caractères de string.punctuation.

1.2.6. Conversion majuscules en minuscules et inversement

On désire transorfmer les caractères majuscules en minuscules et inversement à partir de lignes_sans_ponctuation.

Exercice 1.6

Ajoutez le traitement adéquat (cf. doc) et stockez le résultat dans la liste lignes_casse_inversee.

On pensera à utiliser pour chaque caractère la fonction car.isupper() qui détermine si un caractère est une majuscule et car.lower() ou car.upper() pour convertir en minuscule ou en majuscule.

Affichez le résultat.

1.2.7. Dictionnaire des mots

On désire créer un dictionnaire des mots et leur nombre d'occurrences à partir de lignes_sans_ponctuation :

{'travail': 1, 'sur': 1, 'les': 2, 'chaînes': 1, 'de': 2, 'caractères': 1, 'on': 3, 'considère': 1, 'un': 1, 'fichier': 2, 'non': 1, 'vide': 1, 'le': 4, 'charge': 1, 'et': 1, 'décompose': 1, 'suivant': 1, 'lignes': 3, 'qui': 2, 'composent': 1, 'attention': 1, 'peut': 1, 'contenir': 1, 'des': 3, 'vides': 1, 'ou': 2, 'alors': 1, 'contiennent': 1, 'espaces': 1, 'en': 2, 'début': 1, 'fin': 1, 'ligne': 1}

On voit ici que le mot 'le' apparaît 4 fois, 'des' apparaît 3 fois, etc.

Exercice 1.7

Créez une variable de type dictionnaire appelée dico à partir des lignes de lignes_sans_ponctuation.

On pensera à utiliser la méthode split() associée aux chaînes de caractères pour obtenir les mots de chaque ligne et on pensera également à convertir chaque mot en minuscule.

1.2.8. Affichage compréhensible du dictionnaire

On désire afficher le dictionnaire de manière plus compréhensible par ordre décroissant du nombre d'occurrences de chaque mot : 

le                  : 4
on                  : 3
lignes              : 3
des                 : 3
les                 : 2
...
début               : 1
fin                 : 1
ligne               : 1

Exercice 1.8

Utilisez la méthode dico.values() afin de récupérer une liste des occurrences de chaque mot, transformez cette liste en un ensemble, puis retransformez cet ensemble en une liste que vous trierez (cf doc sort) en ordre décroissant.

En partant de l'occurrence la plus grande, affichez les mots du dictionnaire qui apparaissent avec cette occurrence, puis continuez en passant à l'occurrence suivante.