Fichiers en Python : lire, écrire et ajouter du texte

Manipuler des fichiers est une étape importante quand on apprend Python. Tant qu’un programme ne travaille qu’avec des variables temporaires, les données disparaissent dès que le script se termine. Les fichiers permettent au contraire de conserver du texte, de relire une liste d’informations plus tard, de créer un journal d’activité simple, ou encore de sauvegarder des résultats.

Dans ce tutoriel, vous allez apprendre à lire, écrire et ajouter du texte dans des fichiers en Python, pas à pas. L’objectif est de rester sur des exemples accessibles aux débutants, sans aller vers des formats plus avancés. Vous verrez d’abord ce qu’est un fichier texte, puis la fonction open(), les modes d’ouverture les plus utiles, la lecture complète ou ligne par ligne, l’écriture, l’ajout de contenu, et enfin quelques erreurs fréquentes à éviter.

Tous les exemples utilisent du texte simple. Ils peuvent être testés dans un fichier Python classique, dans un terminal, ou dans l’environnement de développement de votre choix.

Prérequis

Savoir lancer un script Python.
Connaître les variables, les chaînes de caractères et l’affichage avec print().
Avoir Python installé sur votre machine.
Savoir où se trouve le dossier dans lequel vous enregistrez vos scripts.

Matériel nécessaire

Python installé
Un éditeur de code ou un IDE
Un dossier de travail contenant vos scripts et fichiers texte

Étapes

1
Comprendre ce qu’est un fichier texte

Un fichier texte est un fichier qui contient des caractères lisibles, par exemple des phrases, des listes ou des notes. En Python débutant, c’est souvent le type de fichier le plus simple à manipuler.
Exemples de contenus possibles dans un fichier texte :
- une liste de courses ;
- un journal de notes ;
- des résultats enregistrés par un script ;
- un petit rapport généré automatiquement.
Quand votre script lit un fichier, il récupère le contenu pour l’utiliser dans le programme. Quand il écrit dans un fichier, il enregistre du texte sur le disque. Quand il ajoute du texte, il conserve l’ancien contenu et place le nouveau à la fin.
Il est utile de bien distinguer ces trois actions :
- lire : récupérer un contenu existant ;
- écrire : créer un contenu ou remplacer l’ancien ;
- ajouter : conserver l’existant et écrire à la suite.
2
Découvrir la fonction open()

En Python, on ouvre un fichier avec la fonction open(). Elle prend au minimum le nom du fichier, et souvent un mode d’ouverture.
Exemple général :
python
```
fichier = open("notes.txt", "r")
```
Ici :
- "notes.txt" est le nom du fichier ;
- "r" signifie que l’on ouvre le fichier en lecture.
Une fois le fichier ouvert, on peut lire ou écrire selon le mode choisi. Ensuite, il faut le refermer avec close().
python
```
fichier = open("notes.txt", "r")
contenu = fichier.read()
print(contenu)
fichier.close()
```
Ce code fonctionne, mais Python propose une manière plus sûre et plus pratique : with.
python
```
with open("notes.txt", "r") as fichier:
    contenu = fichier.read()
    print(contenu)
```
Avec with, le fichier est refermé automatiquement à la fin du bloc. C’est la méthode recommandée pour débuter, car elle évite les oublis.
3
Connaître les modes d’ouverture utiles

Le second argument de open() indique comment vous voulez utiliser le fichier. Pour ce tutoriel, les trois modes principaux sont :
- "r" : lecture ;
- "w" : écriture ;
- "a" : ajout.
Mode lecture : "r"
Ce mode sert à lire un fichier existant.
python
```
with open("notes.txt", "r") as fichier:
    contenu = fichier.read()
    print(contenu)
```
Si le fichier n’existe pas, Python renvoie une erreur.
Mode écriture : "w"
Ce mode sert à écrire dans un fichier. Si le fichier existe déjà, son contenu est remplacé.
python
```
with open("notes.txt", "w") as fichier:
    fichier.write("Bonjour\n")
```
Il faut donc être prudent : "w" efface l’ancien contenu avant d’écrire le nouveau.
Mode ajout : "a"
Ce mode sert à ajouter du texte à la fin d’un fichier sans supprimer le contenu déjà présent.
python
```
with open("notes.txt", "a") as fichier:
    fichier.write("Nouvelle ligne\n")
```
Ce mode est utile pour enrichir progressivement un fichier, par exemple un journal simple ou une liste de notes.
4
Lire tout le contenu d’un fichier avec read()

La méthode read() permet de lire tout le contenu d’un fichier en une seule fois. C’est souvent la première méthode à apprendre.
python
```
with open("notes.txt", "r") as fichier:
    contenu = fichier.read()
    print(contenu)
```
Ici, le texte complet du fichier est stocké dans la variable contenu.
Supposons que le fichier notes.txt contienne :
python
```
Première note
Deuxième note
Troisième note
```
Alors print(contenu) affichera ces trois lignes.
Cette approche est simple et pratique pour les petits fichiers texte. Elle permet ensuite de faire des traitements simples sur la chaîne obtenue, comme rechercher un mot, compter des caractères ou afficher le contenu tel quel.
Exemple avec un message avant l’affichage :
python
```
with open("notes.txt", "r") as fichier:
    contenu = fichier.read()

print("Contenu du fichier :")
print(contenu)
```
Remarquez que la lecture se fait dans le bloc with, puis vous pouvez utiliser la variable en dehors si vous en avez besoin ensuite.
5
Lire une seule ligne avec readline()

Si vous voulez lire seulement une ligne à la fois, vous pouvez utiliser readline().
python
```
with open("notes.txt", "r") as fichier:
    ligne1 = fichier.readline()
    ligne2 = fichier.readline()

print(ligne1)
print(ligne2)
```
Chaque appel à readline() lit la ligne suivante.
Cela peut être utile si vous savez que le fichier a une structure simple et que vous voulez traiter les lignes une par une dans un ordre précis.
Exemple :
python
```
with open("profil.txt", "r") as fichier:
    nom = fichier.readline()
    ville = fichier.readline()

print("Nom :", nom)
print("Ville :", ville)
```
Attention : la ligne lue peut contenir un retour à la ligne en fin de texte. Lors de l’affichage, cela peut donner un saut de ligne supplémentaire selon votre usage. Pour nettoyer ce cas, on peut utiliser strip().
python
```
with open("profil.txt", "r") as fichier:
    nom = fichier.readline().strip()
    ville = fichier.readline().strip()

print("Nom :", nom)
print("Ville :", ville)
```
Dans ce tutoriel, strip() est simplement utilisé pour retirer les caractères d’espacement en début et fin de chaîne, notamment le retour à la ligne final quand il est présent.
6
Lire un fichier ligne par ligne avec une boucle for

Une façon très courante de lire un fichier texte consiste à parcourir ses lignes avec une boucle for.
python
```
with open("notes.txt", "r") as fichier:
    for ligne in fichier:
        print(ligne)
```
À chaque tour de boucle, la variable ligne contient une ligne du fichier.
Cette méthode est claire pour un débutant, surtout quand on veut afficher ou traiter chaque ligne séparément.
Exemple avec numérotation simple :
python
```
numero = 1

with open("notes.txt", "r") as fichier:
    for ligne in fichier:
        print(numero, ligne.strip())
        numero = numero + 1
```
Ici :
- on commence avec numero = 1 ;
- on lit chaque ligne du fichier ;
- on utilise strip() pour éviter un saut de ligne supplémentaire ;
- on augmente le numéro à chaque passage.
C’est une bonne base pour créer des scripts simples qui parcourent un fichier de données textuelles, une liste ou une suite de notes.
7
Écrire du texte dans un fichier avec write()

Pour écrire dans un fichier, on utilise le mode "w" puis la méthode write().
python
```
with open("notes.txt", "w") as fichier:
    fichier.write("Bonjour")
```
Si notes.txt n’existe pas, Python le crée. S’il existe déjà, son ancien contenu est remplacé.
La méthode write() écrit exactement la chaîne fournie. Si vous voulez plusieurs lignes, il faut ajouter vous-même le caractère \n.
python
```
with open("notes.txt", "w") as fichier:
    fichier.write("Première ligne\n")
    fichier.write("Deuxième ligne\n")
    fichier.write("Troisième ligne\n")
```
Après exécution, le fichier contiendra trois lignes.
Exemple concret : créer une petite liste de tâches.
python
```
with open("taches.txt", "w") as fichier:
    fichier.write("Acheter du pain\n")
    fichier.write("Réviser Python\n")
    fichier.write("Envoyer un message\n")
```
Vous pouvez ensuite ouvrir taches.txt dans votre éditeur pour vérifier le résultat.
Quand on débute, il est important de retenir que "w" ne sert pas à compléter un fichier existant, mais à écrire un nouveau contenu. Si vous relancez le script avec d’autres lignes, le contenu précédent sera remplacé.
8
Ajouter du texte à la fin d’un fichier avec le mode "a"

Quand vous voulez conserver le contenu déjà présent et écrire du nouveau texte à la fin, utilisez le mode "a".
python
```
with open("journal.txt", "a") as fichier:
    fichier.write("Nouvelle entrée\n")
```
Si journal.txt existe déjà, la nouvelle ligne est ajoutée à la fin. S’il n’existe pas, Python le crée.
Exemple avec plusieurs ajouts successifs :
python
```
with open("journal.txt", "a") as fichier:
    fichier.write("Début de session\n")
    fichier.write("Lecture du fichier terminée\n")
    fichier.write("Fin de session\n")
```
Le mode ajout est pratique pour :
- enregistrer des notes au fur et à mesure ;
- garder une trace simple d’actions ;
- compléter un fichier sans effacer son contenu.
Faites attention aux retours à la ligne. Si vous oubliez \n, le nouveau texte risque de se coller à la fin de la dernière ligne existante.
Exemple :
python
```
with open("journal.txt", "a") as fichier:
    fichier.write("Une ligne de plus")
```
Dans ce cas, le texte est ajouté tel quel. Si le fichier précédent ne se terminait pas par un retour à la ligne, l’affichage final peut sembler mal organisé.
9
Choisir entre écrire et ajouter

Les débutants confondent souvent les modes "w" et "a". Pourtant, leur différence est essentielle.
Utilisez "w" si vous voulez :
- créer un nouveau contenu complet ;
- remplacer le contenu précédent ;
- réécrire un fichier depuis zéro.
Utilisez "a" si vous voulez :
- conserver l’ancien contenu ;
- ajouter de nouvelles lignes à la fin ;
- faire grandir un fichier au fil du temps.
Exemple de différence :
python
```
with open("exemple.txt", "w") as fichier:
    fichier.write("Texte A\n")
```
Si vous relancez ensuite :
python
```
with open("exemple.txt", "w") as fichier:
    fichier.write("Texte B\n")
```
Le fichier ne contiendra plus Texte A, mais seulement Texte B.
En revanche :
python
```
with open("exemple.txt", "a") as fichier:
    fichier.write("Texte C\n")
```
ajoutera Texte C à la fin du contenu actuel.
Une bonne habitude consiste à se poser la question suivante avant d’exécuter un script : est-ce que je veux remplacer le fichier, ou seulement compléter son contenu ?
10
Utiliser un chemin de fichier simplement

Quand vous écrivez open("notes.txt", "r"), Python cherche le fichier dans le dossier de travail courant. Pour un débutant, le plus simple est souvent de placer le script Python et le fichier texte dans le même dossier.
Exemple d’organisation :
- mon_script.py
- notes.txt
Dans ce cas, le code reste très simple :
python
```
with open("notes.txt", "r") as fichier:
    print(fichier.read())
```
Si le fichier est dans un autre dossier, il faut fournir un chemin adapté. Pour garder ce tutoriel accessible, l’approche recommandée est de commencer avec des fichiers placés au même endroit que le script.
Ainsi, vous réduisez les risques d’erreur au moment de l’apprentissage et vous comprenez d’abord le fonctionnement de la lecture et de l’écriture elles-mêmes.
11
Exemple complet : créer puis relire un fichier

Voici un petit scénario complet très utile pour s’entraîner : écrire un fichier, puis le relire.
Étape 1 : écrire le contenu
python
```
with open("liste.txt", "w") as fichier:
    fichier.write("Pommes\n")
    fichier.write("Bananes\n")
    fichier.write("Oranges\n")
```
Étape 2 : lire le contenu
python
```
with open("liste.txt", "r") as fichier:
    contenu = fichier.read()

print(contenu)
```
Ce script montre un cycle fréquent :
1. on crée ou remplace un fichier ;
2. on y écrit plusieurs lignes ;
3. on le rouvre en lecture ;
4. on affiche son contenu.
C’est un excellent exercice débutant pour comprendre que les données écrites sont bien enregistrées et peuvent être relues ensuite.
12
Exemple complet : ajouter des lignes sans effacer l’ancien contenu

Dans beaucoup de cas, vous ne voulez pas remplacer le fichier, mais l’enrichir progressivement. Voici un exemple simple.
Créer un fichier avec une première ligne
python
```
with open("suivi.txt", "w") as fichier:
    fichier.write("Jour 1 : début\n")
```
Ajouter de nouvelles lignes
python
```
with open("suivi.txt", "a") as fichier:
    fichier.write("Jour 2 : progression\n")
    fichier.write("Jour 3 : révision\n")
```
Relire le résultat
python
```
with open("suivi.txt", "r") as fichier:
    print(fichier.read())
```
Le contenu final comprend les trois lignes, car les deux dernières ont été ajoutées à la suite.
Cet exemple résume très bien la différence entre création initiale avec "w" et enrichissement ensuite avec "a".
13
Gérer simplement les erreurs les plus courantes

Quand on travaille avec des fichiers, certaines erreurs apparaissent souvent au début.
Le fichier n’existe pas en lecture
Si vous essayez de lire un fichier absent avec le mode "r", Python renvoie une erreur.
python
```
with open("absent.txt", "r") as fichier:
    print(fichier.read())
```
Pour éviter cela pendant vos exercices, vérifiez d’abord que le fichier existe bien dans votre dossier de travail.
Le mauvais mode a été choisi
Utiliser "w" alors que vous vouliez garder le contenu existant est une erreur fréquente. Le fichier est alors remplacé.
Avant de lancer le script, vérifiez toujours si vous vouliez "w" ou "a".
Les retours à la ligne sont oubliés
Si vous écrivez plusieurs textes sans \n, tout peut se retrouver collé sur une seule ligne.
python
```
with open("test.txt", "w") as fichier:
    fichier.write("Ligne 1")
    fichier.write("Ligne 2")
```
Le résultat ne contiendra pas automatiquement deux lignes distinctes. Il faut écrire :
python
```
with open("test.txt", "w") as fichier:
    fichier.write("Ligne 1\n")
    fichier.write("Ligne 2\n")
```
Le fichier est refermé trop tard ou oublié
Si vous n’utilisez pas with, vous devez penser à close(). Pour débuter, utilisez with aussi souvent que possible.
14
Bonne pratique débutant : toujours préférer with

Dans presque tous les exemples simples de ce tutoriel, with est utilisé. Ce n’est pas un hasard.
Comparez :
python
```
fichier = open("notes.txt", "r")
contenu = fichier.read()
print(contenu)
fichier.close()
```
et :
python
```
with open("notes.txt", "r") as fichier:
    contenu = fichier.read()
    print(contenu)
```
La seconde forme est plus lisible et plus sûre pour un débutant. Elle réduit le risque d’oublier de fermer le fichier. C’est donc une excellente habitude à prendre dès le départ.
Vous pouvez utiliser cette structure quel que soit le mode :
- "r" pour lire ;
- "w" pour écrire ;
- "a" pour ajouter.
Exemples :
python
```
with open("lecture.txt", "r") as fichier:
    print(fichier.read())
```
python
```
with open("ecriture.txt", "w") as fichier:
    fichier.write("Bonjour\n")
```
python
```
with open("ajout.txt", "a") as fichier:
    fichier.write("Encore une ligne\n")
```
15
Mini-projet débutant : carnet de notes texte

Pour terminer, voici un mini-projet très simple qui combine lecture, écriture et ajout. Le but est de créer un petit carnet de notes dans un fichier texte.
1. Créer le carnet
python
```
with open("carnet.txt", "w") as fichier:
    fichier.write("Mes notes\n")
    fichier.write("---------\n")
```
On crée ici un fichier avec un titre.
2. Ajouter quelques notes
python
```
with open("carnet.txt", "a") as fichier:
    fichier.write("Apprendre open()\n")
    fichier.write("Tester read()\n")
    fichier.write("Comprendre la différence entre w et a\n")
```
Le fichier est complété sans perdre le titre déjà écrit.
3. Lire le carnet
python
```
with open("carnet.txt", "r") as fichier:
    contenu = fichier.read()

print(contenu)
```
Ce mini-projet vous entraîne à :
- créer un fichier ;
- ajouter du texte ;
- relire le contenu final.
Vous pouvez l’améliorer de manière progressive, par exemple en ajoutant plus de lignes, en lisant le fichier ligne par ligne, ou en affichant chaque note avec un numéro à l’aide d’une boucle.

Erreurs fréquentes & dépannage

Utiliser le mode "w" par erreur : ce mode remplace le contenu existant.
Oublier \n : plusieurs textes peuvent se retrouver collés sur une seule ligne.
Lire un fichier absent avec "r" : Python renvoie une erreur si le fichier n’existe pas.
Oublier de fermer un fichier : utilisez with pour éviter ce problème.
Placer le fichier dans le mauvais dossier : pour débuter, gardez le script et le fichier texte dans le même dossier.

Astuces & pour aller plus loin

Commencez vos essais avec des fichiers très simples comme notes.txt ou test.txt.
Après chaque écriture, ouvrez le fichier dans votre éditeur pour vérifier le résultat concret.
Utilisez strip() quand vous lisez ligne par ligne et que l’affichage contient des sauts de ligne gênants.
Choisissez le mode d’ouverture avant même d’écrire le code : lire, remplacer ou ajouter.
Prenez l’habitude d’utiliser with open(...) dans presque tous vos exercices sur les fichiers.

Questions fréquentes

Quelle est la différence entre "w" et "a" en Python ?

Le mode "w" écrit un nouveau contenu et remplace l’ancien s’il existe. Le mode "a" ajoute du texte à la fin du fichier sans supprimer le contenu déjà présent.

Pourquoi utiliser with pour ouvrir un fichier ?

Le bloc with referme automatiquement le fichier à la fin. Cela rend le code plus simple et évite d’oublier close().

Comment lire tout un fichier texte d’un coup ?

Vous pouvez ouvrir le fichier en mode "r" puis utiliser read() pour récupérer tout le contenu dans une chaîne de caractères.

Comment lire un fichier ligne par ligne ?

Vous pouvez parcourir le fichier avec une boucle for. À chaque tour, vous récupérez une ligne dans une variable, par exemple for ligne in fichier:.

Pourquoi mes lignes s’écrivent-elles à la suite ?

La méthode write() n’ajoute pas automatiquement de saut de ligne. Il faut insérer \n dans les chaînes quand vous voulez passer à la ligne suivante.

Conclusion

Vous savez maintenant manipuler des fichiers texte en Python à un niveau débutant. Vous avez vu comment ouvrir un fichier avec open(), lire son contenu avec read() ou ligne par ligne, écrire du texte avec write(), et ajouter du contenu sans effacer l’existant grâce au mode "a".

La compétence la plus importante à retenir est le choix du bon mode d’ouverture : "r" pour lire, "w" pour remplacer, et "a" pour compléter. En prenant aussi l’habitude d’utiliser with, vous disposerez d’une base solide pour tous vos premiers scripts qui sauvegardent ou relisent du texte.

Le mieux, à partir d’ici, est de pratiquer sur de petits exemples : une liste, un journal simple, ou un carnet de notes. Ce sont des exercices courts, mais ils installent des réflexes très utiles pour la suite de l’apprentissage de Python.

Prérequis

Matériel nécessaire

Étapes

Comprendre ce qu’est un fichier texte

Découvrir la fonction open()

Connaître les modes d’ouverture utiles

Mode lecture : "r"

Mode écriture : "w"

Mode ajout : "a"

Lire tout le contenu d’un fichier avec read()

Lire une seule ligne avec readline()

Lire un fichier ligne par ligne avec une boucle for

Écrire du texte dans un fichier avec write()

Ajouter du texte à la fin d’un fichier avec le mode "a"

Choisir entre écrire et ajouter

Utilisez "w" si vous voulez :

Utilisez "a" si vous voulez :

Utiliser un chemin de fichier simplement

Exemple complet : créer puis relire un fichier

Étape 1 : écrire le contenu

Étape 2 : lire le contenu

Exemple complet : ajouter des lignes sans effacer l’ancien contenu

Créer un fichier avec une première ligne

Ajouter de nouvelles lignes

Relire le résultat

Gérer simplement les erreurs les plus courantes

Le fichier n’existe pas en lecture

Le mauvais mode a été choisi

Les retours à la ligne sont oubliés

Le fichier est refermé trop tard ou oublié

Bonne pratique débutant : toujours préférer with

Mini-projet débutant : carnet de notes texte

1. Créer le carnet

2. Ajouter quelques notes

3. Lire le carnet

Erreurs fréquentes & dépannage

Astuces & pour aller plus loin

Questions fréquentes

Quelle est la différence entre "w" et "a" en Python ?

Pourquoi utiliser with pour ouvrir un fichier ?

Comment lire tout un fichier texte d’un coup ?

Comment lire un fichier ligne par ligne ?

Pourquoi mes lignes s’écrivent-elles à la suite ?

Conclusion

Commentaires· Aucun commentaire pour l'instant

Laisser un commentaire

Mode lecture : `"r"`

Mode écriture : `"w"`

Mode ajout : `"a"`

Utilisez `"w"` si vous voulez :

Utilisez `"a"` si vous voulez :