Lire et ecrire des fichiers en Python : guide complet

Pourquoi manipuler des fichiers en Python ?

Dans tes projets NSI, tu vas vite te rendre compte qu'un programme qui ne fait que des calculs en mémoire est limité. Pour créer des applications utiles, comme un gestionnaire de notes, un petit jeu avec sauvegarde ou un analyseur de données, tu dois pouvoir stocker des informations de manière permanente. C'est là que les fichiers entrent en jeu ! Ils sont le pont entre la mémoire vive (éphémère) et le disque dur (persistant). Savoir les manipuler est une compétence fondamentale en informatique et en Python.

Imagine que tu crées un quiz. Sans fichier, les questions et les meilleurs scores disparaissent à chaque fermeture du programme. Avec des fichiers, tu peux les sauvegarder et les recharger à volonté. Dans ce guide, on se concentre sur les fichiers texte (`.txt`, `.csv`), les plus courants pour commencer.

Ouvrir et fermer un fichier : la base avec `open()`

Avant toute opération, il faut ouvrir une ligne de communication entre ton programme Python et le fichier sur le disque. Pour cela, on utilise la fonction intégrée open().

Le mode d'ouverture : une décision cruciale

Le deuxième argument de open() est le mode. Il détermine ce que tu as le droit de faire avec le fichier. Voici les principaux :

• 'r' (read) : Lecture seule. Le fichier doit exister. C'est le mode par défaut.
• 'w' (write) : Écriture. Attention ! Si le fichier existe, il est écrasé et remplacé. S'il n'existe pas, il est créé.
• 'a' (append) : Ajout à la fin. Tu écris à la suite du contenu existant, sans rien effacer. Le fichier est créé s'il n'existe pas.
• 'r+' : Lecture et écriture. Le fichier doit exister.

La bonne pratique : le gestionnaire de contexte (`with`)

Il est essentiel de fermer un fichier après usage pour libérer les ressources. Le moyen le plus sûr et le plus pythonique est d'utiliser le mot-clé with.

Pourquoi utiliser `with` ? Il garantit que le fichier sera fermé automatiquement, même si une erreur se produit pendant les opérations. Oublie les oublis de `close()` !

Voici la structure type :

with open('mon_fichier.txt', 'r') as fichier:
    # Opérations de lecture ici
    contenu = fichier.read()
# Une fois sorti du bloc 'with', le fichier est automatiquement fermé.
print(contenu)

Lire le contenu d'un fichier texte

Plusieurs méthodes existent pour lire un fichier. Le choix dépend de ce que tu veux en faire.

1. Lire l'intégralité : `.read()`

Parfait pour les fichiers de petite taille. Elle renvoie tout le contenu sous forme d'une seule chaîne de caractères.

with open('poeme.txt', 'r') as f:
    texte_complet = f.read()
print(texte_complet)

2. Lire ligne par ligne : `.readline()` et `.readlines()`

• .readline() : lit la ligne suivante (avec le caractère de saut de ligne `\n`).
• .readlines() : lit toutes les lignes et les renvoie dans une liste. Chaque élément de la liste est une ligne.

with open('donnees.csv', 'r') as f:
    lignes = f.readlines()

for ligne in lignes:
    print(f"Ligne : {ligne.rstrip()}")  # .rstrip() enlève le \n à la fin

3. L'itérateur le plus efficace

Le plus simple et le plus économique en mémoire pour traiter un fichier ligne à ligne est d'itérer directement sur l'objet fichier :

with open('gros_fichier.log', 'r') as f:
    for ligne in f:          # Itère directement sur 'f'
        # Traite chaque ligne ici, sans tout charger en mémoire
        if "ERREUR" in ligne:
            print(ligne.strip())

Écrire et modifier un fichier

Passons à l'écriture. Souviens-toi : le mode 'w' écrase, le mode 'a' ajoute.

Écrire avec `.write()` et `.writelines()`

La méthode .write() prend une chaîne de caractères. Attention, elle n'ajoute pas de saut de ligne automatiquement !

with open('journal.txt', 'w') as f:  # Mode 'w' : création/écrasement
    f.write("=== Début du journal ===\n")
    f.write("Première entrée.\n")

with open('journal.txt', 'a') as f:  # Mode 'a' : ajout
    f.write("Deuxième entrée ajoutée.\n")

La méthode .writelines() prend une liste de chaînes et les écrit à la suite. Idéal avec une liste préparée.

Un exemple concret : créer un fichier CSV

Un CSV (Comma-Separated Values) est un fichier texte où les valeurs sont séparées par des virgules. C'est très utile pour exporter des données.

eleves = [
    ["Nom", "Prénom", "Note"],
    ["Dupont", "Alice", 17],
    ["Martin", "Léo", 15],
    ["Bernard", "Chloé", 19]
]

with open('notes_classe.csv', 'w') as f:
    for ligne in eleves:
        # Convertit chaque élément en string et les joint par une virgule
        ligne_csv = ",".join(str(element) for element in ligne)
        f.write(ligne_csv + "\n")  # N'oublie pas le saut de ligne !

Gérer les erreurs et adopter les bonnes pratiques

Que se passe-t-il si tu essaies d'ouvrir en lecture un fichier qui n'existe pas ? Python lève une exception FileNotFoundError. Il faut anticiper cela.

Utiliser les blocs `try...except`

C'est la manière propre de gérer les erreurs potentielles.

nom_fichier = "config.ini"
try:
    with open(nom_fichier, 'r') as f:
        config = f.read()
except FileNotFoundError:
    print(f"Erreur : Le fichier '{nom_fichier}' est introuvable.")
    # Tu peux ici créer un fichier par défaut si nécessaire
except PermissionError:
    print(f"Erreur : Tu n'as pas les droits pour lire '{nom_fichier}'.")

Récapitulatif des bonnes pratiques

• Toujours utiliser `with open(...) as f` pour être sûr de fermer le fichier.
• Choisis le bon mode ('r', 'w', 'a') pour éviter d'écraser des données par erreur.
• Pour lire un gros fichier, préfère itérer dessus plutôt que d'utiliser `.read()`.
• Pense à gérer les chemins relatifs/absolus. Ton fichier `data.txt` doit être dans le même dossier que ton script, ou tu dois spécifier le chemin complet.
• N'oublie pas les sauts de ligne (`\n`) quand tu écris.

Avec ces bases solides, tu es prêt à rendre tes programmes interactifs et persistants. La prochaine étape ? Explorer le module `json` pour sauvegarder des structures de données complexes comme des listes ou des dictionnaires !