Python
Obtenir facilement tous les fichiers d'un répertoire: Explication en Python

Obtenir facilement tous les fichiers d'un répertoire : Explication en Python

MoeNagy Dev

Obtenir tous les fichiers d'un répertoire avec Python

Importance de la liste des fichiers dans un répertoire

Comprendre la structure des fichiers de votre projet est essentiel pour une gestion de fichiers et une automatisation efficaces. Pouvoir répertorier les fichiers d'un répertoire peut vous aider à :

  • Comprendre l'organisation des fichiers de votre projet : En répertoriant les fichiers d'un répertoire, vous pouvez rapidement voir quels fichiers sont présents, leurs noms et leur organisation au sein de la structure du répertoire.
  • Automatiser les tâches liées aux fichiers : La liste programmée des fichiers vous permet d'effectuer diverses tâches, telles que les sauvegardes de fichiers, l'organisation des fichiers multimédias ou l'analyse du code source, de manière automatisée et efficace.
  • Analyser le contenu et les métadonnées des fichiers : Une fois que vous avez une liste de fichiers, vous pouvez traiter plus en détail les informations, telles que la taille des fichiers, l'heure de modification ou d'autres métadonnées, pour obtenir des informations sur votre projet.

Manipulation de base des fichiers en Python

Avant d'aborder la façon de répertorier les fichiers d'un répertoire, examinons rapidement les bases de la manipulation des fichiers en Python.

Ouvrir et fermer des fichiers

En Python, vous pouvez ouvrir un fichier à l'aide de la fonction open().

La syntaxe de base est la suivante :

file = open("filename.txt", "r")
# Effectuez des opérations sur le fichier
file.close()

Le deuxième argument de la fonction open() spécifie le mode, comme "r" pour la lecture, "w" pour l'écriture ou "a" pour l'ajout.

Il est important de fermer le fichier une fois que vous avez fini de l'utiliser pour vous assurer que toutes les modifications sont enregistrées et que les ressources du système sont libérées correctement.

Lecture et écriture du contenu d'un fichier

Une fois qu'un fichier est ouvert, vous pouvez lire son contenu à l'aide de la méthode read() :

file = open("filename.txt", "r")
content = file.read()
print(content)
file.close()

Pour écrire dans un fichier, vous pouvez utiliser la méthode write() :

file = open("filename.txt", "w")
file.write("Ceci est un contenu à écrire dans le fichier.")
file.close()

Répertorier les fichiers dans un répertoire

Maintenant, explorons comment répertorier les fichiers d'un répertoire à l'aide de Python.

Utilisation du module os

Le module os en Python fournit un ensemble de fonctions pour interagir avec le système d'exploitation, y compris la gestion des fichiers et des répertoires. Pour répertorier les fichiers d'un répertoire, nous utiliserons la fonction os.listdir().

import os
 
répertoire = "/chemin/vers/le/répertoire"
fichiers = os.listdir(répertoire)
print(fichiers)

Cela affichera une liste de tous les fichiers et répertoires présents dans le répertoire spécifié.

Notez que os.listdir() renvoie les noms des fichiers et répertoires, mais pas leurs chemins complets. Si vous avez besoin des chemins complets, vous pouvez combiner os.listdir() avec os.path.join() :

import os
 
répertoire = "/chemin/vers/le/répertoire"
chemins_fichiers = [os.path.join(répertoire, nom_fichier) for nom_fichier in os.listdir(répertoire)]
print(chemins_fichiers)

Cela vous donnera une liste de chemins de fichiers complets, comprenant le répertoire et le nom du fichier.

Gestion des chemins relatifs et absolus

Lorsque vous travaillez avec des chemins de fichiers, vous pouvez utiliser des chemins relatifs ou absolus. Les chemins relatifs sont basés sur le répertoire de travail actuel, tandis que les chemins absolus spécifient le chemin complet à partir du répertoire racine.

Pour obtenir le répertoire de travail actuel, vous pouvez utiliser os.getcwd() :

import os
 
répertoire_actuel = os.getcwd()
print(répertoire_actuel)

Vous pouvez ensuite utiliser ces informations pour construire des chemins relatifs ou absolus selon vos besoins.

Filtrer les fichiers par extension

Souvent, vous souhaiterez ne répertorier que les fichiers ayant une extension spécifique, telle que .txt ou .py. Vous pouvez y parvenir en utilisant différentes techniques.

Vérification des extensions de fichiers

Une façon de filtrer les fichiers par extension consiste à vérifier l'extension du fichier à l'aide d'opérations sur les chaînes de caractères :

import os
 
répertoire = "/chemin/vers/le/répertoire"
fichiers_txt = [f for f in os.listdir(répertoire) if f.endswith(".txt")]
print(fichiers_txt)

Cela utilise une compréhension de liste pour créer une nouvelle liste ne contenant que les fichiers avec l'extension .txt.

Alternativement, vous pouvez utiliser la fonction os.path.splitext() pour extraire l'extension du fichier :

import os
 
répertoire = "/chemin/vers/le/répertoire"
fichiers_py = [f for f in os.listdir(répertoire) if os.path.splitext(f)[1] == ".py"]
print(fichiers_py)

Cette approche sépare le nom du fichier de son extension, ce qui vous permet de vérifier directement l'extension.

Parcourir récursivement les sous-répertoires

Si votre projet a une structure de répertoires complexe avec des sous-répertoires, vous souhaiterez peut-être répertorier de manière récursive tous les fichiers de l'ensemble de l'arborescence des répertoires. La fonction os.walk() peut vous aider dans cette tâche.

import os
 
répertoire = "/chemin/vers/le/répertoire"
for racine, répertoires, fichiers in os.walk(répertoire):
    for fichier in fichiers:
        print(os.path.join(racine, fichier))

La fonction os.walk() renvoie trois valeurs pour chaque répertoire qu'elle parcourt :

  1. racine : Le répertoire courant en cours de traitement.
  2. répertoires : Une liste de sous-répertoires dans le répertoire courant.
  3. fichiers : Une liste de fichiers dans le répertoire courant.

En itérant sur la liste fichiers, vous pouvez accéder au chemin complet de chaque fichier dans l'ensemble de l'arborescence des répertoires.

Tri et organisation des listes de fichiers

Une fois que vous avez une liste de fichiers, vous pouvez souhaiter les trier ou les organiser d'une manière spécifique. La fonction intégrée sorted() de Python peut vous aider dans cette tâche.

Tri alphabétique

Pour trier la liste de fichiers par ordre alphabétique, vous pouvez utiliser la fonction sorted() :

import os
 
répertoire = "/chemin/vers/le/répertoire"
fichiers = sorted(os.listdir(répertoire))
print(fichiers)

Cela triera la liste de fichiers par ordre alphabétique.

Tri par taille de fichier ou heure de modification

Vous pouvez également trier la liste de fichiers en fonction de leur taille ou de leur horodatage de modification. Pour ce faire, vous pouvez fournir une fonction key personnalisée à la fonction sorted().

import os
 
directory = "/chemin/vers/le/dossier"
files = sorted(os.listdir(directory), key=lambda x: os.path.getsize(os.path.join(directory, x)), reverse=True)
print(files)

Cela triera la liste de fichiers par taille de fichier dans l'ordre décroissant.

Pour trier par horodatage de modification, vous pouvez utiliser os.path.getmtime() à la place de os.path.getsize() :

import os
from datetime import datetime
 
directory = "/chemin/vers/le/dossier"
files = sorted(os.listdir(directory), key=lambda x: os.path.getmtime(os.path.join(directory, x)), reverse=True)
print(files)

Cela triera la liste de fichiers par horodatage de modification dans l'ordre décroissant.

Travailler avec les métadonnées de fichiers

En plus des noms et des chemins de fichiers, vous pouvez également vouloir récupérer des informations sur les fichiers, comme leur taille et leur horodatage de modification. Python fournit des fonctions pour accéder à ces métadonnées.

Récupérer la taille et l'horodatage de modification des fichiers

Vous pouvez utiliser la fonction os.path.getsize() pour obtenir la taille d'un fichier et os.path.getmtime() pour obtenir l'heure de dernière modification.

import os
from datetime import datetime
 
directory = "/chemin/vers/le/dossier"
nom_fichier = "exemple.txt"
chemin_fichier = os.path.join(directory, nom_fichier)
 
taille_fichier = os.path.getsize(chemin_fichier)
heure_modification = os.path.getmtime(chemin_fichier)
print(f"Taille du fichier : {taille_fichier} octets")
print(f"Dernière modification : {datetime.fromtimestamp(heure_modification)}")

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

Formatage de la taille du fichier et des informations temporelles

Pour rendre la taille du fichier et les informations temporelles plus lisibles, vous pouvez les formater en conséquence.

import os
from datetime import datetime
 
directory = "/chemin/vers/le/dossier"
nom_fichier = "exemple.txt"
chemin_fichier = os.path.join(directory, nom_fichier)
 
taille_fichier = os.path.getsize(chemin_fichier)
heure_modification = os.path.getmtime(chemin_fichier)
 
# Formatage de la taille du fichier
if taille_fichier < 1024:
    taille_fichier_str = f"{taille_fichier} octets"
elif taille_fichier < 1024 * 1024:
    taille_fichier_str = f"{taille_fichier / 1024:.2f} Ko"
else:
    taille_fichier_str = f"{taille_fichier / (1024 * 1024):.2f} Mo"
 
# Formatage de l'heure de modification
heure_modification_str = datetime.fromtimestamp(heure_modification).strftime("%Y-%m-%d %H:%M:%S")
 
print(f"Taille du fichier : {taille_fichier_str}")
print(f"Dernière modification : {heure_modification_str}")

Cela affichera la taille du fichier sous une forme plus lisible pour l'homme (octets, Ko ou Mo) et l'heure de modification sous la forme d'une chaîne de date et d'heure formatée.

Gérer les erreurs et les cas particuliers

Lorsque vous travaillez avec des opérations de fichiers, il est important de gérer les erreurs potentielles et les cas particuliers de manière appropriée. L'exception OSError intégrée à Python peut vous aider dans ce cas.

import os
 
directory = "/chemin/vers/le/dossier"
 
try:
    files = os.listdir(directory)
    for file in files:
        chemin_fichier = os.path.join(directory, file)
        taille_fichier = os.path.getsize(chemin_fichier)
        print(f"Fichier : {file}, Taille : {taille_fichier} octets")
except OSError as e:
    print(f"Erreur : {e}")
    print("Impossible d'accéder au répertoire ou de récupérer les informations sur le fichier.")

Dans cet exemple, nous enveloppons la liste des fichiers et la récupération de la taille du fichier dans un bloc try-except pour intercepter toutes les exceptions OSError qui peuvent se produire, par exemple lorsque le répertoire n'est pas accessible ou qu'un fichier ne peut pas être lu.

En gérant ces exceptions, vous pouvez fournir un message d'erreur plus explicite au lieu de laisser le programme planter.

Applications pratiques et cas d'utilisation

Maintenant que vous avez une bonne compréhension de la liste des fichiers dans un répertoire, explorons quelques applications pratiques et cas d'utilisation.

Sauvegarde de fichiers et synchronisation

Un cas d'utilisation courant consiste à créer des sauvegardes de fichiers ou à synchroniser des fichiers entre différents emplacements. En listant les fichiers dans un répertoire, vous pouvez identifier les fichiers qui doivent être sauvegardés ou synchronisés.

import os
import shutil
 
source_dir = "/chemin/vers/le/répertoire/source"
backup_dir = "/chemin/vers/le/répertoire/de/sauvegarde"
 
for filename in os.listdir(source_dir):
    src_path = os.path.join(source_dir, filename)
    dst_path = os.path.join(backup_dir, filename)
    shutil.copy2(src_path, dst_path)
    print(f"Sauvegardé : {filename}")

Cet exemple copie tous les fichiers du source_dir vers le répertoire backup_dir, créant ainsi une sauvegarde des fichiers.

Organisation des fichiers multimédias

Un autre cas d'utilisation consiste à organiser les fichiers multimédias (par exemple, les photos, les vidéos) en fonction de leurs extensions de fichier ou de leurs métadonnées. En listant les fichiers dans un répertoire, vous pouvez les trier et les déplacer vers des sous-répertoires appropriés.

import os
import shutil
 
media_dir = "/chemin/vers/le/répertoire/des/médias"
photo_dir = "/chemin/vers/le/répertoire/des/photos"
video_dir = "/chemin/vers/le/répertoire/des/vidéos"
 
for filename in os.listdir(media_dir):
    src_path = os.path.join(media_dir, filename)
    if filename.endswith(".jpg") or filename.endswith(".png"):
        dst_path = os.path.join(photo_dir, filename)
    elif filename.endswith(".mp4") or filename.endswith(".mov"):
        dst_path = os.path.join(video_dir, filename)
    else:
        continue
    shutil.move(src_path, dst_path)
    print(f"Déplacé : {filename}")

Cet exemple trie les fichiers multimédias dans le répertoire media_dir en fonction de leurs extensions de fichier, déplaçant les fichiers image dans le répertoire photo_dir et les fichiers vidéo dans le répertoire video_dir.

Analyse de code source et gestion de projet

La liste des fichiers dans un répertoire peut également être utile pour l'analyse de code source et la gestion de projet. Vous pouvez utiliser la liste des fichiers pour :

  • Identifier les fichiers constituant un projet logiciel
  • Analyser la structure et l'organisation des fichiers
  • Générer des rapports sur les tailles de fichiers, les horodatages de modification et d'autres métadonnées

Ces informations peuvent vous aider à mieux comprendre et gérer vos projets logiciels.

Concepts Python intermédiaires

Classes et programmation orientée objet (POO)

En Python, les classes sont les éléments fondamentaux de la programmation orientée objet. Elles vous permettent de créer des types de données personnalisés avec leurs propres attributs et méthodes. Voici un exemple d'une classe Voiture simple :

class Voiture:
    def __init__(self, marque, modèle, année):
        self.marque = marque
        self.modèle = modèle
        self.année = année
 
    def commencer(self):
        print(f"La voiture {self.marque} {self.modèle} {self.année} a démarré.")
 
    def arrêter(self):
        print(f"La voiture {self.marque} {self.modèle} {self.année} s'est arrêtée.")

Dans cet exemple, la classe Voiture a trois attributs (marque, modèle et année) et deux méthodes (commencer() et arrêter()). La méthode __init__() est une méthode spéciale qui est automatiquement appelée lorsque vous créez une nouvelle instance de la classe Voiture.

Vous pouvez créer des instances de la classe Voiture de cette manière :

ma_voiture = Voiture("Toyota", "Corolla", 2015)
ma_voiture.commencer()  # Sortie : La voiture Toyota Corolla 2015 a démarré.
ma_voiture.arrêter()   # Sortie : La voiture Toyota Corolla 2015 s'est arrêtée.

La POO (Programmation Orientée Objet) prend également en charge l'héritage, qui vous permet de créer de nouvelles classes basées sur des classes existantes. Voici un exemple d'une classe VoitureElectrique qui hérite de la classe Voiture :

class VoitureElectrique(Voiture):
    def __init__(self, marque, modèle, année, capacité_batterie):
        super().__init__(marque, modèle, année)
        self.capacité_batterie = capacité_batterie
 
    def charger(self):
        print(f"La voiture {self.marque} {self.modèle} {self.année} est en train de se charger.")

La classe VoitureElectrique hérite des attributs marque, modèle et année, ainsi que des méthodes commencer() et arrêter() de la classe Voiture. Elle ajoute également un nouvel attribut (capacité_batterie) et une nouvelle méthode (charger()).

ma_voiture_electrique = VoitureElectrique("Tesla", "Model S", 2020, 100)
ma_voiture_electrique.commencer()  # Sortie : La voiture Tesla Model S 2020 a démarré.
ma_voiture_electrique.charger()  # Sortie : La voiture Tesla Model S 2020 est en train de se charger.

Modules et Packages

En Python, les modules sont des fichiers uniques contenant du code, tandis que les packages sont des collections de modules liés. Les modules vous permettent d'organiser votre code et de le réutiliser dans différents projets.

Voici un exemple d'un module simple appelé math_functions.py :

def additionner(a, b):
    return a + b
 
def soustraire(a, b):
    return a - b
 
def multiplier(a, b):
    return a * b
 
def diviser(a, b):
    return a / b

Vous pouvez ensuite importer et utiliser les fonctions de ce module dans un autre fichier Python :

from math_functions import additionner, soustraire
print(additionner(2, 3))  # Sortie : 5
print(soustraire(5, 3))  # Sortie : 2

Les packages, en revanche, vous permettent de regrouper des modules liés ensemble. Par exemple, vous pourriez créer un package math avec des modules distincts pour différents types d'opérations mathématiques, tels que arithmetique.py, geometrie.py et statistiques.py.

math/
    __init__.py
    arithmetique.py
    geometrie.py
    statistiques.py

Vous pouvez ensuite importer les modules du package math de cette manière :

from math.arithmetique import additionner, soustraire
from math.geometrie import calculer_surface
from math.statistiques import moyenne, mediane

Exceptions et Gestion des erreurs

En Python, les exceptions sont un moyen de gérer les erreurs qui se produisent pendant l'exécution du programme. Vous pouvez utiliser des blocs try-except pour capturer et gérer les exceptions.

Voici un exemple de gestion d'une ZeroDivisionError :

def diviser(a, b):
    try:
        resultat = a / b
        print(f"Le résultat est : {resultat}")
    except ZeroDivisionError:
        print("Erreur : Impossible de diviser par zéro.")
 
diviser(10, 2)  # Sortie : Le résultat est : 5.0
diviser(10, 0)  # Sortie : Erreur : Impossible de diviser par zéro.

Vous pouvez également utiliser la clause finally pour exécuter du code que l'exception ait été levée ou non :

def ouvrir_fichier(nom_fichier):
    try:
        fichier = open(nom_fichier, 'r')
        contenu = fichier.read()
        print(contenu)
    except FileNotFoundError:
        print(f"Erreur : {nom_fichier} introuvable.")
    finally:
        fichier.close()
 
ouvrir_fichier('example.txt')

De plus, vous pouvez définir vos propres exceptions personnalisées en créant une nouvelle classe qui hérite de la classe Exception :

class ErreurSaisieInvalide(Exception):
    pass
 
def calculer_surface(forme, *args):
    if forme == 'rectangle':
        longueur, largeur = args
        return longueur * largeur
    elif forme =='cercle':
        rayon, = args
        return 3.14 * rayon ** 2
    else:
        raise ErreurSaisieInvalide("Forme invalide fournie.")
 
try:
    print(calculer_surface('rectangle', 5, 10))  # Sortie : 50
    print(calculer_surface('cercle', 3))  # Sortie : 28.26
    print(calculer_surface('triangle', 3, 4))  # Lève une ErreurSaisieInvalide
except ErreurSaisieInvalide as e:
    print(e)

Entrée/Sortie de Fichiers et Chemins

Python fournit des fonctions et des modules intégrés pour travailler avec des fichiers et des chemins de fichiers. Voici un exemple de lecture et d'écriture dans un fichier :

# Écriture dans un fichier
with open('example.txt', 'w') as fichier:
    fichier.write("Bonjour, le monde !\n")
    fichier.write("Ceci est un fichier texte d'exemple.")
 
# Lecture à partir d'un fichier
with open('example.txt', 'r') as fichier:
    contenu = fichier.read()
    print(contenu)  # Sortie : Bonjour, le monde !\nCeci est un fichier texte d'exemple.

L'instruction with est utilisée pour s'assurer que le fichier est correctement fermé après la fin des opérations, même si une exception est levée.

Vous pouvez également utiliser le module os pour travailler avec des chemins de fichiers et des répertoires :

import os
 
# Obtenir le répertoire de travail actuel
répertoire_courant = os.getcwd()
print(répertoire_courant)
 
# Joindre des chemins
chemin_fichier = os.path.join(répertoire_courant, 'exemple', 'fichier.txt')
print(chemin_fichier)
 
# Vérifier si un fichier ou un répertoire existe
if os.path.exists(chemin_fichier):
    print("Le fichier existe.")
else:
    print("Le fichier n'existe pas.")

Conclusion

Dans ce tutoriel, vous avez appris plusieurs concepts Python de niveau intermédiaire, notamment :

  • Les classes et la programmation orientée objet (POO)
  • Les modules et les packages
  • Les exceptions et la gestion des erreurs
  • Fichier I/O et chemins

Ces concepts sont essentiels pour construire des applications Python plus complexes et robustes. En comprenant et en appliquant ces techniques, vous pouvez écrire un code plus propre, plus maintenable et plus polyvalent.

N'oubliez pas que la meilleure façon d'améliorer vos compétences en Python est de pratiquer et d'expérimenter avec ces concepts. Essayez de les implémenter dans vos propres projets et défiez-vous continuellement pour apprendre de nouvelles choses.

Bon codage !

MoeNagy Dev