Gestion de fichiers Python : lire, écrire et ajouter des fichiers en sécurité

Les fichiers, c'est juste des chaînes avec un chemin

La plupart des programmes finissent par avoir besoin de lire ou d'écrire un fichier — configs, données utilisateur, logs, exports CSV, petits caches. Python garde ça simple avec une seule fonction intégrée, open(), plus un bloc with pour s'assurer que les choses se ferment proprement.

Parcourons les cas courants.

Lire un fichier entier

La lecture la plus simple :

with open("notes.txt") as f:
    contents = f.read()

print(contents)

open("notes.txt") ouvre le fichier en lecture (le défaut). Le bloc with veut dire que Python fermera le fichier quand tu sortiras du bloc — même si une exception est levée. Une fois fermé, tu ne peux plus utiliser f ; le texte vit dans contents.

contents est une seule chaîne contenant tout le fichier. Bien pour les petits fichiers ; mauvais pour un log de 2 Go.

Lire ligne par ligne

Pour les fichiers plus grands, itère au lieu de tout lire en mémoire :

with open("big.log") as f:
    for line in f:
        if "ERROR" in line:
            print(line.strip())

Chaque itération produit une ligne y compris le retour à la ligne final — c'est pour ça que .strip() apparaît si souvent. Si tu veux une liste de lignes, f.readlines() le fait, mais généralement l'itération directe est ce que tu veux.

Écrire un fichier

Pour écrire, passe le mode comme second argument :

with open("output.txt", "w") as f:
    f.write("first line\n")
    f.write("second line\n")

Deux choses à noter :

• "w" écrase. Si output.txt existe déjà, son contenu disparaît au moment où open s'exécute.
• Tu dois ajouter les retours à la ligne toi-même. f.write("hello") écrit exactement ces cinq caractères — pas de retour à la ligne final.

Pour ajouter au lieu d'écraser :

with open("output.txt", "a") as f:
    f.write("another line\n")

Tu peux aussi donner plusieurs lignes à la fois avec writelines :

lines = ["a\n", "b\n", "c\n"]
with open("letters.txt", "w") as f:
    f.writelines(lines)

Même règle : tu fournis les retours à la ligne.

print vers un fichier

print a un argument file, une façon facile d'écrire sans les retours à la ligne manuels :

with open("log.txt", "w") as f:
    print("started", file=f)
    print("finished", file=f)

Chaque print écrit ses arguments plus un retour à la ligne final. Pour une sortie décontractée, c'est souvent la plus belle forme.

Mode texte vs binaire

Par défaut, open est en mode texte. Python décode les octets en chaînes (en utilisant UTF-8 par défaut sur les plateformes modernes) et gère la traduction des fins de ligne.

Pour les images, PDF, fichiers compilés, ou tout ce qui n'est pas du texte, ouvre en mode binaire en ajoutant "b" au mode :

with open("image.png", "rb") as f:
    data = f.read()

print(len(data))  # nombre d'octets

with open("image_copy.png", "wb") as f:
    f.write(data)

En mode binaire, tu obtiens des objets bytes au lieu de str, et Python ne touche pas aux fins de ligne.

Spécifier l'encodage

Pour les fichiers texte, sois explicite sur l'encodage. UTF-8 est presque toujours le bon choix en 2026 :

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

Si tu affaires à des fichiers legacy d'une boîte purement Windows, tu pourrais voir aussi cp1252 ou latin-1. Deviner mal te donne des caractères corrompus ou un UnicodeDecodeError.

pathlib : la façon moderne de gérer les chemins

Le module pathlib de la bibliothèque standard te donne une API plus ergonomique que les chaînes brutes :

from pathlib import Path

path = Path("notes.txt")

# Lecture et écriture simples.
contents = path.read_text(encoding="utf-8")
path.write_text("new contents\n", encoding="utf-8")

# Construire des chemins sans s'inquiéter de / vs \.
data_dir = Path("data")
log_path = data_dir / "today.log"

print(log_path)
print(log_path.exists())
print(log_path.suffix)       # ".log"
print(log_path.stem)         # "today"
print(log_path.parent)       # "data"

Path.read_text() et write_text() sont des raccourcis pour le motif with open(...) as f quand tu veux juste des lectures et écritures en un seul coup. Pour l'itération ligne par ligne, tu utilises toujours open ou path.open().

Un petit exemple de bout en bout

Lire une liste d'éléments d'un fichier, les filtrer, et écrire le résultat dans un autre fichier :

from pathlib import Path

source = Path("items.txt")
destination = Path("filtered.txt")

items = source.read_text().splitlines()
kept = [item for item in items if item and not item.startswith("#")]

destination.write_text("\n".join(kept) + "\n")

print(f"Kept {len(kept)} items out of {len(items)}")

splitlines() est le compagnon orienté lignes de join. Il découpe sur les caractères de retour à la ligne sans les garder — pratique quand tu vas rejoindre les morceaux de toute façon.

Quand quelque chose cloche

Ouvrir un fichier qui n'existe pas lève FileNotFoundError. Essayer de lire un fichier pour lequel tu n'as pas la permission lève PermissionError. Les deux sont des sous-classes d'OSError, qui est à son tour une sous-classe d'Exception — on parlera de la gestion correcte des exceptions à la prochaine page.

Pour l'instant, un aperçu rapide de ce à quoi ressemble la gestion d'erreur :

from pathlib import Path

path = Path("maybe.txt")

try:
    contents = path.read_text()
except FileNotFoundError:
    print("File doesn't exist — starting fresh.")
    contents = ""

print(repr(contents))

Habitudes clés

• Utilise toujours with open(...) au lieu de open + close manuel.
• Passe toujours encoding= pour les fichiers texte ; UTF-8 par défaut.
• Itère les gros fichiers ligne par ligne ; ne les .read() pas en entier.
• Pour les chemins et les motifs courants de lecture/écriture, utilise pathlib — ça t'épargnera beaucoup de gymnastique de chaînes.

Ensuite : JSON. La plupart des fichiers texte du monde réel que tu liras ne sont pas des lignes simples — ils sont structurés, et JSON est la forme la plus courante. Les mêmes habitudes with open(...) s'appliquent directement.