Pour lire un fichier en Python, on utilise la fonction intégrée open().
On peut ouvrir un fichier en mode lecture en passant 'r' comme mode d'ouverture :
# Exemple d'ouverture d'un fichier en mode lecture
fichier = open('exemple.txt', 'r', encoding='utf-8')Points importants:
'r': le mode lecture permet uniquement de lire le contenu du fichier.encoding='utf-8': spécifie que le fichier est encodé en UTF-8.Via os.path.exists() du module os.
import os
# Chemin du fichier
file_path = 'exemple.txt'
# Vérification de l'existence du fichier
if os.path.exists(file_path):
# Ouverture du fichier en mode lecture
with open(file_path, 'r', encoding='utf-8') as fichier:
contenu = fichier.read()
print("Contenu du fichier :")
print(contenu)
else:
print("Le fichier n'existe pas.")Pour une approche plus orientée PPO Path de pathlib dispose d'une méthode .exists() (vu plus loin).
read()Lit l'intégralité du contenu du fichier sous forme d'une chaîne de caractères.
with open('exemple.txt', 'r', encoding='utf-8') as fichier:
contenu = fichier.read()
print(contenu)readline()Lit une seule ligne à la fois.
with open('exemple.txt', 'r', encoding='utf-8') as fichier:
ligne = fichier.readline()
while ligne:
print(ligne, end='') # 'end' pour éviter d'ajouter une nouvelle ligne supplémentaire
ligne = fichier.readline()readlines()Lit toutes les lignes du fichier et retourne une liste où chaque élément est une ligne
with open('exemple.txt', 'r', encoding='utf-8') as fichier:
lignes = fichier.readlines()
for ligne in lignes:
print(ligne, end='')Il est essentiel de fermer le fichier après l'avoir utilisé pour libérer les ressources associées.
Il y a deux manières: close() et with
close()On peut fermer le fichier manuellement:
fichier = open('exemple.txt', 'r', encoding='utf-8')
contenu = fichier.read()
print(contenu)
fichier.close() # Fermeture du fichierwithLe bloc with garantit que le fichier sera fermé automatiquement à la sortie du bloc, même si une exception se produit:
with open('exemple.txt', 'r', encoding='utf-8') as fichier:
contenu = fichier.read()
print(contenu)
# Ici, le fichier est automatiquement fermétry/exceptPour rendre le code robuste et éviter que le programme ne plante en cas d'erreur (par exemple, fichier non trouvé), il est judicieux d'utiliser un bloc try/except.
Exemple complet:
try:
# Ouverture du fichier en mode lecture avec l'encodage UTF-8
with open('exemple.txt', 'r', encoding='utf-8') as fichier:
# Lecture complète du contenu du fichier
contenu = fichier.read()
print(contenu)
except FileNotFoundError:
print("Erreur : Le fichier 'exemple.txt' n'a pas été trouvé.")
except IOError as e:
# Gestion d'autres erreurs d'entrée/sortie
print(f"Erreur d'Entrée/Sortie : {e}")
except Exception as e:
# Catch all pour toute autre exception
print(f"Une erreur inattendue est survenue : {e}")Points à retenir:
with: Il assure la bonne fermeture du fichier automatiquement et rend le code plus clair et concis.encoding='utf-8' évite des erreurs de décodage.try/except: Ils permettent de gérer les exceptions de manière contrôlée et d'offrir une meilleure expérience utilisateur (par exemple, afficher un message d'erreur utile).Pour écrire dans un fichier texte, vous pouvez utiliser la fonction open() avec les modes suivants :
'w': ouvre le fichier en mode écriture. Si le fichier n'existe pas, il sera créé. Si le fichier existe, son contenu sera écrasé.'a': ouvre le fichier en mode ajout. Si le fichier n'existe pas, il sera créé. Si le fichier existe, le nouveau contenu sera ajouté à la fin du fichier.# Ouvrir un fichier en mode écriture
file = open('example.txt', 'w')
# Ouvrir un fichier en mode ajout
file = open('example.txt', 'a')write() et writelines()write(text): écrit une chaîne de texte dans le fichier.writelines(lines): écrit une liste de chaînes de texte dans le fichier. Chaque élément de la liste est écrit comme une ligne distincte.with open('example.txt', 'w') as file:
file.write('Bonjour, monde!\n')
file.writelines(['Ligne 1\n', 'Ligne 2\n', 'Ligne 3\n'])Path de pathlibLa bibliothèque pathlib offre une manière plus moderne et flexible de travailler avec les fichiers.
from pathlib import Path
file_path = Path('example.txt')
file_path.write_text('Écrire avec pathlib.', encoding='utf-8')pathlib utilise une approche orientée objet pour représenter les chemins de fichiers, ce qui rend le code plus lisible et plus facile à comprendre. Par exemple, vous pouvez facilement créer un objet Path et utiliser ses méthodes pour manipuler les chemins.
from pathlib import Path
# Créer un objet Path
path = Path('example.txt')
# Vérifier si le fichier existe
if path.exists():
print("Le fichier existe.")pathlib gère automatiquement les différences entre les systèmes de fichiers sous Windows, macOS et Linux, ce qui rend le code plus portable.
# Chemins sous Windows et Unix
windows_path = Path(r'C:\Users\Utilisateur\example.txt')
unix_path = Path('/home/utilisateur/example.txt')Avec pathlib, vous pouvez facilement manipuler et construire des chemins de fichiers. Par exemple, vous pouvez ajouter des composants à un chemin, obtenir le répertoire parent, ou changer l'extension d'un fichier.
path = Path('/home/utilisateur/documents')
# Ajouter un composant au chemin
new_path = path / 'example.txt'
# Obtenir le répertoire parent
parent_dir = path.parent
# Changer l'extension du fichier
new_file_path = new_path.with_suffix('.md')pathlib fournit des méthodes intégrées pour effectuer des opérations courantes sur les fichiers et les répertoires, telles que lire ou écrire des fichiers, lister les fichiers dans un répertoire, et plus encore.
# Lire le contenu d'un fichier
content = path.read_text(encoding='utf-8')
# Écrire dans un fichier
path.write_text('Nouveau contenu', encoding='utf-8')
# Lister les fichiers dans un répertoire
for file in path.iterdir():
print(file.name)pathlib lève des exceptions spécifiques qui facilitent la gestion des erreurs liées aux fichiers et aux répertoires.
from pathlib import Path
path = Path('example.txt')
if path.exists():
try:
content = path.read_text(encoding='utf-8')
except IOError as e:
print(f"Erreur d'entrée/sortie: {e}")
else:
print("Le fichier n'existe pas.")pathlib s'intègre bien avec d'autres bibliothèques Python, ce qui en fait un choix naturel pour les nouveaux projets.
open() avec les modes 'w' et 'x'Pour créer un nouveau fichier texte en Python, vous pouvez utiliser la fonction open() avec les modes suivants.
'w' (écriture)Ce mode ouvre un fichier pour écriture. Si le fichier n'existe pas, il sera créé. Si le fichier existe déjà, son contenu sera écrasé.
with open('new_file.txt', 'w', encoding='utf-8') as file:
file.write('Ceci est une nouvelle ligne.\n')'x' (création exclusive)Ce mode crée un nouveau fichier et échoue si le fichier existe déjà. Cela garantit que vous ne remplacerez pas accidentellement un fichier existant.
try:
with open('new_file.txt', 'x', encoding='utf-8') as file:
file.write('Ce fichier vient d\'être créé.\n')
except FileExistsError:
print("Le fichier existe déjà.")La bibliothèque pathlib offre une manière moderne et intuitive de travailler avec les fichiers. Vous pouvez utiliser Path pour créer des fichiers avec une syntaxe claire.
from pathlib import Path
# Créer un fichier avec pathlib
file_path = Path('new_file.txt')
file_path.write_text('Créé avec pathlib.\n', encoding='utf-8')osLe module os de Python fournit une fonction rename() qui permet de renommer un fichier ou un répertoire. Voici comment l'utiliser avec une vérification de l'existence du fichier et une gestion des erreurs:
import os
# Chemins du fichier d'origine et du fichier de destination
ancien_nom = 'ancien_fichier.txt'
nouveau_nom = 'nouveau_fichier.txt'
# Vérification de l'existence du fichier et renommage
if os.path.exists(ancien_nom):
try:
os.rename(ancien_nom, nouveau_nom)
print(f"Le fichier a été renommé de {ancien_nom} à {nouveau_nom}.")
except PermissionError:
print("Vous n'avez pas les permissions nécessaires pour renommer ce fichier.")
else:
print(f"Le fichier {ancien_nom} n'existe pas.")pathlibLa bibliothèque pathlib offre une approche orientée objet pour manipuler les chemins de fichiers, y compris le renommage. Voici comment utiliser pathlib pour renommer un fichier avec une vérification de l'existence et une gestion des erreurs:
from pathlib import Path
# Chemins du fichier d'origine et du fichier de destination
ancien_chemin = Path('ancien_fichier.txt')
nouveau_chemin = Path('nouveau_fichier.txt')
# Vérification de l'existence du fichier et renommage
if ancien_chemin.exists():
try:
ancien_chemin.rename(nouveau_chemin)
print(f"Le fichier a été renommé de {ancien_chemin} à {nouveau_chemin}.")
except PermissionError:
print("Vous n'avez pas les permissions nécessaires pour renommer ce fichier.")
else:
print(f"Le fichier {ancien_chemin} n'existe pas.")osLe module os de Python fournit une fonction remove() qui permet de supprimer un fichier. Voici comment l'utiliser avec une vérification de l'existence du fichier et une gestion des erreurs:
import os
# Chemin du fichier à supprimer
fichier_a_supprimer = 'fichier_a_supprimer.txt'
# Vérification de l'existence du fichier et suppression
if os.path.exists(fichier_a_supprimer):
try:
os.remove(fichier_a_supprimer)
print(f"Le fichier {fichier_a_supprimer} a été supprimé.")
except PermissionError:
print("Vous n'avez pas les permissions nécessaires pour supprimer ce fichier.")
except OSError as e:
print(f"Erreur lors de la suppression du fichier: {e}")
else:
print(f"Le fichier {fichier_a_supprimer} n'existe pas.")pathlibLa bibliothèque pathlib offre une approche orientée objet pour manipuler les chemins de fichiers, y compris la suppression. Voici comment utiliser pathlib pour supprimer un fichier avec une vérification de l'existence et une gestion des erreurs:
from pathlib import Path
# Chemin du fichier à supprimer
fichier_a_supprimer = Path('fichier_a_supprimer.txt')
# Vérification de l'existence du fichier et suppression
if fichier_a_supprimer.exists():
try:
fichier_a_supprimer.unlink()
print(f"Le fichier {fichier_a_supprimer} a été supprimé.")
except PermissionError:
print("Vous n'avez pas les permissions nécessaires pour supprimer ce fichier.")
except OSError as e:
print(f"Erreur lors de la suppression du fichier: {e}")
else:
print(f"Le fichier {fichier_a_supprimer} n'existe pas.")Pour lire des données depuis un fichier CSV, vous pouvez utiliser la fonction csv.reader ou la classe csv.DictReader.
Pour écrire des données dans un fichier CSV, vous pouvez utiliser la classe csv.writer ou csv.DictWriter.
csv.readerLa fonction csv.reader permet de lire les données sous forme de listes.
import csv
from pathlib import Path
# Chemin du fichier CSV
csv_file = Path('data.csv')
# Vérification de l'existence du fichier et lecture
if csv_file.exists():
try:
with open(csv_file, mode='r', newline='', encoding='utf-8') as file:
reader = csv.reader(file)
for row in reader:
print(row)
except PermissionError:
print("Vous n'avez pas les permissions nécessaires pour lire ce fichier.")
except IOError as e:
print(f"Erreur d'E/S: {e}")
else:
print(f"Le fichier {csv_file} n'existe pas.")csv.DictReaderLa classe csv.DictReader permet de lire les données sous forme de dictionnaires, ce qui est utile pour accéder aux valeurs par leurs noms de colonne.
import csv
from pathlib import Path
# Chemin du fichier CSV
csv_file = Path('data_dict.csv')
# Vérification de l'existence du fichier et lecture
if csv_file.exists():
try:
with open(csv_file, mode='r', newline='', encoding='utf-8') as file:
reader = csv.DictReader(file)
for row in reader:
print(row)
except PermissionError:
print("Vous n'avez pas les permissions nécessaires pour lire ce fichier.")
except IOError as e:
print(f"Erreur d'E/S: {e}")
else:
print(f"Le fichier {csv_file} n'existe pas.")csv.writerLa classe csv.writer permet d'écrire des données sous forme de listes.
import csv
from pathlib import Path
# Chemin du fichier CSV
csv_file = Path('data.csv')
# Données à écrire
data = [
['Nom', 'Âge', 'Ville'],
['Alice', 30, 'Paris'],
['Bob', 25, 'Lyon']
]
# Vérification de l'existence du fichier et écriture
try:
with open(csv_file, mode='w', newline='', encoding='utf-8') as file:
writer = csv.writer(file)
writer.writerows(data)
print(f"Les données ont été écrites dans {csv_file}.")
except PermissionError:
print("Vous n'avez pas les permissions nécessaires pour écrire dans ce fichier.")
except IOError as e:
print(f"Erreur d'E/S: {e}")csv.DictWriterLa classe csv.DictWriter permet d'écrire des données sous forme de dictionnaires, ce qui est utile pour des structures de données plus complexes.
import csv
from pathlib import Path
# Chemin du fichier CSV
csv_file = Path('data_dict.csv')
# Données à écrire
data = [
{'Nom': 'Alice', 'Âge': 30, 'Ville': 'Paris'},
{'Nom': 'Bob', 'Âge': 25, 'Ville': 'Lyon'}
]
# En-têtes
fieldnames = ['Nom', 'Âge', 'Ville']
# Vérification de l'existence du fichier et écriture
try:
with open(csv_file, mode='w', newline='', encoding='utf-8') as file:
writer = csv.DictWriter(file, fieldnames=fieldnames)
writer.writeheader()
writer.writerows(data)
print(f"Les données ont été écrites dans {csv_file}.")
except PermissionError:
print("Vous n'avez pas les permissions nécessaires pour écrire dans ce fichier.")
except IOError as e:
print(f"Erreur d'E/S: {e}")Pour obtenir le répertoire de travail actuel, vous pouvez utiliser la fonction os.getcwd().
import os
# Obtenir le répertoire de travail actuel
current_directory = os.getcwd()
print(f"Le répertoire de travail actuel est : {current_directory}")Pour changer le répertoire de travail actuel, utilisez la fonction os.chdir().
import os
# Nouveau répertoire de travail
new_directory = '/path/to/new/directory'
# Vérification de l'existence du répertoire et changement
if os.path.exists(new_directory) and os.path.isdir(new_directory):
try:
os.chdir(new_directory)
print(f"Le répertoire de travail a été changé pour : {new_directory}")
except PermissionError:
print("Vous n'avez pas les permissions nécessaires pour accéder à ce répertoire.")
else:
print(f"Le répertoire {new_directory} n'existe pas ou n'est pas un répertoire.")Pour créer un nouveau répertoire, utilisez la fonction os.mkdir().
import os
# Chemin du nouveau répertoire
new_directory = '/path/to/new/directory'
# Vérification de l'existence du répertoire et création
if not os.path.exists(new_directory):
try:
os.mkdir(new_directory)
print(f"Le répertoire {new_directory} a été créé.")
except PermissionError:
print("Vous n'avez pas les permissions nécessaires pour créer ce répertoire.")
else:
print(f"Le répertoire {new_directory} existe déjà.")Pour renommer un répertoire, utilisez la fonction os.rename().
import os
# Chemins du répertoire d'origine et du répertoire de destination
old_directory = '/path/to/old/directory'
new_directory = '/path/to/new/directory'
# Vérification de l'existence du répertoire et renommage
if os.path.exists(old_directory) and os.path.isdir(old_directory):
try:
os.rename(old_directory, new_directory)
print(f"Le répertoire a été renommé de {old_directory} à {new_directory}.")
except PermissionError:
print("Vous n'avez pas les permissions nécessaires pour renommer ce répertoire.")
except OSError as e:
print(f"Erreur lors du renommage du répertoire: {e}")
else:
print(f"Le répertoire {old_directory} n'existe pas.")Pour supprimer un répertoire, utilisez la fonction os.rmdir(). Notez que le répertoire doit être vide.
import os
# Chemin du répertoire à supprimer
directory_to_remove = '/path/to/directory'
# Vérification de l'existence du répertoire et suppression
if os.path.exists(directory_to_remove) and os.path.isdir(directory_to_remove):
try:
os.rmdir(directory_to_remove)
print(f"Le répertoire {directory_to_remove} a été supprimé.")
except PermissionError:
print("Vous n'avez pas les permissions nécessaires pour supprimer ce répertoire.")
except OSError as e:
print(f"Erreur lors de la suppression du répertoire: {e}")
else:
print(f"Le répertoire {directory_to_remove} n'existe pas.")Voir le paragraphe sur shutil, pour la suppression d'un répertoire non vide.
Pour lister le contenu d'un répertoire, utilisez la fonction os.walk().
import os
# Chemin du répertoire à lister
directory_to_list = '/path/to/directory'
# Vérification de l'existence du répertoire et listage
if os.path.exists(directory_to_list) and os.path.isdir(directory_to_list):
try:
for dirpath, dirnames, filenames in os.walk(directory_to_list):
print(f"Répertoire actuel : {dirpath}")
print(f"Sous-répertoires : {dirnames}")
print(f"Fichiers : {filenames}")
print("-" * 40)
except PermissionError:
print("Vous n'avez pas les permissions nécessaires pour lister ce répertoire.")
else:
print(f"Le répertoire {directory_to_list} n'existe pas.")Vous pouvez définir une fonction réutilisable pour lister les fichiers d'un répertoire en utilisant os.walk().
import os
def list_files_in_directory(directory):
"""Liste les fichiers dans un répertoire de manière récursive."""
if os.path.exists(directory) and os.path.isdir(directory):
try:
for dirpath, _, filenames in os.walk(directory):
for file in filenames:
print(os.path.join(dirpath, file))
except PermissionError:
print("Vous n'avez pas les permissions nécessaires pour lister ce répertoire.")
else:
print(f"Le répertoire {directory} n'existe pas.")
# Utilisation de la fonction
list_files_in_directory('/path/to/directory')Le module shutil de Python fournit un ensemble d'opérations de haut niveau pour manipuler les fichiers et les répertoires. Il est particulièrement utile pour les tâches courantes telles que la copie, le déplacement, le renommage, la suppression et l'archivage de fichiers et de répertoires.
La fonction shutil.copy(src, dst) copie le fichier src vers dst. Si dst est un répertoire, le fichier est copié à l'intérieur de ce répertoire avec son nom d'origine.
import shutil
# Chemin du fichier source et de la destination
src = 'source.txt'
dst = 'destination.txt'
try:
shutil.copy(src, dst)
print(f"Le fichier {src} a été copié vers {dst}.")
except FileNotFoundError:
print(f"Le fichier {src} n'existe pas.")
except PermissionError:
print("Vous n'avez pas les permissions nécessaires pour copier ce fichier.")La fonction shutil.copytree(src, dst) copie récursivement le répertoire src vers dst.
import shutil
# Chemin du répertoire source et de la destination
src = 'source_directory'
dst = 'destination_directory'
try:
shutil.copytree(src, dst)
print(f"Le répertoire {src} a été copié vers {dst}.")
except FileNotFoundError:
print(f"Le répertoire {src} n'existe pas.")
except PermissionError:
print("Vous n'avez pas les permissions nécessaires pour copier ce répertoire.")
except FileExistsError:
print(f"Le répertoire de destination {dst} existe déjà.")La fonction shutil.move(src, dst) déplace ou renomme le fichier ou le répertoire src vers dst.
import shutil
# Chemin du fichier source et de la destination
src = 'old_name.txt'
dst = 'new_name.txt'
try:
shutil.move(src, dst)
print(f"Le fichier {src} a été déplacé/renommé vers {dst}.")
except FileNotFoundError:
print(f"Le fichier {src} n'existe pas.")
except PermissionError:
print("Vous n'avez pas les permissions nécessaires pour déplacer ce fichier.") La fonction shutil.rmtree(path) supprime un répertoire et tout son contenu de manière récursive.
import os
import shutil
def remove_directory(directory_path):
"""Supprime un répertoire et son contenu de manière récursive."""
if os.path.exists(directory_path) and os.path.isdir(directory_path):
try:
# Supprimer le répertoire et tout son contenu
shutil.rmtree(directory_path)
print(f"Le répertoire {directory_path} et son contenu ont été supprimés.")
except PermissionError:
print("Vous n'avez pas les permissions nécessaires pour supprimer ce répertoire.")
except OSError as e:
print(f"Erreur lors de la suppression du répertoire: {e}")
else:
print(f"Le répertoire {directory_path} n'existe pas.")
# Chemin du répertoire à supprimer
directory_to_remove = '/path/to/directory'
# Utilisation de la fonction
remove_directory(directory_to_remove)La fonction shutil.make_archive(base_name, format, ...) crée une archive (comme un fichier zip ou tar) à partir de fichiers et de répertoires.
import shutil
# Chemin du répertoire à archiver
directory_to_archive = 'directory_to_archive'
try:
archive_name = shutil.make_archive('archive_name', 'zip', directory_to_archive)
print(f"L'archive {archive_name} a été créée.")
except FileNotFoundError:
print(f"Le répertoire {directory_to_archive} n'existe pas.")
except PermissionError:
print("Vous n'avez pas les permissions nécessaires pour créer une archive.")Les f-strings (ou formatted string literals) offrent une manière élégante et concise de formater des chaînes de caractères en Python. Elles permettent d'incorporer des expressions directement dans les chaînes, ce qui facilite la lecture et l'écriture du code.
Les f-strings sont créées en plaçant un f ou F avant une chaîne de caractères, et en utilisant des accolades {} pour évaluer des expressions à l'intérieur de la chaîne.
name = "Alice"
age = 30
# Utilisation d'une f-string pour formater une chaîne
formatted_string = f"Nom: {name}, Âge: {age}"
print(formatted_string) Vous pouvez exécuter des expressions arithmétiques ou appeler des fonctions directement dans les f-strings.
value = 10
# Exécution d'une expression arithmétique
result = f"Le double de {value} est {value * 2}."
print(result)
# Appel d'une fonction
def greet(name):
return f"Bonjour, {name}!"
message = f"{greet('Bob')}"
print(message) Les raw strings sont utilisées pour traiter le caractère backslash (\) comme un caractère littéral, ce qui est utile lorsque vous travaillez avec des expressions régulières ou des chemins de fichiers sous Windows.
Pour créer une raw string, préfixez la chaîne avec r ou R.
# Exemple de raw string
raw_string = r"C:\Users\NomUtilisateur\nouveau_dossier"
print(raw_string)
# Comparaison avec une chaîne normale
normal_string = "C:\\Users\\NomUtilisateur\\nouveau_dossier"
print(normal_string) Le caractère backslash (\) est un caractère spécial en Python utilisé pour échapper d'autres caractères spéciaux dans une chaîne.
\n: Nouvelle ligne\t: Tabulation horizontale\\: Backslash littéral\': Guillemet simple littéral\": Guillemet double littéral# Exemple d'utilisation des séquences d'échappement
escaped_string = "Première ligne\nDeuxième ligne\tIndentation"
print(escaped_string) Vous pouvez utiliser le backslash pour échapper les guillemets dans une chaîne.
# Échapper les guillemets
quote_string = "Il a dit : \"Bonjour !\""
print(quote_string) Les f-strings ne peuvent pas contenir de backslash en tant que partie d'une expression à l'intérieur des accolades {}. Si vous avez besoin d'utiliser des backslashes dans des expressions, vous devez les traiter en dehors des f-strings.
# Exemple incorrect : cela provoquera une erreur
# incorrect_string = f"Chemin : {r"C:\Users\NomUtilisateur"}"
# Solution : traiter le backslash en dehors de la f-string
path = r"C:\Users\NomUtilisateur"
correct_string = f"Chemin : {path}"
print(correct_string)