Accueil › Cours › Les fichiers

Fichiers texte et fichiers de données en algo et Python (pickle)

Chapitre 23 · 3ème SI, Bac SI

Garde les données après la fin du programme : fichiers texte ligne par ligne, fichiers de données d'enregistrements, tri d'un fichier.

Les leçons de ce chapitre

Le fichier texte
Traiter un fichier texte
Le fichier de données
Trier un fichier

Leçon 23.1 : Le fichier texte

11 min

Les variables disparaissent quand le programme s'arrête. Un fichier garde les données sur le disque. Un fichier texte contient des lignes de caractères, comme un document du bloc-notes.

Ouvrir("prenoms.txt", F, "w") crée le fichier (et l'efface s'il existe). Mode "r" pour lire, "a" pour ajouter à la fin.
Ecrire_nl(F, ch) écrit ch puis passe à la ligne. Lire_ligne(F, ch) lit la ligne suivante.
Fin_fichier(F) est vrai quand tout est lu. Fermer(F) termine le travail sur le fichier.

En Python

f = open("notes.txt", "w"), f.write(ch + "\n"), f.close().
f.readline() renvoie la ligne avec son \n ; on l'enlève avec .rstrip("\n"). À la fin du fichier, elle renvoie la chaîne vide.

Attention : Python n'a pas de Fin_fichier : on lit tant que la ligne n'est pas vide. Évite donc les lignes vides au milieu d'un fichier.

Astuce : Ici, les fichiers sont créés dans un dossier à part, propre à ton programme : il est vidé à chaque exercice.

En Python

On écrit trois villes dans un fichier, puis on le relit ligne par ligne.

f = open("villes.txt", "w")
f.write("Tunis" + "\n")
f.write("Sfax" + "\n")
f.write("Tozeur" + "\n")
f.close()
f = open("villes.txt", "r")
n = 0
ch = f.readline().rstrip("\n")
while ch != "":
    n = n + 1
    print(n, ch)
    ch = f.readline().rstrip("\n")
f.close()

En algorithme

En algorithme, la boucle s'arrête avec Fin_fichier(F).

Algorithme Villes
Début
  Ouvrir("villes.txt", F, "w")
  Ecrire_nl(F, "Tunis")
  Ecrire_nl(F, "Sfax")
  Ecrire_nl(F, "Tozeur")
  Fermer(F)
  Ouvrir("villes.txt", F, "r")
  n ← 0
  Tant que Non Fin_fichier(F) Faire
    Lire_ligne(F, ch)
    n ← n + 1
    Ecrire(n, " ", ch)
  FinTantQue
  Fermer(F)
Fin

TDO
Objet | Type/Nature
F | Fichier texte
n | Entier
ch | Chaîne

Leçon 23.2 : Traiter un fichier texte

11 min

On lit souvent un fichier déjà rempli pour en tirer une information : compter les lignes, calculer une moyenne, chercher un mot, ou recopier une partie des lignes dans un autre fichier.

Une ligne lue est une chaîne : convertis-la avec Valeur(ch) (en Python int(ch) ou float(ch)) pour calculer.
Pour recopier, on ouvre deux fichiers : l'un en lecture ("r"), l'autre en écriture ("w").

Astuce : Dans les exercices de cette leçon, le fichier de départ existe déjà dans le dossier du programme.

En Python

Le fichier temperatures.txt contient une température par ligne. On calcule la moyenne.

f = open("temperatures.txt", "r")
s = 0
n = 0
ch = f.readline().rstrip("\n")
while ch != "":
    s = s + int(ch)
    n = n + 1
    ch = f.readline().rstrip("\n")
f.close()
print("Moyenne :", s / n)

En algorithme

Valeur(ch) transforme la ligne en nombre.

Algorithme Moyenne
Début
  Ouvrir("temperatures.txt", F, "r")
  s ← 0
  n ← 0
  Tant que Non Fin_fichier(F) Faire
    Lire_ligne(F, ch)
    s ← s + Valeur(ch)
    n ← n + 1
  FinTantQue
  Fermer(F)
  Ecrire("Moyenne : ", s / n)
Fin

TDO
Objet | Type/Nature
F | Fichier texte
s, n | Entier
ch | Chaîne

Leçon 23.3 : Le fichier de données

12 min

Un fichier de données (ou fichier typé) range des valeurs d'un même type : des entiers, ou des enregistrements entiers (un élève complet à chaque fois). On l'ouvre en mode binaire : "wb", "rb", "ab".

TDNT : FEleves = Fichier d'Eleve ; TDO : F | FEleves.
Ecrire(F, e) écrit un élève entier, Lire(F, e) lit l'élève suivant.
En Python : from pickle import dump, load, puis dump(e, f) et e = load(f).

Attention : Python n'a pas de Fin_fichier pour ces fichiers : load lève l'erreur EOFError à la fin. On lit donc dans un try, et le except EOFError arrête la boucle.

En Python

On enregistre trois élèves, puis on relit le fichier pour afficher les admis.

from pickle import dump, load

f = open("classe.dat", "wb")
for i in range(3):
    e = {"nom": "", "moy": 0.0}
    e["nom"] = input()
    e["moy"] = float(input())
    dump(e, f)
f.close()
f = open("classe.dat", "rb")
arret = False
while not arret:
    try:
        e = load(f)
        if e["moy"] >= 10:
            print(e["nom"], e["moy"])
    except EOFError:
        arret = True
f.close()

En algorithme

En algorithme, Fin_fichier(F) arrête la lecture.

Algorithme Admis
Début
  Ouvrir("classe.dat", F, "wb")
  Pour i de 1 à 3 Faire
    Lire(e.nom)
    Lire(e.moy)
    Ecrire(F, e)
  FinPour
  Fermer(F)
  Ouvrir("classe.dat", F, "rb")
  Tant que Non Fin_fichier(F) Faire
    Lire(F, e)
    Si e.moy ≥ 10 Alors
      Ecrire(e.nom, " ", e.moy)
    FinSi
  FinTantQue
  Fermer(F)
Fin

TDNT
Eleve = Enregistrement
  nom : Chaîne
  moy : Réel
Fin
FEleves = Fichier d'Eleve

TDO
Objet | Type/Nature
F | FEleves
e | Eleve
i | Entier

Leçon 23.4 : Trier un fichier

11 min

On ne trie pas directement dans un fichier. On procède en trois étapes, dans la mémoire centrale :

Transférer le contenu du fichier dans un tableau.
Trier le tableau (sélection, bulles, insertion…).
Réécrire le tableau trié dans le fichier (ouvert en "w").

Astuce : La même méthode sert pour insérer ou supprimer un élément au milieu d'un fichier : on le modifie dans le tableau, puis on réécrit tout le fichier.

En Python

Le fichier ages.txt est transféré dans une liste, trié par sélection, puis réécrit.

f = open("ages.txt", "r")
t = [0] * 50
n = 0
ch = f.readline().rstrip("\n")
while ch != "":
    t[n] = int(ch)
    n = n + 1
    ch = f.readline().rstrip("\n")
f.close()
for i in range(n - 1):
    pmin = i
    for j in range(i + 1, n):
        if t[j] < t[pmin]:
            pmin = j
    aux = t[i]
    t[i] = t[pmin]
    t[pmin] = aux
f = open("ages.txt", "w")
for i in range(n):
    f.write(str(t[i]) + "\n")
f.close()
f = open("ages.txt", "r")
ch = f.readline().rstrip("\n")
while ch != "":
    print(ch)
    ch = f.readline().rstrip("\n")
f.close()

En algorithme

Les trois étapes : transfert, tri, réécriture.

Algorithme TrierFichier
Début
  Ouvrir("ages.txt", F, "r")
  n ← 0
  Tant que Non Fin_fichier(F) Faire
    Lire_ligne(F, ch)
    n ← n + 1
    T[n] ← Valeur(ch)
  FinTantQue
  Fermer(F)
  Pour i de 1 à n - 1 Faire
    pmin ← i
    Pour j de i + 1 à n Faire
      Si T[j] < T[pmin] Alors
        pmin ← j
      FinSi
    FinPour
    aux ← T[i]
    T[i] ← T[pmin]
    T[pmin] ← aux
  FinPour
  Ouvrir("ages.txt", F, "w")
  Pour i de 1 à n Faire
    Ecrire_nl(F, convch(T[i]))
  FinPour
  Fermer(F)
  Ouvrir("ages.txt", F, "r")
  Tant que Non Fin_fichier(F) Faire
    Lire_ligne(F, ch)
    Ecrire(ch)
  FinTantQue
  Fermer(F)
Fin

TDO
Objet | Type/Nature
F | Fichier texte
T | Tableau de 50 Entiers
n, i, j, pmin, aux | Entier
ch | Chaîne

S'entraîner gratuitement

Chaque leçon a 3 exercices gratuits avec indices pour appliquer ce chapitre avec Hannibot.

Ouvrir le chapitre dans Mission Carthage Essayer dans le compilateur en ligne

← Chapitre précédent : Les algorithmes récurrents · Chapitre suivant : Tri Shell, tri par comptage, fusion →

Tous les chapitres · Voir les devoirs corrigés de 2ème TI

Cours écrit pour Mission Carthage d'après le programme officiel. Ton professeur reste la référence.