> Lire un fichier Python et écrire dedans : open/with, modes r/w/a, read, readlines, write, CSV, JSON, chemins pathlib et gestion d'erreurs, avec des exemples.

*Source : https://coder-studio.com/tutoriels/lire-ecrire-fichier-python/*

---

[// Python](https://coder-studio.com/tutoriels/)

# Lire et écrire un fichier en Python

Par **Kévin Papot** · publié le 3 décembre 2025

Savoir **lire un fichier en Python** — et écrire dedans — est indispensable dès qu’un programme doit conserver des données : logs, configurations, exports, sauvegardes. Python rend ces opérations simples et sûres. Ce guide couvre de façon exhaustive chaque cas courant : la fonction `open`, le bloc `with`, les différents modes, les méthodes de lecture et d’écriture, les formats CSV et JSON, la gestion des chemins avec `pathlib` et le traitement des erreurs.

## Ouvrir un fichier avec open et with

La fonction `open()` ouvre un fichier ; le bloc `with` garantit sa fermeture automatique, même en cas d’erreur. C’est la manière recommandée.

```
with open("notes.txt", "r", encoding="utf-8") as fichier:
    contenu = fichier.read()
    print(contenu)
# le fichier est fermé automatiquement à la sortie du bloc
```

Précisez toujours `encoding="utf-8"` pour éviter les problèmes d’accents. Sans `with`, il faudrait appeler `fichier.close()` manuellement, ce qu’on oublie facilement.

## Les modes d’ouverture

Le deuxième argument de `open()` indique ce qu’on veut faire.

-   `"r"` : lecture seule (par défaut). Erreur si le fichier n’existe pas.
-   `"w"` : écriture. **Écrase** le contenu existant, crée le fichier au besoin.
-   `"a"` : ajout (append). Écrit à la fin sans effacer l’existant.
-   `"x"` : création exclusive. Erreur si le fichier existe déjà.
-   `"r+"` : lecture et écriture.
-   Ajoutez `"b"` (ex. `"rb"`, `"wb"`) pour le mode binaire (images, PDF).

```
# Écrase tout
with open("journal.txt", "w", encoding="utf-8") as f:
    f.write("Nouvelle journée\n")

# Ajoute à la suite
with open("journal.txt", "a", encoding="utf-8") as f:
    f.write("Ligne supplémentaire\n")
```

Attention au mode `"w"` : il vide le fichier dès l’ouverture. Utilisez `"a"` si vous voulez conserver le contenu.

## Lire un fichier : read, readline, readlines

Plusieurs méthodes selon le besoin.

```
with open("notes.txt", "r", encoding="utf-8") as f:
    tout = f.read()          # tout le contenu en une seule chaîne

with open("notes.txt", "r", encoding="utf-8") as f:
    ligne = f.readline()     # la première ligne seulement

with open("notes.txt", "r", encoding="utf-8") as f:
    lignes = f.readlines()   # liste de toutes les lignes
    # ['ligne 1\n', 'ligne 2\n', ...]
```

Pour les gros fichiers, la méthode la plus efficace est d’itérer directement, ligne par ligne, sans tout charger en mémoire :

```
with open("gros_fichier.txt", "r", encoding="utf-8") as f:
    for ligne in f:
        print(ligne.strip())   # strip() enlève le \n final
```

`strip()` supprime les espaces et sauts de ligne en bordure. Le résultat de la lecture est souvent une liste, que vous pouvez traiter comme n’importe quelle [liste Python](https://coder-studio.com/tutoriels/listes-python/).

## Écrire dans un fichier : write et writelines

```
lignes = ["pomme", "banane", "cerise"]

with open("fruits.txt", "w", encoding="utf-8") as f:
    f.write("Liste de courses\n")
    for fruit in lignes:
        f.write(fruit + "\n")

# Ou d'un coup avec writelines (n'ajoute pas les \n automatiquement)
with open("fruits.txt", "w", encoding="utf-8") as f:
    f.writelines(f"{fruit}\n" for fruit in lignes)
```

`write` n’ajoute **pas** de saut de ligne : pensez à `"\n"` vous-même. `writelines` écrit une séquence de chaînes sans séparateur non plus.

## Lire et écrire un fichier CSV

Le module `csv` gère proprement les fichiers tabulaires (séparateurs, guillemets).

```
import csv

# Écriture
with open("contacts.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["nom", "email"])
    writer.writerow(["Alice", "alice@mail.fr"])
    writer.writerow(["Bob", "bob@mail.fr"])

# Lecture
with open("contacts.csv", "r", newline="", encoding="utf-8") as f:
    reader = csv.reader(f)
    for ligne in reader:
        print(ligne)   # ['nom', 'email'], puis ['Alice', ...]
```

Pour manipuler chaque ligne comme un dictionnaire (clé = en-tête), utilisez `csv.DictReader` et `csv.DictWriter` :

```
import csv

with open("contacts.csv", "r", newline="", encoding="utf-8") as f:
    for ligne in csv.DictReader(f):
        print(ligne["nom"], "-", ligne["email"])
```

Le paramètre `newline=""` évite les lignes vides parasites sous Windows : ne l’oubliez pas avec le module `csv`.

## Lire et écrire un fichier JSON

Le module `json` convertit entre objets Python (dictionnaires, listes) et texte JSON.

```
import json

donnees = {
    "nom": "Alice",
    "age": 30,
    "langages": ["Python", "JavaScript"],
}

# Écrire du JSON dans un fichier
with open("profil.json", "w", encoding="utf-8") as f:
    json.dump(donnees, f, indent=2, ensure_ascii=False)

# Lire du JSON depuis un fichier
with open("profil.json", "r", encoding="utf-8") as f:
    charge = json.load(f)
    print(charge["nom"])        # Alice
    print(charge["langages"])   # ['Python', 'JavaScript']
```

`indent=2` rend le fichier lisible et `ensure_ascii=False` conserve les accents. Pour convertir vers/depuis une chaîne (et non un fichier), utilisez `json.dumps` et `json.loads`.

## Gérer les chemins avec pathlib

Le module `pathlib` offre une façon moderne et portable de manipuler les chemins, indépendamment du système d’exploitation.

```
from pathlib import Path

dossier = Path("data")
fichier = dossier / "notes.txt"   # concaténation propre

print(fichier.exists())    # le fichier existe-t-il ?
print(fichier.name)        # notes.txt
print(fichier.suffix)      # .txt
print(fichier.parent)      # data

dossier.mkdir(exist_ok=True)   # crée le dossier s'il manque

# pathlib lit et écrit directement
fichier.write_text("Bonjour\n", encoding="utf-8")
print(fichier.read_text(encoding="utf-8"))
```

L’opérateur `/` remplace les concaténations à base de `\` ou `/`, ce qui évite les bugs entre Windows, macOS et Linux. `write_text` et `read_text` sont des raccourcis pratiques pour les petits fichiers.

## Gérer les erreurs

L’accès aux fichiers peut échouer : fichier absent, permissions insuffisantes. Encadrez avec `try / except`.

```
try:
    with open("inexistant.txt", "r", encoding="utf-8") as f:
        print(f.read())
except FileNotFoundError:
    print("Le fichier n'existe pas.")
except PermissionError:
    print("Accès refusé.")
except OSError as e:
    print(f"Erreur d'entrée/sortie : {e}")
```

Interceptez des exceptions précises (`FileNotFoundError`, `PermissionError`) plutôt qu’un `except` générique : votre programme réagira de façon adaptée. Vérifier `Path(...).exists()` avant d’ouvrir peut aussi éviter certains cas d’erreur.

## Conclusion

Vous savez désormais lire et écrire des fichiers en Python dans tous les cas de figure : `open` et `with`, les modes `r`/`w`/`a`, les méthodes `read`, `readlines` et `write`, les formats CSV et JSON, la gestion des chemins avec `pathlib` et le traitement des erreurs. Ces compétences ouvrent la porte à l’automatisation : sauvegarde de données, génération de rapports, traitement de logs.

### À lire ensuite

-   [Manipuler les chaînes de caractères en Python](https://coder-studio.com/tutoriels/manipuler-chaines-python/)
-   [Les dictionnaires en Python](https://coder-studio.com/tutoriels/dictionnaires-python/)
-   [Les listes en Python](https://coder-studio.com/tutoriels/listes-python/)