Gestion des fichiers en Python

07 Feb 2017 07 Feb 2017 29608 vues ESSADDOUKI Mostafa 11 min de lecture

Introduction

Dans de nombreuses applications, les données doivent être conservées après l'exécution d'un programme. Or, les variables Python (listes, dictionnaires, etc.) sont stockées en mémoire vive (RAM) et disparaissent lorsque le programme se termine.

Fichiers et persistance Pour stocker les données de manière permanente, on utilise des fichiers stockés sur le disque dur, indépendants du cycle de vie du programme.

Un fichier permet par exemple de :

  • sauvegarder des résultats de calcul ;
  • stocker des données expérimentales ;
  • lire un jeu de données ;
  • enregistrer des configurations ou des journaux (logs).
Formats courants Les principaux formats de fichiers rencontrés en Python sont : .txt (texte brut), .csv (données tabulaires), .json (données structurées), et les fichiers binaires.

Ouvrir un fichier

Avant toute opération, il faut ouvrir le fichier avec la fonction open.

Syntaxe
f = open("nom_fichier", mode)
  • "nom_fichier" : chemin absolu ou relatif du fichier.
  • mode : chaîne décrivant le mode d'ouverture.
ModeSignificationRemarque
"r"Lecture seuleErreur si le fichier n'existe pas
"w"ÉcritureEfface le contenu existant
"a"Ajout à la finCrée le fichier s'il n'existe pas
"x"Création exclusiveErreur si le fichier existe déjà
"r+"Lecture + écriturePointeur en début de fichier
"rb" / "wb"Mode binaire (lecture / écriture)Pour fichiers non texte (images, PDF…)

Exemple — Ouverture en lecture

f = open("donnees.txt", "r")
Astuce — Chemins Windows Pour indiquer un chemin contenant des antislashs (Windows), utilisez des chaînes brutes préfixées par r : r"C:\dossier\fichier.txt". Cela évite d'interpréter \n, \t, etc. comme des caractères spéciaux.

Fermer un fichier

Après utilisation, il est obligatoire de fermer le fichier.

Syntaxe
f.close()

La fermeture du fichier permet de :

  • libérer les ressources système ;
  • garantir que les données sont bien écrites sur le disque (flush) ;
  • éviter les corruptions de fichiers.

Exemple — Ouverture, lecture et fermeture

f = open("donnees.txt", "r")
contenu = f.read()
f.close()
print(contenu)
Bonne pratique Dans la pratique, on préfère le bloc with qui ferme le fichier automatiquement, même en cas d'erreur. Voir la section dédiée.

Lire un fichier

Python propose plusieurs méthodes pour lire le contenu d'un fichier texte, adaptées à des cas d'usage différents.

Lire tout le contenu : read()

Syntaxe
texte = f.read()     # lit tout le fichier en une chaîne
texte = f.read(n)    # lit au plus n caractères

Exemple — Lecture complète

Supposons le fichier langages.txt suivant :

Contenu du fichier — langages.txt
Python
Java
C++
f = open("langages.txt", "r")
texte = f.read()
f.close()
print(texte)
Sortie
Python
Java
C++

Lire ligne par ligne : readline()

Syntaxe
ligne = f.readline()   # retourne la prochaine ligne (avec '\n')

À chaque appel, readline() avance le curseur de lecture d'une ligne. Quand le fichier est entièrement lu, elle retourne une chaîne vide "".

Exemple — Lecture de deux lignes successives

f = open("langages.txt", "r")
ligne1 = f.readline()   # "Python\n"
ligne2 = f.readline()   # "Java\n"
f.close()
print(repr(ligne1))     # affiche le \n visible
Sortie
'Python\n'
Astuce Pour supprimer le saut de ligne en fin de chaîne, utilisez ligne.strip() ou plus précisément ligne.rstrip('\n') si vous voulez conserver les espaces en début de ligne.

Lire toutes les lignes : readlines()

Syntaxe
lignes = f.readlines()  # retourne une liste de chaînes

Exemple — Obtenir la liste des lignes

f = open("langages.txt", "r")
lignes = f.readlines()
f.close()
print(lignes)
Sortie
['Python\n', 'Java\n', 'C++\n']

Parcourir avec une boucle for — méthode recommandée

Syntaxe
for ligne in f:
    # traitement
Efficacité mémoire C'est la méthode la plus efficace en mémoire : Python ne charge qu'une ligne à la fois, ce qui est crucial pour les grands fichiers (plusieurs centaines de Mo ou Go).

Exemple — Afficher chaque ligne sans double saut de ligne

f = open("langages.txt", "r")
for ligne in f:
    print(ligne.strip())   # strip() supprime le \n
f.close()
Sortie
Python
Java
C++
MéthodeRetourUsage recommandé
f.read()str — tout le fichierPetits fichiers, traitement global
f.read(n)strn caractèresLecture partielle, protocoles binaires
f.readline()str — une ligneLecture séquentielle contrôlée
f.readlines()list[str] — toutes les lignesAccès aléatoire aux lignes (petits fichiers)
for ligne in fstr — ligne par ligne⭐ Méthode recommandée — grands fichiers

Écrire dans un fichier

Syntaxe
f.write(chaine)       # écrit la chaîne dans le fichier
f.writelines(liste)   # écrit toutes les chaînes de la liste
Remarque write() n'ajoute pas automatiquement de saut de ligne. Il faut explicitement écrire "\n" si nécessaire.

Exemple — Écriture dans un nouveau fichier

f = open("resultat.txt", "w")
f.write("Bonjour\n")
f.write("Python\n")
f.close()

Contenu du fichier resultat.txt obtenu :

Contenu du fichier
Bonjour
Python
Danger — Mode "w" Le mode "w" efface entièrement le contenu précédent du fichier avant d'écrire. Pour ajouter sans effacer le contenu existant, utiliser le mode "a".

Ajouter dans un fichier

Syntaxe
f = open("fichier.txt", "a")
f.write("Nouvelle ligne\n")
f.close()

Le mode "a" (append) place le curseur en fin de fichier : les données existantes sont préservées, et les nouvelles données sont ajoutées à la suite.

Astuce Si le fichier n'existe pas encore, le mode "a" le crée automatiquement, comme le mode "w". C'est donc la méthode sûre pour alimenter un fichier de log en continu.

Utilisation de with — méthode recommandée

Gestionnaire de contexte La construction with open(...) as f: est le gestionnaire de contexte de Python. Elle garantit la fermeture automatique du fichier en fin de bloc, même si une exception survient pendant le traitement.
Syntaxe
with open("donnees.txt", "r") as f:
    contenu = f.read()
# f est automatiquement fermé ici — même en cas d'erreur
Sans withAvec with
Fermeture manuelle obligatoire (f.close())Fermeture automatique en fin de bloc
Risque d'oubli si une exception est levéeSûr même en cas d'erreur
Code plus verbeuxCode plus lisible et concis
Fuite de ressource possibleRessources toujours libérées

Exemple — Lecture avec with

with open("donnees.txt", "r") as f:
    for ligne in f:
        print(ligne.strip())

Exemple — Écriture avec with

with open("resultat.txt", "w") as f:
    f.write("Ligne 1\n")
    f.write("Ligne 2\n")
Astuce — Encodage Pour éviter les problèmes avec les caractères accentués (é, à, ç…), précisez toujours l'encodage : open("fichier.txt", "r", encoding="utf-8").

Exemples complets

Compter les lignes d'un fichier

Écrire une fonction compter_lignes(nom) qui retourne le nombre de lignes d'un fichier texte.

def compter_lignes(nom_fichier):
    compteur = 0
    with open(nom_fichier, "r") as f:
        for ligne in f:
            compteur += 1
    return compteur

print(compter_lignes("donnees.txt"))  # Résultat : 3
Astuce — Version concise On peut aussi écrire de façon plus concise : return sum(1 for _ in open(nom_fichier)) mais la version avec with reste préférable pour la sécurité (fermeture garantie du fichier).

Sauvegarder une liste dans un fichier

Sauvegarder la liste [10, 20, 30, 40] dans le fichier nombres.txt, un nombre par ligne.

nombres = [10, 20, 30, 40]

with open("nombres.txt", "w") as f:
    for x in nombres:
        f.write(str(x) + "\n")

Fichier nombres.txt obtenu :

Contenu du fichier
10
20
30
40
Astuce — Version avec writelines On peut utiliser writelines pour écrire la liste en une seule instruction : f.writelines(str(x) + "\n" for x in nombres).

Lire un fichier de nombres

Écrire une fonction lire_nombres(fichier) qui lit nombres.txt et retourne une liste d'entiers.

def lire_nombres(fichier):
    L = []
    with open(fichier, "r") as f:
        for ligne in f:
            L.append(int(ligne.strip()))
    return L

print(lire_nombres("nombres.txt"))
Sortie
[10, 20, 30, 40]
Remarque strip() est indispensable ici pour supprimer le \n avant la conversion avec int(). Sans cela, Python lèverait une ValueError.

Statistiques sur un fichier

Écrire une fonction statistiques(fichier) qui lit un fichier de nombres entiers (un par ligne) et affiche leur somme, moyenne, minimum et maximum.

def statistiques(fichier):
    nombres = []
    with open(fichier, "r") as f:
        for ligne in f:
            nombres.append(int(ligne.strip()))

    n = len(nombres)
    print(f"Nb de valeurs : {n}")
    print(f"Somme         : {sum(nombres)}")
    print(f"Moyenne       : {sum(nombres)/n:.2f}")
    print(f"Minimum       : {min(nombres)}")
    print(f"Maximum       : {max(nombres)}")

statistiques("nombres.txt")
Sortie
Nb de valeurs : 4
Somme         : 100
Moyenne       : 25.00
Minimum       : 10
Maximum       : 40

Gestion des erreurs

Erreurs fréquentes Un programme robuste anticipeles situations d'erreur, notamment :
  • le fichier demandé n'existe pas (FileNotFoundError) ;
  • les permissions insuffisantes (PermissionError) ;
  • un format de données inattendu dans le fichier (ValueError).
Syntaxe — try / except
try:
    with open("donnees.txt", "r") as f:
        contenu = f.read()
except FileNotFoundError:
    print("Erreur : fichier introuvable.")
except PermissionError:
    print("Erreur : accès refusé.")

Exemple — Vérifier l'existence avant d'ouvrir

import os

nom = "donnees.txt"

if os.path.exists(nom):
    with open(nom, "r") as f:
        print(f.read())
else:
    print(f"Le fichier '{nom}' n'existe pas.")
Module os.path Le module os.pathoffre plusieurs fonctions utiles pour manipuler les chemins et vérifier l'état des fichiers :
  • os.path.exists(p) — vérifie si le chemin existe
  • os.path.isfile(p) — vérifie que c'est bien un fichier
  • os.path.getsize(p) — retourne la taille en octets
  • os.path.basename(p) — retourne le nom du fichier seul
  • os.path.dirname(p) — retourne le répertoire parent

Bonnes pratiques

Règles à respecter
  1. Toujours utiliser with open pour fermer automatiquement le fichier.
  2. Encadrer les opérations dans un try/except pour gérer les erreurs.
  3. Utiliser strip() lors de la lecture pour nettoyer les retours à la ligne.
  4. Préciser l'encodage si nécessaire : open("f.txt", "r", encoding="utf-8").
  5. Préférer la boucle for sur le fichier à readlines() pour les grands fichiers.

Exemple — Modèle complet et robuste

import os

def lire_fichier_robuste(nom_fichier):
    """Lit un fichier texte de façon sûre et retourne son contenu ligne par ligne."""
    if not os.path.isfile(nom_fichier):
        print(f"[ERREUR] Le fichier '{nom_fichier}' est introuvable.")
        return []
    try:
        lignes = []
        with open(nom_fichier, "r", encoding="utf-8") as f:
            for ligne in f:
                lignes.append(ligne.strip())
        return lignes
    except PermissionError:
        print(f"[ERREUR] Accès refusé au fichier '{nom_fichier}'.")
        return []

contenu = lire_fichier_robuste("donnees.txt")
for ligne in contenu:
    print(ligne)

Discussion (0)

Soyez le premier à laisser un commentaire !

Laisser un commentaire

Votre commentaire sera visible après modération.