TD F1 : lecture / écriture dans un fichier texte¶

On s’intéresse dans ce chapitre aux Entrées/Sorties fichier, autrement dit à la lecture ou à l'écriture d’un fichier. En effet, lorsque l'on souhaite sauvegarder des informations et les récupérer entre diverses sessions, il est indispensable de pouvoir les transférer depuis la mémoire vive (RAM) vers un support physique (type disque dur). Il y a de nombreuses façon de procéder, et on se contentera ici d'utiliser une méthode universelle par le biais de lecture/écriture de fichiers en mode texte.

Remarque :

  • on se servira beaucoup des listes dans ce TD. Si vous n'êtes pas parfaitement au clair, ou si vous voulez tout savoir (ou presque) sur ce type, aller par exemple lire les pages correspondantes sur W3school.
  • on utilisera aussi les dictionnaires. Il n'y a rien sur coding game, mais si les cours n'ont pas suffit, vous pouvez consulter le site W3school.

I. Écriture dans un fichier¶

1. Un premier exemple pour voir si tout fonctionne¶

Q1. En utilsant le cours, écrire une fonction save_my_list(nomfich : str, datas : list) qui reçoit deux arguments. Le premier est un nom de fichier, le deuxième une liste de chaînes de caractères. La fonction doit écrire dans le fichier nomfich les chaînes contenues dans la liste datas (une chaine par ligne).

Pour visualiser le fichier ainsi crée : cliquer sur le menu Capytale (en haut à gauche), puis suivre Fichiers annexes puis Disponibles le temps de la session, choisir alors le fichier test.txt et cliquer sur télécharger. Le fichier est alors sauvegardé dans votre espace personnel sur le disque dur de l'ordinateur. Ouvrez ce fichier avec un éditeur classique (style bloc note ou notepad ...) et consultez son contenu en vérifiant qu'il est conforme aux attentes.

In [1]:
def save_my_list(nomfich : str,datas : list):
    """
    Reçoit un nom de fichier et une liste de données (chaque élément étant une
    chaîne de caractères terminée par le symbole de retour à la ligne \n),
    et sauvegarde ces données dans un fichier sur le disque dur
    """
    
    with # à compléter...
    
    print(f"le fichier '{nomfich}'' a été créé")

# On teste :
lst = [
    'Une première ligne\n'
    'Une deuxième ligne\n'
    'Une troisième sans le caractère de fin de ligne'
    'pour voir comment apparait la dernière ligne'
]

print(lst)
save_my_list(nomfich='test.txt', datas=lst)

['Une première ligne\nUne deuxième ligne\nUne troisième sans le caractère de fi nde lignepour voir comment apparait la dernière ligne']
le fichier 'test.txt'' a été créé

2. Pour s'exercer : écriture d'une table de mutiplications¶

L'objectif de cet exercice est d'obtenir un fichier texte représentant la table de multiplication des entiers de 1 à 10 sous cette forme (pour l'instant on n'affiche pas les en-têtes):

txt
1   2   3 ... 10
2   4   6 ... 20
3   6   9 ... 30
...
10 ...        100

La version chaine de caractères commencerait ainsi (visualiser les caractères \t et \n):

txt
"1\t2\t3 ... 10\t\n2\t4\t ..."

Étape 1 : création des données

Q2. Écrire une fonction multiples(n : int)->str qui reçoit un entier n et qui renvoie une chaine de caractères contenant les 10 premiers mutliples de n. Par exemple, si elle reçoit le nombre 3, la fonction doit renvoyer la chaine :

'3\t6\t9\t12\t15\t18\t21\t24\t27\30\n'

On utilisera la fonction str(...) pour convertir des nombres en chaine, et on n'oubliera pas d'insérer les caractères \t pour créer des tabulations entre les valeurs et le \n à la fin pour le retour à la ligne.

In [2]:
def multiples(n : int) -> str :
    """ reçoit un entier `n` et qui renvoie une chaine de caractères contenant les 10 premiers mutliples de `n`
    Par exemple, si elle reçoit le nombre 3, la fonction doit renvoyer la chaine :
    '3\t6\t9\t12\t15\t18\t21\t24\t27\30\n'
    """
    chaine = ''
    
    # à compléter
    
    return chaine

# on teste
print(multiples(3))

3	6	9	12	15	18	21	24	27	30

Q3. Écrire une fonction table(n : int) -> str qui reçoit un entier n et qui renvoie une chaine de caractère contenant la table de multiplication des entiers de 1 à n avec le format précédent... (On pensera à utiliser la fonction multiples(...) créee à la question précédente...)

In [4]:
def table(n : int) -> str :
    """ reçoit un entier n et renvoie une chaine de caractères
    représentant la table de multiplication des entiers 1 à n"""
    
    table_mult = ''
    
    # à compléter
        
    return table_mult

# on teste

print(table(5))

1	2	3	4	5	6	7	8	9	10
2	4	6	8	10	12	14	16	18	20
3	6	9	12	15	18	21	24	27	30
4	8	12	16	20	24	28	32	36	40
5	10	15	20	25	30	35	40	45	50

Étape 2 : écriture du fichier sur le disque dur

Q4. Compléter le code de la fonction save_table(n : int) -> None qui doit créer un fichier nommé table_mult.txt dont le contenu est la table de multiplication des entiers de 1 à n sous la forme demandée par l'énoncé.

In [8]:
def save_table(n : int):
    """
    Crée le fichier 'table_mult.txt' qui représente la table de multiplication
    """
    tab = table(n)
    with # à compléter...
    
    print(f"fichier table_mult.txt crée avec succès")

# on teste :
save_table(10)

# pour voir le résultat : télécharger le fichier crée en allant comme au début du TD dans
# le menu 'Capytale' -> 'fichiers annexes' -> 'disponibles le temps de la session'

fichier table_mult.txt crée avec succès

Q6 (facultatif, pour aller un peu plus loin !) Pour ceux qui ont le temps, on va améliorer un peu la présentation. Écrire une fonction save_tableX_2() qui améliore le fichier texte pour obtenir quelque chose comme cela : image.png

In [ ]:
def save_tableX_2()->list:
    """
    Crée le fichier 'table_mult2.txt' qui représente la table de multiplication raffinée
    """
    # ... à completer ...
save_tableX_2()
# aller voir dans le menu capytale pour télécharger le fichier...

II. Lecture d'un fichier¶

Pour ouvrir un fichier en lecture le principe est le même que pour l'écriture mais on modifie la variable mode pour passer en lecture : mode='r' (r pour read).

II.1. Lecture d'un fichier en entier ¶

Q7 En utilisant le cours, compléter la fonction suivante qui permet de récupérer le contenu du fichier test.txt crée en début de TD.

In [ ]:
def read_myfile1(nomfich : str) -> str :
    """
    récupère et renvoie la chaine de caractères contenue dans le fichier
    nommé 'nomfich'
    """
    
    # à compléter
    
    
    return txt

# on teste :
print(read_myfile1('test.txt'))

II.2 Lecture d'un fichier ligne par ligne¶

Q8. Utiliser le cours pour compléter la fonction ci-dessous dont le rôle est précisé dans la docstring

In [ ]:
def read_myfile2(nomfich):
    """ reçoit un nom de fichier 'nomfich' et renvoie le contenu
    de ce fichier sous forme d'une liste de chaîne de caractères
    (chaque élément de la liste contient une ligne du fichier texte)
    Remarque : 
        Les lignes commençant par # ainsi quel les lignes vides 
        doivent être exclues"""
    datas = []
    
    # à compléter
    return datas

# on teste :
datas = read_myfile2('test.txt')         
print(datas)

III. Exercices¶

III.1. comptage de mots¶

En français, lorsque l'on vous demande de faire un résumé, on vous impose souvent un nombre de mots. Voyons comment automatiser cette tâche en python.

Pour faire simple (mais pas totalement juste...), on va considérer que les mots dans un texte sont séparés par l'un des caractères contenus dans la liste separateurs = ["'"," ","\n"] ('apostrophe', 'espace' et '\n' qui on on le rappelle représente le caractère de retour à la ligne). On n'a pas mis par exemple la virgule ou le point car ceux-ci doivent en principe être suivis d'un espace...

On rappelle deux informations qui peuvent être utiles:

  • on peut tester l'apartenance d'un élément à une liste avec l'opérateur in. Par exemple si x est une variable de type str et s une liste de chaines, alors l'instruction x in s renvoie True si x est dans la liste et False sinon.

  • une chaîne de caractères est un itérable, c'est à dire que l'on peut par exemple utiliser une boucle for pour parcourir tous ses caractères.

L'objectif de cet exercice est de récupérer le contenu d'un texte et compter (approximativement) le nombre de mots qu'il contient.

Q9. En utilisant la fonction read_myfile1 de la Q7 du paragraphe II.1 lecture d'un fichier en entier, éctrire un script pour afficher le contenu du fichier star_wars.txt.

In [ ]:
# affiche le contenu du texte 'stra_wats.txt'

# à compléter

Q10. Écrire une fonction nb_words(text : str) -> int qui reçoit un texte (type str) et qui renvoie le nombre de mots.

In [ ]:
def nb_words(text : str) -> int:
    """
    Compte le nombres de mots contenus dans la chaine 'text'
    """
    separateurs = ["'", " ", "\n"]
    nb = 1
    # ... à compléter ...
    return nb

# on teste  :
print(nb_words('Bonjour les amis'))

Q11. Compter le nombre de mots du texte star_wars.txt

Réponse : # à compléter

Comparer à ce que vous donne un logiciel tel que word ou libre office pour voir...

In [4]:
# nb de mots du texte 'stra_wars.txt'

# à compléter

III.2 Palindromes¶

L'objectif de cet exercice est de compter le nombres de palindromes dans la langue française.

Q12. En vous inspirant du TD D2 (boucles for), écrire une fonction palindrome(mot : str) -> boolean qui reçoit une chaine de caractère et qui renvoie True si c'est un palindrome et False sinon.

In [ ]:

Q13. Lié à cette activité vous trouverez un fichier nommé liste_francais_gutemberg_conv.txt qui contient (à peu près) tous les mots de la langue française (un mot par ligne).

Écrire une fonction dictionnaire() -> list qui va lire ce fichier et renvoyer la liste de tous les mots.

In [ ]:

Q14. Écrire enfin un script python qui affiche le nombre de mots contenus dans ce fichier, ainsi que tous les palindromes qu'il contient et leur nombre.

In [ ]: