Python
Explorer rapidement le répertoire Python : lister facilement tous les fichiers

Explorer rapidement le répertoire Python : lister facilement tous les fichiers

MoeNagy Dev

Exploration de la liste Python de tous les fichiers dans un répertoire

Obtenir le répertoire de travail actuel

Comprendre le répertoire de travail actuel

Le répertoire de travail actuel est le répertoire dans lequel votre script Python s'exécute actuellement. C'est l'emplacement par défaut où votre script recherchera les fichiers et les répertoires, et où il créera de nouveaux fichiers, sauf si vous spécifiez explicitement un chemin différent.

Déterminer le répertoire de travail actuel à l'aide du module os

Pour obtenir le répertoire de travail actuel en Python, vous pouvez utiliser la fonction os.getcwd() du module os :

import os
 
current_dir = os.getcwd()
print(f"Le répertoire de travail actuel est : {current_dir}")

Cela affichera le chemin complet du répertoire de travail actuel sur votre système.

Lister tous les fichiers dans un répertoire

Utiliser la fonction os.listdir()

Pour obtenir une liste de tous les fichiers et répertoires dans le répertoire de travail actuel, vous pouvez utiliser la fonction os.listdir() :

import os
 
files_and_dirs = os.listdir()
print(f"Contenu du répertoire actuel : {files_and_dirs}")

Cela renverra une liste de tous les éléments (fichiers et répertoires) dans le répertoire de travail actuel.

Gérer les répertoires vides

Si le répertoire de travail actuel est vide, os.listdir() renverra une liste vide. Vous pouvez vérifier cette condition et la gérer en conséquence :

import os
 
files_and_dirs = os.listdir()
if not files_and_dirs:
    print("Le répertoire actuel est vide.")
else:
    print(f"Contenu du répertoire actuel : {files_and_dirs}")

Trier la liste des fichiers

Si vous souhaitez trier la liste des fichiers, vous pouvez utiliser la fonction sorted() :

import os
 
files_and_dirs = sorted(os.listdir())
print(f"Contenu du répertoire actuel trié : {files_and_dirs}")

Cela renverra la liste des fichiers et répertoires dans l'ordre alphabétique.

Gérer les sous-répertoires

Parcourir de manière récursive les sous-répertoires

Pour répertorier tous les fichiers et répertoires, y compris ceux des sous-répertoires, vous pouvez utiliser une approche récursive. Cela consiste à appeler la fonction os.listdir() pour chaque sous-répertoire et à construire la liste complète des fichiers.

import os
 
def list_all_files(directory):
    """
    Parcourt de manière récursive un répertoire et ses sous-répertoires,
    renvoyant une liste de tous les fichiers.
    """
    file_list = []
    for item in os.listdir(directory):
        item_path = os.path.join(directory, item)
        if os.path.isfile(item_path):
            file_list.append(item_path)
        elif os.path.isdir(item_path):
            file_list.extend(list_all_files(item_path))
    return file_list
 
# Exemple d'utilisation
all_files = list_all_files(os.getcwd())
print(f"Tous les fichiers dans le répertoire et les sous-répertoires : {all_files}")

Cette fonction list_all_files() prend en entrée le chemin d'un répertoire et renvoie une liste de tous les fichiers de ce répertoire et de ses sous-répertoires.

Distinction des fichiers et des répertoires

Les fonctions os.path.isfile() et os.path.isdir() peuvent être utilisées pour déterminer si un élément de la liste des répertoires est un fichier ou un répertoire, respectivement.

import os
 
for item in os.listdir(os.getcwd()):
    item_path = os.path.join(os.getcwd(), item)
    if os.path.isfile(item_path):
        print(f"{item} est un fichier.")
    elif os.path.isdir(item_path):
        print(f"{item} est un répertoire.")
    else:
        print(f"{item} est un type inconnu.")

Ce code parcourra le contenu du répertoire actuel et affichera si chaque élément est un fichier, un répertoire ou un type inconnu.

Gérer les fichiers et répertoires masqués

Par défaut, os.listdir() inclura les fichiers et répertoires masqués (ceux qui commencent par un point, par exemple .hidden_file.txt ou .hidden_directory/). Si vous souhaitez les exclure, vous pouvez les filtrer :

import os
 
all_items = os.listdir(os.getcwd())
visible_items = [item for item in all_items if not item.startswith(".")]
print(f"Fichiers et répertoires visibles : {visible_items}")

Cela créera une nouvelle liste visible_items qui ne contient que les fichiers et répertoires non masqués.

Travailler avec les chemins de fichiers

Construire des chemins de fichiers complets

Lorsque vous travaillez avec des fichiers dans un répertoire, vous avez souvent besoin du chemin de fichier complet, qui inclut le répertoire et le nom du fichier. Vous pouvez utiliser la fonction os.path.join() pour construire le chemin complet :

import os
 
directory = os.getcwd()
filename = "example.txt"
full_path = os.path.join(directory, filename)
print(f"Le chemin de fichier complet est : {full_path}")

Cela affichera le chemin de fichier complet, qui inclut le répertoire de travail actuel et le nom du fichier.

Joindre les noms de répertoires et de fichiers

La fonction os.path.join() peut également être utilisée pour joindre plusieurs composants de chemin, tels que des noms de répertoires et des noms de fichiers :

import os
 
directory1 = "documents"
directory2 = "reports"
filename = "report.pdf"
full_path = os.path.join(directory1, directory2, filename)
print(f"Le chemin de fichier complet est : {full_path}")

Cela créera le chemin "documents/reports/report.pdf".

Normaliser les chemins de fichiers

Parfois, les chemins de fichiers peuvent contenir des éléments inutiles ou redondants, tels que . (répertoire actuel) ou .. (répertoire parent). Vous pouvez utiliser la fonction os.path.normpath() pour normaliser le chemin et supprimer ces éléments :

import os
 
messy_path = "documents/./reports/../images/image.jpg"
normalized_path = os.path.normpath(messy_path)
print(f"Le chemin normalisé est : {normalized_path}")

Ce code renverra "documents/images/image.jpg", en supprimant les éléments inutiles . et ...

Filtrer la liste de fichiers

Sélection des fichiers en fonction des extensions de fichiers

Si vous souhaitez filtrer la liste de fichiers pour inclure uniquement les fichiers avec une extension spécifique, vous pouvez utiliser une compréhension de liste:

import os
 
all_files = os.listdir(os.getcwd())
txt_files = [file for file in all_files if file.endswith(".txt")]
print(f"Fichiers texte dans le répertoire courant: {txt_files}")

Cela créera une nouvelle liste txt_files qui ne contient que les fichiers avec l'extension .txt.

Exclusion de fichiers ou de répertoires spécifiques

Vous pouvez également exclure certains fichiers ou répertoires de la liste. Par exemple, pour exclure les fichiers ou répertoires commençant par un point (éléments masqués):

import os
 
all_items = os.listdir(os.getcwd())
visible_items = [item for item in all_items if not item.startswith(".")]
print(f"Fichiers et répertoires visibles: {visible_items}")

Utilisation d'expressions régulières pour un filtrage avancé

Pour des besoins de filtrage plus complexes, vous pouvez utiliser des expressions régulières. Le module re en Python offre un moyen puissant de faire correspondre des motifs dans des chaînes de caractères. Voici un exemple d'utilisation d'une expression régulière pour filtrer la liste de fichiers:

import os
import re
 
all_files = os.listdir(os.getcwd())
pattern = r"^rapport_\d{4}.txt$"
matching_files = [file for file in all_files if re.match(pattern, file)]
print(f"Fichiers correspondant au motif: {matching_files}")

Cela créera une liste matching_files qui ne contient que les fichiers dont les noms correspondent au motif d'expression régulière "^rapport_\d{4}.txt$", qui recherche les fichiers commençant par "rapport_", suivis de quatre chiffres, et se terminant par ".txt".

Affichage des informations sur les fichiers

Récupération de la taille du fichier, de la date de création/modification

Vous pouvez utiliser les fonctions os.path.getsize() et os.path.getmtime() pour obtenir respectivement la taille et l'heure de modification d'un fichier:

import os
from datetime import datetime
 
file_path = os.path.join(os.getcwd(), "exemple.txt")
file_size = os.path.getsize(file_path)
modification_time = os.path.getmtime(file_path)
print(f"Taille du fichier: {file_size} octets")
print(f"Dernière modification: {datetime.fromtimestamp(modification_time)}")

Cela affichera la taille du fichier en octets et l'heure de dernière modification du fichier "exemple.txt".

Impression des détails du fichier de manière formatée

Vous pouvez créer une fonction pour imprimer les détails du fichier de manière organisée et lisible:

import os
from datetime import datetime
 
def imprimer_infos_fichier(chemin_fichier):
    """
    Imprime des informations détaillées sur un fichier, y compris son nom, sa taille et son heure de modification.
    """
    nom_fichier = os.path.basename(chemin_fichier)
    taille_fichier = os.path.getsize(chemin_fichier)
    heure_modification = os.path.getmtime(chemin_fichier)
    print(f"Nom du fichier: {nom_fichier}")
    print(f"Taille du fichier: {taille_fichier} octets")
    print(f"Dernière modification: {datetime.fromtimestamp(heure_modification)}")
 
# Exemple d'utilisation
imprimer_infos_fichier(os.path.join(os.getcwd(), "exemple.txt"))

Cela affichera le nom du fichier, sa taille et l'heure de dernière modification de manière formatée.

Gestion des erreurs et des exceptions

Gérer les problèmes de permission

Lorsque vous travaillez avec des fichiers et des répertoires, vous pouvez rencontrer des erreurs liées aux autorisations. Vous pouvez utiliser un bloc try-except pour gérer ces exceptions:

import os
 
try:
    fichier_restreint = os.path.join(os.getcwd(), "restreint.txt")
    taille_fichier = os.path.getsize(fichier_restreint)
    print(f"Taille du fichier: {taille_fichier} octets")
except PermissionError:
    print(f"Erreur: Vous n'avez pas la permission d'accéder à {fichier_restreint}")

Ce code essaiera d'obtenir la taille du fichier "restreint.txt" et, en cas d'erreur PermissionError, il affichera un message d'erreur.

Capturer et gérer les exceptions OSError

Le module os peut générer des exceptions OSError pour divers problèmes liés aux fichiers et aux répertoires. Vous pouvez capturer et gérer ces exceptions:

import os
 
try:
    fichier_inexistant = os.path.join(os.getcwd(), "inexistant.txt")
    taille_fichier = os.path.getsize(fichier_inexistant)
    print(f"Taille du fichier: {taille_fichier} octets")
except OSError as e:
    print(f"Erreur: {e}")

Ce code essaiera d'obtenir la taille du fichier "inexistant.txt" et, si une erreur OSError se produit (par exemple, le fichier n'existe pas), il affichera le message d'erreur.

Applications pratiques

Scripts de sauvegarde et d'archivage

Vous pouvez utiliser les techniques de liste de fichiers pour créer des scripts de sauvegarde ou d'archivage. Par exemple, vous pouvez créer un script qui compresse tous les fichiers d'un répertoire et de ses sous-répertoires dans un seul fichier ZIP.

import os
import zipfile
 
def sauvegarder_repertoire(repertoire, nom_fichier_zip):
    """
    Crée une archive ZIP de tous les fichiers d'un répertoire et de ses sous-répertoires.
    """
    with zipfile.ZipFile(nom_fichier_zip, "w") as fichier_zip:
        for racine, _, fichiers in os.walk(repertoire):
            for fichier in fichiers:
                chemin_fichier = os.path.join(racine, fichier)
                fichier_zip.write(chemin_fichier)
 
# Exemple d'utilisation
sauvegarder_repertoire(os.getcwd(), "sauvegarde.zip")
print("La sauvegarde du répertoire est terminée.")

Cette fonction sauvegarder_repertoire() prend un chemin de répertoire et un nom de fichier ZIP en entrée, et crée une archive ZIP de tous les fichiers du répertoire et de ses sous-répertoires.

Outils d'organisation et de nettoyage des fichiers

Vous pouvez utiliser les techniques de liste de fichiers et de filtrage pour créer des scripts qui organisent ou nettoient des fichiers dans un répertoire. Par exemple, vous pouvez trier les fichiers dans des sous-répertoires en fonction de leurs extensions de fichier.

import os
import shutil
 
def organiser_fichiers(repertoire):
    """
    Organise les fichiers dans un répertoire en les déplaçant dans des sous-répertoires en fonction de
    leurs extensions.
    """
    for fichier in os.listdir(repertoire):
        if os.path.isfile(fichier):
            extension = os.path.splitext(fichier)[1]
            dossier_destination = os.path.join(repertoire, extension.strip("."))
            os.makedirs(dossier_destination, exist_ok=True)
            shutil.move(fichier, dossier_destination)
 
# Exemple d'utilisation
organiser_fichiers(os.getcwd())
print("Les fichiers ont été organisés avec succès.")

Cette fonction organiser_fichiers() prend un répertoire en entrée et trie les fichiers dans des sous-répertoires en fonction de leurs extensions de fichier. Voici un exemple d'une fonction simple qui calcule l'aire d'un rectangle :

def calculate_area(length, width):
    area = length * width
    return area
 
# Utilisation
rectangle_length = 5
rectangle_width = 3
result = calculate_area(rectangle_length, rectangle_width)
print(f"L'aire du rectangle est de {result} unités carrées.")

Dans cet exemple, la fonction calculate_area() prend deux paramètres, length et width, et calcule l'aire en les multipliant. La fonction retourne ensuite l'aire calculée.

Vous pouvez également définir des fonctions qui ne prennent aucun paramètre et ne renvoient aucune valeur :

def greet_user():
    print("Bonjour, utilisateur !")
 
# Utilisation
greet_user()

Les fonctions peuvent également avoir des valeurs par défaut pour leurs paramètres, ce qui les rend plus flexibles :

def calculate_circle_area(radius, pi=3.14159):
    area = pi * radius ** 2
    return area
 
# Utilisation
circle_radius = 4
result = calculate_circle_area(circle_radius)
print(f"L'aire du cercle est de {result} unités carrées.")
 
# Utilisation avec une valeur de pi personnalisée
result = calculate_circle_area(circle_radius, pi=3.14)
print(f"L'aire du cercle est de {result} unités carrées.")

Dans cet exemple, la fonction calculate_circle_area() a une valeur par défaut de 3.14159 pour le paramètre pi, mais vous pouvez également passer une valeur personnalisée si nécessaire.

Modules et paquets

La conception modulaire de Python vous permet d'organiser votre code en composants réutilisables appelés modules. Les modules sont des fichiers Python qui contiennent des fonctions, des classes et des variables. Vous pouvez importer des modules et utiliser la fonctionnalité qu'ils fournissent dans votre propre code.

Voici un exemple de la façon d'utiliser le module intégré math :

import math
 
# Utilisation
radius = 5
circle_area = math.pi * radius ** 2
print(f"L'aire du cercle est de {circle_area:.2f} unités carrées.")

Dans cet exemple, nous importons le module math et utilisons sa constante pi pour calculer l'aire d'un cercle.

Vous pouvez également importer des fonctions ou des variables spécifiques à partir d'un module :

from math import pi, sqrt
 
# Utilisation
radius = 5
circle_area = pi * radius ** 2
square_root = sqrt(25)
print(f"L'aire du cercle est de {circle_area:.2f} unités carrées.")
print(f"La racine carrée de 25 est {square_root}.")

Cette approche vous permet d'accéder directement aux fonctions pi et sqrt(), sans avoir à les préfixer avec le nom de module math..

Python prend également en charge la création de packages, qui sont des collections de modules liés. Les packages vous aident à organiser votre code dans une structure hiérarchique, ce qui facilite la gestion et la distribution de votre logiciel.

Voici un exemple de la façon de créer un package simple :

my_package/
    __init__.py
    math_utils.py
    string_utils.py

Dans cet exemple, my_package est le package, et math_utils.py et string_utils.py sont les modules du package. Le fichier __init__.py est requis pour marquer le répertoire en tant que package.

Vous pouvez ensuite importer et utiliser les fonctions des modules du package :

from my_package.math_utils import calculate_area
from my_package.string_utils import reverse_string
 
# Utilisation
rectangle_area = calculate_area(5, 3)
print(f"L'aire du rectangle est de {rectangle_area} unités carrées.")
 
reversed_text = reverse_string("Python")
print(f"La chaîne inversée est : {reversed_text}")

L'organisation de votre code en modules et en packages le rend plus facile à maintenir, réutilisable et plus facile à distribuer.

Gestion des exceptions

En Python, les exceptions sont des événements qui se produisent pendant l'exécution d'un programme et perturbent le déroulement normal des instructions du programme. La gestion des exceptions est un aspect important de l'écriture de code robuste et fiable.

Voici un exemple de gestion d'une exception ZeroDivisionError :

def divide_numbers(a, b):
    try:
        result = a / b
        return result
    except ZeroDivisionError:
        print("Erreur : Division par zéro.")
        return None
 
# Utilisation
dividende = 10
diviseur = 0
resultat = divide_numbers(dividende, diviseur)
if resultat is not None:
    print(f"Le résultat de {dividende} / {diviseur} est {resultat}.")
else:
    print("Impossible d'effectuer la division.")

Dans cet exemple, la fonction divide_numbers() essaie de diviser le paramètre a par le paramètre b. Si b est zéro, une exception ZeroDivisionError est levée, et la fonction la gère en affichant un message d'erreur et en renvoyant None.

Vous pouvez également gérer plusieurs exceptions dans un seul bloc try-except :

def process_input(user_input):
    try:
        value = int(user_input)
        return value
    except ValueError:
        print("Erreur : Entrée invalide. Veuillez entrer un nombre.")
        return None
    except Exception as e:
        print(f"Une erreur inattendue s'est produite : {e}")
        return None
 
# Utilisation
user_input = input("Entrez un nombre : ")
resultat = process_input(user_input)
if resultat is not None:
    print(f"La valeur saisie est : {resultat}")

Dans cet exemple, la fonction process_input() essaie d'abord de convertir l'entrée utilisateur user_input en un entier en utilisant la fonction int(). Si l'entrée n'est pas un numéro valide, une exception ValueError est levée, qui est gérée en affichant un message d'erreur et en renvoyant None. De plus, la fonction gère également toutes les autres exceptions inattendues en affichant un message d'erreur générique et en renvoyant None.

La gestion des exceptions est essentielle pour créer des applications robustes et conviviales qui peuvent gérer gracieusement des situations inattendues.

Entrées/Sorties de fichiers

Python dispose de fonctions et de méthodes intégrées pour lire à partir de fichiers et y écrire. Cela vous permet de persister les données et d'interagir avec le système de fichiers.

Voici un exemple de lecture à partir d'un fichier :

# Lecture à partir d'un fichier
with open("example.txt", "r") as file:
    contenu = file.read()
    print(f"Contenu du fichier:\n{contenu}")

Dans cet exemple, la fonction open() est utilisée pour ouvrir le fichier "example.txt" en mode lecture ("r"). L'instruction with assure que le fichier est correctement fermé après l'exécution du bloc de code, même en cas d'exception.

Vous pouvez également lire le fichier ligne par ligne :

# Lecture du fichier ligne par ligne
with open("example.txt", "r") as file:
    for line in file:
        print(line.strip())

Cet exemple lit le fichier ligne par ligne et affiche chaque ligne après avoir supprimé les espaces vides au début et à la fin à l'aide de la méthode strip().

Pour écrire dans un fichier, vous pouvez utiliser le mode d'écriture ("w") ou le mode d'ajout ("a") :

# Écriture dans un fichier
with open("output.txt", "w") as file:
    file.write("Ceci est la première ligne.\n")
    file.write("Ceci est la deuxième ligne.\n")
 
# Ajout dans un fichier
with open("output.txt", "a") as file:
    file.write("Ceci est une nouvelle ligne ajoutée au fichier.\n")

Dans le premier exemple, le fichier "output.txt" est ouvert en mode écriture, et deux lignes de texte y sont écrites. Dans le deuxième exemple, le même fichier est ouvert en mode ajout, et une nouvelle ligne est ajoutée à la fin du fichier.

Les opérations d'entrée/sortie de fichiers sont essentielles pour des tâches telles que la lecture de fichiers de configuration, l'enregistrement de données et la sauvegarde/chargement de l'état d'une application.

Conclusion

Dans ce tutoriel, vous avez appris divers concepts intermédiaires de Python, notamment les fonctions, les modules et les packages, la gestion des exceptions et les opérations d'entrée/sortie de fichiers. Ces sujets sont fondamentaux pour la création d'applications Python plus complexes et robustes.

En comprenant les fonctions, vous pouvez créer un code réutilisable et modulaire qui peut être facilement maintenu et étendu. Les modules et les packages vous aident à organiser votre code, le rendant plus gérable et partageable. La gestion des exceptions est cruciale pour écrire un logiciel fiable capable de gérer élégamment les situations imprévues. Enfin, les opérations d'entrée/sortie de fichiers vous permettent de persister et d'interagir avec des données, ce qui est essentiel pour de nombreuses applications du monde réel.

En continuant à explorer et à pratiquer Python, n'oubliez pas d'expérimenter avec ces concepts, d'essayer différentes utilisations et d'élargir continuellement vos connaissances. La polyvalence de Python et son écosystème étendu de bibliothèques et de frameworks en font un langage puissant pour une large gamme d'applications, du développeur web à l'analyse de données et au-delà.

MoeNagy Dev