Introduction
Dans de nombreuses applications, les données doivent être conservées après l'exécution d'un programme. Or, les variables Python (listes, dictionnaires, etc.) sont stockées en mémoire vive (RAM) et disparaissent lorsque le programme se termine.
Un fichier permet par exemple de :
- sauvegarder des résultats de calcul ;
- stocker des données expérimentales ;
- lire un jeu de données ;
- enregistrer des configurations ou des journaux (logs).
.txt (texte brut), .csv (données tabulaires), .json (données structurées), et les fichiers binaires.Ouvrir un fichier
Avant toute opération, il faut ouvrir le fichier avec la fonction open.
f = open("nom_fichier", mode)"nom_fichier": chemin absolu ou relatif du fichier.mode: chaîne décrivant le mode d'ouverture.
| Mode | Signification | Remarque |
|---|---|---|
"r" | Lecture seule | Erreur si le fichier n'existe pas |
"w" | Écriture | Efface le contenu existant |
"a" | Ajout à la fin | Crée le fichier s'il n'existe pas |
"x" | Création exclusive | Erreur si le fichier existe déjà |
"r+" | Lecture + écriture | Pointeur en début de fichier |
"rb" / "wb" | Mode binaire (lecture / écriture) | Pour fichiers non texte (images, PDF…) |
Exemple — Ouverture en lecture
f = open("donnees.txt", "r")r : r"C:\dossier\fichier.txt". Cela évite d'interpréter \n, \t, etc. comme des caractères spéciaux.Fermer un fichier
Après utilisation, il est obligatoire de fermer le fichier.
f.close()La fermeture du fichier permet de :
- libérer les ressources système ;
- garantir que les données sont bien écrites sur le disque (flush) ;
- éviter les corruptions de fichiers.
Exemple — Ouverture, lecture et fermeture
f = open("donnees.txt", "r")
contenu = f.read()
f.close()
print(contenu)with qui ferme le fichier automatiquement, même en cas d'erreur. Voir la section dédiée.Lire un fichier
Python propose plusieurs méthodes pour lire le contenu d'un fichier texte, adaptées à des cas d'usage différents.
Lire tout le contenu : read()
texte = f.read() # lit tout le fichier en une chaîne
texte = f.read(n) # lit au plus n caractèresExemple — Lecture complète
Supposons le fichier langages.txt suivant :
Python Java C++
f = open("langages.txt", "r")
texte = f.read()
f.close()
print(texte)Python Java C++
Lire ligne par ligne : readline()
ligne = f.readline() # retourne la prochaine ligne (avec '\n')À chaque appel, readline() avance le curseur de lecture d'une ligne. Quand le fichier est entièrement lu, elle retourne une chaîne vide "".
Exemple — Lecture de deux lignes successives
f = open("langages.txt", "r")
ligne1 = f.readline() # "Python\n"
ligne2 = f.readline() # "Java\n"
f.close()
print(repr(ligne1)) # affiche le \n visible'Python\n'
ligne.strip() ou plus précisément ligne.rstrip('\n') si vous voulez conserver les espaces en début de ligne.Lire toutes les lignes : readlines()
lignes = f.readlines() # retourne une liste de chaînesExemple — Obtenir la liste des lignes
f = open("langages.txt", "r")
lignes = f.readlines()
f.close()
print(lignes)['Python\n', 'Java\n', 'C++\n']
Parcourir avec une boucle for — méthode recommandée
for ligne in f:
# traitementExemple — Afficher chaque ligne sans double saut de ligne
f = open("langages.txt", "r")
for ligne in f:
print(ligne.strip()) # strip() supprime le \n
f.close()Python Java C++
| Méthode | Retour | Usage recommandé |
|---|---|---|
f.read() | str — tout le fichier | Petits fichiers, traitement global |
f.read(n) | str — n caractères | Lecture partielle, protocoles binaires |
f.readline() | str — une ligne | Lecture séquentielle contrôlée |
f.readlines() | list[str] — toutes les lignes | Accès aléatoire aux lignes (petits fichiers) |
for ligne in f | str — ligne par ligne | ⭐ Méthode recommandée — grands fichiers |
Écrire dans un fichier
f.write(chaine) # écrit la chaîne dans le fichier
f.writelines(liste) # écrit toutes les chaînes de la listewrite() n'ajoute pas automatiquement de saut de ligne. Il faut explicitement écrire "\n" si nécessaire.Exemple — Écriture dans un nouveau fichier
f = open("resultat.txt", "w")
f.write("Bonjour\n")
f.write("Python\n")
f.close()Contenu du fichier resultat.txt obtenu :
Bonjour Python
"w" efface entièrement le contenu précédent du fichier avant d'écrire. Pour ajouter sans effacer le contenu existant, utiliser le mode "a".Ajouter dans un fichier
f = open("fichier.txt", "a")
f.write("Nouvelle ligne\n")
f.close()Le mode "a" (append) place le curseur en fin de fichier : les données existantes sont préservées, et les nouvelles données sont ajoutées à la suite.
"a" le crée automatiquement, comme le mode "w". C'est donc la méthode sûre pour alimenter un fichier de log en continu.Utilisation de with — méthode recommandée
with open(...) as f: est le gestionnaire de contexte de Python. Elle garantit la fermeture automatique du fichier en fin de bloc, même si une exception survient pendant le traitement.with open("donnees.txt", "r") as f:
contenu = f.read()
# f est automatiquement fermé ici — même en cas d'erreurSans with | Avec with |
|---|---|
Fermeture manuelle obligatoire (f.close()) | Fermeture automatique en fin de bloc |
| Risque d'oubli si une exception est levée | Sûr même en cas d'erreur |
| Code plus verbeux | Code plus lisible et concis |
| Fuite de ressource possible | Ressources toujours libérées |
Exemple — Lecture avec with
with open("donnees.txt", "r") as f:
for ligne in f:
print(ligne.strip())Exemple — Écriture avec with
with open("resultat.txt", "w") as f:
f.write("Ligne 1\n")
f.write("Ligne 2\n")open("fichier.txt", "r", encoding="utf-8").Exemples complets
Compter les lignes d'un fichier
Écrire une fonction compter_lignes(nom) qui retourne le nombre de lignes d'un fichier texte.
def compter_lignes(nom_fichier):
compteur = 0
with open(nom_fichier, "r") as f:
for ligne in f:
compteur += 1
return compteur
print(compter_lignes("donnees.txt")) # Résultat : 3return sum(1 for _ in open(nom_fichier)) mais la version avec with reste préférable pour la sécurité (fermeture garantie du fichier).Sauvegarder une liste dans un fichier
Sauvegarder la liste [10, 20, 30, 40] dans le fichier nombres.txt, un nombre par ligne.
nombres = [10, 20, 30, 40]
with open("nombres.txt", "w") as f:
for x in nombres:
f.write(str(x) + "\n")Fichier nombres.txt obtenu :
10 20 30 40
writelines On peut utiliser writelines pour écrire la liste en une seule instruction : f.writelines(str(x) + "\n" for x in nombres).Lire un fichier de nombres
Écrire une fonction lire_nombres(fichier) qui lit nombres.txt et retourne une liste d'entiers.
def lire_nombres(fichier):
L = []
with open(fichier, "r") as f:
for ligne in f:
L.append(int(ligne.strip()))
return L
print(lire_nombres("nombres.txt"))[10, 20, 30, 40]
strip() est indispensable ici pour supprimer le \n avant la conversion avec int(). Sans cela, Python lèverait une ValueError.Statistiques sur un fichier
Écrire une fonction statistiques(fichier) qui lit un fichier de nombres entiers (un par ligne) et affiche leur somme, moyenne, minimum et maximum.
def statistiques(fichier):
nombres = []
with open(fichier, "r") as f:
for ligne in f:
nombres.append(int(ligne.strip()))
n = len(nombres)
print(f"Nb de valeurs : {n}")
print(f"Somme : {sum(nombres)}")
print(f"Moyenne : {sum(nombres)/n:.2f}")
print(f"Minimum : {min(nombres)}")
print(f"Maximum : {max(nombres)}")
statistiques("nombres.txt")Nb de valeurs : 4 Somme : 100 Moyenne : 25.00 Minimum : 10 Maximum : 40
Gestion des erreurs
- le fichier demandé n'existe pas (
FileNotFoundError) ; - les permissions insuffisantes (
PermissionError) ; - un format de données inattendu dans le fichier (
ValueError).
try:
with open("donnees.txt", "r") as f:
contenu = f.read()
except FileNotFoundError:
print("Erreur : fichier introuvable.")
except PermissionError:
print("Erreur : accès refusé.")Exemple — Vérifier l'existence avant d'ouvrir
import os
nom = "donnees.txt"
if os.path.exists(nom):
with open(nom, "r") as f:
print(f.read())
else:
print(f"Le fichier '{nom}' n'existe pas.")os.path Le module os.pathoffre plusieurs fonctions utiles pour manipuler les chemins et vérifier l'état des fichiers :os.path.exists(p)— vérifie si le chemin existeos.path.isfile(p)— vérifie que c'est bien un fichieros.path.getsize(p)— retourne la taille en octetsos.path.basename(p)— retourne le nom du fichier seulos.path.dirname(p)— retourne le répertoire parent
Bonnes pratiques
- Toujours utiliser
with openpour fermer automatiquement le fichier. - Encadrer les opérations dans un
try/exceptpour gérer les erreurs. - Utiliser
strip()lors de la lecture pour nettoyer les retours à la ligne. - Préciser l'encodage si nécessaire :
open("f.txt", "r", encoding="utf-8"). - Préférer la boucle
forsur le fichier àreadlines()pour les grands fichiers.
Exemple — Modèle complet et robuste
import os
def lire_fichier_robuste(nom_fichier):
"""Lit un fichier texte de façon sûre et retourne son contenu ligne par ligne."""
if not os.path.isfile(nom_fichier):
print(f"[ERREUR] Le fichier '{nom_fichier}' est introuvable.")
return []
try:
lignes = []
with open(nom_fichier, "r", encoding="utf-8") as f:
for ligne in f:
lignes.append(ligne.strip())
return lignes
except PermissionError:
print(f"[ERREUR] Accès refusé au fichier '{nom_fichier}'.")
return []
contenu = lire_fichier_robuste("donnees.txt")
for ligne in contenu:
print(ligne)
Discussion (0)
Soyez le premier à laisser un commentaire !
Laisser un commentaire
Votre commentaire sera visible après modération.