Les méthodes Python file.write(), file.writelines(), writable & write_through

Contenu du cours

À propos des méthodes d’écriture sur fichiers
La méthode file.write() : écrire une chaîne unique
Simuler file.writeline() : écrire une ligne avec retour chariot
La méthode file.writelines() : écrire plusieurs lignes
Différence essentielle entre write() et writelines()
La méthode file.writable() : vérifier si le fichier supporte l’écriture
Le paramètre write_through() : contrôler le buffer d’écriture

1. À propos des méthodes d’écriture sur fichiers

En Python, pour manipuler des fichiers textes, on utilise l’objet fichier obtenu avec open(). Trois méthodes permettent d’écrire : write(), writelines(). Note : writeline n’existe pas seule — il s’agit souvent d’une confusion avec write() ajoutant \n manuellement. Nous verrons aussi comment simuler writeline si nécessaire.

Ces méthodes ne retournent rien, mais modifient directement le contenu du fichier. Il est essentiel d’ouvrir le fichier en mode écriture : 'w' (écrase), 'a' (ajoute) ou 'x' (création exclusive).

2. La méthode file.write() : écrire une chaîne unique

write() écrit exactement la chaîne passée en paramètre, sans ajout automatique de retour à la ligne. C’est la méthode la plus simple pour écrire du texte brut.

# Ouvrir (ou créer) un fichier en mode écriture
fichier = open("exemple_write.txt", "w", encoding="utf-8")

# write() ne met pas de \n automatiquement
fichier.write("Première ligne sans retour chariot")
fichier.write("Ceci sera collé à la ligne précédente")

# Ajouter manuellement \n
fichier.write("\nTroisième ligne après saut explicite\n")
fichier.write("Dernière ligne")

# Ne pas oublier de fermer
fichier.close()

# Vérification rapide (lecture)
with open("exemple_write.txt", "r", encoding="utf-8") as f:
    contenu = f.read()
    print(repr(contenu))
    # sortie: 'Première ligne sans retour chariotCeci sera collé à la ligne précédente\nTroisième ligne après saut explicite\nDernière ligne'

# Ouvrir (ou créer) un fichier en mode écriture

fichier = open("exemple_write.txt", "w", encoding="utf-8")

# write() ne met pas de \n automatiquement

fichier.write("Première ligne sans retour chariot")

fichier.write("Ceci sera collé à la ligne précédente")

# Ajouter manuellement \n

fichier.write("\nTroisième ligne après saut explicite\n")

fichier.write("Dernière ligne")

# Ne pas oublier de fermer

fichier.close()

# Vérification rapide (lecture)

with open("exemple_write.txt", "r", encoding="utf-8") as f:

contenu = f.read()

print(repr(contenu))

# sortie: 'Première ligne sans retour chariotCeci sera collé à la ligne précédente\nTroisième ligne après saut explicite\nDernière ligne'

3. Simuler file.writeline() : écrire une ligne avec retour chariot

Il n’existe pas de méthode writeline(). Pour écrire une ligne terminée correctement, on utilise write() + '\n'. On peut créer une petite fonction utilitaire si nécessaire.

# Écrire des lignes avec saut de ligne automatique
f = open("lignes_propres.txt", "w", encoding="utf-8")

# writeline "maison" : write + \n
def writeline(fichier, ligne):
    fichier.write(ligne + "\n")

writeline(f, "Ligne 1 : Python est génial")
writeline(f, "Ligne 2 : Les fichiers sont simples")
writeline(f, "Ligne 3 : Fin du bloc")

f.close()

# Affichage du contenu
with open("lignes_propres.txt", "r", encoding="utf-8") as f:
    for ligne in f:
        print(ligne, end="")
# sortie:
# Ligne 1 : Python est génial
# Ligne 2 : Les fichiers sont simples
# Ligne 3 : Fin du bloc

# Écrire des lignes avec saut de ligne automatique

f = open("lignes_propres.txt", "w", encoding="utf-8")

# writeline "maison" : write + \n

def writeline(fichier, ligne):

fichier.write(ligne + "\n")

writeline(f, "Ligne 1 : Python est génial")

writeline(f, "Ligne 2 : Les fichiers sont simples")

writeline(f, "Ligne 3 : Fin du bloc")

f.close()

# Affichage du contenu

with open("lignes_propres.txt", "r", encoding="utf-8") as f:

for ligne in f:

print(ligne, end="")

# sortie:

# Ligne 1 : Python est génial

# Ligne 2 : Les fichiers sont simples

# Ligne 3 : Fin du bloc

4. La méthode file.writelines() : écrire plusieurs lignes

writelines() accepte un itérable de chaînes (liste, tuple, etc.). Elle écrit chaque chaîne successivement, mais sans insérer de \n entre elles. Il faut donc que chaque chaîne contienne déjà son propre caractère de fin de ligne.

# Liste de lignes à écrire (chaque élément doit contenir \n si besoin)
donnees = [
    "Nom: Alice\n",
    "Âge: 30\n",
    "Ville: Paris\n",
    "---\n"
]

with open("writelines_demo.txt", "w", encoding="utf-8") as fichier:
    fichier.writelines(donnees)  # écrit toutes les chaînes à la suite

# Lecture pour vérifier
with open("writelines_demo.txt", "r", encoding="utf-8") as f:
    print(f.read())
# sortie:
# Nom: Alice
# Âge: 30
# Ville: Paris
# ---

# Liste de lignes à écrire (chaque élément doit contenir \n si besoin)

donnees = [

"Nom: Alice\n",

"Âge: 30\n",

"Ville: Paris\n",

"---\n"

]

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

fichier.writelines(donnees) # écrit toutes les chaînes à la suite

# Lecture pour vérifier

with open("writelines_demo.txt", "r", encoding="utf-8") as f:

print(f.read())

# sortie:

# Nom: Alice

# Âge: 30

# Ville: Paris

# ---

5. Différence essentielle entre write() et writelines()

write() : un seul argument chaîne. writelines() : un itérable de chaînes. Aucune des deux n’ajoute automatiquement de retour à la ligne. Exemple comparatif concret.

# Comparaison côte à côte
f = open("comparaison.txt", "w", encoding="utf-8")

# write simple
f.write("write() : une seule chaîne\n")
f.write("write() : une autre ligne\n")

# writelines avec des chaînes bien formatées (contenant \n)
lignes_pour_writelines = [
    "writelines() : première ligne\n",
    "writelines() : deuxième ligne\n",
    "writelines() : troisième sans \\n ?"  # volontairement pas de \n
]
f.writelines(lignes_pour_writelines)

f.close()

with open("comparaison.txt", "r", encoding="utf-8") as f:
    contenu = f.read()
    print(repr(contenu))
# sortie:
# 'write() : une seule chaîne\nwrite() : une autre ligne\nwritelines() : première ligne\nwritelines() : deuxième ligne\nwritelines() : troisième sans \\n ?'
# La dernière partie n'a pas de retour à la ligne (attention à l'effet)

# Comparaison côte à côte

f = open("comparaison.txt", "w", encoding="utf-8")

# write simple

f.write("write() : une seule chaîne\n")

f.write("write() : une autre ligne\n")

# writelines avec des chaînes bien formatées (contenant \n)

lignes_pour_writelines = [

"writelines() : première ligne\n",

"writelines() : deuxième ligne\n",

"writelines() : troisième sans \\n ?" # volontairement pas de \n

]

f.writelines(lignes_pour_writelines)

f.close()

with open("comparaison.txt", "r", encoding="utf-8") as f:

contenu = f.read()

print(repr(contenu))

# sortie:

# 'write() : une seule chaîne\nwrite() : une autre ligne\nwritelines() : première ligne\nwritelines() : deuxième ligne\nwritelines() : troisième sans \\n ?'

# La dernière partie n'a pas de retour à la ligne (attention à l'effet)

6. La méthode file.writable() : vérifier si le fichier supporte l’écriture

writable() est une méthode qui retourne True si le fichier a été ouvert en mode écriture ('w', 'a', 'r+', 'w+', etc.), sinon False. Très utile pour éviter des erreurs lorsqu’on reçoit un objet fichier en paramètre.

# Créer d'abord le fichier 
with open("test_lecture.txt", "w") as f:
    f.write("Contenu initial")
f.close()

# Maintenant on peut ouvrir en lecture
f_lecture = open("test_lecture.txt", "r")  # lecture seule
f_ecriture = open("test_ecriture.txt", "w")  # écriture
f_ajout = open("test_ajout.txt", "a")  # ajout

print(f_lecture.writable())   # sortie: False
print(f_ecriture.writable())  # sortie: True
print(f_ajout.writable())     # sortie: True

f_lecture.close()
f_ecriture.close()
f_ajout.close()
"""
Output:
False
True
True
"""

# Créer d'abord le fichier

with open("test_lecture.txt", "w") as f:

f.write("Contenu initial")

f.close()

# Maintenant on peut ouvrir en lecture

f_lecture = open("test_lecture.txt", "r") # lecture seule

f_ecriture = open("test_ecriture.txt", "w") # écriture

f_ajout = open("test_ajout.txt", "a") # ajout

print(f_lecture.writable()) # sortie: False

print(f_ecriture.writable()) # sortie: True

print(f_ajout.writable()) # sortie: True

f_lecture.close()

f_ecriture.close()

f_ajout.close()

"""

Output:

False

True

"""

7. Le paramètre write_through() : contrôler le buffer d’écriture

write_through n’est pas une méthode, mais un paramètre du constructeur open() pour les fichiers ouverts en mode texte avec buffering. Lorsqu’on utilise open(file, 'w', buffering=1, write_through=True), chaque appel à write() ou writelines() vide immédiatement le buffer sur le disque (équivalent à un flush() automatique).

Par défaut, write_through=False : les écritures sont bufferisées pour des performances optimales. write_through=True garantit qu’aucune donnée n’est perdue en cas de crash, mais ralentit les écritures fréquentes.

# Sans write_through : bufferisation classique
with open("buffer_normal.txt", "w", encoding="utf-8") as f:
    f.write("Première ligne\n")
    # ici les données peuvent encore être dans le buffer mémoire
    f.write("Deuxième ligne\n")
    # à la fermeture (sortie du with), tout est vidé sur le disque

# Avec write_through=True : écriture immédiate sur le disque
with open("buffer_through.txt", "w", encoding="utf-8", buffering=1, write_through=True) as f:
    f.write("Écriture immédiate 1\n")  # vidé directement sur disque
    f.write("Écriture immédiate 2\n")  # vidé directement sur disque
    # Pas d'attente, mais plus lent pour beaucoup de petites écritures

# Démonstration de l'effet buffer (sans write_through)
import time
with open("test_perf.txt", "w", encoding="utf-8") as f:
    debut = time.time()
    for i in range(1000):
        f.write(f"Ligne {i}\n")
    fin = time.time()
    print(f"Sans write_through : {fin - debut:.4f} secondes")
    # sortie: Sans write_through : 0.0023 secondes (exemple)

with open("test_perf_through.txt", "w", encoding="utf-8", buffering=1, write_through=True) as f:
    debut = time.time()
    for i in range(1000):
        f.write(f"Ligne {i}\n")
    fin = time.time()
    print(f"Avec write_through : {fin - debut:.4f} secondes")
    # sortie: Avec write_through : 0.0156 secondes (exemple, plus lent)

# Sans write_through : bufferisation classique

with open("buffer_normal.txt", "w", encoding="utf-8") as f:

f.write("Première ligne\n")

# ici les données peuvent encore être dans le buffer mémoire

f.write("Deuxième ligne\n")

# à la fermeture (sortie du with), tout est vidé sur le disque

# Avec write_through=True : écriture immédiate sur le disque

with open("buffer_through.txt", "w", encoding="utf-8", buffering=1, write_through=True) as f:

f.write("Écriture immédiate 1\n") # vidé directement sur disque

f.write("Écriture immédiate 2\n") # vidé directement sur disque

# Pas d'attente, mais plus lent pour beaucoup de petites écritures

# Démonstration de l'effet buffer (sans write_through)

import time

with open("test_perf.txt", "w", encoding="utf-8") as f:

debut = time.time()

for i in range(1000):

f.write(f"Ligne {i}\n")

fin = time.time()

print(f"Sans write_through : {fin - debut:.4f} secondes")

# sortie: Sans write_through : 0.0023 secondes (exemple)

with open("test_perf_through.txt", "w", encoding="utf-8", buffering=1, write_through=True) as f:

debut = time.time()

for i in range(1000):

f.write(f"Ligne {i}\n")

fin = time.time()

print(f"Avec write_through : {fin - debut:.4f} secondes")

# sortie: Avec write_through : 0.0156 secondes (exemple, plus lent)

8. Techniques et pièges à éviter

Ne pas oublier de fermer le fichier ou d’utiliser le with (contexte). write() et writelines() n’ajoutent jamais \n – c’est la responsabilité du développeur. Éviter la confusion writeline() qui n’existe pas. Utiliser writable() avant d’écrire dans un fichier reçu en paramètre. Utiliser write_through=True uniquement quand la persistance immédiate est critique (logs système, transactions).

# Piège fréquent : oublier \n dans writelines
mauvais_exemple = ["Ligne A", "Ligne B", "Ligne C"]
with open("erreur_commune.txt", "w", encoding="utf-8") as f:
    f.writelines(mauvais_exemple)  # résultat : "Ligne ALigne BLigne C" sans sauts

with open("erreur_commune.txt", "r", encoding="utf-8") as f:
    print(repr(f.read()))
# sortie: 'Ligne ALigne BLigne C'

# Bonne pratique : ajouter \n dans chaque élément
bon_exemple = [ligne + "\n" for ligne in mauvais_exemple]
with open("bonne_pratique.txt", "w", encoding="utf-8") as f:
    f.writelines(bon_exemple)

with open("bonne_pratique.txt", "r", encoding="utf-8") as f:
    print(repr(f.read()))
# sortie: 'Ligne A\nLigne B\nLigne C\n'

# Bonne pratique : vérifier writable() avant écriture
def ecriture_securisee(fichier, contenu):
    if fichier.writable():
        fichier.write(contenu)
        return True
    return False

with open("securise.txt", "w") as f:
    if ecriture_securisee(f, "Données importantes\n"):
        print("Sauvegarde OK")
    # sortie: Sauvegarde OK

# Piège fréquent : oublier \n dans writelines

mauvais_exemple = ["Ligne A", "Ligne B", "Ligne C"]

with open("erreur_commune.txt", "w", encoding="utf-8") as f:

f.writelines(mauvais_exemple) # résultat : "Ligne ALigne BLigne C" sans sauts

with open("erreur_commune.txt", "r", encoding="utf-8") as f:

print(repr(f.read()))

# sortie: 'Ligne ALigne BLigne C'

# Bonne pratique : ajouter \n dans chaque élément

bon_exemple = [ligne + "\n" for ligne in mauvais_exemple]

with open("bonne_pratique.txt", "w", encoding="utf-8") as f:

f.writelines(bon_exemple)

with open("bonne_pratique.txt", "r", encoding="utf-8") as f:

print(repr(f.read()))

# sortie: 'Ligne A\nLigne B\nLigne C\n'

# Bonne pratique : vérifier writable() avant écriture

def ecriture_securisee(fichier, contenu):

if fichier.writable():

fichier.write(contenu)

return True

return False

with open("securise.txt", "w") as f:

if ecriture_securisee(f, "Données importantes\n"):

print("Sauvegarde OK")

# sortie: Sauvegarde OK

Résumé : utilisez write() pour une chaîne, writelines() pour une liste de chaînes, et n’oubliez jamais les \n pour les retours à la ligne. La méthode writeline() n’existe pas en Python standard. writable() vérifie les droits d’écriture, et write_through=True force la persistance immédiate sur le disque.

Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/

Post Views: 43

Les méthodes Python file.write(), file.writelines(), writable & write_through

1. À propos des méthodes d’écriture sur fichiers

2. La méthode file.write() : écrire une chaîne unique

3. Simuler file.writeline() : écrire une ligne avec retour chariot

4. La méthode file.writelines() : écrire plusieurs lignes

5. Différence essentielle entre write() et writelines()

6. La méthode file.writable() : vérifier si le fichier supporte l’écriture

7. Le paramètre write_through() : contrôler le buffer d’écriture

8. Techniques et pièges à éviter

Apprendre Raspberry Pi 3 ou Pi Zero sur Nano-Ordinateur

Python pour le Data Scientist - 2e éd- Machine Learning

Apprendre Raspberry Pi : Série pour les Nuls 2ème édition

Leave a Reply Cancel reply

Apprendre à Développer des Applications Web avec PHP et Symfony (2e édition)

Apprendre l'Informatique avec Python - Méthodes et exercices - MPSI-PCSI

Python pour la Data Science & Analyse des Données