27. Lire et écrire dans des fichiers

Jusqu’à présent, toutes les données de nos programmes étaient temporaires — stockées dans des variables qui disparaissent lorsque le programme se termine. Pour créer des programmes qui se souviennent d’informations entre deux exécutions, nous devons travailler avec des fichiers. Les fichiers nous permettent d’enregistrer des données sur disque et de les relire plus tard, ce qui rend possible aussi bien des paramètres de configuration que le stockage de données utilisateur.

Dans ce chapitre, vous apprendrez à lire et à écrire dans des fichiers texte en Python. Nous commencerons par comprendre les chemins de fichiers et la manière dont Python localise les fichiers, puis nous verrons l’ouverture, la lecture, l’écriture et la fermeture correcte des fichiers. Vous apprendrez différents modes de fichier, l’encodage du texte, et comment gérer les erreurs courantes qui surviennent lors des opérations sur les fichiers.

27.1) Chemins de fichiers et répertoire de travail courant

Avant de pouvoir travailler avec des fichiers, nous devons comprendre comment Python les localise sur le système de fichiers de votre ordinateur.

27.1.1) Comprendre les chemins de fichiers

Un chemin de fichier est l’adresse d’un fichier sur votre ordinateur. Il indique à Python exactement où trouver un fichier. Il existe deux types de chemins :

Les chemins absolus spécifient l’emplacement complet depuis la racine du système de fichiers :

• Windows : C:\Users\Alice\Documents\data.txt
• macOS/Linux : /home/alice/documents/data.txt

Les chemins relatifs spécifient un emplacement relatif au répertoire de travail courant :

• data.txt (fichier dans le répertoire courant)
• reports/sales.txt (fichier dans un sous-répertoire)
• ../config.txt (fichier dans le répertoire parent)

Le répertoire de travail courant(current working directory) (CWD) est le dossier où Python cherche les fichiers lorsque vous utilisez des chemins relatifs. Lorsque vous exécutez un script Python, le CWD est le répertoire depuis lequel vous avez lancé la commande, pas nécessairement celui où se trouve le fichier du script.

Par exemple :

# Directory structure:
/home/alice/
  └── projects/
      └── script.py
 
# Running from the projects folder:
$ cd /home/alice/projects
$ python script.py
# CWD is /home/alice/projects
 
# Running from the parent folder:
$ cd /home/alice
$ python projects/script.py
# CWD is /home/alice (not where script.py is!)

Vous pouvez vérifier le répertoire de travail courant avec :

import os
 
# Récupérer le répertoire de travail courant
current_dir = os.getcwd()
print(f"Current directory: {current_dir}")

Output:

Current directory: /home/alice/projects/file_demo

La fonction os.getcwd() renvoie le chemin absolu du répertoire de travail courant. C’est utile pour comprendre où Python cherchera les fichiers lorsque vous utilisez des chemins relatifs.

Comprendre le répertoire de travail courant est important parce qu’il détermine où Python cherchera lorsque vous utilisez un chemin relatif comme "data.txt". Si vous exécutez votre script depuis /home/alice/projects/ et ouvrez "data.txt", Python cherche /home/alice/projects/data.txt.

27.1.2) Utiliser efficacement les chemins relatifs

Quand vous travaillez avec des fichiers, les chemins relatifs sont souvent plus pratiques que les chemins absolus, car ils rendent votre code portable — il fonctionne quel que soit l’endroit où se trouve le dossier du projet sur différents ordinateurs.

Voici des schémas courants de chemins relatifs :

# Fichier dans le répertoire de travail courant
filename = "student_grades.txt"
 
# Fichier dans un sous-répertoire (dossier data dans le répertoire courant)
filename = "data/student_grades.txt"
 
# Fichier dans le répertoire parent
filename = "../shared_data.txt"

Pour les exemples de ce chapitre, nous utiliserons principalement des noms de fichiers simples comme "data.txt". Cela signifie :

• Les fichiers de données doivent se trouver dans le même répertoire où vous exécutez la commande Python
• Si votre script se trouve dans /home/alice/projects/ et que vous exécutez python script.py depuis ce répertoire, Python cherchera data.txt dans /home/alice/projects/

Cette approche rend les exemples clairs et centrés sur les opérations sur les fichiers plutôt que sur la navigation dans les chemins. Si vous obtenez une FileNotFoundError, utilisez os.getcwd() pour vérifier où Python cherche les fichiers.

27.1.3) Séparateurs de chemin selon les systèmes d’exploitation

Différents systèmes d’exploitation utilisent des caractères différents pour séparer les répertoires dans les chemins :

• Windows utilise des antislashs : data\reports\sales.txt
• macOS et Linux utilisent des slashs : data/reports/sales.txt

Python gère cela automatiquement lorsque vous utilisez des slashs dans votre code — ils fonctionnent sur tous les systèmes d’exploitation :

# Cela fonctionne sur Windows, macOS et Linux
filename = "data/reports/sales.txt"

Python convertit les slashs en séparateur approprié pour votre système d’exploitation.

27.2) Ouvrir et fermer des fichiers

Pour travailler avec un fichier, nous devons d’abord l’ouvrir, ce qui crée une connexion entre notre programme et le fichier sur disque. Quand nous avons terminé, nous devons le fermer afin de libérer les ressources système et de nous assurer que toutes les données sont correctement enregistrées.

27.2.1) La fonction open()

La fonction open() crée un objet fichier qui représente la connexion à un fichier. Dans sa forme la plus simple, vous fournissez le nom de fichier :

# Ouvrir un fichier en lecture (le mode par défaut)
file = open("message.txt")

Cela ouvre le fichier message.txt dans le répertoire courant. La fonction open() renvoie un objet fichier, que nous stockons dans la variable file. Cet objet fournit des méthodes pour lire depuis le fichier ou y écrire.

Cependant, cette approche de base a un problème critique : si une erreur survient après l’ouverture du fichier, le fichier pourrait ne jamais être fermé. Voyons pourquoi fermer les fichiers est important.

27.2.2) Pourquoi fermer les fichiers est important

Quand vous ouvrez un fichier, le système d’exploitation alloue des ressources pour maintenir cette connexion. Si vous ne fermez pas le fichier :

• Les données pourraient ne pas être enregistrées : lors de l’écriture dans des fichiers, les données sont souvent mises en tampon en mémoire et ne sont écrites sur disque que lorsque le fichier est fermé
• Les ressources système sont gaspillées : chaque fichier ouvert consomme de la mémoire et des descripteurs de fichiers
• D’autres programmes peuvent être bloqués : certains systèmes empêchent d’autres programmes d’accéder à un fichier déjà ouvert

Pour fermer un fichier, appelez sa méthode close() :

file = open("message.txt")
# ... travailler avec le fichier ...
file.close()  # Libérer les ressources et s’assurer que les données sont enregistrées

27.2.3) Le problème de la fermeture manuelle

Fermer les fichiers manuellement est source d’erreurs. Si une exception survient entre l’ouverture et la fermeture, l’appel à close() pourrait ne jamais s’exécuter :

file = open("data.txt")
result = process_data(file)  # Si cela lève une exception...
file.close()  # ...cela ne s’exécute jamais !

C’est un problème tellement courant que Python fournit une meilleure solution : l’instruction with, que nous verrons en section 27.4. Pour l’instant, comprenez que l’ouverture et la fermeture manuelles des fichiers demandent une attention particulière pour garantir que close() est toujours appelé.

27.2.4) Vérifier si un fichier est ouvert

Un objet fichier possède un attribut closed qui vous indique si le fichier est fermé :

file = open("data.txt")
print(file.closed)  # Output: False
 
file.close()
print(file.closed)  # Output: True

Une fois qu’un fichier est fermé, tenter de lire dedans ou d’y écrire lèvera une erreur :

file = open("data.txt")
file.close()
 
# This raises ValueError: I/O operation on closed file
content = file.read()

Le message d’erreur indique clairement le problème : vous essayez d’effectuer une opération d’E/S (entrée/sortie) sur un fichier déjà fermé.

27.3) Comprendre les modes de fichier (r, w, a, texte vs binaire) et l’encodage

Lorsque vous ouvrez un fichier, vous pouvez spécifier un mode qui détermine quelles opérations sont autorisées et comment le fichier est traité. Comprendre les modes est crucial pour travailler correctement avec les fichiers.

27.3.1) Mode texte vs mode binaire

Les fichiers peuvent être ouverts selon deux modes fondamentaux :

Le mode texte(text mode) (par défaut) traite le fichier comme contenant du texte. Python :

• Convertit les fins de ligne en \n quelle que soit la plateforme
• Gère l’encodage du texte (conversion entre bytes et chaînes)
• Permet de lire et d’écrire des chaînes

Le mode binaire(binary mode) traite le fichier comme des bytes bruts. Python :

• Lit et écrit des objets bytes, pas des chaînes
• Ne fait aucune conversion ni interprétation
• Est utilisé pour les images, l’audio, la vidéo et d’autres fichiers non textuels

Pour ce chapitre, nous nous concentrerons sur le mode texte, celui que vous utiliserez le plus souvent. Le mode binaire est indiqué en ajoutant 'b' à la chaîne de mode (comme 'rb' ou 'wb'), mais nous n’en aurons pas besoin pour des fichiers texte.

27.3.2) Les trois principaux modes de fichier

Python fournit trois modes principaux pour ouvrir des fichiers texte :

Le mode lecture('r') - Ouvre un fichier en lecture seule :

file = open("data.txt", "r")  # ou simplement open("data.txt")

• Le fichier doit déjà exister, sinon Python lève FileNotFoundError
• Vous pouvez lire le fichier mais vous ne pouvez pas y écrire
• C’est le mode par défaut si vous n’en spécifiez pas

Le mode écriture('w') - Ouvre un fichier en écriture :

file = open("output.txt", "w")

• Crée le fichier s’il n’existe pas
• Efface tout le contenu existant si le fichier existe déjà
• Vous pouvez écrire dans le fichier mais vous ne pouvez pas le lire
• Utilisez-le lorsque vous voulez créer un nouveau fichier ou remplacer complètement un fichier existant

Le mode ajout('a') - Ouvre un fichier en ajout (append) :

file = open("log.txt", "a")

• Crée le fichier s’il n’existe pas
• Préserve le contenu existant et ajoute le nouveau contenu à la fin
• Vous pouvez écrire dans le fichier mais vous ne pouvez pas le lire
• Utilisez-le lorsque vous voulez ajouter à un fichier existant sans perdre son contenu actuel

Voici une comparaison de la manière dont ces modes affectent un fichier existant :

# Supposons que data.txt contient : "Hello\nWorld\n"
 
# Mode lecture - contenu inchangé
file = open("data.txt", "r")
file.close()
# Le fichier contient toujours : "Hello\nWorld\n"
 
# Mode écriture - contenu effacé
file = open("data.txt", "w")
file.write("New content\n")
file.close()
# Le fichier contient maintenant : "New content\n"
 
# Mode ajout - contenu préservé, nouveau contenu ajouté
file = open("data.txt", "a")
file.write("Added line\n")
file.close()
# Le fichier contient maintenant : "New content\nAdded line\n"

27.3.3) Comprendre l’encodage du texte

Lorsque vous travaillez avec des fichiers texte, Python doit savoir comment convertir entre les bytes stockés sur disque et les caractères de chaîne dans votre programme. Ce processus de conversion s’appelle l’encodage(encoding).

L’encodage le plus courant est UTF-8, qui peut représenter n’importe quel caractère de n’importe quelle langue. C’est l’encodage par défaut en Python 3 et la norme pour les fichiers texte modernes.

# Spécifier explicitement l’encodage UTF-8 (même si c’est généralement le défaut)
file = open("data.txt", "r", encoding="utf-8")

Pourquoi l’encodage est-il important ? Considérez ce fichier texte contenant un nom avec un caractère accentué :

# Écrire un fichier avec des caractères spéciaux
file = open("names.txt", "w", encoding="utf-8")
file.write("José\n")
file.write("François\n")
file.write("Müller\n")
file.close()
 
# Le relire
file = open("names.txt", "r", encoding="utf-8")
content = file.read()
file.close()
print(content)

Output:

José
François
Müller

Si vous essayez d’ouvrir un fichier avec le mauvais encodage, vous pourriez voir des caractères illisibles ou obtenir une erreur. Utilisez toujours UTF-8 pour les nouveaux fichiers, sauf si vous avez une raison spécifique d’utiliser un encodage différent.

27.3.4) Variations de mode supplémentaires

Python fournit des caractères de mode supplémentaires qui peuvent être combinés avec les modes principaux :

Les modes plus permettent à la fois la lecture et l’écriture :

• 'r+' - Lecture et écriture (le fichier doit exister)
• 'w+' - Écriture et lecture (efface le contenu existant)
• 'a+' - Ajout et lecture (préserve le contenu existant)

Pour les débutants, il est plus clair d’ouvrir un fichier une fois pour le lire et séparément pour l’écrire plutôt que d’utiliser les modes plus. Nous nous en tiendrons aux modes simples ('r', 'w', 'a') dans ce chapitre.

27.4) Utiliser with pour gérer les fichiers automatiquement

L’instruction with fournit une manière plus propre et plus sûre de travailler avec des fichiers. Elle ferme automatiquement le fichier lorsque vous avez terminé, même si une erreur survient.

27.4.1) Syntaxe de l’instruction with

Voici comment utiliser with pour ouvrir un fichier :

with open("data.txt", "r") as file:
    content = file.read()
    print(content)
# Le fichier est automatiquement fermé ici

La syntaxe comporte plusieurs parties :

• with - Mot-clé qui démarre le gestionnaire de contexte(context manager)
• open("data.txt", "r") - Ouvre le fichier
• as file - Crée une variable pour référencer l’objet fichier
• : - Commence le bloc indenté
• Bloc indenté - Code qui travaille avec le fichier
• Après le bloc - Le fichier est automatiquement fermé

L’avantage clé : Python garantit que le fichier sera fermé quand le bloc with se termine, quelle que soit la façon dont il se termine (normalement, avec un return, ou à cause d’une exception).

27.4.2) Pourquoi with est meilleur que la fermeture manuelle

Comparez ces deux approches :

# Fermeture manuelle - risquée
file = open("data.txt", "r")
content = file.read()
result = process(content)  # Si cela lève une exception...
file.close()  # ...cela ne s’exécute jamais
 
# Utiliser with - sûr
with open("data.txt", "r") as file:
    content = file.read()
    result = process(content)  # Même si cela lève une exception...
# ...le fichier est quand même fermé automatiquement

L’instruction with utilise le protocole de gestionnaire de contexte(context manager protocol) de Python (que nous explorerons en détail au chapitre 28). Pour l’instant, voyez cela comme une garantie : « Je nettoierai cette ressource quand vous aurez terminé, quoi qu’il arrive. »

27.4.3) Travailler avec plusieurs fichiers

Vous pouvez ouvrir plusieurs fichiers dans une seule instruction with :

with open("input.txt", "r") as infile, open("output.txt", "w") as outfile:
    content = infile.read()
    outfile.write(content.upper())
# Les deux fichiers sont automatiquement fermés ici

C’est utile lorsque vous devez lire depuis un fichier et écrire dans un autre simultanément. Les deux fichiers sont garantis d’être correctement fermés, même si une erreur survient.

27.4.4) L’objet fichier n’est valide qu’à l’intérieur du bloc with

Une fois que le bloc with se termine, le fichier est fermé et vous ne pouvez plus utiliser l’objet fichier :

with open("data.txt", "r") as file:
    content = file.read()
    print("Inside with block:", file.closed)  # Output: Inside with block: False
 
print("Outside with block:", file.closed)  # Output: Outside with block: True
 
# This raises ValueError: I/O operation on closed file
more_content = file.read()

Ce comportement est intentionnel — il vous empêche d’utiliser accidentellement un fichier fermé. Si vous avez besoin du contenu du fichier en dehors du bloc with, stockez-le dans une variable (comme content ci-dessus) avant la fin du bloc.

À partir de maintenant dans le chapitre, nous utiliserons with pour toutes les opérations sur les fichiers. C’est l’approche recommandée et celle que vous devriez utiliser dans votre propre code.

27.5) Lire des fichiers texte

Maintenant que nous comprenons comment ouvrir des fichiers en toute sécurité avec with, explorons les différentes façons de lire le contenu de fichiers texte.

27.5.1) Lire tout le fichier avec read()

La méthode read() lit tout le contenu du fichier sous forme d’une seule chaîne :

with open("message.txt", "r") as file:
    content = file.read()
    print(content)

Si message.txt contient :

Welcome to Python!
This is a text file.
It has multiple lines.

Output:

Welcome to Python!
This is a text file.
It has multiple lines.

La méthode read() inclut tous les caractères de nouvelle ligne (\n) du fichier. Lorsque vous affichez la chaîne, Python affiche chaque ligne sur une ligne séparée grâce à ces caractères de nouvelle ligne.

Vous pouvez aussi lire un nombre spécifique de caractères en passant un nombre à read() :

with open("message.txt", "r") as file:
    first_ten = file.read(10)  # Lire les 10 premiers caractères
    print(f"First 10 characters: '{first_ten}'")

Output:

First 10 characters: 'Welcome to'

Lire le fichier entier est simple et fonctionne bien pour les petits fichiers. Cependant, pour les grands fichiers (mégaoctets ou gigaoctets), tout lire d’un coup peut consommer trop de mémoire. Dans ces cas, lire ligne par ligne est plus efficace.

27.5.2) Lire ligne par ligne avec readline()

La méthode readline() lit une seule ligne depuis le fichier, y compris le caractère de nouvelle ligne à la fin :

with open("message.txt", "r") as file:
    line1 = file.readline()
    line2 = file.readline()
    line3 = file.readline()
    print(f"Line 1: {line1}")
    print(f"Line 2: {line2}")
    print(f"Line 3: {line3}")

Output:

Line 1: Welcome to Python!
 
Line 2: This is a text file.
 
Line 3: It has multiple lines.
 

Remarquez les lignes vides supplémentaires dans la sortie. Chaque ligne lue depuis le fichier se termine par \n, et print() ajoute un autre saut de ligne. Pour éviter cela, utilisez la méthode rstrip() pour supprimer les espaces en fin de chaîne :

with open("message.txt", "r") as file:
    line1 = file.readline().rstrip()
    line2 = file.readline().rstrip()
    print(f"Line 1: {line1}")
    print(f"Line 2: {line2}")

Output:

Line 1: Welcome to Python!
Line 2: This is a text file.

Lorsque readline() atteint la fin du fichier, elle renvoie une chaîne vide "". Cela vous permet de détecter quand il n’y a plus de lignes à lire :

with open("message.txt", "r") as file:
    while True:
        line = file.readline()
        if line == "":  # Fin de fichier
            break
        print(line.rstrip())

Cependant, il existe une manière plus « Pythonique » de lire les fichiers ligne par ligne.

27.5.3) Itérer sur les lignes avec une boucle for

Les objets fichier sont itérables(iterable), ce qui signifie que vous pouvez les parcourir directement avec une boucle for. C’est la manière la plus courante et la plus Pythonique de lire un fichier ligne par ligne :

with open("message.txt", "r") as file:
    for line in file:
        print(line.rstrip())

Output:

Welcome to Python!
This is a text file.
It has multiple lines.

Cette approche est :

• Plus propre : pas besoin de readline() ni de vérifier des chaînes vides
• Plus efficace : Python lit le fichier par morceaux, sans charger tout le fichier en mémoire
• Plus Pythonique : utilise l’itération, qui est un concept central de Python

Chaque itération de la boucle lit la ligne suivante du fichier. Quand il n’y a plus de lignes, la boucle se termine automatiquement.

27.5.4) Lire toutes les lignes dans une liste avec readlines()

La méthode readlines() lit toutes les lignes du fichier et les renvoie sous forme d’une liste de chaînes :

with open("message.txt", "r") as file:
    lines = file.readlines()
 
print(f"Number of lines: {len(lines)}")
for i, line in enumerate(lines, start=1):
    print(f"Line {i}: {line.rstrip()}")

Output:

Number of lines: 3
Line 1: Welcome to Python!
Line 2: This is a text file.
Line 3: It has multiple lines.

Chaque élément de la liste est une chaîne contenant une ligne du fichier, y compris son caractère de nouvelle ligne. C’est utile lorsque vous devez :

• Accéder aux lignes par index : lines[0], lines[1], etc.
• Traiter les lignes plusieurs fois
• Connaître le nombre total de lignes avant le traitement

Cependant, comme read(), readlines() charge tout le fichier en mémoire. Pour les grands fichiers, itérer avec une boucle for est plus économe en mémoire.

27.6) Écrire dans des fichiers texte et ajouter du contenu

Écrire dans des fichiers est tout aussi important que les lire. Python fournit des méthodes simples pour créer de nouveaux fichiers ou modifier des fichiers existants.

27.6.1) Écrire dans un fichier avec write()

Pour écrire dans un fichier, ouvrez-le en mode écriture ('w') et utilisez la méthode write() :

with open("output.txt", "w") as file:
    file.write("Hello, World!\n")
    file.write("This is a new file.\n")

Après exécution de ce code, output.txt contient :

Hello, World!
This is a new file.

Points importants à propos de write() :

• Elle écrit une chaîne dans le fichier
• Elle n’ajoute pas automatiquement de caractères de nouvelle ligne — vous devez inclure \n vous-même
• Elle renvoie le nombre de caractères écrits (même si, en général, on l’ignore)
• Si le fichier existe déjà, le mode écriture efface tout le contenu existant avant d’écrire

Voyons ce qui se passe lorsque nous écrivons dans un fichier existant :

# D’abord, créer un fichier avec du contenu
with open("demo.txt", "w") as file:
    file.write("Original content\n")
 
# Maintenant, le rouvrir en mode écriture
with open("demo.txt", "w") as file:
    file.write("New content\n")
 
# Lire le fichier pour voir ce qu’il contient
with open("demo.txt", "r") as file:
    print(file.read())

Output:

New content

Le contenu original a disparu. Le mode écriture commence toujours avec un fichier vide, qu’il s’agisse de créer un nouveau fichier ou d’écraser un fichier existant.

27.6.2) Écrire plusieurs lignes

Vous pouvez appeler write() plusieurs fois pour écrire plusieurs lignes :

with open("shopping_list.txt", "w") as file:
    file.write("Apples\n")
    file.write("Bananas\n")
    file.write("Oranges\n")

27.6.3) Écrire des données depuis des collections

Une tâche courante consiste à écrire dans un fichier des données provenant de listes ou d’autres collections :

students = ["Alice", "Bob", "Carol", "David"]
 
with open("students.txt", "w") as file:
    for student in students:
        file.write(student + "\n")

Cela crée students.txt contenant :

Alice
Bob
Carol
David

27.6.4) Ajouter du contenu à un fichier

Quand vous voulez ajouter du contenu à la fin d’un fichier existant sans effacer ce qui s’y trouve déjà, utilisez le mode ajout ('a') :

# Créer un fichier avec un contenu initial
with open("log.txt", "w") as file:
    file.write("Program started\n")
 
# Plus tard, ajouter du contenu
with open("log.txt", "a") as file:
    file.write("Processing data\n")
    file.write("Processing complete\n")
 
# Lire le fichier pour voir tout le contenu
with open("log.txt", "r") as file:
    print(file.read())

Output:

Program started
Processing data
Processing complete

Le mode ajout est parfait pour les fichiers de log, où vous souhaitez conserver un historique continu des événements. Chaque fois que vous ouvrez le fichier en mode ajout, le nouveau contenu est ajouté à la fin, en préservant tout ce qui existait déjà.

27.7) Gérer les erreurs courantes d’E/S de fichiers

Les opérations sur les fichiers peuvent échouer pour de nombreuses raisons : le fichier n’existe pas, vous n’avez pas l’autorisation d’y accéder, le disque est plein, ou le fichier est déjà ouvert par un autre programme. Apprendre à gérer ces erreurs correctement rend vos programmes plus robustes et plus conviviaux.

27.7.1) FileNotFoundError : lorsqu’un fichier n’existe pas

L’erreur de fichier la plus courante se produit lorsque vous essayez de lire un fichier qui n’existe pas :

# ATTENTION : cela lèvera FileNotFoundError si data.txt n’existe pas
with open("data.txt", "r") as file:
    content = file.read()

Si data.txt n’existe pas, Python lève :

FileNotFoundError: [Errno 2] No such file or directory: 'data.txt'

Pour gérer cela proprement, utilisez un bloc try-except (comme nous l’avons appris au chapitre 25) :

try:
    with open("data.txt", "r") as file:
        content = file.read()
        print(content)
except FileNotFoundError:
    print("Error: The file 'data.txt' was not found.")
    print("Please check the filename and try again.")

Output (si le fichier n’existe pas) :

Error: The file 'data.txt' was not found.
Please check the filename and try again.

Cette approche empêche votre programme de planter et fournit un message utile à l’utilisateur.

27.7.2) PermissionError : lorsque vous ne pouvez pas accéder à un fichier

Parfois, vous n’avez pas la permission de lire ou d’écrire un fichier :

try:
    with open("/root/protected.txt", "r") as file:
        content = file.read()
except PermissionError:
    print("Error: You don't have permission to access this file.")

Les erreurs de permission peuvent survenir lorsque :

• Le fichier appartient à un autre utilisateur
• Le fichier se trouve dans un répertoire système protégé
• Le fichier est marqué en lecture seule et vous essayez d’y écrire
• Sous Windows, le fichier est ouvert dans un autre programme

27.7.3) IsADirectoryError : lorsque vous essayez d’ouvrir un répertoire

Si vous essayez par accident d’ouvrir un répertoire au lieu d’un fichier :

try:
    with open("my_folder", "r") as file:
        content = file.read()
except IsADirectoryError:
    print("Error: 'my_folder' is a directory, not a file.")

Cela peut arriver lorsque vous avez à la fois un fichier et un répertoire aux noms similaires, ou lorsque vous oubliez d’inclure le nom du fichier dans un chemin.

27.7.4) UnicodeDecodeError : lorsque l’encodage ne correspond pas

Si vous essayez de lire un fichier avec le mauvais encodage, vous pourriez obtenir une UnicodeDecodeError :

try:
    with open("data.txt", "r", encoding="utf-8") as file:
        content = file.read()
except UnicodeDecodeError:
    print("Error: The file encoding doesn't match UTF-8.")
    print("The file might use a different encoding.")

Cette erreur survient lorsque le fichier contient des bytes qui ne sont pas valides en UTF-8. Si vous rencontrez cela, le fichier pourrait :

• Utiliser un encodage différent (comme Latin-1 ou Windows-1252)
• Être un fichier binaire que vous essayez de lire comme du texte
• Être corrompu

27.7.5) Gérer plusieurs types d’erreurs

Vous pouvez intercepter plusieurs types d’erreurs dans un seul bloc try-except :

filename = input("Enter filename: ")
 
try:
    with open(filename, "r") as file:
        content = file.read()
        print(content)
except FileNotFoundError:
    print(f"Error: '{filename}' does not exist.")
except PermissionError:
    print(f"Error: You don't have permission to read '{filename}'.")
except IsADirectoryError:
    print(f"Error: '{filename}' is a directory, not a file.")
except UnicodeDecodeError:
    print(f"Error: '{filename}' contains invalid text encoding.")

Cela fournit des messages d’erreur spécifiques et utiles pour chaque type de problème. L’utilisateur sait exactement ce qui s’est mal passé et peut prendre les mesures appropriées.

27.7.6) Utiliser un gestionnaire d’exception fourre-tout

Parfois, vous voulez intercepter toute erreur inattendue liée aux fichiers au-delà des types spécifiques que nous avons couverts. Vous pouvez utiliser un gestionnaire général Exception comme fourre-tout après vos gestionnaires spécifiques :

filename = input("Enter filename: ")
 
try:
    with open(filename, "r") as file:
        content = file.read()
        print(content)
except FileNotFoundError:
    print(f"Error: '{filename}' not found.")
except PermissionError:
    print(f"Error: No permission to read '{filename}'.")
except IsADirectoryError:
    print(f"Error: '{filename}' is a directory.")
except UnicodeDecodeError:
    print(f"Error: '{filename}' has invalid encoding.")
except Exception as e:
    print(f"Unexpected error reading file: {e}")

Cela garantit que votre programme gère même des erreurs que vous n’aviez pas anticipées. La variable e contient l’objet exception, qui inclut un message d’erreur descriptif. L’afficher donne à l’utilisateur des détails techniques sur ce qui s’est mal passé.

Travailler avec des fichiers est une compétence fondamentale en programmation. Vous avez appris à :

• Comprendre les chemins de fichiers et le répertoire de travail courant
• Ouvrir et fermer correctement des fichiers
• Utiliser différents modes de fichier pour lire, écrire et ajouter
• Gérer automatiquement des fichiers avec l’instruction with
• Lire des fichiers en utilisant différentes méthodes (read(), readline(), itération, readlines())
• Écrire du contenu et en ajouter dans des fichiers
• Gérer correctement les erreurs courantes d’E/S de fichiers

Ces compétences vous permettent de créer des programmes qui persistent les données entre les exécutions, de traiter des fichiers texte, de générer des rapports, et bien plus encore. Dans le prochain chapitre, nous explorerons en profondeur les gestionnaires de contexte(context managers), en comprenant le mécanisme qui permet à l’instruction with de fonctionner et comment créer vos propres gestionnaires de contexte pour gérer des ressources au-delà des fichiers.