Maîtriser la gestion des fichiers en Python

La gestion des fichiers est une compétence essentielle en Python. Elle permet de lire, écrire et manipuler des données stockées dans des fichiers sur le disque dur. Que ce soit pour traiter des fichiers texte, des données structurées ou pour enregistrer les résultats d’un programme, savoir comment gérer les fichiers est indispensable pour tout développeur en Python.

Pourquoi gérer les fichiers en Python

Les fichiers sont un moyen courant de stocker et d’échanger des données. En Python, la gestion des fichiers permet de :

• Lire des données depuis des fichiers pour les traiter ou les analyser.
• Écrire des données dans des fichiers pour les sauvegarder ou les partager.
• Manipuler différents types de fichiers, tels que les fichiers texte, CSV, JSON, etc.
• Automatiser des tâches liées au traitement de données, comme la génération de rapports ou la transformation de données.

Comprendre comment interagir avec les fichiers permet de développer des applications plus complètes et utiles.

Ouvrir et fermer des fichiers

Pour travailler avec un fichier en Python, il faut d’abord l’ouvrir en utilisant la fonction intégrée open(). Cette fonction retourne un objet fichier qui peut être utilisé pour lire ou écrire dans le fichier. Une fois les opérations terminées, il est important de fermer le fichier en appelant la méthode close() pour libérer les ressources.

Syntaxe de base :

fichier = open('chemin/vers/fichier.txt', mode)
## Opérations sur le fichier
fichier.close()

Le paramètre mode spécifie le mode d’ouverture du fichier, comme lecture ou écriture.

Exemple d’ouverture en lecture :

fichier = open('donnees.txt', 'r')
## Lecture du fichier
fichier.close()

Exemple d’ouverture en écriture :

fichier = open('resultats.txt', 'w')
## Écriture dans le fichier
fichier.close()

Il est essentiel de fermer le fichier après utilisation pour éviter les fuites de ressources et les problèmes de corruption de données.

Lire des fichiers

Une fois le fichier ouvert en mode lecture, plusieurs méthodes permettent de lire son contenu.

Lire tout le contenu

La méthode read() lit tout le contenu du fichier et le retourne sous forme de chaîne de caractères.

Exemple :

fichier = open('donnees.txt', 'r')
contenu = fichier.read()
print(contenu)
fichier.close()

Lire ligne par ligne

La méthode readline() lit une seule ligne à la fois.

Exemple :

fichier = open('donnees.txt', 'r')
ligne = fichier.readline()
while ligne:
    print(ligne.strip())
    ligne = fichier.readline()
fichier.close()

Lire toutes les lignes

La méthode readlines() retourne une liste contenant toutes les lignes du fichier.

Exemple :

fichier = open('donnees.txt', 'r')
lignes = fichier.readlines()
for ligne in lignes:
    print(ligne.strip())
fichier.close()

Itérer sur le fichier

Il est également possible d’itérer directement sur l’objet fichier.

Exemple :

fichier = open('donnees.txt', 'r')
for ligne in fichier:
    print(ligne.strip())
fichier.close()

Cette méthode est efficace pour les fichiers volumineux car elle lit une ligne à la fois.

Écrire dans des fichiers

Pour écrire dans un fichier, il faut l’ouvrir en mode écriture ('w'), ajout ('a') ou lecture-écriture ('r+').

Écrire du texte

La méthode write() permet d’écrire une chaîne de caractères dans le fichier.

Exemple :

fichier = open('resultats.txt', 'w')
fichier.write('Ceci est un test.\n')
fichier.write('Écriture dans un fichier en Python.\n')
fichier.close()

Écrire plusieurs lignes

Il est possible d’écrire une liste de lignes avec la méthode writelines().

Exemple :

lignes = ['Ligne 1\n', 'Ligne 2\n', 'Ligne 3\n']
fichier = open('resultats.txt', 'w')
fichier.writelines(lignes)
fichier.close()

Ajouter du contenu à un fichier existant

En ouvrant le fichier en mode ajout ('a'), le nouveau contenu est ajouté à la fin du fichier sans effacer le contenu existant.

Exemple :

fichier = open('resultats.txt', 'a')
fichier.write('Nouvelle ligne ajoutée.\n')
fichier.close()

Modes d’ouverture des fichiers

Le paramètre mode de la fonction open() détermine comment le fichier est ouvert.

• 'r' : Lecture seule. Le fichier doit exister.
• 'w' : Écriture seule. Crée un nouveau fichier ou écrase le fichier existant.
• 'a' : Ajout. Écrit à la fin du fichier s’il existe, sinon le crée.
• 'r+' : Lecture et écriture. Le fichier doit exister.
• 'w+' : Lecture et écriture. Crée un nouveau fichier ou écrase le fichier existant.
• 'a+' : Lecture et ajout. Lit et ajoute à la fin du fichier.

On peut ajouter 'b' pour le mode binaire (par exemple, 'rb' pour lire un fichier binaire).

Exemple d’ouverture en mode binaire :

fichier = open('image.png', 'rb')
contenu = fichier.read()
fichier.close()

Utiliser le bloc ‘with’

L’utilisation du mot-clé with permet de gérer automatiquement l’ouverture et la fermeture du fichier, même en cas d’exception. Cela rend le code plus sûr et plus lisible.

Syntaxe :

with open('chemin/vers/fichier.txt', mode) as fichier:
    # Opérations sur le fichier

Le fichier est automatiquement fermé à la fin du bloc with.

Exemple :

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

Travailler avec différents formats de fichiers

Fichiers CSV

Les fichiers CSV (Comma-Separated Values) sont couramment utilisés pour stocker des données tabulaires.

Lecture d’un fichier CSV :

import csv

with open('donnees.csv', 'r') as fichier_csv:
    lecteur = csv.reader(fichier_csv)
    for ligne in lecteur:
        print(ligne)

Écriture dans un fichier CSV :

import csv

donnees = [['Nom', 'Age'], ['Alice', '30'], ['Bob', '25']]

with open('resultats.csv', 'w', newline='') as fichier_csv:
    ecrivain = csv.writer(fichier_csv)
    ecrivain.writerows(donnees)

Fichiers JSON

Les fichiers JSON (JavaScript Object Notation) sont utilisés pour stocker des données structurées de manière hiérarchique.

Lecture d’un fichier JSON :

import json

with open('donnees.json', 'r') as fichier_json:
    donnees = json.load(fichier_json)
    print(donnees)

Écriture dans un fichier JSON :

import json

donnees = {'nom': 'Alice', 'age': 30, 'ville': 'Paris'}

with open('resultats.json', 'w') as fichier_json:
    json.dump(donnees, fichier_json)

Les exceptions liées aux fichiers

Lors de la gestion des fichiers, plusieurs exceptions peuvent survenir, comme FileNotFoundError, PermissionError ou IOError. Il est important de gérer ces exceptions pour rendre le programme plus robuste.

Exemple de gestion d’exception :

try:
    with open('inexistant.txt', 'r') as fichier:
        contenu = fichier.read()
except FileNotFoundError:
    print("Erreur : le fichier n'a pas été trouvé.")
except PermissionError:
    print("Erreur : permissions insuffisantes pour ouvrir le fichier.")
except Exception as e:
    print(f"Erreur inattendue : {e}")

Exercice

Enoncé

L’objectif de ce programme est de lire un fichier texte contenant des informations sur des utilisateurs, traiter ces informations et les afficher de manière formatée. Le programme est conçu pour gérer les erreurs courantes, comme l’absence du fichier ou un mauvais formatage des données dans le fichier.

Ce que doit contenir le programme :

1. Une fonction pour lire le fichier : Le programme lit un fichier texte contenant des informations utilisateur. Le fichier contient plusieurs lignes, chaque ligne ayant le format : nom,age,ville.
2. Une fonction pour traiter les lignes : Le programme doit analyser chaque ligne, en extraire les informations et les traiter.
3. Une fonction pour afficher les informations : Le programme doit afficher les informations extraites (nom, âge, ville) de manière lisible.
4. Gestion des erreurs :
   • Gérer les erreurs lorsque le fichier est absent (afficher un message approprié).
   • Gérer les erreurs lorsque certaines lignes sont mal formatées (afficher un message indiquant la ligne problématique).
5. Une fonction principale : C’est le point d’entrée du programme qui gère l’exécution des différentes étapes.

Fonctionnement du programme :

1. Lecture du fichier texte :
   • Le programme commence par lire un fichier texte contenant des informations d’utilisateurs.
   • Le fichier à lire s’appelle utilisateurs.txt et doit être placé dans le même répertoire que le programme.
   • Chaque ligne du fichier doit être formatée comme ceci : nom,âge,ville. Par exemple :

     Alice,30,Paris
     Bob,25,Lyon

2. Gestion des erreurs lors de la lecture :
   • Si le fichier n’existe pas, le programme affiche un message d’erreur : Erreur : Le fichier 'utilisateurs.txt' n'a pas été trouvé.
   • Si le fichier est trouvé, il lit toutes les lignes et les renvoie pour être traitées.
3. Traitement des lignes :
   • Le programme analyse chaque ligne lue à partir du fichier.
   • Il s’attend à ce que chaque ligne soit correctement formatée avec trois éléments séparés par des virgules : nom, âge, ville.
   • Si une ligne n’est pas correctement formatée, le programme affiche un message d’erreur spécifique à cette ligne : Erreur de format : 'ligne' ne contient pas les informations attendues.
4. Affichage des informations :
   • Pour chaque ligne correctement formatée, le programme affiche les informations de l’utilisateur de manière claire : Nom: Alice, Âge: 30, Ville: Paris
5. Exécution du programme :
   • Lorsque le programme est lancé, il exécute la fonction principale, qui lit le fichier, traite les lignes et affiche les résultats.

Réponse

Étape 1 : Lecture simple d’un fichier sans fonction

Nous commençons par écrire un programme très simple qui lit un fichier nommé utilisateurs.txt et affiche son contenu.

Voici un fichier exemple utilisateurs.txt :

Alice,30,Paris
Bob,25,Lyon
Claire,28,Marseille

Commençons par écrire un programme qui ouvre puis lit le fichier, affiche chaque ligne dans une boucle et finit par fermer le fichier :

# Lecture du fichier utilisateurs.txt
fichier = open('utilisateurs.txt', 'r')
lignes = fichier.readlines()

# Afficher chaque utilisateur
for ligne in lignes:
    print(ligne.strip())  # .strip() pour enlever les espaces et retours à la ligne

fichier.close()

Explication :

• open() : Ouvre le fichier en mode lecture ('r').
• readlines() : Lit toutes les lignes du fichier et les stocke dans une liste.
• strip() : Supprime les espaces inutiles et les sauts de ligne à la fin de chaque ligne.

Sortie attendue :

Alice,30,Paris
Bob,25,Lyon
Claire,28,Marseille

Étape 2 : Ajout de la gestion des exceptions

Nous allons maintenant gérer les erreurs courantes qui peuvent survenir lors de la lecture du fichier, comme un fichier qui n’existe pas. Si le fichier utilisateurs.txt n’est pas trouvé, une erreur FileNotFoundError est levée.

Code avec gestion d’erreurs (toujours sans fonction) :

# Gestion des erreurs lors de la lecture du fichier
try:
    fichier = open('utilisateurs.txt', 'r')
    lignes = fichier.readlines()

    # Afficher chaque utilisateur
    for ligne in lignes:
        print(ligne.strip())

    fichier.close()

except FileNotFoundError:
    print("Erreur : Le fichier 'utilisateurs.txt' n'a pas été trouvé.")

** Explication :**

• Bloc try : Le code susceptible de lever une exception est placé dans ce bloc.
• FileNotFoundError : Si le fichier n’existe pas, cette exception est levée et le programme affiche un message d’erreur au lieu de planter.

**Cas de fichier manquant: **

Si le fichier utilisateurs.txt n’existe pas, le programme affiche :

Erreur : Le fichier 'utilisateurs.txt' n'a pas été trouvé.

Étape 3 : Ajouter une vérification du format des lignes

Maintenant, nous allons ajouter une gestion des erreurs au cas où une ligne dans le fichier serait mal formatée. Par exemple, si une ligne ne contient pas trois éléments (nom, âge, ville), nous afficherons un message d’erreur spécifique pour cette ligne.

Code avec gestion des erreurs de format (sans fonction) :

# Gestion des erreurs lors de la lecture du fichier et du format des lignes
try:
    fichier = open('utilisateurs.txt', 'r')
    lignes = fichier.readlines()

    # Traitement de chaque ligne utilisateur
    for ligne in lignes:
        try:
            nom, age, ville = ligne.strip().split(',')
            print(f"Nom: {nom}, Âge: {age}, Ville: {ville}")
        except ValueError:
            print(f"Erreur de format : '{ligne.strip()}' ne contient pas les informations attendues.")

    fichier.close()

except FileNotFoundError:
    print("Erreur : Le fichier 'utilisateurs.txt' n'a pas été trouvé.")

Explication :

• Bloc try dans un try : Le premier bloc try gère les erreurs liées à l’ouverture du fichier, tandis que le second gère les erreurs liées au format des lignes.
• ValueError : Si une ligne ne peut pas être divisée en trois éléments par split(','), une exception ValueError est levée.

Étape 4 : Refactorisation avec des fonctions

Maintenant que notre code fonctionne correctement, nous allons l’organiser en fonctions pour le rendre plus lisible, modulaire et maintenable. Cela nous permet aussi de réutiliser des parties de code et de séparer les responsabilités dans notre programme.

Code refactorisé avec des fonctions :

#!/usr/bin/env python3
# Auteur : Stéphane ROBERT
# Date : 2024-09-04
# Description : Ce programme lit un fichier texte contenant des informations
#               sur des utilisateurs, les traite et les affiche. Il gère les erreurs
#               liées à l'absence du fichier et aux lignes mal formatées.

# Fonction pour lire le fichier
def lire_fichier(nom_fichier):
    try:
        with open(nom_fichier, 'r') as fichier:
            return fichier.readlines()  # Lire toutes les lignes du fichier
    except FileNotFoundError:
        print(f"Erreur : Le fichier '{nom_fichier}' n'a pas été trouvé.")
        return None

# Fonction pour traiter les lignes du fichier
def traiter_lignes(lignes):
    for ligne in lignes:
        try:
            nom, age, ville = ligne.strip().split(',')
            afficher_utilisateur(nom, age, ville)
        except ValueError:
            print(f"Erreur de format : '{ligne.strip()}' ne contient pas les informations attendues.")

# Fonction pour afficher les informations d'un utilisateur
def afficher_utilisateur(nom, age, ville):
    print(f"Nom: {nom}, Âge: {age}, Ville: {ville}")

# Fonction principale pour exécuter le programme
def programme_principal():
    nom_fichier = 'utilisateurs.txt'
    lignes = lire_fichier(nom_fichier)

    if lignes:
        traiter_lignes(lignes)

# Exécution du programme
if __name__ == '__main__':
    programme_principal()

Explication :

1. lire_fichier() : Ouvre le fichier et retourne les lignes. Si le fichier est manquant, un message d’erreur est affiché.
2. traiter_lignes() : Traite chaque ligne en la découpant et en vérifiant si elle respecte le bon format (nom, âge, ville).
3. afficher_utilisateur() : Affiche les informations d’un utilisateur sous forme formatée.
4. programme_principal() : Fonction principale qui orchestre la lecture et le traitement des données.

Bonnes pratiques pour la gestion des fichiers

• Utiliser le bloc with pour assurer la fermeture automatique des fichiers.
• Gérer les exceptions pour informer l’utilisateur en cas d’erreur.
• Spécifier le bon encodage lors de l’ouverture des fichiers texte (par défaut 'utf-8').

Exemple avec encodage :

with open('donnees.txt', 'r', encoding='utf-8') as fichier:
    contenu = fichier.read()

• Éviter d’utiliser des chemins de fichiers en dur. Utiliser le module os ou pathlib pour construire des chemins indépendants du système d’exploitation.

Exemple avec pathlib :

from pathlib import Path

chemin = Path('dossier') / 'fichier.txt'
with open(chemin, 'r') as fichier:
    contenu = fichier.read()

• Ne pas oublier de fermer les fichiers si le bloc with n’est pas utilisé.

Conclusion

La gestion des fichiers en Python est une compétence fondamentale pour tout développeur. Elle permet de lire et d’écrire des données, de manipuler différents formats de fichiers et d’automatiser de nombreuses tâches liées au traitement de données. En maîtrisant les méthodes d’ouverture, de lecture, d’écriture et en adoptant les bonnes pratiques, il est possible de créer des programmes robustes et efficaces.

Note

Ce cours n’est qu’une partie de la formation Python :

• Débutez avec Python
• Écrire des fonctions en Python
• Formatez les chaînes de caractères en Python
• Utiliser des listes en Python
• Utiliser des tuples en Python
• Utiliser des dictionnaires en Python
• Maîtriser la gestion des exceptions en Python
• Utiliser des Templates Jinja
• Utiliser des Environnements Virtuels Python
• Créer des Modules et des Packages Python
• Les bases de la P.O.O
• Manipuler des données au format JSON
• Manipuler des données au format YAML
• Tracer les informations de votre application avec Logging
• Utiliser les décorateurs
• Améliorer la qualité de votre code

De nouveaux cours viendront s’ajouter bientôt !