Lire des fichiers en Python – Guide complet

La lecture de fichiers est l'une des tâches les plus courantes en Python — que ce soit pour charger une configuration, traiter des journaux, importer des données CSV ou lire des ressources binaires. Ce chapitre couvre toutes les méthodes que Python propose pour lire le contenu d'un fichier : du plus simple appel read() à l'itération ligne par ligne économe en mémoire, en passant par le mode binaire, la gestion de l'encodage, le contrôle de la position dans le fichier et l'API moderne pathlib.

Ouvrir un fichier en lecture

Toute opération sur les fichiers commence par la fonction intégrée open(). Pour ouvrir un fichier en mode lecture, utilisez la chaîne de mode "r" (qui est la valeur par défaut quand aucun mode n'est précisé) :

file_object = open("notes.txt", "r", encoding="utf-8")

• "r" — ouvre en lecture ; lève FileNotFoundError si le fichier n'existe pas.
• encoding="utf-8" — spécifiez toujours l'encodage des caractères pour les fichiers texte afin que votre code fonctionne de manière identique sur Windows, macOS et Linux.

Toujours utiliser un bloc with

La façon la plus sûre d'ouvrir un fichier est d'utiliser une instruction with. Python ferme automatiquement le fichier à la sortie du bloc — même si une exception survient — ce qui évite les fuites de ressources et garantit que toutes les données en mémoire tampon sont vidées.

with open("notes.txt", "r", encoding="utf-8") as f:
    contents = f.read()
# File is automatically closed here

Appeler open() en dehors d'un bloc with et oublier file.close() est une source fréquente d'erreurs « trop de fichiers ouverts » dans les scripts à longue durée d'exécution.

Lire l'intégralité du fichier avec read()

read() retourne le contenu complet du fichier sous forme d'une seule chaîne de caractères.

Lire un fichier entier en une fois

with open("notes.txt", "r", encoding="utf-8") as f:
    contents = f.read()

print(contents)

Utilisez read() quand :

• Le fichier est suffisamment petit pour tenir confortablement en mémoire.
• Vous avez besoin du texte complet sous forme d'une seule chaîne (par exemple pour l'analyser ou y faire une recherche).

Pour les fichiers potentiellement volumineux (journaux, dumps de données), préférez les approches ligne par ligne décrites ci-dessous.

Lire un nombre fixe de caractères

Passez un entier n à read(n) pour lire au plus n caractères à partir de la position actuelle. Les appels suivants à read(n) reprennent là où le dernier s'est arrêté.

Lire les 50 premiers caractères

with open("notes.txt", "r", encoding="utf-8") as f:
    first_chunk = f.read(50)
    second_chunk = f.read(50)

print(repr(first_chunk))
print(repr(second_chunk))

Cette approche par blocs est utile lorsque vous souhaitez prévisualiser un fichier ou le traiter en morceaux de taille fixe sans tout charger en mémoire.

Lire une ligne à la fois avec readline()

readline() lit une ligne du fichier, incluant le caractère de saut de ligne \n en fin de ligne. Il retourne une chaîne vide "" quand la fin du fichier est atteinte, ce qui facilite l'itération jusqu'à la fin de fichier.

Lire un fichier ligne par ligne avec readline()

with open("notes.txt", "r", encoding="utf-8") as f:
    line = f.readline()
    while line:
        print(line, end="")   # line already contains '\n'
        line = f.readline()

L'argument end="" dans print() empêche l'apparition d'un double saut de ligne (l'un provenant de la ligne du fichier et l'autre du comportement par défaut de print).

readline() est utile lorsque vous devez traiter une ligne d'en-tête différemment du reste, ou lorsque vous souhaitez arrêter la lecture en cours de fichier selon une condition.

Itérer sur les lignes (façon la plus pythonique)

Itérer directement sur un objet fichier est la manière la plus idiomatique et la plus économe en mémoire de traiter un fichier texte ligne par ligne. Python lit une ligne à la fois sans charger l'intégralité du fichier en mémoire.

Itérer sur les lignes avec une boucle for

with open("notes.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line, end="")

Ce modèle est préférable à read() + split("\n") et à l'appel de readline() dans une boucle while, car il est plus court et gère correctement tous les cas limites (y compris les fichiers qui ne se terminent pas par un saut de ligne).

Rechercher un motif lors de l'itération

with open("server.log", "r", encoding="utf-8") as f:
    for line in f:
        if "ERROR" in line:
            print(line, end="")

Lire toutes les lignes dans une liste avec readlines()

readlines() retourne une liste dont chaque élément est une ligne du fichier (avec le caractère de saut de ligne inclus). Cela charge l'intégralité du fichier en mémoire.

Lire toutes les lignes dans une liste

with open("notes.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()

print(lines[0])        # first line
print(lines[-1])       # last line
print(len(lines))      # total number of lines

Utilisez readlines() lorsque vous avez besoin d'un accès aléatoire à des lignes spécifiques par index. Pour un traitement séquentiel du début à la fin, le modèle for line in f est plus économe en mémoire.

Supprimer les caractères de saut de ligne

Les lignes retournées par readline(), readlines() et l'itération avec for incluent toutes le \n final. Utilisez .strip() ou .rstrip("\n") pour le supprimer :

with open("notes.txt", "r", encoding="utf-8") as f:
    lines = [line.rstrip("\n") for line in f]

print(lines)  # ['Line one', 'Line two', 'Line three']

Choisir la bonne méthode de lecture

Position dans le fichier : tell() et seek()

Tout objet fichier ouvert maintient un pointeur de position interne qui avance au fil de la lecture. Deux méthodes permettent de l'inspecter et de le contrôler :

• tell() — retourne le décalage en octets depuis le début du fichier.
• seek(offset, whence=0) — déplace le pointeur. Avec whence=0 (valeur par défaut), le décalage est calculé depuis le début ; whence=1 depuis la position actuelle ; whence=2 depuis la fin.

Lire un fichier deux fois en utilisant seek(0)

with open("notes.txt", "r", encoding="utf-8") as f:
    first_pass = f.read()
    print(f"Position after first read: {f.tell()}")

    f.seek(0)   # rewind to the beginning
    second_pass = f.read()

print(first_pass == second_pass)  # True

seek() est particulièrement utile en mode "r+" (lecture et écriture), où vous pourriez lire une section d'un fichier puis écraser une partie spécifique dans le même appel à open().

Gestion des erreurs lors de la lecture

Un script bien écrit anticipe toujours les façons dont la lecture d'un fichier peut échouer.

Gérer les erreurs de lecture courantes

try:
    with open("data.txt", "r", encoding="utf-8") as f:
        content = f.read()
except FileNotFoundError:
    print("Error: the file does not exist.")
except PermissionError:
    print("Error: you do not have permission to read this file.")
except UnicodeDecodeError:
    print("Error: the file contains bytes that are not valid UTF-8.")
except OSError as e:
    print(f"OS error: {e}")

Exceptions courantes que vous rencontrerez :

Consultez Python Try Except pour un guide complet sur la gestion des exceptions.

Encodage des caractères

Lorsque Python ouvre un fichier en mode texte, il doit savoir comment convertir les octets bruts en caractères. Passez toujours encoding= explicitement plutôt que de vous fier à la valeur par défaut de la plateforme, qui diffère entre Windows (cp1252) et la plupart des systèmes Unix (utf-8).

Valeurs d'encodage courantes :

Détecter ou ignorer les problèmes d'encodage :

Si vous n'êtes pas sûr de l'encodage d'un fichier, vous pouvez demander à Python de remplacer les octets non décodables par un caractère de remplacement plutôt que de lever une erreur :

with open("mystery.txt", "r", encoding="utf-8", errors="replace") as f:
    content = f.read()

Les autres valeurs pour errors sont "ignore" (ignorer silencieusement les octets incorrects) et "strict" (par défaut — lève UnicodeDecodeError).

Lire des fichiers binaires

Ouvrez un fichier en mode binaire en ajoutant "b" à la chaîne de mode ("rb"). Le mode binaire retourne des objets bytes bruts au lieu de chaînes de caractères, ce qui convient aux images, à l'audio, aux archives compressées, aux exécutables et à toute donnée non textuelle.

Lire un fichier binaire

with open("photo.jpg", "rb") as f:
    data = f.read()

print(type(data))   # <class 'bytes'>
print(len(data))    # size in bytes

Copier un fichier binaire

with open("photo.jpg", "rb") as src:
    data = src.read()

with open("photo_backup.jpg", "wb") as dst:
    dst.write(data)

Ne spécifiez pas encoding en mode binaire — Python lève ValueError si vous essayez.

Lire efficacement de grands fichiers

Charger un fichier de plusieurs gigaoctets avec read() peut épuiser la mémoire système. Les solutions sont :

Itération ligne par ligne (fichiers texte)

with open("huge_log.txt", "r", encoding="utf-8") as f:
    for line in f:
        process(line)   # only one line in memory at a time

Blocs de taille fixe (fichiers binaires)

CHUNK_SIZE = 65536  # 64 KB

with open("large_file.bin", "rb") as f:
    while True:
        chunk = f.read(CHUNK_SIZE)
        if not chunk:
            break
        process(chunk)

Ces deux modèles maintiennent une utilisation mémoire constante quelle que soit la taille du fichier.

Lire des fichiers avec pathlib

Python 3.4 a introduit pathlib.Path, qui fournit une interface orientée objet aux chemins du système de fichiers. Pour des lectures et écritures simples en une seule fois, les objets Path sont plus concis que open().

Lire du texte avec Path.read_text()

from pathlib import Path

content = Path("notes.txt").read_text(encoding="utf-8")
print(content)

Lire des octets avec Path.read_bytes()

from pathlib import Path

data = Path("photo.jpg").read_bytes()
print(len(data))  # file size in bytes

read_text() et read_bytes() ouvrent le fichier, lisent son contenu entier et le ferment en un seul appel. Utilisez-les pour les petits fichiers lorsque vous avez juste besoin du contenu. Utilisez open() avec un bloc with lorsque vous avez besoin d'une itération ligne par ligne, d'une lecture par blocs, de seek() ou de tout autre contrôle fin.

Vérifier qu'un fichier existe avant de le lire

from pathlib import Path

p = Path("data.txt")
if p.exists() and p.is_file():
    content = p.read_text(encoding="utf-8")
else:
    print("File not found.")

Remarque : p.exists() peut retourner un résultat obsolète dans du code multi-threadé. Dans ces cas, il est plus sûr de tenter la lecture et d'intercepter FileNotFoundError.

Exemple pratique : lire un simple fichier de configuration

De nombreux scripts lisent un fichier de configuration en texte brut qui stocke une paire key=value par ligne. Voici un exemple complet et fonctionnel :

Analyser un fichier de configuration key=value

from pathlib import Path

def load_config(path):
    config = {}
    with open(path, "r", encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if not line or line.startswith("#"):
                continue          # skip blank lines and comments
            key, _, value = line.partition("=")
            config[key.strip()] = value.strip()
    return config

# Example config.txt contents:
# host = localhost
# port = 8080
# debug = true

config = load_config("config.txt")
# config == {'host': 'localhost', 'port': '8080', 'debug': 'true'}

str.partition("=") divise uniquement sur le premier =, de sorte que les valeurs contenant = (comme les chaînes Base64) sont gérées correctement.

Chapitres associés

• Python File Handling — modes d'ouverture, instruction with, seek(), fichiers binaires, aperçu de pathlib
• Python Write / Create Files — écriture, création et ajout de contenu dans des fichiers
• Python Delete Files — suppression de fichiers et de répertoires en toute sécurité
• Python Try Except — gestion des exceptions en Python
• Python CSV — lecture et écriture de fichiers CSV avec le module csv