Entrées/Sorties Fichier Python

Entrées/Sorties de fichiers Python

Ce chapitre couvre les opérations d’entrée/sortie (I/O - Input/Output) fondamentales en Python, en se concentrant sur l’interaction avec la console (entrée/sortie standard) et les fichiers.

Afficher à l’écran

La fonction print() est la principale méthode pour afficher une sortie sur la sortie standard (généralement la console). Vous pouvez passer zéro ou plusieurs objets à imprimer, séparés par des virgules.

# Impression simple
print("Hello, Python!")

# Impression de plusieurs éléments (séparés par des espaces par défaut)
name = "Alice"
age = 30
print("Name:", name, "Age:", age)

# Utilisation des f-strings pour une sortie formatée (recommandé)
print(f"Name: {name}, Age: {age}")

# Contrôle des caractères séparateur et de fin
print("Item 1", "Item 2", sep=" | ") # Séparateur personnalisé
print("First line", end=" - ")       # Caractère de fin personnalisé (par défaut est '\n')
print("Second line")

Ceci produit le résultat suivant :

Hello, Python!
Name: Alice Age: 30
Name: Alice, Age: 30
Item 1 | Item 2
First line - Second line

Lecture de l’entrée clavier

Python fournit la fonction intégrée input() pour lire une ligne de texte depuis l’entrée standard (généralement le clavier).

La fonction input()

La fonction input([prompt]) affiche la chaîne prompt facultative, attend que l’utilisateur tape une entrée et appuie sur Entrée, puis renvoie le texte saisi sous forme de chaîne de caractères (string).

#!/usr/bin/env python3

user_name = input("Enter your name: ")
print(f"Hello, {user_name}!")

# L'entrée est toujours une chaîne, convertir si nécessaire
age_str = input("Enter your age: ")
try:
    age_int = int(age_str)
    print(f"You will be {age_int + 1} next year.")
except ValueError:
    print("Invalid age entered. Please enter a number.")

L’exécution de ce script pourrait ressembler à ceci :

Enter your name: Bob
Hello, Bob!
Enter your age: 25
You will be 26 next year.

Note : La fonction raw_input() de Python 2 est remplacée par input() dans Python 3. L’ancienne fonction input() de Python 2 (qui évaluait l’entrée) est supprimée.

Ouverture et fermeture de fichiers

Python fournit des fonctions et des méthodes intégrées pour la manipulation de fichiers.

La fonction open() et l’instruction with

Avant de lire ou d’écrire, vous devez ouvrir un fichier en utilisant open(). La méthode fortement recommandée est d’utiliser l’instruction with, car elle garantit que le fichier est automatiquement fermé par la suite, même si des erreurs se produisent.

Syntaxe

with open(file_path, mode='r', encoding=None) as file_object:
    # Travailler avec file_object ici
    pass # Le fichier est automatiquement fermé en quittant le bloc 'with'

Détails des paramètres :

• file_path : Chaîne de caractères (string) contenant le chemin d’accès au fichier.
• mode : Détermine comment le fichier est ouvert (par exemple, ‘r’ pour lecture, ‘w’ pour écriture, ‘a’ pour ajout, ‘b’ pour binaire, ’+’ pour mise à jour). La valeur par défaut est 'r' (lecture de texte).
• encoding : Spécifie l’encodage du texte (par exemple, 'utf-8', 'ascii'). Crucial pour les fichiers texte afin d’assurer une interprétation correcte des caractères sur différents systèmes. Spécifiez toujours l’encodage pour les fichiers texte. 'utf-8' est un choix courant et sûr.
• Des options de mise en tampon (buffering) existent également mais sont moins fréquemment modifiées.

Modes de fichier en détail :

Mode	Description
r	Lecture (par défaut). Erreur si le fichier n’est pas trouvé.
rb	Lecture en mode binaire.
r+	Lecture et écriture. Pointeur au début. Erreur si le fichier n’est pas trouvé.
rb+	Lecture et écriture en mode binaire. Pointeur au début.
w	Écriture. Crée le fichier ou tronque le fichier existant.
wb	Écriture en mode binaire. Crée ou tronque.
w+	Écriture et lecture. Crée ou tronque.
wb+	Écriture et lecture en mode binaire. Crée ou tronque.
a	Ajout (append). Crée le fichier s’il n’est pas trouvé. Pointeur à la fin.
ab	Ajout en mode binaire. Crée s’il n’est pas trouvé. Pointeur à la fin.
a+	Ajout et lecture. Crée s’il n’est pas trouvé. Pointeur à la fin pour l’écriture.
ab+	Ajout et lecture en mode binaire. Crée s’il n’est pas trouvé. Pointeur à la fin pour l’écriture.
x	Création exclusive. Erreur si le fichier existe.
xb	Création exclusive en mode binaire.
x+	Création exclusive, lecture et écriture.
xb+	Création exclusive, lecture et écriture en mode binaire.

Les attributs de l’objet fichier

L’objet fichier renvoyé par open() possède plusieurs attributs utiles :

Attribut	Description
file.closed	Booléen indiquant si le fichier est fermé.
file.mode	Le mode avec lequel le fichier a été ouvert.
file.name	Le nom du fichier.
file.encoding	L’encodage utilisé pour le fichier (pour les modes texte).

Exemple

#!/usr/bin/env python3

file_path = "sample.txt"

# Ouvrir un fichier en écriture (crée ou écrase)
try:
    with open(file_path, "w", encoding="utf-8") as f:
        print(f"Nom du fichier : {f.name}")
        print(f"Fermé ou non : {f.closed}")
        print(f"Mode d'ouverture : {f.mode}")
        print(f"Encodage : {f.encoding}")
        f.write("This is a sample line.\n")
    # Après la sortie du bloc 'with'
    print(f"\nFichier fermé maintenant ? {f.closed}") # Note : f est toujours défini, mais le fichier est fermé

except IOError as e:
    print(f"Error opening or writing file: {e}")

Ceci produit un résultat similaire à :

Name of the file: sample.txt
Closed or not : False
Opening mode : w
Encoding : utf-8

File closed now? True

La méthode close() (et pourquoi with est meilleure)

Les objets fichier ont une méthode close(). Si vous ouvrez un fichier sans l’instruction with, vous devez appeler explicitement close() pour vous assurer que les données sont écrites sur le disque et que les ressources sont libérées. Cependant, oublier de fermer ou rencontrer des erreurs avant la fermeture peut entraîner des problèmes.

Fermeture manuelle (moins recommandée) :

# Ouverture/fermeture manuelle - À éviter si possible
f = None # Initialiser à None
try:
    f = open("old_style.txt", "w", encoding="utf-8")
    print(f"File name: {f.name}")
    f.write("Manual close example.\n")
finally:
    if f:
        f.close() # Doit s'assurer que close() est appelée
        print("File closed manually.")

L’utilisation de l’instruction with est la pratique standard et la plus sûre en Python moderne.

Lecture et écriture de fichiers

Les objets fichier fournissent des méthodes pour lire et écrire des données.

La méthode write()

Écrit une chaîne de caractères (en mode texte) ou des octets (en mode binaire) dans le fichier. Il n’ajoute pas automatiquement de caractères de nouvelle ligne ( ). Renvoie le nombre de caractères/octets écrits.

Syntaxe

file_object.write(data)

Exemple

#!/usr/bin/env python3

file_path = "output.txt"

try:
    with open(file_path, "w", encoding="utf-8") as f:
        num_chars = f.write("Python is a great language.\n")
        print(f"Wrote {num_chars} characters.")
        f.write("Yes, it's great!!\n")
    print(f"Successfully wrote to {file_path}")
except IOError as e:
    print(f"Error writing file: {e}")

# Le contenu de output.txt sera :
# Python is a great language.
# Yes, it's great!!

La méthode read()

Lit les données du fichier. En mode texte, lit les caractères ; en mode binaire, lit les octets.

Syntaxe

file_object.read(size=-1)

Ici, size est le nombre facultatif de caractères/octets à lire. S’il est omis ou négatif, il lit jusqu’à la fin du fichier.

Exemple (utilisant output.txt créé ci-dessus)

#!/usr/bin/env python3

file_path = "output.txt"

try:
    with open(file_path, "r", encoding="utf-8") as f:
        # Lire les 10 premiers caractères
        first_part = f.read(10)
        print(f"First 10 chars: '{first_part}'")

        # Lire le reste du fichier
        rest_of_file = f.read()
        print(f"Rest of file: '{rest_of_file}'")

    print("\nLecture du fichier entier en une seule fois:")
    with open(file_path, "r", encoding="utf-8") as f:
        all_content = f.read()
        print(f"'{all_content}'")

except FileNotFoundError:
    print(f"Error: File '{file_path}' not found.")
except IOError as e:
    print(f"Error reading file: {e}")

Ceci produit le résultat suivant :

First 10 chars: 'Python is '
Rest of file: 'a great language.\nYes, it's great!!\n'

Reading entire file at once:
'Python is a great language.\nYes, it's great!!\n'

Autres méthodes de lecture :

• readline() : Lit une ligne, y compris le final (ou jusqu’à EOF).
• readlines() : Lit toutes les lignes dans une liste de chaînes de caractères (strings), chacune incluant son .

Exemple (lecture ligne par ligne) :

print("\nLecture avec readline():")
try:
    with open(file_path, "r", encoding="utf-8") as f:
        line1 = f.readline()
        line2 = f.readline()
        print(f"Line 1: {line1.strip()}") # .strip() supprime les espaces blancs en début/fin de chaîne
        print(f"Line 2: {line2.strip()}")
except FileNotFoundError:
    print(f"Error: File '{file_path}' not found.")

Positions de fichier (seek et tell)

tell() : Renvoie la position actuelle (décalage en octets depuis le début) du pointeur de fichier.

seek(offset, whence=0) : Déplace le pointeur de fichier. offset est le nombre d’octets à déplacer. whence détermine le point de référence :

• 0 (par défaut) : Position absolue depuis le début du fichier.
• 1 : Position relative par rapport à l’emplacement actuel du pointeur.
• 2 : Position relative par rapport à la fin du fichier (le décalage est généralement négatif).

Exemple

#!/usr/bin/env python3

file_path = "output.txt"

try:
    with open(file_path, "r+", encoding="utf-8") as f: # Ouvrir en lecture et écriture
        # Lire les 10 premiers caractères
        str_data = f.read(10)
        print(f"Read String is : '{str_data}'")

        # Vérifier la position actuelle
        position = f.tell()
        print(f"Current file position : {position}")

        # Repositionner le pointeur au début
        f.seek(0, 0)
        str_data = f.read(10) # Lire à nouveau
        print(f"Again read String is : '{str_data}'")

        # Aller à la fin et écrire
        f.seek(0, 2) # Se déplacer à la fin
        f.write("Appending using seek.\n")

except FileNotFoundError:
    print(f"Error: File '{file_path}' not found.")
except IOError as e:
    print(f"Error accessing file: {e}")

Ceci produit le résultat suivant :

Read String is : 'Python is '
Current file position : 10
Again read String is : 'Python is '

Opérations du système de fichiers (os et pathlib)

Des modules comme os et pathlib fournissent des fonctions pour les tâches du système de fichiers au-delà de la lecture/écriture du contenu des fichiers.

Le module os

Fournit un moyen indépendant de la plateforme pour interagir avec le système d’exploitation.

Renommer des fichiers : os.rename(current_name, new_name)

import os

# Créer d'abord un fichier factice
with open("test1.txt", "w") as f: f.write("dummy")

try:
    os.rename("test1.txt", "test2.txt")
    print("Renamed test1.txt to test2.txt")
except OSError as e:
    print(f"Error renaming file: {e}")

Supprimer des fichiers : os.remove(file_name) ou os.unlink(file_name)

try:
    os.remove("test2.txt")
    print("Removed test2.txt")
except OSError as e:
    print(f"Error removing file: {e}")

Le module pathlib (Approche moderne)

Offre une interface orientée objet aux chemins de fichiers, conduisant souvent à un code plus lisible.

from pathlib import Path

# Créer un fichier factice
dummy_file = Path("pathlib_test1.txt")
dummy_file.write_text("dummy content", encoding="utf-8")

new_file_path = Path("pathlib_test2.txt")
new_dir_path = Path("my_test_dir")

# Renommer
try:
    dummy_file.rename(new_file_path)
    print(f"Renamed {dummy_file} to {new_file_path}")
except OSError as e:
    print(f"Error renaming: {e}")

# Supprimer
try:
    new_file_path.unlink() # Utiliser unlink() pour les fichiers
    print(f"Removed {new_file_path}")
except OSError as e:
    print(f"Error removing: {e}")

# Créer un répertoire
try:
    new_dir_path.mkdir(exist_ok=True) # exist_ok=True évite l'erreur si le répertoire existe
    print(f"Created directory {new_dir_path}")
except OSError as e:
    print(f"Error creating directory: {e}")

# Obtenir le répertoire courant
print(f"Current directory: {Path.cwd()}")

# Supprimer un répertoire (doit être vide)
try:
    new_dir_path.rmdir() # Utiliser rmdir() pour les répertoires
    print(f"Removed directory {new_dir_path}")
except OSError as e:
    print(f"Error removing directory (may not be empty): {e}")

Répertoires en Python

Les modules os et pathlib fournissent tous deux des fonctions pour gérer les répertoires.

Créer des répertoires :

os.mkdir(path) ou Path(path).mkdir()

Changer de répertoire :

os.chdir(path) (Modifie le répertoire de travail courant pour le processus)

Obtenir le répertoire courant :

os.getcwd() ou Path.cwd()

Supprimer des répertoires :

os.rmdir(path) ou Path(path).rmdir() (Le répertoire doit être vide)

Pour supprimer des répertoires avec du contenu, utilisez shutil.rmtree(path) (à utiliser avec prudence !).

Récapitulatif des outils de fichier et de répertoire

• Fonction intégrée open() : Pour lire/écrire le contenu des fichiers (à utiliser avec with).
• Module os : Approche traditionnelle basée sur des fonctions pour les interactions avec l’OS (chemins, processus). Sous-module os.path pour la manipulation des chemins.
• Module pathlib : Approche moderne orientée objet pour la manipulation des chemins et les opérations de fichiers de base. Souvent préféré.
• Module shutil : Pour les opérations de fichiers de haut niveau (copie, déplacement, suppression d’arborescences de répertoires).