Les fichiers

Objectifs

À la fin de ce chapitre, l’élève doit être capable de :

• définir un fichier et distinguer un fichier texte d’un fichier de données ;
• déclarer, ouvrir, lire, écrire et fermer un fichier, en algorithmique et en Python ;
• parcourir un fichier de façon séquentielle, du premier élément au dernier ;
• ajouter, supprimer, modifier et trier le contenu d’un fichier ;
• transférer des données d’un fichier texte vers un fichier de données, et inversement.

Plan du chapitre

1. Introduction
2. Notion de fichier
3. Les fichiers texte
4. Les fichiers de données
5. Transferts entre fichiers
6. Erreurs fréquentes
7. Retenons

1. Introduction

Activité 1

Un professeur écrit un programme qui saisit les noms et les moyennes des élèves de sa classe, puis affiche la moyenne de la classe. Il saisit les trente élèves et obtient le résultat.

Le lendemain, un élève absent la veille lui remet sa note. Le professeur relance son programme pour l’ajouter.

Questions

1. Que doit faire le professeur pour obtenir la nouvelle moyenne de la classe ?
2. Pourquoi les données saisies la veille ne sont-elles plus disponibles ?
3. Que faudrait-il pour éviter cette nouvelle saisie ?

Réponse

Le professeur doit ressaisir les trente élèves de la veille, puis le nouvel élève. Les données saisies la veille ont été placées dans la mémoire centrale de l’ordinateur pendant l’exécution du programme ; cette mémoire est volatile et son contenu a disparu à la fin de l’exécution.

Pour éviter cette nouvelle saisie, il faut enregistrer les données sur un support qui les conserve après la fin du programme : disque dur, clé USB ou espace de stockage en ligne. Sur ces supports, les données sont organisées en fichiers.

2. Notion de fichier

2.1 Définition

Définition. Un fichier est un ensemble structuré de données, nommé et enregistré sur un support de stockage lisible par l’ordinateur.

On distingue deux types de fichiers :

• le fichier texte, dont le contenu est une suite de caractères organisée en lignes, lisible par l’être humain ;
• le fichier de données, dont le contenu est une suite d’objets de même type — entiers, réels ou enregistrements — enregistrés sous forme binaire.

Un fichier se distingue d’un tableau sur trois points : sa taille n’est pas fixée au moment de la déclaration, ses éléments n’ont pas d’indice, et son parcours se fait nécessairement du premier élément vers le dernier. Le tableau est une structure de traitement ; le fichier est une structure de conservation.

2.2 Nom logique et nom physique

Dans un programme, tout fichier possède deux noms.

• Le nom physique est le chemin d’accès au fichier sur le support de stockage, par exemple "D:\eleves.dat".
• Le nom logique est l’identificateur par lequel le programme désigne ce fichier, par exemple F.

La primitive Ouvrir établit la correspondance entre ces deux noms. Toutes les autres primitives — lecture, écriture, test de fin de fichier, fermeture — n’utilisent que le nom logique.

2.3 Organisation d’un fichier

Un fichier texte est organisé en lignes successives. Un fichier de données est organisé en blocs successifs, chaque bloc contenant un objet, par exemple un enregistrement.

Représentation d’un fichier texte. Chaque ligne se termine par le caractère de fin de ligne, représenté ici par le symbole ↵ : c’est le symbole de la touche Entrée du clavier, et c’est en appuyant sur cette touche que l’on crée ce caractère. Il ne s’affiche jamais à l’écran, et il ne s’écrit jamais dans un algorithme.

11223344#Bacha Sarra#18.75↵
10556677#Ben Saleh Omar#17.25↵
12889900#Mekki Mohamed Amine#16.75↵
…

Représentation d’un fichier de données. Chaque bloc contient un enregistrement, avec tous ses champs.

Remarque importante. Cette représentation est un schéma. Le contenu réel d’un fichier de données n’est pas lisible : le schéma montre sa structure, et non ce que l’on verrait en ouvrant le fichier dans un éditeur de texte.

Dans les deux cas, les éléments sont placés les uns à la suite des autres, et l’accès se fait de façon séquentielle : pour atteindre un élément, il faut avoir lu tous ceux qui le précèdent.

2.4 La position courante

Le système retient en permanence l’endroit du fichier où en est la lecture ou l’écriture. Cette marque est appelée le pointeur du fichier.

À l’ouverture, le pointeur est placé au début du fichier en mode lecture ou en mode création, et à la fin du fichier en mode ajout. Chaque lecture et chaque écriture le font avancer d’elles-mêmes, jusqu’à l’élément suivant.

Après l’ouverture en lecture : le pointeur est placé sur le premier bloc.

Après deux lectures : le pointeur est placé sur le troisième bloc. Les deux premiers ont été lus et ne peuvent plus être atteints.

Après la lecture du dernier bloc : le pointeur est placé après la fin du fichier. C’est dans cette position que la fonction Fin_fichier retourne Vrai.

Remarque importante. Aucune instruction ne permet de déplacer directement le pointeur. C’est la raison pour laquelle un fichier se parcourt toujours du début vers la fin, sans retour en arrière.

3. Les fichiers texte

3.1 Définition

Définition. Un fichier texte est une suite de caractères organisée en lignes. Chaque ligne se termine par un caractère de fin de ligne qui ne s’affiche pas à l’écran, mais qui est bien enregistré dans le fichier.

C’est ce caractère de fin de ligne qui sépare deux lignes. Une écriture qui ne le place pas laisse la ligne ouverte : le texte écrit ensuite vient se placer à sa suite, sur la même ligne.

Un fichier texte peut être ouvert et lu avec un simple éditeur de texte, comme le Bloc-notes.

Exemple. Le fichier eleves.txt contient la liste d’une classe, à raison d’une ligne par élève. Chaque ligne contient le numéro de la carte d’identité, le nom et la moyenne de l’élève, séparés par le caractère #.

11223344#Bacha Sarra#18.75
10556677#Ben Saleh Omar#17.25
12889900#Mekki Mohamed Amine#16.75
11334455#Baccara Lina#15.75
10998877#Ragued Kaslen#8.5

Ce fichier sert d’exemple dans toute la partie consacrée aux fichiers texte.

3.2 Déclaration

Le type Fichier texte est un type prédéfini : il ne nécessite aucune déclaration dans le tableau de déclaration des nouveaux types.

Tableau de déclaration des objets

Exemple

3.3 Ouverture et fermeture

Ouverture

Syntaxe algorithmique

Ouvrir(nom_physique, nom_logique, mode)

Le paramètre mode est une chaîne de caractères qui précise l’usage du fichier.

Exemple

Ouvrir("D:\eleves.txt", F1, "r")
Ouvrir("D:\admis.txt", F2, "w")
Ouvrir("D:\eleves.txt", F3, "a")

Remarque importante. L’effacement provoqué par le mode "w" est immédiat : il se produit à l’ouverture, avant toute écriture. Un fichier de cent lignes ouvert en mode "w" puis refermé sans qu’aucune écriture n’ait eu lieu devient un fichier vide.

Fermeture

Syntaxe algorithmique

Fermer(nom_logique)

Tant qu’un fichier n’a pas été fermé, l’enregistrement effectif de son contenu sur le support n’est pas garanti.

En Python

nom_logique = open(nom_physique, mode)
nom_logique.close()

Les modes "r", "w" et "a" ont le même effet qu’en algorithmique.

F1 = open("D:/eleves.txt", "r")
F1.close()

3.4 Lecture

Syntaxe algorithmique

Lire_ligne(nom_logique, ch) lit la ligne courante et la range dans la chaîne ch.

Lire(nom_logique, ch) lit la totalité du fichier et la range dans la chaîne ch.

Après la lecture d’une ligne, le pointeur passe au début de la ligne suivante. La chaîne obtenue ne contient pas le caractère de fin de ligne.

Exemple. Après Ouvrir("D:\eleves.txt", F, "r"), l’instruction Lire_ligne(F, ch) range dans ch la chaîne "11223344#Bacha Sarra#18.75". Une seconde instruction Lire_ligne(F, ch) y range "10556677#Ben Saleh Omar#17.25".

En Python

Remarque importante. En Python, readline() rend la ligne avec son caractère de fin de ligne "\n". On le retire par ch = ch[:len(ch) - 1]. Cette opération est propre à Python : elle n’a pas d’équivalent à écrire en algorithmique. Elle suppose que chaque ligne, y compris la dernière, se termine par "\n" : c’est le cas des fichiers écrits par un programme avec F.write(ch + "\n"). Si la dernière ligne n’a pas de fin de ligne, son dernier caractère serait perdu.

3.5 Écriture

Syntaxe algorithmique

Écrire(nom_logique, ch) écrit la chaîne ch sans passer à la ligne.

Écrire_nl(nom_logique, ch) écrit la chaîne ch puis le caractère de fin de ligne.

Exemple

Ouvrir("D:\admis.txt", F, "w")
Écrire_nl(F, "11223344#Bacha Sarra#18.75")
Écrire_nl(F, "10556677#Ben Saleh Omar#17.25")
Fermer(F)

Le fichier admis.txt contient alors deux lignes.

Remarque importante. Les primitives Écrire et Écrire_nl d’un fichier texte reçoivent une chaîne de caractères. Pour écrire une valeur numérique, on la convertit d’abord à l’aide de la fonction Convch.

En Python

3.6 Test de fin de fichier

Syntaxe algorithmique

Fin_fichier(nom_logique) est une fonction qui retourne Vrai si le pointeur est à la fin du fichier, et Faux sinon.

La fonction Fin_fichier teste la position du pointeur avant toute lecture.

En Python

Python ne dispose pas d’une fonction équivalente pour les fichiers texte. On lit d’abord, puis on teste la valeur lue : la méthode readline() rend la chaîne vide "" lorsqu’il n’y a plus rien à lire.

3.7 Parcours d’un fichier texte

Pour traiter toutes les lignes d’un fichier dont on ne connaît pas le nombre, on répète la lecture tant que la fin du fichier n’est pas atteinte.

Ouvrir(nom_physique, F, "r")
Tant que Non(Fin_fichier(F)) Faire
    Lire_ligne(F, ch)
    // traitement de la ligne ch
Fin Tant que
Fermer(F)

Trois règles s’appliquent à ce parcours :

• la lecture se place à l’intérieur de la boucle ;
• aucune lecture n’est faite avant la boucle, puisque Fin_fichier répond sans lire ;
• aucune variable booléenne n’est nécessaire pour détecter la fin du fichier : c’est le rôle de Fin_fichier.

Choix de la structure répétitive

Application : afficher la liste de la classe

Procédure Afficher_Liste (nomF : Chaîne de caractères)
DEBUT
    Ouvrir(nomF, F, "r")
    Tant que Non(Fin_fichier(F)) Faire
        Lire_ligne(F, ch)
        Écrire(ch)
    Fin Tant que
    Fermer(F)
FIN

TDOL

En Python

La traduction Python n’a pas la même forme, puisque Python lit avant de tester :

def Afficher_Liste(nomF):
    F = open(nomF, "r")
    ch = F.readline()
    while ch != "":
        ch = ch[:len(ch) - 1]
        print(ch)
        ch = F.readline()
    F.close()

Remarque importante. La forme Python est une traduction de l’algorithme, pas son modèle. En algorithmique, on n’écrit ni lecture avant la boucle, ni retrait du caractère de fin de ligne.

3.8 Découper une ligne

Une ligne d’un fichier texte est une seule chaîne de caractères. Lorsqu’elle contient plusieurs informations séparées par un caractère, il faut les extraire à l’aide des fonctions prédéfinies sur les chaînes : Pos, Sous_chaine, Long et Valeur.

Exemple. Soit ch = "11223344#Bacha Sarra#18.75". Les positions commencent à 0.

Lorsque la ligne contient deux séparateurs, on procède en deux temps : on extrait le premier champ, on garde le reste de la ligne, et l’on recommence sur ce reste.

Remarque importante. La borne de fin de Sous_chaine est exclue. Pour prendre la chaîne jusqu’à son dernier caractère, la borne est Long(ch), et non Long(ch) - 1.

Application : la moyenne de la classe

Fonction Moyenne_Texte (nomF : Chaîne de caractères) : Réel
DEBUT
    Ouvrir(nomF, F, "r")
    s ← 0
    nb ← 0
    Tant que Non(Fin_fichier(F)) Faire
        Lire_ligne(F, ch)
        p ← Pos("#", ch)
        reste ← Sous_chaine(ch, p + 1, Long(ch))
        p ← Pos("#", reste)
        s ← s + Valeur(Sous_chaine(reste, p + 1, Long(reste)))
        nb ← nb + 1
    Fin Tant que
    Fermer(F)
    Si nb = 0 Alors
        m ← 0
    Sinon
        m ← s / nb
    FinSi
    Retourner m
FIN

TDOL

Sur le fichier eleves.txt du paragraphe 3.1, cette fonction retourne 15.4.

Application 1 — Répertoire

Le fichier texte "repertoire.txt" contient une liste de contacts, à raison d’un contact par ligne, sous la forme Prénom:téléphone.

Adam:98700800
Chaima:28999777
Ghaith:22000000
Souhaila:41568987
Takwa:52525252
Yasser:22999888
Manar:51114441
Mariem:21213232
Nawres:98123546
Nour:50900900
Louay:51800900

Travail demandé

1. Écrire l’algorithme de la procédure Ajouter_Fin(nomF, c, t) qui ajoute le contact de prénom c et de téléphone t à la fin du fichier.
2. Écrire l’algorithme de la procédure Ajouter_Debut(nomF, c, t) qui ajoute ce même contact au début du fichier.
3. Écrire l’algorithme de la procédure Supprimer(nomF, c) qui supprime du répertoire le contact de prénom c.
4. Écrire l’algorithme de la procédure Modifier(nomF, c, nt) qui remplace par nt le numéro de téléphone du contact de prénom c.
5. Écrire l’algorithme de la procédure Trier(nomF) qui trie les contacts dans l’ordre croissant des prénoms.

N.B. nomF est une chaîne de caractères contenant l’emplacement et le nom physique du fichier. Le répertoire contient au plus 200 contacts. Aucun prénom ne contient le caractère :.

Procédure Ajouter_Fin (nomF, c, t : Chaîne de caractères)
DEBUT
    Ouvrir(nomF, F, "a")
    Écrire_nl(F, c + ":" + t)
    Fermer(F)
FIN

Procédure Ajouter_Debut (nomF, c, t : Chaîne de caractères)
DEBUT
    Ouvrir(nomF, F, "r")
    n ← 0
    Tant que Non(Fin_fichier(F)) Faire
        Lire_ligne(F, ch)
        T[n] ← ch
        n ← n + 1
    Fin Tant que
    Fermer(F)
    Ouvrir(nomF, F, "w")
    Écrire_nl(F, c + ":" + t)
    Pour i de 0 à n - 1 Faire
        Écrire_nl(F, T[i])
    Fin Pour
    Fermer(F)
FIN

Procédure Supprimer (nomF, c : Chaîne de caractères)
DEBUT
    Ouvrir(nomF, F, "r")
    n ← 0
    Tant que Non(Fin_fichier(F)) Faire
        Lire_ligne(F, ch)
        p ← Pos(":", ch)
        Si Sous_chaine(ch, 0, p) ≠ c Alors
            T[n] ← ch
            n ← n + 1
        FinSi
    Fin Tant que
    Fermer(F)
    Ouvrir(nomF, F, "w")
    Pour i de 0 à n - 1 Faire
        Écrire_nl(F, T[i])
    Fin Pour
    Fermer(F)
FIN

Procédure Modifier (nomF, c, nt : Chaîne de caractères)
DEBUT
    Ouvrir(nomF, F, "r")
    n ← 0
    Tant que Non(Fin_fichier(F)) Faire
        Lire_ligne(F, ch)
        p ← Pos(":", ch)
        Si Sous_chaine(ch, 0, p) = c Alors
            T[n] ← c + ":" + nt
        Sinon
            T[n] ← ch
        FinSi
        n ← n + 1
    Fin Tant que
    Fermer(F)
    Ouvrir(nomF, F, "w")
    Pour i de 0 à n - 1 Faire
        Écrire_nl(F, T[i])
    Fin Pour
    Fermer(F)
FIN

Procédure Trier (nomF : Chaîne de caractères)
DEBUT
    Ouvrir(nomF, F, "r")
    n ← 0
    Tant que Non(Fin_fichier(F)) Faire
        Lire_ligne(F, ch)
        T[n] ← ch
        n ← n + 1
    Fin Tant que
    Fermer(F)
    Pour i de 1 à n - 1 Faire
        aux ← T[i]
        j ← i
        Tant que (j > 0) Et (Prenom(T[j-1]) > Prenom(aux)) Faire
            T[j] ← T[j-1]
            j ← j - 1
        Fin Tant que
        T[j] ← aux
    Fin Pour
    Ouvrir(nomF, F, "w")
    Pour i de 0 à n - 1 Faire
        Écrire_nl(F, T[i])
    Fin Pour
    Fermer(F)
FIN

Fonction Prenom (ch : Chaîne de caractères) : Chaîne de caractères
DEBUT
    Retourner Sous_chaine(ch, 0, Pos(":", ch))
FIN

4. Les fichiers de données

Activité 2

On reprend la fonction Moyenne_Texte du paragraphe 3.8.

Questions

1. Combien d’opérations de découpage et de conversion faut-il effectuer pour chaque ligne du fichier, uniquement pour obtenir la moyenne de l’élève ?
2. Si le fichier contenait dix champs par élève, comment évoluerait ce travail ?
3. Quelle forme devraient avoir les données enregistrées pour que chaque élève soit lu en une seule opération, avec ses champs déjà séparés et déjà du bon type ?

Réponse

Pour chaque ligne, il faut deux recherches du séparateur, deux extractions et une conversion de la chaîne obtenue en nombre. Avec dix champs, ce travail serait multiplié d’autant, et chaque programme qui utilise le fichier devrait le refaire.

Il faudrait que chaque élève soit enregistré sous la forme d’un enregistrement, avec ses trois champs déjà typés. C’est ce que permet le fichier de données.

4.1 Définition

Définition. Un fichier de données est une suite d’objets de même type — entiers, réels ou, le plus souvent, enregistrements — enregistrés sous forme binaire.

Son contenu n’est pas lisible dans un éditeur de texte. Il porte habituellement l’extension .dat et se manipule en mode binaire.

Un objet lu dans un fichier de données est obtenu en une seule opération, avec ses champs déjà séparés et déjà typés.

Exemple. Le fichier eleves.dat, qui contient les mêmes élèves que le fichier eleves.txt du paragraphe 3.1, se représente ainsi :

Chaque bloc est un enregistrement de type Eleve. Une instruction Lire(F, E) range un bloc entier dans la variable E.

4.2 Déclaration

Un fichier de données se déclare dans le tableau de déclaration des nouveaux types. Lorsque ses éléments sont des enregistrements, la déclaration se fait en deux temps : on déclare d’abord le type enregistrement, puis le type fichier qui le contient.

Syntaxe — tableau de déclaration des nouveaux types

nom_type = Fichier de type_éléments

Exemple. Le fichier eleves.dat contient un enregistrement par élève.

TDNT

TDO

Lorsque ses éléments sont d’un type prédéfini — entier, réel, caractère —, une seule déclaration suffit : Freel = Fichier de Réel.

Remarque importante. Un type se déclare avant d’être utilisé : le tableau de déclaration des nouveaux types précède toujours le tableau de déclaration des objets.

4.3 Ouverture et fermeture

Syntaxe algorithmique

Ouvrir(nom_physique, nom_logique, mode)

Fermer(nom_logique)

Ce sont les trois modes du fichier texte, suivis de la lettre b. Leur effet est le même, y compris l’effacement provoqué par "wb".

En Python

F = open("D:/eleves.dat", "rb")
F.close()

4.4 Lecture et écriture

Syntaxe algorithmique

Lire(nom_logique, objet) lit l’objet courant du fichier et le range dans la variable objet.

Écrire(nom_logique, objet) écrit le contenu de la variable objet dans le fichier.

Exemple

E.CIN ← "11223344"
E.Nom ← "Bacha Sarra"
E.Moyenne ← 18.75
Ouvrir("D:\eleves.dat", F, "wb")
Écrire(F, E)
Fermer(F)

Remarque importante. Le nom logique du fichier est toujours le premier paramètre : on écrit Écrire(F, E), jamais Écrire(E, F).

Les objets se lisent dans l’ordre où ils ont été écrits. La variable de lecture doit être du même type que les éléments du fichier.

En Python

La lecture et l’écriture utilisent le module pickle.

from pickle import load, dump

Remarque importante. L’ordre des paramètres s’inverse d’un langage à l’autre : Écrire(F, E) se traduit par dump(E, F).

En Python, un enregistrement est représenté par un dictionnaire : le champ E.Moyenne s’écrit E['Moyenne'].

4.5 Test de fin de fichier

La fonction Fin_fichier(nom_logique) s’emploie de la même façon que pour un fichier texte.

En Python

Le module pickle n’offre aucun test de fin de fichier : la fonction load provoque une erreur lorsqu’il n’y a plus d’objet à lire. On intercepte cette erreur à l’aide de la structure try / except.

fin = False
while not (fin):
    try:
        E = load(F)
        # traitement de E
    except:
        fin = True

Remarque importante. Le traitement se place à l’intérieur du bloc try, juste après load. Placé après le bloc except, il serait exécuté une fois de trop, sur un objet qui n’a pas été lu.

4.6 Parcours d’un fichier de données

Le parcours d’un fichier de données a exactement la même structure que celui d’un fichier texte : Lire remplace Lire_ligne, et le mode "rb" remplace le mode "r".

Remarque importante. Sur un fichier texte, Lire(F, ch) rend le fichier entier en une seule opération. Sur un fichier de données, Lire(F, E) ne rend qu’un seul objet : aucune primitive ne lit la totalité du fichier en une fois. Pour traiter tous les objets, le parcours est obligatoire.

Ouvrir(nom_physique, F, "rb")
Tant que Non(Fin_fichier(F)) Faire
    Lire(F, E)
    // traitement de E
Fin Tant que
Fermer(F)

Application : la moyenne de la classe

Fonction Moyenne_Classe (nomF : Chaîne de caractères) : Réel
DEBUT
    Ouvrir(nomF, F, "rb")
    s ← 0
    nb ← 0
    Tant que Non(Fin_fichier(F)) Faire
        Lire(F, E)
        s ← s + E.Moyenne
        nb ← nb + 1
    Fin Tant que
    Fermer(F)
    Si nb = 0 Alors
        m ← 0
    Sinon
        m ← s / nb
    FinSi
    Retourner m
FIN

TDOL

Sur un fichier eleves.dat contenant les cinq élèves du paragraphe 3.1, cette fonction retourne 15.4, comme Moyenne_Texte.

En Python

from pickle import load

def Moyenne_Classe(nomF):
    F = open(nomF, "rb")
    s = 0
    nb = 0
    fin = False
    while not (fin):
        try:
            E = load(F)
            s = s + E['Moyenne']
            nb = nb + 1
        except:
            fin = True
    F.close()
    if nb == 0:
        m = 0
    else:
        m = s / nb
    return m

4.7 Modifier un fichier : trois traitements

Le pointeur d’un fichier ne peut qu’avancer (paragraphe 2.4). Il en résulte qu’un fichier ne se modifie pas en place : on ne peut ni remplacer un élément situé au milieu du fichier, ni le supprimer. Trois traitements sont possibles.

Remarque importante. L’ajout est la seule modification qui ne réécrit pas le fichier. Toutes les autres passent par une reconstruction complète.

Les mêmes traitements s’appliquent aux fichiers texte, avec les modes "r", "a" et "w" : l’application 1 en a donné les exemples.

Rechercher un élève

Fonction Existe (nomF, c : Chaîne de caractères) : Booléen
DEBUT
    Ouvrir(nomF, F, "rb")
    trouve ← Faux
    Tant que Non(Fin_fichier(F)) Et Non(trouve) Faire
        Lire(F, E)
        Si E.CIN = c Alors
            trouve ← Vrai
        FinSi
    Fin Tant que
    Fermer(F)
    Retourner trouve
FIN

TDOL

La lecture s’arrête dès que l’élève est trouvé. La variable trouve mémorise le succès de la recherche ; elle ne remplace pas Fin_fichier, qui continue de détecter la fin du fichier.

Ajouter un élève

Procédure Ajouter_Eleve (nomF : Chaîne de caractères, E : Eleve)
DEBUT
    Si Existe(nomF, E.CIN) Alors
        Écrire("Cet élève figure déjà dans le fichier.")
    Sinon
        Ouvrir(nomF, F, "ab")
        Écrire(F, E)
        Fermer(F)
    FinSi
FIN

TDOL

Supprimer un élève

Procédure Supprimer_Eleve (nomF, c : Chaîne de caractères)
DEBUT
    Ouvrir(nomF, F, "rb")
    n ← 0
    Tant que Non(Fin_fichier(F)) Faire
        Lire(F, E)
        Si E.CIN ≠ c Alors
            T[n] ← E
            n ← n + 1
        FinSi
    Fin Tant que
    Fermer(F)
    Ouvrir(nomF, F, "wb")
    Pour i de 0 à n - 1 Faire
        Écrire(F, T[i])
    Fin Pour
    Fermer(F)
FIN

TDNT local — TabE = Tableau de 40 Eleve

TDOL

Schéma de la reconstruction — suppression de l’élève de CIN 12889900

4.8 Relire ou charger ?

Face à un traitement demandé, la question à se poser est la suivante : un seul passage dans l’ordre du fichier suffit-il ?

Le chargement a toujours la même forme :

Ouvrir(nomF, F, "rb")
n ← 0
Tant que Non(Fin_fichier(F)) Faire
    Lire(F, E)
    T[n] ← E
    n ← n + 1
Fin Tant que
Fermer(F)

Remarque importante. Il faut distinguer la taille déclarée du tableau — 40 pour le type TabE du paragraphe 4.7 — et sa taille effective n, qui est le nombre d’éléments réellement chargés depuis le fichier. Tous les traitements qui suivent portent sur les éléments d’indice 0 à n - 1, jamais sur la taille déclarée.

5. Transferts entre fichiers

5.1 Du fichier texte au fichier de données

Exemple. On veut créer le fichier eleves.dat à partir du fichier eleves.txt du paragraphe 3.1. Chaque ligne est découpée selon la méthode du paragraphe 3.8, et les champs obtenus sont rangés dans un enregistrement, qui est écrit dans le fichier de données.

Procédure Transferer (nomT, nomD : Chaîne de caractères)
DEBUT
    Ouvrir(nomT, Ft, "r")
    Ouvrir(nomD, Fd, "wb")
    Tant que Non(Fin_fichier(Ft)) Faire
        Lire_ligne(Ft, ch)
        p ← Pos("#", ch)
        E.CIN ← Sous_chaine(ch, 0, p)
        reste ← Sous_chaine(ch, p + 1, Long(ch))
        p ← Pos("#", reste)
        E.Nom ← Sous_chaine(reste, 0, p)
        E.Moyenne ← Valeur(Sous_chaine(reste, p + 1, Long(reste)))
        Écrire(Fd, E)
    Fin Tant que
    Fermer(Ft)
    Fermer(Fd)
FIN

TDOL

5.2 Du fichier de données au fichier texte

Exemple. On veut enregistrer dans le fichier texte admis.txt les élèves du fichier eleves.dat dont la moyenne est supérieure ou égale à 10, à raison d’une ligne par élève, sous la forme CIN#Nom#Moyenne.

Procédure Exporter_Admis (nomD, nomT : Chaîne de caractères)
DEBUT
    Ouvrir(nomD, Fd, "rb")
    Ouvrir(nomT, Ft, "w")
    Tant que Non(Fin_fichier(Fd)) Faire
        Lire(Fd, E)
        Si E.Moyenne ≥ 10 Alors
            Écrire_nl(Ft, E.CIN + "#" + E.Nom + "#" + Convch(E.Moyenne))
        FinSi
    Fin Tant que
    Fermer(Fd)
    Fermer(Ft)
FIN

TDOL

Le fichier admis.txt obtenu contient quatre lignes :

11223344#Bacha Sarra#18.75
10556677#Ben Saleh Omar#17.25
12889900#Mekki Mohamed Amine#16.75
11334455#Baccara Lina#15.75

Remarque importante. La concaténation par + ne s’applique qu’à des chaînes : le champ réel Moyenne est converti par Convch avant d’être concaténé.

Application 2 — Compétition

Afin d’automatiser la gestion des résultats d’une compétition EA Sports de l’année 2027, on utilise le fichier de données "FiFa2027.dat", enregistré sur le disque D, qui contient les joueurs d’une poule. Une poule compte de 8 à 32 joueurs. Chaque joueur est décrit par :

• Code : une chaîne de caractères formée d’une lettre majuscule suivie de 9 chiffres ;
• Score : un entier positif ou nul.

Exemple — début du fichier FiFa2027.dat :

On donne les déclarations suivantes :

Travail demandé

1. Écrire l’algorithme de la procédure Remplir(nomF, n) qui crée le fichier et y saisit les n joueurs de la poule. Le code et le score sont contrôlés à la saisie.
2. Écrire l’algorithme de la procédure Ajouter(nomF) qui saisit un joueur supplémentaire et l’ajoute à la fin du fichier, à condition que la poule ne soit pas complète (32 joueurs) et que son code n’y figure pas déjà ; dans le cas contraire, elle affiche un message qui en donne la raison.
3. Écrire l’algorithme de la procédure Trier(nomF) qui trie les joueurs dans l’ordre décroissant du score. À score égal, les joueurs sont départagés par ordre croissant de leur code.
4. Écrire l’algorithme de la procédure Classement(nomF, nomFt) qui enregistre dans le fichier texte nomFt le classement des joueurs, à raison d’une ligne par joueur, sous la forme rang) Code : Score.
5. Écrire l’algorithme du programme principal, qui saisit le nombre de joueurs de la poule et appelle les modules dans l’ordre utile.

N.B. nomF et nomFt sont des chaînes de caractères contenant l’emplacement et le nom physique des fichiers.

ALGORITHME Competition
DEBUT
    Répéter
        Écrire("Nombre de joueurs de la poule : "), Lire(n)
    Jusqu'à (n ≥ 8) Et (n ≤ 32)
    nomf ← "D:\FiFa2027.dat"
    Remplir(nomf, n)
    Ajouter(nomf)
    Trier(nomf)
    Classement(nomf, "D:\Classement.txt")
FIN

Procédure Remplir (nomF : Chaîne de caractères, n : Entier)
DEBUT
    Ouvrir(nomF, F, "wb")
    Pour i de 0 à n - 1 Faire
        Répéter
            Écrire("Code du joueur ", i + 1, " : "), Lire(E.Code)
        Jusqu'à Valide(E.Code)
        Répéter
            Écrire("Score : "), Lire(E.Score)
        Jusqu'à E.Score ≥ 0
        Écrire(F, E)
    Fin Pour
    Fermer(F)
FIN

Fonction Valide (ch : Chaîne de caractères) : Booléen
DEBUT
    Retourner (Long(ch) = 10) Et (ch[0] ∈ ["A".."Z"])
              Et Estnum(Sous_chaine(ch, 1, Long(ch)))
FIN

Procédure Ajouter (nomF : Chaîne de caractères)
DEBUT
    Si Taille(nomF) = 32 Alors
        Écrire("La poule est complète.")
    Sinon
        Répéter
            Écrire("Code du nouveau joueur : "), Lire(E.Code)
        Jusqu'à Valide(E.Code)
        Si Existe(nomF, E.Code) Alors
            Écrire("Ce joueur existe déjà.")
        Sinon
            Répéter
                Écrire("Score : "), Lire(E.Score)
            Jusqu'à E.Score ≥ 0
            Ouvrir(nomF, F, "ab")
            Écrire(F, E)
            Fermer(F)
        FinSi
    FinSi
FIN

Fonction Taille (nomF : Chaîne de caractères) : Entier
DEBUT
    Ouvrir(nomF, F, "rb")
    n ← 0
    Tant que Non(Fin_fichier(F)) Faire
        Lire(F, E)
        n ← n + 1
    Fin Tant que
    Fermer(F)
    Retourner n
FIN

Fonction Existe (nomF, c : Chaîne de caractères) : Booléen
DEBUT
    Ouvrir(nomF, F, "rb")
    trouve ← Faux
    Tant que Non(Fin_fichier(F)) Et Non(trouve) Faire
        Lire(F, E)
        Si E.Code = c Alors
            trouve ← Vrai
        FinSi
    Fin Tant que
    Fermer(F)
    Retourner trouve
FIN

Procédure Trier (nomF : Chaîne de caractères)
DEBUT
    Ouvrir(nomF, F, "rb")
    n ← 0
    Tant que Non(Fin_fichier(F)) Faire
        Lire(F, E)
        T[n] ← E
        n ← n + 1
    Fin Tant que
    Fermer(F)
    Pour i de 1 à n - 1 Faire
        aux ← T[i]
        j ← i
        Tant que (j > 0) Et ((T[j-1].Score < aux.Score)
                  Ou ((T[j-1].Score = aux.Score) Et (T[j-1].Code > aux.Code))) Faire
            T[j] ← T[j-1]
            j ← j - 1
        Fin Tant que
        T[j] ← aux
    Fin Pour
    Ouvrir(nomF, F, "wb")
    Pour i de 0 à n - 1 Faire
        Écrire(F, T[i])
    Fin Pour
    Fermer(F)
FIN

Procédure Classement (nomF, nomFt : Chaîne de caractères)
DEBUT
    Ouvrir(nomF, Fd, "rb")
    Ouvrir(nomFt, Ft, "w")
    r ← 1
    Tant que Non(Fin_fichier(Fd)) Faire
        Lire(Fd, E)
        Écrire_nl(Ft, Convch(r) + ") " + E.Code + " : " + Convch(E.Score))
        r ← r + 1
    Fin Tant que
    Fermer(Fd)
    Fermer(Ft)
FIN

1) E222222222 : 95
2) G333333333 : 95
3) A123456789 : 70
4) D999999999 : 70
5) K777777777 : 70
6) B000000001 : 50
7) C555555555 : 50
8) F111111111 : 12
9) H444444444 : 0

6. Erreurs fréquentes

Les erreurs suivantes, relevées sur le module Transferer du paragraphe 5.1, sont les plus fréquentes dans les copies.

Remarque importante. Aucune de ces instructions n’est fausse en elle-même : Lire est correcte sur un fichier de données, et le mode "rb" est correct pour consulter un fichier. Une instruction sur un fichier n’est juste ou fausse que par rapport au type du fichier et à l’usage que l’on veut en faire.

7. Retenons

Fichier. Un fichier est un ensemble structuré de données, nommé et enregistré sur un support de stockage. Il conserve les données après la fin de l’exécution du programme.

Deux types. Le fichier texte est une suite de caractères organisée en lignes. Le fichier de données est une suite d’objets de même type, manipulée en mode binaire.

Parcours. Un fichier se parcourt du début vers la fin. Lorsque le nombre d’éléments est inconnu, on utilise Tant que Non(Fin_fichier(F)) Faire, avec la lecture à l’intérieur de la boucle.

Trois traitements. Le parcours ne modifie rien. L’ajout, en mode "a" ou "ab", est la seule modification qui ne réécrit pas le fichier. Toutes les autres modifications passent par une reconstruction : chargement dans un tableau, traitement du tableau, réécriture du fichier.

Transferts. Du texte vers les données, on découpe chaque ligne et l’on convertit les champs numériques par Valeur. Des données vers le texte, on convertit les champs numériques par Convch, puis l’on concatène.

Python. Python n’a pas de fonction Fin_fichier : on teste la chaîne vide pour un fichier texte, et l’on utilise try / except pour un fichier de données. La forme Python est une traduction de l’algorithme, et non son modèle.

Teste tes connaissances

Un quiz corrigé question par question, puis des flashcards pour mémoriser les notions du chapitre.