Python
Obtenir rapidement la liste des fichiers d'un répertoire : un guide Python

Obtenir rapidement la liste des fichiers d'un répertoire : un guide Python

MoeNagy Dev

Exploration des modules os et os.path

Aperçu des modules os et os.path

Les modules os et os.path en Python fournissent une manière indépendante de la plate-forme pour interagir avec le système de fichiers du système d'exploitation. Ces modules offrent une large gamme de fonctionnalités, allant de l'énumération des fichiers dans un répertoire à la gestion des chemins de fichiers et de répertoires.

Accéder au répertoire de travail actuel

Vous pouvez utiliser la fonction os.getcwd() pour obtenir le répertoire de travail actuel :

import os
 
repertoire_actuel = os.getcwd()
print(repertoire_actuel)

Cela affichera le chemin absolu du répertoire de travail actuel.

Énumérer les fichiers dans le répertoire actuel

La fonction os.listdir() peut être utilisée pour énumérer tous les fichiers et répertoires dans le répertoire de travail actuel :

import os
 
fichiers_et_repertoires = os.listdir()
print(fichiers_et_repertoires)

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

Utilisation de la fonction os.listdir()

Notions de base sur os.listdir()

La fonction os.listdir() prend un argument optionnel, qui est le chemin vers le répertoire dont vous voulez énumérer le contenu. Si aucun argument n'est fourni, elle énumérera le contenu du répertoire de travail actuel.

import os
 
# Énumérer les fichiers dans le répertoire actuel
fichiers_et_repertoires = os.listdir()
print(fichiers_et_repertoires)
 
# Énumérer les fichiers dans un répertoire spécifique
repertoire_specifique = "/chemin/vers/le/répertoire"
fichiers_et_repertoires = os.listdir(repertoire_specifique)
print(fichiers_et_repertoires)

Énumérer les fichiers dans un répertoire spécifique

Pour énumérer les fichiers dans un répertoire spécifique, passez le chemin vers le répertoire en argument à os.listdir() :

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

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

Gestion des chemins relatifs et absolus

Vous pouvez utiliser à la fois des chemins relatifs et absolus avec os.listdir(). Les chemins relatifs sont interprétés par rapport au répertoire de travail actuel, tandis que les chemins absolus sont interprétés comme le chemin complet vers le répertoire.

import os
 
# Utilisation d'un chemin relatif
chemin_rel = "documents"
fichiers_et_repertoires = os.listdir(chemin_rel)
print(fichiers_et_repertoires)
 
# Utilisation d'un chemin absolu
chemin_abs = "/home/utilisateur/documents"
fichiers_et_repertoires = os.listdir(chemin_abs)
print(fichiers_et_repertoires)

Filtrer la liste des fichiers

Exclusion des répertoires de la liste

Si vous voulez uniquement énumérer les fichiers d'un répertoire et pas les répertoires eux-mêmes, vous pouvez utiliser la fonction os.path.isfile() pour filtrer la liste :

import os
 
répertoire = "/chemin/vers/le/répertoire"
tous_les_éléments = os.listdir(répertoire)
fichiers = [élément for élément in tous_les_éléments if os.path.isfile(os.path.join(répertoire, élément))]
print(fichiers)

Cela créera une nouvelle liste fichiers qui contient uniquement les noms de fichiers, en excluant les répertoires.

Filtrage par extension de fichier

Pour filtrer la liste de fichiers par extension de fichier, vous pouvez utiliser une compréhension de liste :

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

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

Utilisation de la compréhension de liste pour un filtrage avancé

Les compréhensions de liste peuvent être utilisées pour appliquer une logique de filtrage plus complexe. Par exemple, pour obtenir une liste de fichiers avec une extension spécifique et d'une taille supérieure à une certaine valeur :

import os
 
répertoire = "/chemin/vers/le/répertoire"
tous_les_éléments = os.listdir(répertoire)
fichiers_csv_grands = [
    élément
    for élément in tous_les_éléments
    if élément.endswith(".csv") and os.path.getsize(os.path.join(répertoire, élément)) > 1024 * 1024
]
print(fichiers_csv_grands)

Cela créera une nouvelle liste fichiers_csv_grands qui ne contient que les fichiers CSV du répertoire qui sont supérieurs à 1 Mo.

Énumération récursive des fichiers dans les sous-répertoires

Exploration des sous-répertoires avec os.walk()

La fonction os.walk() peut être utilisée pour parcourir récursivement une arborescence de répertoires et énumérer tous les fichiers des sous-répertoires. Elle renvoie un générateur qui produit un 3-tuple pour chaque répertoire visité : le chemin vers le répertoire, une liste des répertoires dans ce répertoire et une liste des fichiers dans ce répertoire.

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

Cela affichera le chemin complet de chaque fichier dans l'arborescence de répertoires, en commençant par le répertoire spécifié.

Gestion des chemins de fichiers de manière récursive

Lorsque vous utilisez os.walk(), vous devez gérer correctement les chemins de fichiers, en particulier lorsque vous traitez des sous-répertoires. La fonction os.path.join() peut être utilisée pour construire le chemin complet d'un fichier en combinant le chemin du répertoire et le nom du fichier.

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

Cela affichera le chemin complet de chaque fichier, en tenant compte de la structure du répertoire.

Personnalisation du format de sortie

Vous pouvez personnaliser le format de sortie selon vos besoins. Par exemple, vous pouvez afficher la taille du fichier et la date de modification ainsi que le chemin du fichier :

import os
from datetime import datetime
 
répertoire = "/chemin/vers/le/répertoire"
for rép, dirs, fichiers in os.walk(répertoire):
    for fichier in fichiers:
        chemin_complet = os.path.join(rép, fichier)
```python
import os
 
# Obtenir la taille du fichier
full_path = "/chemin/vers/fichier.txt"
file_size = os.path.getsize(full_path)
print(f"Taille du fichier: {file_size} octets")
 
# Obtenir le temps de modification du fichier
mod_time = os.path.getmtime(full_path)
mod_time_str = datetime.fromtimestamp(mod_time).strftime("%Y-%m-%d %H:%M:%S")
print(f"Mise à jour: {mod_time_str}")

Cela affichera le chemin du fichier, sa taille et sa date de dernière modification pour chaque fichier de l'arborescence du répertoire.

Travailler avec le module os.path

Joindre des chemins avec os.path.join()

La fonction os.path.join() est utilisée pour construire des chemins de fichiers en joignant intelligemment un ou plusieurs composants de chemin. Elle gère les séparateurs de chemin appropriés (par exemple, les barres obliques sur les systèmes de type Unix, les barres obliques inverses sur Windows) en fonction du système d'exploitation.

import os
 
directory = "/chemin/vers/répertoire"
filename = "exemple.txt"
full_path = os.path.join(directory, filename)
print(full_path)

Cela affichera le chemin complet du fichier, avec les séparateurs de chemin appropriés pour le système d'exploitation actuel.

Vérifier si un chemin est un fichier ou un répertoire

Les fonctions os.path.isfile() et os.path.isdir() peuvent être utilisées pour vérifier si un chemin donné représente un fichier ou un répertoire, respectivement.

import os
 
path = "/chemin/vers/fichier.txt"
if os.path.isfile(path):
    print(f"{path} est un fichier.")
else:
    print(f"{path} n'est pas un fichier.")
 
path = "/chemin/vers/répertoire"
if os.path.isdir(path):
    print(f"{path} est un répertoire.")
else:
    print(f"{path} n'est pas un répertoire.")

Obtenir la taille du fichier et le temps de modification

Les fonctions os.path.getsize() et os.path.getmtime() peuvent être utilisées pour obtenir la taille d'un fichier et l'heure de sa dernière modification, respectivement.

import os
from datetime import datetime
 
path = "/chemin/vers/fichier.txt"
file_size = os.path.getsize(path)
mod_time = os.path.getmtime(path)
mod_time_str = datetime.fromtimestamp(mod_time).strftime("%Y-%m-%d %H:%M:%S")
print(f"Taille du fichier: {file_size} octets")
print(f"Dernière modification: {mod_time_str}")

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

Gestion de la compatibilité multiplateforme

Prise en compte des différences entre les systèmes d'exploitation

Les modules os et os.path sont conçus pour fournir une interface indépendante de la plate-forme, mais il existe encore quelques différences dans la manière dont les chemins de fichiers sont gérés sur différentes plateformes (par exemple, Windows utilise des barres obliques inverses, tandis que les systèmes de type Unix utilisent des barres obliques).

Assurer un comportement cohérent sur les différentes plateformes

Pour vous assurer que votre code fonctionne de manière cohérente sur différentes plateformes, vous devez utiliser les fonctions et méthodes appropriées du module os.path, telles que os.path.join(), os.path.normpath() et os.path.normcase().

Utilisation de os.path.normpath() et os.path.normcase()

La fonction os.path.normpath() peut être utilisée pour normaliser un chemin en supprimant les séparateurs redondants et les références ascendantes (par exemple, ../). La fonction os.path.normcase() peut être utilisée pour normaliser la casse d'un chemin, ce qui est important sur les systèmes de fichiers sensibles à la casse.

import os
 
# Normaliser un chemin
path = "/chemin/vers/../fichier.txt"
normalized_path = os.path.normpath(path)
print(normalized_path)  # Sortie: "/chemin/fichier.txt"
 
# Normaliser la casse d'un chemin
path = "/CHEMIN/vers/FICHIER.txt"
normalized_path = os.path.normcase(path)
print(normalized_path)  # Sortie: "/chemin/vers/fichier.txt" (sur les systèmes de type Unix)

En utilisant ces fonctions, vous pouvez vous assurer que vos chemins de fichiers sont formatés de manière cohérente sur différents systèmes d'exploitation.

Tri et organisation de la liste des fichiers

Trier la liste des fichiers par nom, taille ou heure de modification

Vous pouvez trier la liste des fichiers en fonction de différentes attributs, tels que le nom du fichier, la taille ou l'heure de modification. La fonction sorted() peut être utilisée à cet effet, ainsi que les fonctions-clés appropriées.

import os
 
directory = "/chemin/vers/répertoire"
files = os.listdir(directory)
 
# Trier par nom de fichier
sorted_files = sorted(files)
print(sorted_files)
 
# Trier par taille de fichier
file_sizes = [(f, os.path.getsize(os.path.join(directory, f))) for f in files]
sorted_files = sorted(file_sizes, key=lambda x: x[1])
print(sorted_files)
 
# Trier par heure de modification
file_mod_times = [(f, os.path.getmtime(os.path.join(directory, f))) for f in files]
sorted_files = sorted(file_mod_times, key=lambda x: x[1])
print(sorted_files)

Cela affichera la liste des fichiers triée par nom, taille et heure de modification, respectivement.

Regroupement des fichiers par extension ou par d'autres attributs

Vous pouvez regrouper les fichiers par leur extension ou d'autres attributs à l'aide d'un dictionnaire ou d'un defaultdict :

import os
from collections import defaultdict
 
directory = "/chemin/vers/répertoire"
files = os.listdir(directory)
 
# Regrouper les fichiers par extension
file_groups = defaultdict(list)
for file in files:
    extension = os.path.splitext(file)[1][1:]
    file_groups[extension].append(file)
 
for extension, files in file_groups.items():
    print(f"Fichiers avec l'extension {extension} : {', '.join(files)}")
 
# Regrouper les fichiers par taille (en Mo)
file_sizes = [(f, os.path.getsize(os.path.join(directory, f))) for f in files]
file_groups = defaultdict(list)
for file, size in file_sizes:
    size_mb = size / (1024 * 1024)
    file_groups[f"{size_mb:.2f} Mo"].append(file)
 
for size, files in file_groups.items():
    print(f"Fichiers de taille {size} : {', '.join(files)}")

Cela regroupera les fichiers par

Structures de données

Listes

Les listes sont l'une des structures de données les plus polyvalentes en Python. Elles sont des collections ordonnées d'éléments, qui peuvent être de différents types de données. Voici un exemple :

my_list = [1, 'pomme', 3.14, True]

Vous pouvez accéder aux éléments individuels d'une liste en utilisant leur indice, qui commence à 0 :

print(my_list[0])  # Sortie: 1
print(my_list[2])  # Sortie: 3.14

Vous pouvez également modifier les éléments d'une liste :

my_list[1] = 'banane'
print(my_list)  # Sortie: [1, 'banane', 3.14, True]

Les listes possèdent de nombreuses méthodes intégrées, telles que append(), insert(), remove() et sort().

Tuples

Les tuples sont similaires aux listes, mais ils sont immuables, ce qui signifie que vous ne pouvez pas modifier leurs éléments après leur création. Les tuples sont définis à l'aide de parenthèses () au lieu de crochets [].

my_tuple = (1, 'apple', 3.14, True)
print(my_tuple[0])  # Output: 1

Les tuples sont utiles lorsque vous souhaitez garantir que l'ordre et le contenu d'une collection de données restent inchangés.

Dictionnaires

Les dictionnaires sont des collections non ordonnées de paires clé-valeur. Ils sont définis à l'aide d'accolades {} et chaque paire clé-valeur est séparée par un deux-points :.

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
print(my_dict['name'])  # Output: 'John'

Vous pouvez ajouter, modifier et supprimer des paires clé-valeur dans un dictionnaire :

my_dict['email'] = 'john@example.com'
my_dict['age'] = 31
del my_dict['city']

Les dictionnaires sont puissants pour stocker et récupérer des données basées sur des clés uniques.

Ensembles

Les ensembles sont des collections non ordonnées d'éléments uniques. Ils sont définis à l'aide d'accolades {} ou de la fonction set().

my_set = {1, 2, 3, 4, 5}
print(2 in my_set)  # Output: True
print(6 in my_set)  # Output: False

Les ensembles sont utiles pour effectuer des opérations telles que l'union, l'intersection et la différence entre des collections de données.

Flux de contrôle

Instructions conditionnelles

Les instructions conditionnelles en Python utilisent les mots clés if, elif et else pour exécuter différents blocs de code en fonction de certaines conditions.

x = 10
if x > 0:
    print("x is positive")
elif x < 0:
    print("x is negative")
else:
    print("x is zero")

Boucles

Python dispose de deux structures de boucle principales : for et while. La boucle for est utilisée pour itérer sur des séquences (comme des listes, des tuples ou des chaînes de caractères), tandis que la boucle while est utilisée pour exécuter un bloc de code tant qu'une certaine condition est vraie.

# Boucle for
fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)
 
# Boucle while
count = 0
while count < 5:
    print(count)
    count += 1

Vous pouvez également utiliser les instructions break et continue pour contrôler le flux d'une boucle.

Compréhensions de liste

Les compréhensions de liste permettent de créer de nouvelles listes basées sur des listes existantes. Elles sont particulièrement utiles pour transformer ou filtrer des données.

# Créer une nouvelle liste avec les carrés des nombres de 1 à 10
squares = [x**2 for x in range(1, 11)]
print(squares)  # Output: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
 
# Créer une nouvelle liste avec les nombres pairs de 1 à 10
even_numbers = [x for x in range(1, 11) if x % 2 == 0]
print(even_numbers)  # Output: [2, 4, 6, 8, 10]

Fonctions

Les fonctions en Python sont définies à l'aide du mot clé def. Elles peuvent accepter des paramètres et renvoyer des valeurs.

def greet(name):
    """Saluer la personne avec le nom donné."""
    print(f"Hello, {name}!")
 
greet("Alice")  # Output: Hello, Alice!

Vous pouvez également définir des fonctions avec des valeurs par défaut pour les paramètres et des arguments de longueur variable.

def calculate_area(length, width=1):
    """Calculer l'aire d'un rectangle."""
    return length * width
 
print(calculate_area(5, 3))  # Output: 15
print(calculate_area(4))  # Output: 4 (la largeur par défaut est 1)
 
def sum_numbers(*args):
    """Calculer la somme de n'importe quel nombre d'arguments."""
    return sum(args)
 
print(sum_numbers(1, 2, 3))  # Output: 6
print(sum_numbers(4, 5, 6, 7, 8))  # Output: 30

Les fonctions peuvent également être définies sous la forme de fonctions lambda (fonctions anonymes) pour des opérations simples d'une seule ligne.

square = lambda x: x**2
print(square(5))  # Output: 25

Modules et packages

La bibliothèque standard de Python offre une large gamme de modules intégrés que vous pouvez utiliser dans vos programmes. Vous pouvez également créer vos propres modules et packages pour organiser votre code.

# Utilisation d'un module intégré
import math
print(math.pi)  # Output: 3.141592653589793
 
# Création d'un module personnalisé
# my_module.py
def greet(name):
    print(f"Hello, {name}!")
 
# Utilisation du module personnalisé
import my_module
my_module.greet("Alice")  # Output: Hello, Alice!

Les packages sont des collections de modules, et ils vous aident à structurer votre code et à gérer les dépendances.

Gestion des exceptions

Le mécanisme de gestion des exceptions de Python vous permet de gérer les erreurs et les situations inattendues dans votre code.

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Error: Division by zero")
else:
    print(f"Result: {result}")
finally:
    print("This block will always execute.")

Vous pouvez également définir vos propres exceptions personnalisées et les lever lorsque cela est nécessaire.

class InvalidInputError(Exception):
    pass
 
def divide(a, b):
    if b == 0:
        raise InvalidInputError("Error: Division by zero")
    return a / b
 
try:
    print(divide(10, 0))
except InvalidInputError as e:
    print(e)

Entrée/Sortie de fichiers

Python fournit des fonctions intégrées pour lire à partir de fichiers et écrire dans des fichiers.

# Écriture dans un fichier
with open("output.txt", "w") as file:
    file.write("Hello, World!")
 
# Lecture à partir d'un fichier
with open("input.txt", "r") as file:
    content = file.read()
    print(content)

L'instruction with garantit que le fichier est correctement fermé après l'opération.

Conclusion

Dans ce tutoriel sur Python, nous avons couvert un large éventail de sujets, notamment les structures de données, le flux de contrôle, les fonctions, les modules et packages, la gestion des exceptions et l'entrée/sortie de fichiers. En comprenant ces concepts, vous serez bien parti pour devenir un programmeur Python compétent. N'oubliez pas de pratiquer régulièrement et d'explorer le vaste écosystème des bibliothèques et frameworks Python pour développer vos compétences et créer des applications puissantes.

MoeNagy Dev