Comment écrire dans un fichier en Python ?

J’écris dans un fichier en Python avec open(), le bon mode d’ouverture et souvent with pour fermer proprement. Le vrai sujet, c’est d’éviter d’écraser un fichier sans le vouloir, gérer les lignes, les chemins, et produire des fichiers fiables.

Comment écrire un premier fichier ?

On peut créer ou écraser un fichier avec open() en mode w, puis écrire dedans avec write().

Le mode w, c’est le mode “write”, donc écriture. Il fait deux choses très simples, mais il faut bien les avoir en tête. Si le fichier n’existe pas, Python le crée. Si le fichier existe déjà, Python remplace tout son contenu. Et là, c’est le piège classique. J’ai déjà vu des débutants perdre un fichier de notes complet juste parce qu’ils avaient utilisé w en pensant “ajouter une ligne”. Non, w repart de zéro.

Voilà l’exemple le plus simple possible :

file = open('rapport.txt', 'w')
file.write('Bonjour')
file.close()

Ici, Python ouvre un fichier appelé rapport.txt. Si le fichier n’existe pas, il le crée dans le dossier où le script est lancé. Ensuite, write() écrit le texte Bonjour. Puis close() ferme le fichier.

La fermeture est importante. Tant que le fichier n’est pas fermé, Python peut garder certaines informations en mémoire avant de les écrire vraiment sur le disque. Dans un petit script, ça passe souvent inaperçu. Dans un vrai traitement, ça peut créer des bugs pénibles.

Pour vérifier ce qu’on vient d’écrire, on peut rouvrir le fichier en mode r. Le mode r veut dire “read”, donc lecture.

file = open('rapport.txt', 'r')
contenu = file.read()
file.close()

print(contenu)

Ce code ouvre le même fichier, lit tout son contenu avec read(), ferme le fichier, puis affiche le résultat. Vous devriez voir :

Bonjour

Cette méthode marche très bien pour comprendre le principe. Elle est claire, directe, et elle montre bien ce qui se passe. Mais elle a une contrainte : il faut penser à fermer le fichier soi-même avec close(). Et quand on commence à écrire plus de code, c’est exactement le genre de détail qu’on oublie facilement.

Pourquoi utiliser with open ?

La forme with open() est la manière la plus propre d’écrire dans un fichier en Python. Elle a un gros avantage tout simple : Python ferme automatiquement le fichier à la fin du bloc. Pas besoin de penser à appeler close(), pas besoin de gérer ce détail à la main.

Le principe est simple. Quand on entre dans le bloc with, Python ouvre le fichier. Quand on sort du bloc, même si une erreur arrive au milieu, Python le referme proprement. C’est ce qu’on appelle un gestionnaire de contexte, mais honnêtement, retenez surtout ça : with s’occupe du ménage à votre place.

Dans un script rapide, oublier close() arrive vite. On teste un export, on génère un rapport, on écrit quelques logs, et on passe à autre chose. Sauf que derrière, un fichier mal fermé peut rester verrouillé, incomplet, ou se comporter bizarrement selon le système.

with open('rapport.txt', 'w', encoding='utf-8') as file:
    file.write("Rapport du jour\n")
    file.write("Tout s'est bien passé.\n")

Ici, le mode ‘w’ veut dire “write”, donc écriture. Si le fichier n’existe pas, Python le crée. S’il existe déjà, Python remplace son contenu. Le nom file est juste une variable qui représente le fichier ouvert.

Pour relire ce qu’on vient d’écrire, on peut utiliser le même réflexe avec le mode ‘r’, pour “read”, donc lecture.

with open('rapport.txt', 'r', encoding='utf-8') as file:
    contenu = file.read()

print(contenu)

Je précise presque toujours encoding=’utf-8′. C’est une bonne habitude, surtout dès qu’il y a des accents, des exports CSV, des logs ou des rapports qui vont être relus ailleurs. Sans encodage explicite, Python utilise parfois l’encodage par défaut du système, et là, selon Windows, Linux, un serveur ou une machine locale, vous pouvez avoir des surprises.

J’ai déjà vu des automatisations casser juste à cause d’un fichier mal fermé ou d’un encodage implicite. Rien de spectaculaire, juste un script qui marche chez quelqu’un et plante chez un autre. C’est pénible, et ça se règle souvent avec with open() et encoding=’utf-8′.

With règle la fermeture du fichier. Reste maintenant un autre point important : choisir le bon mode d’ouverture, parce qu’écrire, ajouter du contenu ou protéger un fichier existant, ce n’est pas du tout la même chose.

Quel mode d’ouverture choisir ?

Le mode d’ouverture dépend simplement de ce que vous voulez faire avec le fichier : écrire dedans, ajouter du contenu, créer un nouveau fichier sans écraser l’ancien, ou juste lire. C’est souvent là que les erreurs arrivent. J’ai déjà vu un script de reporting effacer un fichier complet juste parce qu’il utilisait w au lieu de a. Rien de dramatique si on a une sauvegarde, beaucoup moins drôle sinon.

Les modes à connaître dans ce contexte sont assez simples :

  • Le mode w sert à écrire dans un fichier. Si le fichier existe déjà, Python efface son contenu avant d’écrire. C’est pratique quand on veut régénérer un fichier propre, mais c’est aussi le mode le plus risqué.
  • Le mode a sert à ajouter du contenu à la fin du fichier. Le contenu existant reste intact. C’est le bon choix pour des logs, des exports progressifs, ou un historique.
  • Le mode x sert à créer un fichier uniquement s’il n’existe pas déjà. Si le fichier existe, Python déclenche une erreur. C’est très utile quand on veut éviter une suppression accidentelle.
  • Le mode r sert à lire un fichier. Il ne permet pas d’écrire, et il déclenche une erreur si le fichier n’existe pas.
Mode Action Risque principal Cas d’usage
w Écrit dans le fichier et écrase l’ancien contenu Supprimer des données sans le vouloir Générer un fichier propre à chaque exécution
a Ajoute du contenu à la fin du fichier Accumuler trop de données si on ne contrôle pas Écrire des logs ou compléter un fichier existant
x Crée le fichier seulement s’il n’existe pas Déclencher une erreur si le fichier est déjà là Créer un fichier de manière sûre
r Lit le contenu du fichier Erreur si le fichier n’existe pas Consulter ou traiter un fichier existant

Dans la pratique, w et a sont les plus utilisés quand on écrit des fichiers. Le mode x, lui, est moins fréquent, mais je le trouve très sain dès qu’on manipule des fichiers sensibles.

try:
    with open("rapport.txt", "x", encoding="utf-8") as fichier:
        fichier.write("Premier rapport généré.\n")
except FileExistsError:
    print("Le fichier existe déjà, je ne l’écrase pas.")

Une fois le bon mode choisi, le deuxième sujet qui revient tout le temps, c’est la gestion des lignes.

Comment écrire plusieurs lignes ?

On écrit plusieurs lignes dans un fichier Python soit en ajoutant explicitement \n, soit avec writelines(). Mais attention, writelines() n’ajoute pas les retours à la ligne automatiquement. Je le dis tout de suite parce que son nom piège beaucoup de monde.

La façon la plus simple, c’est d’appeler plusieurs fois write() en ajoutant \n à la fin de chaque ligne.

with open("rapport.txt", "w", encoding="utf-8") as fichier:
    fichier.write("Ligne 1\n")
    fichier.write("Ligne 2\n")
    fichier.write("Ligne 3\n")

Ici, Python écrit bien trois lignes séparées. Sans \n, tout serait collé sur la même ligne. C’est bête, mais c’est exactement le genre de détail qui fait perdre du temps.

Avec writelines(), on peut écrire une liste de chaînes d’un coup. Mais chaque chaîne doit déjà contenir son saut de ligne si on veut une vraie ligne dans le fichier.

lignes = [
    "Première ligne\n",
    "Deuxième ligne\n",
    "Troisième ligne\n"
]

with open("rapport.txt", "w", encoding="utf-8") as fichier:
    fichier.writelines(lignes)

Si votre liste est déjà propre, sans \n, je préfère souvent utiliser ‘\n’.join(lignes). C’est lisible, et on voit clairement ce qui se passe.

lignes = ["Première ligne", "Deuxième ligne", "Troisième ligne"]

with open("rapport.txt", "w", encoding="utf-8") as fichier:
    fichier.write("\n".join(lignes))

Pour ajouter du contenu à la fin d’un fichier, on utilise le mode a, pour append, c’est-à-dire ajouter. C’est très pratique pour un fichier de log, un export incrémental, un suivi d’exécution ou un rapport qui se complète au fil du temps.

with open("log.txt", "w", encoding="utf-8") as fichier:
    fichier.write("Démarrage du traitement\n")

with open("log.txt", "a", encoding="utf-8") as fichier:
    fichier.write("Nouvelle entrée ajoutée à la fin\n")

J’utilise souvent ça chez des clients pour garder une trace simple des automatisations. On lance un script, il ajoute une ligne dans un log, et on sait ce qui s’est passé sans ouvrir un outil compliqué.

Tout ça fonctionne très bien, tant qu’on sait où Python crée réellement le fichier. Et c’est souvent là que les surprises commencent, surtout quand on exécute le script depuis un IDE, un notebook ou un outil d’automatisation.

Où Python crée le fichier ?

Python crée le fichier dans le dossier courant du script ou de l’environnement d’exécution, sauf si on lui donne un chemin précis. C’est souvent là que les surprises commencent. Vous lancez un script, vous écrivez rapport.txt, et le fichier n’apparaît pas “à côté” de ce que vous aviez en tête.

Le dossier courant, c’est le dossier depuis lequel Python est exécuté. Si vous êtes dans un terminal, c’est souvent le dossier affiché avant de lancer la commande. Si vous êtes dans un notebook, un IDE ou un outil d’automatisation, ça peut être autre chose. J’ai déjà vu ça chez un client : le script marchait très bien, mais les fichiers partaient dans le dossier de lancement du serveur, pas dans le dossier du projet.

Il y a deux façons simples de donner un emplacement à Python :

  • Un chemin relatif part du dossier courant. Exemple : rapport.txt crée le fichier dans le dossier courant, et exports/rapport.txt le crée dans un sous-dossier exports.
  • Un chemin absolu donne l’adresse complète du fichier. Exemple sur Windows : C:\Users\Franck\Documents\rapport.txt. Exemple sur macOS ou Linux : /Users/franck/Documents/rapport.txt.

Pour gérer les chemins proprement, j’utilise souvent pathlib. C’est une bibliothèque intégrée à Python, moderne et lisible. Elle évite de bricoler des chaînes de caractères avec des slashs dans tous les sens.

from pathlib import Path

chemin = Path('exports') / 'rapport.txt'

with open(chemin, 'w', encoding='utf-8') as fichier:
    fichier.write('Mon rapport\n')

Attention quand même. Avant d’écrire dans un sous-dossier, ce dossier doit exister. Si exports n’existe pas, Python va lever une erreur. La solution simple, c’est de créer le dossier avant l’écriture.

from pathlib import Path

Path('exports').mkdir(exist_ok=True)

chemin = Path('exports') / 'rapport.txt'

with open(chemin, 'w', encoding='utf-8') as fichier:
    fichier.write('Mon rapport\n')

exist_ok=True veut dire : “Si le dossier existe déjà, ne plante pas”. C’est exactement ce qu’on veut dans la plupart des scripts.

Besoin Solution simple Exemple
Créer un fichier dans le dossier courant Utiliser juste un nom de fichier rapport.txt
Créer un fichier dans un sous-dossier Utiliser un chemin relatif exports/rapport.txt
Créer un fichier à un endroit précis Utiliser un chemin absolu /Users/franck/Documents/rapport.txt
Gérer les chemins proprement Utiliser pathlib Path(‘exports’) / ‘rapport.txt’

Avec with open(), le bon mode, les retours ligne et des chemins propres, vous avez déjà une base solide pour la majorité des scripts Python.

Et maintenant vous écrivez quoi dans vos fichiers Python ?

Écrire dans un fichier en Python, ce n’est pas compliqué. Le vrai déclic, c’est de choisir le bon mode et de prendre de bonnes habitudes dès le départ. J’utilise with open() pour fermer proprement, w quand je veux remplacer, a quand je veux ajouter, x quand je veux protéger l’existant. Pour plusieurs lignes, je garde en tête que writelines() n’ajoute rien tout seul. Et pour les chemins, je préfère être explicite, souvent avec pathlib. Résultat : vous écrivez des fichiers plus propres, plus fiables, et vos scripts deviennent plus simples à maintenir.

FAQ

  • Comment créer un fichier en Python ?
    J’utilise open() avec le mode w. Si le fichier n’existe pas, Python le crée. S’il existe déjà, son contenu est remplacé. Pour éviter d’oublier de fermer le fichier, je préfère écrire avec with open(‘fichier.txt’, ‘w’, encoding=’utf-8′) as file:.
  • Quelle différence entre w et a en Python ?
    w écrit dans le fichier en écrasant le contenu existant. a ajoute le nouveau contenu à la fin du fichier sans supprimer ce qui est déjà présent. Pour un rapport régénéré, j’utilise souvent w. Pour un log, j’utilise plutôt a.
  • Pourquoi utiliser with open plutôt que open seul ?
    with open() ferme automatiquement le fichier quand le bloc est terminé. C’est plus sûr, plus lisible, et ça évite les fichiers mal fermés. C’est la méthode que je recommande dans presque tous les cas, surtout pour des scripts d’automatisation ou de traitement data.
  • Comment écrire plusieurs lignes dans un fichier Python ?
    Je peux appeler write() plusieurs fois avec \n, ou utiliser writelines() avec une liste de chaînes. Attention, writelines() n’ajoute pas automatiquement les retours à la ligne. Il faut les mettre dans les chaînes ou construire le texte avec ‘\n’.join().
  • Comment éviter d’écraser un fichier existant ?
    J’utilise le mode x. Il crée le fichier uniquement s’il n’existe pas déjà. Si le fichier existe, Python lève une erreur FileExistsError. C’est pratique quand on veut protéger un export, un rapport ou un fichier de configuration important.

 

 

A propos de l’auteur

Je suis Franck Scandolera, expert et formateur en Data, tracking avancé server-side, Analytics Engineering, automatisation No/Low Code avec n8n, IA appliquée en entreprise, SEO et GEO. J’accompagne des équipes qui doivent fiabiliser leurs données, automatiser leurs traitements et produire des scripts vraiment exploitables, pas juste du code qui marche une fois sur deux. Avec webAnalyste et Formations Analytics, j’ai travaillé pour Logis Hôtel, Yelloh Village, BazarChic, la Fédération Française de Football, Texdecor et d’autres. Si vous voulez structurer vos automatisations ou vos pipelines data, contactez-moi.

Retour en haut