Écrire dans un fichier avec Python : Comment manipuler des fichiers texte, CSV et JSON en toute sécurité

Pour commencer : Votre premier fichier écrit en Python

La manière la plus rapide de comprendre l'écriture de fichiers en Python est de la mettre en pratique. Commençons par l'exemple le plus simple possible et progressons à partir de là.

Le modèle de base (étape par étape)

À la base, l'écriture dans un fichier suit un modèle simple :

1. Veuillez ouvrir un fichier.
2. Veuillez rédiger le contenu.
3. Veuillez fermer le dossier.

Python fournit la fonction intégrée ` open() ` pour gérer la première étape.

La fonction open(), expliquée de manière simple

La fonction ` open() ` permet de lier votre code Python à un fichier sur le disque. Vous lui communiquez deux éléments :

• Quel fichier souhaitez-vous utiliser ?
• Comment souhaitez-vous procéder ?

En ce qui concerne l'écriture, le mode le plus courant est « "w" », qui signifie « écrire ». Si le fichier n'existe pas, Python le crée. S'il existe, Python le remplace.

file = open("example.txt", "w")
file.write("Hello, world!")
file.close()

Exécutez ce script, et Python créera un fichier nommé example.txt dans le même répertoire que votre code.

Que s'est-il donc passé ?

• open("example.txt", "w") ouvre ou crée le fichier

• write() Envoie du texte dans le fichier

• close() efface les données et libère le fichier

Cela fonctionne, mais ce n'est pas la manière recommandée pour écrire des fichiers à long terme.

La bonne méthode en Python : Utilisation des gestionnaires de contexte

Il est facile d'oublier d'ouvrir et de fermer manuellement les fichiers, et il est également facile de se tromper. C'est pourquoi Python recommande l'utilisation de gestionnaires de contexte.

Voici pourquoi il est préférable d'utiliser with: L'utilisation de ` with ` garantit que le fichier est toujours fermé correctement, même si un problème survient pendant l'écriture. Cela rend votre code plus sécurisé et plus facile à lire.

with open("example.txt", "w") as file:
    file.write("Hello, world!")

Une fois le bloc d'with s terminé, Python ferme automatiquement le fichier. Ce modèle apparaît fréquemment dans le code Python professionnel et mérite d'être mémorisé. Vous le verrez à plusieurs reprises dans notre cursus de compétences en programmation Python et dans notre cours Écrire du code Python propre.

Exemple d'écriture dans un fichier en Python

Appliquons cela à un cas un peu plus concret. Je vais maintenant rédiger une entrée dans mon journal quotidien.

from datetime import date

today = date.today().isoformat()

with open("journal.txt", "a", encoding="utf-8") as file:
    file.write(f"{today}: Practiced writing files in Python.\n")

Cela introduit deux concepts importants :

• Mode d'ajout ("a")

• Rédaction d'entrées structurées et reproductibles

• Chaque exécution ajoute une nouvelle ligne sans supprimer les entrées précédentes.

Comprendre les modes de fichiers : Quand utiliser w, a, x et r+

Une fois que vous savez comment écrire dans un fichier, la décision la plus importante consiste à déterminer comment l'ouvrir. Les modes de fichier déterminent si les données sont écrasées, conservées ou protégées.

Mode écriture (w) : Prendre un nouveau départ

Le mode écriture crée un fichier s'il n'existe pas. Il le remplace également s'il le fait.

with open("report.txt", "w") as file:
    file.write("Daily sales report\n")

Veuillez utiliser cette option lorsque vous souhaitez repartir de zéro. Veuillez noter que ce mode supprime les données existantes sans avertissement.

Mode ajout (a) : Ajouter sans perdre de données

Le mode ajout ajoute du contenu à la fin d'un fichier.

with open("activity.log", "a") as file:
    file.write("User logged in\n")

Ceci est particulièrement adapté aux journaux et aux enregistrements incrémentiels et constitue l'un des modes les plus sécurisés pour les systèmes de production.

Mode exclusif (x) : Création sécurisée de fichiers

Le mode exclusif crée un fichier uniquement s'il n'existe pas déjà.

try:
    with open("config.txt", "x") as file:
        file.write("initialized=true")

except FileExistsError:
    print("File already exists.")

Ceci est utile pour les scripts d'installation où l'écrasement serait risqué.

Mode lecture-écriture (r+) : Modification des fichiers existants

Ce mode permet la lecture et l'écriture, mais nécessite que le fichier existe.

with open("notes.txt", "r+") as file:
    content = file.read()
    file.write("\nNew note added.")

L'écriture s'effectue à la position actuelle du pointeur de fichier, c'est pourquoi il est important de comprendre le mouvement du curseur dans ce contexte.

Quel mode devriez-vous utiliser ? Voici mon guide mental :

• Remplacer les données existantes → w

• Conserver les données et en ajouter d'autres → a

• Empêcher les écrasements → x

• Veuillez lire et mettre à jour le même fichier. r+

Afin de renforcer visuellement ce processus décisionnel :

Le choix du mode de fichier approprié dépend généralement de l'intention : écraser, ajouter, protéger ou modifier.

Rédaction de différents types de contenu en Python

Une fois que vous êtes à l'aise pour ouvrir des fichiers avec le mode approprié, la question suivante est de savoir ce que vous écrivez réellement.

Dans les programmes réels, vous n'écrivez pas toujours une seule chaîne. Vous pouvez enregistrer des listes, exporter des résultats ou travailler avec des données non textuelles telles que des images ou des fichiers PDF. Dans cette section, vous apprendrez à écrire différents types de contenu dans des fichiers de manière sûre et efficace.

Écrire du texte et des chaînes de caractères

Le cas le plus simple consiste à rédiger du texte brut. Python propose deux méthodes principales pour cela : write() et writelines().

write() écrit exactement ce que vous transmettez, sans sauts de ligne automatiques.

with open("example.txt", "w") as file:
    file.write("First line\n")
    file.write("Second line\n")

write() par rapport à writelines()

La principale différence est simple : write() écrit une chaîne à la fois, tandis que writelines() écrit une séquence de chaînes telles quelles ; writelines() n'ajoute pas de sauts de ligne pour vous, chaque élément doit donc déjà se terminer par \n.

Dans la pratique, de nombreux développeurs continuent de privilégier l'utilisation de la méthode ` write() ` dans une boucle, car elle est plus facile à lire.

lines = ["One\n", "Two\n", "Three\n"]

with open("example.txt", "w") as file:
    file.writelines(lines)

Rédiger des listes de manière efficace

items = ["apple", "banana", "cherry"]

content = "\n".join(items)

with open("fruits.txt", "w") as file:
    file.write(content)

La jointure réduit les écritures répétées sur le disque, ce qui est important pour les ensembles de données volumineux.

Écriture de données binaires

Le mode binaire ("wb") est requis pour les fichiers non textuels.

binary_data = b"\x89PNG\r\n\x1a\n"

with open("image.bin", "wb") as file:
    file.write(binary_data)

Utilisation des encodages en Python (Pourquoi votre texte semble illisible)

Les problèmes d'encodage constituent l'un des bugs les plus courants et les plus frustrants dans le traitement des fichiers.

Veuillez toujours spécifier UTF-8.

Le codage explicite évite les problèmes interplateformes et les caractères corrompus, comme vous pouvez le constater ici :

with open("example.txt", "w", encoding="utf-8") as file:
    file.write("Café, résumé, naïve")

Exemple concret : Texte multilingue

Être explicite ici permet d'économiser des heures de débogage par la suite. Voici ce que je veux dire :

customers = ["Ana García", "François Dupont", "Miyuki 山田"]

with open("customers.txt", "w", encoding="utf-8") as file:
    for name in customers:
        file.write(name + "\n")

Techniques avancées d'écriture en Python

Une fois que vous êtes à l'aise avec l'écriture de fichiers en Python, la prochaine série de problèmes ne concerne généralement plus la manière d'écrire, mais plutôt la manière de le faire de manière sûre et efficace.. Les fichiers volumineux, les plantages inattendus et les goulots d'étranglement en termes de performances constituent tous des cas particuliers que nous n'avons pas encore abordés.

Gestion de fichiers volumineux avec écriture par morceaux

La sortie en continu permet de réduire l'utilisation de la mémoire :

def generate_lines():
    for i in range(1_000_000):
        yield f"Line {i}\n"

with open("large.txt", "w", encoding="utf-8") as file:
    for line in generate_lines():
        file.write(line)

Atomic écrit : Prévention de la corruption

L'objectif ici est d'empêcher les écritures partielles si un programme plante en cours de mise à jour.

import os, tempfile

def atomic_write(path, content):
    with tempfile.NamedTemporaryFile("w", delete=False) as tmp:
        tmp.write(content)
    os.replace(tmp.name, path)

Au-delà des fichiers texte : Écriture JSON et CSV

Une fois que vos données sont structurées, le texte brut n'est plus la meilleure option. Python facilite l'écriture de formats structurés courants tels que JSON et CSV, ce qui vous permet de stocker des données d'une manière plus facile à partager, à inspecter et à traiter ultérieurement.

Écrire du JSON

Lorsque vous travaillez avec des dictionnaires ou des données imbriquées, JSON est généralement le format le plus approprié pour l'écriture. Le modulejson intégré à Python ( ) gère la conversion pour vous, vous n'avez donc pas besoin de formater manuellement les chaînes de caractères.

import json

data = {"id": 1, "name": "Jeremiah"}

with open("user.json", "w", encoding="utf-8") as file:
    json.dump(data, file, indent=2)

Écriture CSV

Si vos données sont présentées sous forme de tableaux et sont susceptibles d'être ouvertes dans des feuilles de calcul ou des outils BI, le format CSV est plus adapté. Le module csv vous permet d'écrire des lignes en toute sécurité sans vous soucier des délimiteurs ou des guillemets.

import csv

rows = [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}]

with open("users.csv", "w", newline="", encoding="utf-8") as file:
    writer = csv.DictWriter(file, fieldnames=["id", "name"])
    writer.writeheader()
    writer.writerows(rows)

Erreurs courantes lors de l'écriture dans un fichier en Python

Même si l'écriture de fichiers en Python est simple, quelques petites erreurs ont tendance à causer la plupart des problèmes dans la pratique. Ces problèmes ne sont généralement pas liés à la syntaxe ; ils proviennent de détails négligés tels que la gestion des ressources, les modes de fichiers ou les choix de performances.

Veuillez garder à l'esprit les points suivants.

• Oubli de fermer les fichiers → utiliser ‘with’

• Écrasement involontaire de données → modes de double vérification

• Ignorer l'encodage → toujours spécifier UTF-8

• Écriture inefficace de fichiers volumineux → sortie par lots ou en continu

La plupart des erreurs ici proviennent de petites négligences, et non d'une logique complexe.

Conclusion

L'écriture dans des fichiers en Python commence de manière simple, mais les programmes réels nécessitent davantage d'attention. Dans ce guide, vous avez progressé depuis votre première écriture de fichier jusqu'au choix de modes de fichiers sécurisés, en passant par la gestion correcte des encodages, l'exportation de données structurées et l'application de modèles prêts pour la production.

Le point essentiel à retenir est l'intention : choisissez le mode approprié, soyez explicite en matière d'encodage et rédigez de manière prudente lorsque les données sont importantes.