Python
Récupérer facilement des fichiers dans un répertoire avec Python

Récupérer facilement des fichiers dans un répertoire avec Python

MoeNagy Dev

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

La puissance de os.listdir()

Comprendre la fonction os.listdir()

La fonction os.listdir() est un outil puissant de la bibliothèque standard de Python qui vous permet de récupérer une liste de tous les fichiers et répertoires d'un répertoire spécifié. Cette fonction fait partie du module os, qui fournit un moyen d'interagir avec le système d'exploitation.

Voici un exemple de base de l'utilisation de os.listdir() :

import os
 
chemin_du_répertoire = '/chemin/vers/le/répertoire'
liste_de_fichiers = os.listdir(chemin_du_répertoire)
print(liste_de_fichiers)

Ce code affichera une liste de tous les fichiers et répertoires du chemin_du_répertoire spécifié.

Lister tous les fichiers d'un répertoire

Pour obtenir une liste uniquement des fichiers (et non des répertoires) d'un répertoire, vous pouvez utiliser l'approche suivante :

import os
 
chemin_du_répertoire = '/chemin/vers/le/répertoire'
liste_de_fichiers = [fichier for fichier in os.listdir(chemin_du_répertoire) if os.path.isfile(os.path.join(chemin_du_répertoire, fichier))]
print(liste_de_fichiers)

Dans cet exemple, nous utilisons une compréhension de liste pour filtrer la liste renvoyée par os.listdir() et inclure uniquement les éléments qui sont des fichiers (par opposition aux répertoires) en utilisant la fonction os.path.isfile().

Gérer les sous-répertoires et la récupération récursive des fichiers

Si vous souhaitez récupérer des fichiers non seulement du répertoire spécifié, mais également de ses sous-répertoires, vous pouvez utiliser une approche récursive. Voici un exemple :

import os
 
def obtenir_tous_les_fichiers(chemin_du_répertoire):
    liste_de_fichiers = []
    for répertoire_mère, sous-répertoires, fichiers in os.walk(chemin_du_répertoire):
        for fichier in fichiers:
            liste_de_fichiers.append(os.path.join(répertoire_mère, fichier))
    return liste_de_fichiers
 
chemin_du_répertoire = '/chemin/vers/le/répertoire'
tous_les_fichiers = obtenir_tous_les_fichiers(chemin_du_répertoire)
print(tous_les_fichiers)

Dans cet exemple, nous définissons une fonction obtenir_tous_les_fichiers() qui utilise la fonction os.walk() pour parcourir l'arborescence du répertoire de manière récursive. Pour chaque fichier rencontré, nous construisons le chemin complet du fichier en utilisant os.path.join() et l'ajoutons à la liste_de_fichiers.

Filtrer les fichiers par extension

Spécifier les extensions de fichiers à inclure

Pour récupérer uniquement les fichiers avec des extensions de fichier spécifiques, vous pouvez utiliser l'approche suivante :

import os
 
chemin_du_répertoire = '/chemin/vers/le/répertoire'
extensions_autorisées = ['.txt', '.py', '.jpg']
 
liste_de_fichiers = [fichier for fichier in os.listdir(chemin_du_répertoire) if any(fichier.endswith(extension) for extension in extensions_autorisées)]
print(liste_de_fichiers)

Dans cet exemple, nous définissons une liste extensions_autorisées et utilisons ensuite une compréhension de liste pour filtrer la liste de fichiers renvoyée par os.listdir() afin d'inclure uniquement les fichiers qui ont l'une des extensions spécifiées.

Exclure certaines extensions de fichier

De manière similaire, vous pouvez exclure certaines extensions de fichier en modifiant la compréhension de liste :

import os
 
chemin_du_répertoire = '/chemin/vers/le/répertoire'
extensions_exclues = ['.pyc', '.log']
 
liste_de_fichiers = [fichier for fichier in os.listdir(chemin_du_répertoire) if not any(fichier.endswith(extension) for extension in extensions_exclues)]
print(liste_de_fichiers)

Ici, nous définissons une liste extensions_exclues et utilisons une compréhension de liste pour filtrer la liste de fichiers, en excluant tous les fichiers ayant l'une des extensions spécifiées.

Gérer plusieurs extensions de fichier

Vous pouvez également gérer plusieurs extensions de fichier de manière plus flexible en utilisant un ensemble ou un dictionnaire :

import os
 
chemin_du_répertoire = '/chemin/vers/le/répertoire'
extensions_autorisées = {'.txt', '.py', '.jpg'}
 
liste_de_fichiers = [fichier for fichier in os.listdir(chemin_du_répertoire) if any(fichier.endswith(extension) for extension in extensions_autorisées)]
print(liste_de_fichiers)

Dans cet exemple, nous utilisons un ensemble extensions_autorisées au lieu d'une liste. Cela nous permet d'ajouter ou de supprimer facilement des extensions sans modifier la compréhension de liste.

Trier et organiser la liste de fichiers

Trier la liste de fichiers par ordre alphabétique

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

import os
 
chemin_du_répertoire = '/chemin/vers/le/répertoire'
liste_de_fichiers = os.listdir(chemin_du_répertoire)
liste_de_fichiers_triée = sorted(liste_de_fichiers)
print(liste_de_fichiers_triée)

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

Trier par taille de fichier ou date de modification

Pour trier la liste de fichiers par taille de fichier ou par date de modification, vous pouvez utiliser les fonctions os.path.getsize() et os.path.getmtime(), respectivement :

import os
 
chemin_du_répertoire = '/chemin/vers/le/répertoire'
liste_de_fichiers = os.listdir(chemin_du_répertoire)
 
# Trier par taille de fichier
triée_par_taille = sorted(liste_de_fichiers, key=lambda x: os.path.getsize(os.path.join(chemin_du_répertoire, x)))
print(triée_par_taille)
 
# Trier par date de modification
triée_par_date = sorted(liste_de_fichiers, key=lambda x: os.path.getmtime(os.path.join(chemin_du_répertoire, x)))
print(triée_par_date)

Dans le premier exemple, nous utilisons la fonction sorted() avec une fonction de clé personnalisée qui récupère la taille du fichier en utilisant os.path.getsize(). Dans le deuxième exemple, nous utilisons la date de modification récupérée par os.path.getmtime() comme clé de tri.

Regrouper les fichiers par extension

Pour regrouper les fichiers en fonction de leurs extensions de fichier, vous pouvez utiliser un dictionnaire pour stocker les fichiers regroupés par leurs extensions :

import os
from collections import defaultdict
 
chemin_du_répertoire = '/chemin/vers/le/répertoire'
liste_de_fichiers = os.listdir(chemin_du_répertoire)
 
groupes_de_fichiers = defaultdict(list)
for nom_de_fichier in liste_de_fichiers:
    extension = os.path.splitext(nom_de_fichier)[1].lower()
    groupes_de_fichiers[extension].append(nom_de_fichier)
 
for extension, fichiers in groupes_de_fichiers.items():
    print(f"Fichiers avec l'extension '{extension}': {', '.join(fichiers)}")

Dans cet exemple, nous utilisons un defaultdict du module collections pour créer un dictionnaire qui initialisera automatiquement des listes vides pour les nouvelles extensions de fichier. Ensuite, nous itérons à travers la liste de fichiers, extrayons l'extension du fichier en utilisant os.path.splitext(), et ajoutons le nom de fichier à la liste correspondante dans le dictionnaire file_groups.

Travailler avec Pathlib

Présentation du module Pathlib

Le module pathlib en Python fournit une façon orientée objet de travailler avec les chemins de fichiers. Il offre une approche plus intuitive et multiplateforme par rapport au module os.path traditionnel.

Listing des fichiers en utilisant Pathlib

Voici un exemple de la façon d'utiliser pathlib pour lister les fichiers dans un répertoire :

from pathlib import Path
 
directory_path = '/chemin/vers/répertoire'
file_list = [p.name for p in Path(directory_path).glob('*')]
print(file_list)

Dans cet exemple, nous utilisons la classe Path du module pathlib pour représenter le chemin du répertoire. La méthode glob() est ensuite utilisée pour récupérer une liste de tous les fichiers et répertoires dans le répertoire spécifié.

Accéder aux métadonnées des fichiers avec Pathlib

Vous pouvez également utiliser pathlib pour accéder facilement aux métadonnées des fichiers, telles que la taille du fichier et la date de modification :

from pathlib import Path
 
file_path = '/chemin/vers/fichier.txt'
file_path = Path(file_path)
 
print(f"Nom du fichier : {file_path.name}")
print(f"Taille du fichier : {file_path.stat().st_size} octets")
print(f"Date de modification : {file_path.stat().st_mtime}")

Ce code montre comment récupérer le nom du fichier, la taille du fichier et l'heure de modification en utilisant l'objet pathlib.Path.

Manipulation des fichiers et répertoires cachés

Identification des fichiers et répertoires cachés

Dans de nombreux systèmes de fichiers, les fichiers et répertoires qui commencent par un point (par exemple, .gitignore) sont considérés comme "cachés" et ne sont généralement pas affichés dans les listes de répertoires. Pour inclure ou exclure ces éléments cachés, vous pouvez utiliser l'approche suivante :

import os
 
directory_path = '/chemin/vers/répertoire'
all_items = os.listdir(directory_path)
visible_items = [item for item in all_items if not item.startswith('.')]
hidden_items = [item for item in all_items if item.startswith('.')]
 
print("Éléments visibles :", visible_items)
print("Éléments cachés :", hidden_items)

Dans cet exemple, nous récupérons d'abord la liste complète des éléments dans le répertoire en utilisant os.listdir(). Nous utilisons ensuite deux listes en compréhension pour séparer les éléments visibles et les éléments cachés en fonction du fait que le nom de l'élément commence par un point ou non.

Choisir d'inclure ou d'exclure ces éléments

Selon votre cas d'utilisation, vous pouvez choisir d'inclure ou d'exclure les fichiers et répertoires cachés. Voici un exemple de la façon de gérer cela :

import os
 
directory_path = '/chemin/vers/répertoire'
include_hidden = False
 
all_items = os.listdir(directory_path)
if include_hidden:
    file_list = all_items
else:
    file_list = [item for item in all_items if not item.startswith('.')]
 
print(file_list)

Dans cet exemple, nous introduisons une variable booléenne include_hidden qui contrôle si les éléments cachés doivent être inclus dans la liste finale des fichiers ou non.

Personnaliser le comportement de la recherche de fichiers

Vous pouvez également personnaliser davantage le comportement de la recherche de fichiers en créant une fonction qui vous permet de spécifier des règles personnalisées pour inclure ou exclure des fichiers et répertoires :

import os
 
def get_file_list(directory_path, include_hidden=False, allowed_extensions=None, excluded_extensions=None):
    all_items = os.listdir(directory_path)
    file_list = []
 
    for item in all_items:
        item_path = os.path.join(directory_path, item)
        if os.path.isfile(item_path):
            if allowed_extensions:
                if any(item.endswith(ext) for ext in allowed_extensions):
                    file_list.append(item)
            elif excluded_extensions:
                if not any(item.endswith(ext) for ext in excluded_extensions):
                    file_list.append(item)
            else:
                file_list.append(item)
        elif include_hidden or not item.startswith('.'):
            file_list.append(item)
 
    return file_list
 
# Exemple d'utilisation
directory_path = '/chemin/vers/répertoire'
file_list = get_file_list(directory_path, include_hidden=False, allowed_extensions=['.txt', '.py'])
print(file_list)

Dans cet exemple, la fonction get_file_list() vous permet de spécifier si vous souhaitez inclure des fichiers et des répertoires cachés, ainsi que les extensions de fichier à inclure ou à exclure. Cela offre une façon flexible et personnalisable de récupérer la liste de fichiers en fonction de vos besoins spécifiques.

Combinaison de os.listdir() et os.path.join()

Utilisation de os.path.join() pour construire des chemins de fichiers complets

Lorsque vous travaillez avec la liste de fichiers récupérée à partir de os.listdir(), vous avez souvent besoin de construire des chemins de fichiers complets. Vous pouvez utiliser la fonction os.path.join() à cette fin :

import os
 
directory_path = '/chemin/vers/répertoire'
file_list = os.listdir(directory_path)
full_file_paths = [os.path.join(directory_path, filename) for filename in file_list]
print(full_file_paths)

Dans cet exemple, nous utilisons une compréhension de liste pour itérer à travers la liste de fichiers et construire les chemins de fichiers complets en joignant le chemin du répertoire et les noms de fichiers individuels en utilisant os.path.join().

Itération à travers le répertoire et construction de la liste de fichiers

Vous pouvez combiner os.listdir() et os.path.join() pour construire la liste de fichiers de manière plus efficace :

import os
 
def get_file_list(directory_path):
    file_list = []
    for filename in os.listdir(directory_path):
        file_path = os.path.join(directory_path, filename)
        if os.path.isfile(file_path):
            file_list.append(file_path)
    return file_list
 
directory_path = '/chemin/vers/répertoire'
all_files = get_file_list(directory_path)
print(all_files)
 
## Structures de données
 
### Listes
Les listes sont l'une des structures de données les plus fondamentales en Python. Ce sont des collections ordonnées d'éléments, qui peuvent être de types de données différents. Vous pouvez créer une liste en utilisant des crochets `[]` et séparer les éléments par des virgules.
 
```python
fruits = ['pomme', 'banane', 'cerise']
print(fruits)  # Résultat : ['pomme', 'banane', 'cerise']

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

print(fruits[0])  # Résultat : 'pomme'
print(fruits[1])  # Résultat : 'banane'

Vous pouvez également utiliser des indices négatifs pour accéder aux éléments depuis la fin de la liste.

print(fruits[-1])  # Résultat : 'cerise'
print(fruits[-2])  # Résultat : 'banane'

Les listes supportent de nombreuses opérations, telles que le découpage, la concaténation et la modification.

# Découpage
print(fruits[1:3])  # Résultat : ['banane', 'cerise']
 
# Concaténation
more_fruits = ['orange', 'kiwi']
all_fruits = fruits + more_fruits
print(all_fruits)  # Résultat : ['pomme', 'banane', 'cerise', 'orange', 'kiwi']
 
# Modification
fruits[0] = 'poire'
print(fruits)  # Résultat : ['poire', 'banane', 'cerise']

Tuples

Les tuples sont similaires aux listes, mais ils sont immuables, c'est-à-dire 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.

point = (3, 4)
print(point)  # Résultat : (3, 4)
print(point[0])  # Résultat : 3
print(point[1])  # Résultat : 4

Les tuples peuvent être utiles lorsque vous souhaitez stocker un ensemble fixe de valeurs, telles que des coordonnées ou des enregistrements de bases de données.

Dictionnaires

Les dictionnaires sont des collections non ordonnées de paires clé-valeur. Ils sont définis à l'aide d'accolades {} et les clés et valeurs sont séparées par des deux-points.

personne = {
    'nom': 'Jean Dupont',
    'âge': 35,
    'profession': 'Ingénieur logiciel'
}
print(personne)  # Résultat : {'nom': 'Jean Dupont', 'âge': 35, 'profession': 'Ingénieur logiciel'}

Vous pouvez accéder aux valeurs d'un dictionnaire en utilisant leurs clés.

print(personne['nom'])  # Résultat : 'Jean Dupont'
print(personne['âge'])  # Résultat : 35

Les dictionnaires sont polyvalents et peuvent être utilisés pour stocker différents types de données, y compris des listes et d'autres dictionnaires.

personne = {
    'nom': 'Jean Dupont',
    'âge': 35,
    'hobbies': ['lecture', 'randonnée', 'photographie'],
    'adresse': {
        'rue': '123 rue Principale',
        'ville': 'Villeimaginaire',
        'état': 'CA'
    }
}
 
print(personne['hobbies'])  # Résultat : ['lecture', 'randonnée', 'photographie']
print(personne['adresse']['ville'])  # Résultat : 'Villeimaginaire'

Ensembles

Les ensembles sont des collections non ordonnées d'éléments uniques. Ils sont définis à l'aide d'accolades {} et les éléments sont séparés par des virgules.

couleurs = {'rouge', 'vert', 'bleu'}
print(couleurs)  # Résultat : {'rouge', 'vert', 'bleu'}

Vous pouvez utiliser des ensembles pour effectuer diverses opérations, telles que l'union, l'intersection et la différence.

couleurs1 = {'rouge', 'vert', 'bleu'}
couleurs2 = {'vert', 'jaune', 'orange'}
 
# Union
toutes_les_couleurs = couleurs1 | couleurs2
print(toutes_les_couleurs)  # Résultat : {'rouge', 'vert', 'bleu', 'jaune', 'orange'}
 
# Intersection
couleurs_communes = couleurs1 & couleurs2
print(couleurs_communes)  # Résultat : {'vert'}
 
# Différence
couleurs_uniques1 = couleurs1 - couleurs2
print(couleurs_uniques1)  # Résultat : {'rouge', 'bleu'}

Structures de contrôle

Instructions conditionnelles

En Python, vous pouvez utiliser des instructions conditionnelles pour contrôler le flux de votre programme en fonction de certaines conditions.

L'instruction si-sinon-sinon si est la façon la plus courante de mettre en œuvre une logique conditionnelle.

âge = 25
if âge < 18:
    print("Vous êtes mineur.")
elif âge < 65:
    print("Vous êtes adulte.")
else:
    print("Vous êtes senior.")

Vous pouvez également utiliser l'opérateur ternaire, qui est une méthode abrégée pour écrire des instructions si-sinon simples.

est_étudiant = True
statut = "Étudiant" if est_étudiant else "Non étudiant"
print(statut)  # Résultat : "Étudiant"

Boucles

Les boucles en Python vous permettent d'exécuter plusieurs fois un bloc de code. Les deux types de boucles les plus courants sont les boucles pour et tant que.

Une boucle pour est utilisée pour itérer sur une séquence, telle qu'une liste ou une chaîne de caractères.

fruits = ['pomme', 'banane', 'cerise']
for fruit in fruits:
    print(fruit)

Une boucle tant que est utilisée pour exécuter un bloc de code de manière répétée tant qu'une certaine condition est vraie.

compte = 0
while compte < 5:
    print(compte)
    compte += 1

Vous pouvez également utiliser les instructions break (sortir de la boucle) et continue (passer à l'itération suivante) pour contrôler le flux de vos boucles.

for i in range(10):
    if i == 5:
        break
    print(i)  # Résultat : 0 1 2 3 4
 
for j in range(10):
    if j % 2 == 0:
        continue
    print(j)  # Résultat : 1 3 5 7 9

Fonctions

Les fonctions en Python sont des blocs de code réutilisables qui effectuent une tâche spécifique. Elles sont définies à l'aide du mot-clé def.

def saluer(nom):
    print(f"Bonjour, {nom} !")
 
saluer("Alice")  # Résultat : "Bonjour, Alice !"

Les fonctions peuvent également renvoyer des valeurs en utilisant l'instruction return.

def ajouter_nombres(a, b):
    return a + b
 
résultat = ajouter_nombres(3, 4)
print(résultat)  # Résultat : 7

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

def imprimer_info(nom, âge=30, *args):
    print(f"Nom : {nom}")
    print(f"Âge : {âge}")
    print("Informations supplémentaires :")
    for arg in args:
        print(arg)
 
imprimer_info("John", 35, "Ingénieur logiciel", "Aime la randonnée")

Modules et packages

En Python, vous pouvez organiser votre code en modules et en packages pour le rendre plus modulaire et réutilisable.

Un module est un seul fichier Python qui contient des fonctions, des classes et des variables. Vous pouvez importer des modules à l'aide de l'instruction import.

import math
print(math.pi)  # Résultat : 3.141592653589793

Vous pouvez également importer des éléments spécifiques d'un module en utilisant le mot-clé from.

from math import sqrt
print(sqrt(16))  # Résultat : 4.0

Les packages sont des collections de modules apparentés. Ils sont organisés en répertoires avec un fichier __init__.py qui définit le package.

mon_package/
```python
---
title: Guide du Python
language: fr
---

# Fichiers de module

Vous pouvez ensuite importer des éléments d'un package en utilisant la notation point.

```python
import mon_package.module1
resultat = mon_package.module1.ma_fonction()

Gestion des exceptions

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

Vous pouvez utiliser l'instruction try-except pour attraper et gérer les exceptions.

try:
    resultat = 10 / 0
except ZeroDivisionError:
    print("Erreur : Division par zéro")

Vous pouvez également gérer plusieurs exceptions et fournir un bloc except par défaut.

try:
    num = int(input("Entrez un nombre : "))
    print(10 / num)
except ValueError:
    print("Erreur : Entrée invalide")
except ZeroDivisionError:
    print("Erreur : Division par zéro")
except:
    print("Une erreur inconnue s'est produite")

Vous pouvez également lever vos propres exceptions en utilisant l'instruction raise.

def retirer(solde, montant):
    if montant > solde:
        raise ValueError("Fonds insuffisants")
    return solde - montant
 
try:
    nouveau_solde = retirer(100, 150)
except ValueError as e:
    print(e)

Conclusion

Dans ce tutoriel, vous avez appris différentes structures de données, des instructions de contrôle de flux, des fonctions, des modules et la gestion des exceptions en Python. Ces concepts sont essentiels pour la création d'applications Python plus complexes et robustes. N'oubliez pas de pratiquer et d'expérimenter avec les exemples fournis afin de consolider votre compréhension de ces sujets.

MoeNagy Dev