Niveau : Intermédiaire

Chapitre 22 : Manipulation de Fichiers

open, with, read, write, pathlib, CSV

Objectif

Ce module a pour but de vous apprendre à lire et écrire dans des fichiers en Python. Vous découvrirez la bonne manière d'ouvrir et de fermer des fichiers en utilisant le gestionnaire de contexte with, et comment interagir avec des fichiers texte et des fichiers structurés comme le CSV.

1. Lire un Fichier Texte

La manière la plus courante et la plus sûre de travailler avec des fichiers est d'utiliser l'instruction with. Elle garantit que le fichier sera automatiquement fermé à la fin du bloc, même si des erreurs se produisent.

# 'r' est le mode : 'r' pour read (lecture), 'w' pour write (écriture), 'a' pour append (ajout).
# 't' pour text mode (par défaut), 'b' pour binary mode.
# Donc 'r' est équivalent à 'rt'.

try:
    with open('mon_fichier.txt', 'r', encoding='utf-8') as f:
        # 'f' est l'objet fichier

        # Lire le fichier entier d'un coup
        contenu = f.read()
        print("--- Contenu complet ---")
        print(contenu)

    with open('mon_fichier.txt', 'r', encoding='utf-8') as f:
        # Lire le fichier ligne par ligne (plus efficace pour les gros fichiers)
        print("\n--- Lecture ligne par ligne ---")
        for ligne in f:
            # .strip() enlève les espaces et sauts de ligne en début/fin de chaîne
            print(ligne.strip())

    with open('mon_fichier.txt', 'r', encoding='utf-8') as f:
        # Lire toutes les lignes dans une liste
        lignes = f.readlines()
        print("\n--- Lignes dans une liste ---")
        print(lignes)

except FileNotFoundError:
    print("Erreur : Le fichier n'a pas été trouvé.")

Note sur encoding='utf-8' : Il est crucial de toujours spécifier l'encodage. utf-8 est le standard le plus universel aujourd'hui et gère la plupart des caractères (accents, symboles, etc.). Omettre cet argument peut causer des erreurs sur différents systèmes d'exploitation qui n'ont pas le même encodage par défaut.

2. Écrire dans un Fichier Texte

a. Mode Écriture ('w')

Le mode 'w' (write) ouvre un fichier pour l'écriture. Attention : Si le fichier existe déjà, son contenu sera écrasé. S'il n'existe pas, il sera créé.

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

with open('nouveau_fichier.txt', 'w', encoding='utf-8') as f:
    # Écrire une seule chaîne
    f.write("Hello, World!\n")

    # Écrire une liste de chaînes
    f.writelines(lignes_a_ecrire)

# Vérifions le contenu
with open('nouveau_fichier.txt', 'r', encoding='utf-8') as f:
    print(f.read())

Résultat dans nouveau_fichier.txt :

Hello, World!
Première ligne.
Deuxième ligne.
Troisième ligne.

b. Mode Ajout ('a')

Le mode 'a' (append) ouvre un fichier pour ajouter du contenu à la fin. Si le fichier n'existe pas, il est créé. Le contenu existant n'est pas effacé.

with open('nouveau_fichier.txt', 'a', encoding='utf-8') as f:
    f.write("Ceci est une ligne ajoutée.\n")

# Vérifions à nouveau le contenu
with open('nouveau_fichier.txt', 'r', encoding='utf-8') as f:
    print(f.read())

Nouveau résultat dans nouveau_fichier.txt :

Hello, World!
Première ligne.
Deuxième ligne.
Troisième ligne.
Ceci est une ligne ajoutée.

3. Travailler avec les Chemins de Fichiers (pathlib)

Manipuler les chemins de fichiers avec de simples chaînes de caractères peut être source d'erreurs, notamment entre Windows (qui utilise \) et Linux/macOS (qui utilisent /).

Le module pathlib, introduit en Python 3.4, offre une approche orientée objet pour gérer les chemins de fichiers de manière portable.

from pathlib import Path

# Créer un objet Path
# Le / fonctionne sur tous les systèmes, pathlib le convertira correctement.
chemin = Path('dossier') / 'sous_dossier' / 'mon_fichier.txt'

print(f"Chemin complet : {chemin}")
print(f"Nom du fichier : {chemin.name}")
print(f"Extension : {chemin.suffix}")
print(f"Dossier parent : {chemin.parent}")

# Créer les dossiers parents s'ils n'existent pas
chemin.parent.mkdir(parents=True, exist_ok=True)

# Utiliser le chemin directement avec open()
with open(chemin, 'w', encoding='utf-8') as f:
    f.write("Fichier créé avec pathlib.")

# Vérifier si un fichier existe
if chemin.exists():
    print(f"Le fichier '{chemin}' existe.")

4. Travailler avec des Fichiers CSV

CSV (Comma-Separated Values) est un format texte très courant pour stocker des données tabulaires. Le module csv de la bibliothèque standard facilite grandement sa manipulation.

a. Lire un fichier CSV

Imaginons un fichier personnes.csv :

nom,age,ville
Alice,30,Paris
Bob,25,Lyon
Charlie,35,Marseille

Code Python pour le lire :

import csv

with open('personnes.csv', 'r', encoding='utf-8', newline='') as f:
    # DictReader lit chaque ligne comme un dictionnaire
    lecteur_csv = csv.DictReader(f)

    for ligne in lecteur_csv:
        # ligne est un dictionnaire ordonné (OrderedDict)
        print(f"{ligne['nom']} a {ligne['age']} ans et vit à {ligne['ville']}.")

newline='' est important pour éviter des problèmes de sauts de ligne sur différents systèmes.

b. Écrire un fichier CSV

import csv

# Données à écrire (liste de dictionnaires)
donnees = [
    {'nom': 'David', 'age': 40, 'ville': 'Nantes'},
    {'nom': 'Eve', 'age': 28, 'ville': 'Bordeaux'}
]

# Noms des colonnes (doivent correspondre aux clés des dictionnaires)
noms_colonnes = ['nom', 'age', 'ville']

with open('nouvelles_personnes.csv', 'w', encoding='utf-8', newline='') as f:
    # DictWriter écrit des dictionnaires dans un fichier CSV
    ecrivain_csv = csv.DictWriter(f, fieldnames=noms_colonnes)

    # Écrit la ligne d'en-tête
    ecrivain_csv.writeheader()

    # Écrit les lignes de données
    ecrivain_csv.writerows(donnees)

print("Fichier 'nouvelles_personnes.csv' créé.")

Conclusion

La manipulation de fichiers est une compétence essentielle en programmation. Python la rend particulièrement simple et sûre grâce au gestionnaire de contexte with. En utilisant pathlib pour gérer les chemins et le module csv pour les données tabulaires, vous disposez d'outils robustes pour interagir avec le système de fichiers de manière portable et efficace.

Exercices :

Exercice 22 - Compteur de Mots dans un Fichier

Objectif

Cet exercice a pour but de vous faire pratiquer la lecture de fichiers texte et la manipulation de chaînes de caractères pour compter la fréquence de chaque mot dans un fichier.

Contexte

L'analyse de texte est une tâche courante en programmation. Une des opérations de base est de compter les occurrences de chaque mot pour analyser le contenu d'un texte. Vous allez écrire un script qui lit un fichier, le nettoie, et affiche les 10 mots les plus fréquents.

Énoncé

Étape 1 : Créer le fichier texte

Créez manuellement un fichier nommé texte_a_analyser.txt et copiez-y le contenu suivant :

Python est un langage de programmation puissant. Python est simple à apprendre.
Apprendre Python ouvre de nombreuses portes.
Le langage Python est utilisé dans le développement web, la science des données et l'intelligence artificielle.
La simplicité de Python est un de ses plus grands atouts.

Étape 2 : Écrire le script Python

Créez un fichier Python nommé compteur_mots.py.

1. Définissez une fonction compter_mots(nom_fichier).

   • Cette fonction prend le nom du fichier en argument.
   • Elle doit retourner un dictionnaire où les clés sont les mots et les valeurs sont leur nombre d'occurrences.

2. Dans la fonction, lisez le fichier.

   • Utilisez with open(...) pour ouvrir et lire le contenu du fichier. Assurez-vous de gérer le cas où le fichier n'existe pas avec un bloc try...except FileNotFoundError.

3. Nettoyez et séparez le texte en mots.

   • Convertissez tout le texte en minuscules pour que "Python" et "python" soient comptés comme le même mot.
   • Supprimez les caractères de ponctuation simples comme le . et la ,. Vous pouvez importer le module string et appeler string.punctuationpour obtenir la liste des signes de ponctuations existants.
   • Séparez le texte en une liste de mots en utilisant la méthode split().

4. Comptez les mots.

   • Initialisez un dictionnaire vide, par exemple frequences = {}.
   • Itérez sur votre liste de mots.
   • Pour chaque mot, mettez à jour le dictionnaire. Si le mot est déjà dans le dictionnaire, incrémentez sa valeur. Sinon, ajoutez-le avec une valeur de 1. (L'utilisation de dict.get(mot, 0) + 1 est une manière élégante de le faire).

5. Triez les résultats.

   • Une fois le dictionnaire de fréquences rempli, vous devez le trier par valeur (fréquence) dans l'ordre décroissant.
   • La méthode sorted() avec une fonction lambda comme clé est parfaite pour cela. sorted(dictionnaire.items(), key=lambda item: item[1], reverse=True).
   • Cela retournera une liste de tuples (mot, frequence).

6. Affichez les 10 mots les plus courants.

   • Dans le bloc principal (if __name__ == '__main__':), appelez votre fonction.
   • Affichez les 10 premiers éléments de la liste triée.

Résultat Attendu

L'exécution de compteur_mots.py doit produire une sortie similaire à celle-ci (l'ordre des mots ayant la même fréquence peut varier) :

Les 10 mots les plus fréquents sont :
- python: 5
- est: 4
- de: 3
- la: 3
- un: 2
- langage: 2
- à: 1
- programmation: 1
- puissant: 1
- simple: 1

Cliquez ici pour voir un exemple de code de solution

# compteur_mots.py

import string

def compter_mots(nom_fichier: str) -> list:
    """
    Lit un fichier, compte la fréquence de chaque mot,
    et retourne une liste de (mot, fréquence) triée par fréquence.
    """
    try:
        with open(nom_fichier, 'r', encoding='utf-8') as f:
            contenu = f.read()
    except FileNotFoundError:
        print(f"Erreur : Le fichier '{nom_fichier}' n'a pas été trouvé.")
        return []

    # 1. Mettre en minuscules
    contenu = contenu.lower()

    # 2. Supprimer la ponctuation (méthode simple)
    # On remplace chaque signe de ponctuation par ''
    for ponctuation in string.punctuation:
        contenu = contenu.replace(ponctuation, "")

    # 3. Séparer en mots (split par défaut sur les espaces)
    mots = contenu.split()

    # 4. Compter les fréquences
    frequences = {}
    for mot in mots:
        # dict.get(key, default) retourne la valeur de la clé si elle existe,
        # sinon retourne default.
        frequences[mot] = frequences.get(mot, 0) + 1

    # 5. Trier par fréquence décroissante
    # sorted() retourne une liste
    # key=lambda item: item[1] signifie qu'on trie sur la valeur (la fréquence)
    mots_tries = sorted(frequences.items(), key=lambda item: item[1], reverse=True)

    return mots_tries

if __name__ == "__main__":
    nom_fichier = "texte_a_analyser.txt"
    # Création du fichier pour le test si nécessaire
    # (Ou on suppose qu'il existe comme demandé dans l'énoncé)
    
    resultats = compter_mots(nom_fichier)

    if resultats:
        print("Les 10 mots les plus fréquents sont :")
        for mot, freq in resultats[:10]:
            print(f"- {mot}: {freq}")