Cet article explore les moyens de rechercher efficacement des sous-dossiers spécifiques dans de grands répertoires en Python. Compte tenu du goulot d'étranglement des performances de os.listdir traditionnel lors du traitement de fichiers volumineux, cet article présente en détail comment utiliser la fonctionnalité d'itérateur et le mécanisme de cache de os.scandir pour réduire considérablement les opérations d'E/S et l'utilisation de la mémoire, obtenant ainsi une analyse de répertoire plus rapide et plus optimisée.

Goulots d'étranglement en termes de performances des méthodes traditionnelles d'analyse d'annuaire

En Python, une manière courante d'énumérer le contenu d'un répertoire consiste à utiliser os.listdir(). Cependant, cette approche peut souffrir de problèmes de performances importants lorsqu'il s'agit de répertoires très volumineux contenant des centaines de milliers, voire plus, de fichiers et de sous-dossiers. Les principales raisons sont :

1. Surcharge de deux appels système?: os.listdir() obtiendra d'abord la liste des noms de tous les fichiers et dossiers sous le chemin spécifié. Ensuite, pour déterminer si chaque entrée est un répertoire (par exemple, en utilisant os.path.isdir()), le programme doit effectuer un appel système distinct pour chaque nom de la liste afin d'obtenir ses métadonnées. Cela signifie que pour N entrées, N appels système supplémentaires à os.path.isdir() seront générés, ce qui entra?nera un grand nombre d'opérations d'E/S et une consommation de temps.
2. Utilisation de la mémoire : os.listdir() charge simultanément tous les noms d'entrées d'un répertoire en mémoire, ce qui peut entra?ner une utilisation importante de la mémoire pour les répertoires contenant un grand nombre d'entrées.
3. Correspondance d'expressions régulières?: après avoir obtenu toutes les entrées, filtrez les expressions régulières. Bien que puissant, pour des données massives, chaque correspondance augmentera toujours la charge de calcul.

Voici un exemple typique d’implémentation héritée qui peut entra?ner des problèmes de performances?:

 importer le système d'exploitation
importer re

def find_subfolders_inefficient(dir_of_interest, Starting_string_of_interest)?:
    # 1. Obtenez tous les noms de fichiers et de dossiers all_entries = os.listdir(dir_of_interest)

    # 2. Filtrez tous les sous-dossiers (chaque os.path.isdir() est un appel système)
    tous_sous-dossiers = [
        article pour article dans all_entries 
        si os.path.isdir(os.path.join(dir_of_interest, item))
    ]

    # 3. Utilisez des expressions régulières pour correspondre à regexp_pattern = re.compile(starting_string_of_interest)
    all_subfolders_of_interest = list(filter(regexp_pattern.match, all_subfolders))

    retourner all_subfolders_of_interest

# Exemple d'appel # subfolders = find_subfolders_inefficient('path/to/large/folder', 'prefix_')

os.scandir?: itérateur de répertoire efficace

Afin de résoudre le goulot d'étranglement des performances ci-dessus, Python 3.5 a introduit la fonction os.scandir(). os.scandir() fournit un itérateur de répertoire plus efficace. Ses principaux avantages sont :

1. Réduire les appels système : os.scandir() renvoie un itérateur, et chaque itération génère un objet os.DirEntry. Cet objet DirEntry met en cache le type de fichier et les statistiques (par exemple s'il s'agit d'un répertoire, d'un fichier, etc.) lors de sa création, il n'est donc pas nécessaire d'appeler os.path.isdir() ou os.path.isfile() pour obtenir ces informations. Cela réduit considérablement le nombre de requêtes sur le système de fichiers.
2. Modèle d'itérateur : os.scandir() ne charge pas toutes les entrées en mémoire en même temps, mais génère les objets DirEntry un par un à la demande. Cela le rend extrêmement efficace en termes de mémoire lors de la gestion de très grands répertoires.
3. Accès direct aux attributs : L'objet DirEntry fournit des méthodes et des attributs tels que name (nom de fichier/nom de dossier), path (chemin complet), is_dir(), is_file(), etc., qui peuvent être directement utilisés pour déterminer et obtenir des informations.

Implémentation optimisée?: utilisez os.scandir pour rechercher des sous-dossiers

L'utilisation de os.scandir() pour optimiser la logique de recherche du sous-dossier spécifié peut améliorer considérablement les performances. Ce qui suit est une implémentation optimisée basée sur os.scandir()?:

 importer le système d'exploitation

def find_subfolders_efficient(dir_of_interest, Starting_string_of_interest)?:
    """
    Utilisez os.scandir pour rechercher efficacement des sous-dossiers commen?ant par une cha?ne spécifique dans un répertoire spécifié.

    Args?:
        dir_of_interest (str)?: chemin du répertoire à analyser.
        Starting_string_of_interest (str)?: La cha?ne correspondante de début du nom du sous-dossier.

    Retours?:
        list?: Liste des noms de sous-dossiers correspondants.
    """
    all_subfolders_of_interest = []

    essayer:
        # Parcourez les entrées du répertoire avec os.scandir(dir_of_interest) comme entrées?:
            pour l'entrée dans les entrées :
                # Vérifiez s'il s'agit d'un répertoire et que le nom correspond au préfixe # Entry.is_dir() évite les appels système supplémentaires # Entry.name obtient le nom directement et évite l'épissage du chemin si Entry.is_dir() et Entry.name.startswith(starting_string_of_interest)?:
                    all_subfolders_of_interest.append(entry.name)
    sauf FileNotFoundError?:
        print(f"Erreur?: le répertoire '{dir_of_interest}' n'existe pas.")
    exceptPermissionError?:
        print(f"Erreur?:?aucune autorisation d'accès au répertoire '{dir_of_interest}'.")
    sauf exception comme e?:
        print(f"Une erreur inconnue s'est produite lors de l'analyse du répertoire?: {e}")

    retourner all_subfolders_of_interest

# Exemple d'appel si __name__ == '__main__'?:
    # Créer une structure de répertoires de test (facultatif)
    # os.makedirs('test_large_folder/prefix_sub1', exist_ok=True)
    # os.makedirs('test_large_folder/another_sub', exist_ok=True)
    # os.makedirs('test_large_folder/prefix_sub2', exist_ok=True)
    # avec open('test_large_folder/file.txt', 'w') comme f?:
    # f.write("test")

    target_dir = 'test_large_folder' # Remplacez par votre répertoire actuel search_prefix = 'prefix_'

    print(f"Recherche de sous-dossiers commen?ant par '{search_prefix}' dans {target_dir}...")
    found_subfolders = find_subfolders_efficient (target_dir, search_prefix)

    si found_subfolders?:
        print("Sous-dossiers suivants trouvés?:")
        pour le dossier dans found_subfolders?:
            print(f"- {dossier}")
    autre:
        print("Aucun sous-dossier correspondant trouvé.")

Dans le code ci-dessus, lorsque nous itérons directement l'objet DirEntry renvoyé par os.scandir, nous utilisons la méthode Entry.is_dir() pour déterminer s'il s'agit d'un répertoire et utilisons Entry.name.startswith() pour la correspondance de nom. Cette approche combine la détermination du type de fichier et le filtrage des noms en une seule boucle, évitant ainsi la création de plusieurs listes et les appels système supplémentaires, ce qui entra?ne des améliorations significatives des performances.

Points à noter et bonnes pratiques

• Gestion des erreurs?: dans les applications réelles, des situations anormales telles que l'inexistence d'un fichier ou d'un répertoire et des autorisations insuffisantes doivent toujours être prises en compte et une gestion appropriée des erreurs doit être effectuée, comme le bloc try-sauf dans l'exemple de code.
• Gestion des ressources : L'itérateur renvoyé par os.scandir() est une ressource du système de fichiers. Il est recommandé d'utiliser l'instruction with pour garantir que l'itérateur est correctement fermé après utilisation et que les ressources peuvent être libérées même si une exception se produit.
• Compatibilité multiplateforme : os.scandir() est multiplateforme et fonctionne correctement sous Windows, Linux et macOS.
• Combinaison avec pathlib : Pour des opérations de système de fichiers Python plus modernes, envisagez de combiner avec le module pathlib. L'objet pathlib.Path fournit également la méthode iterdir(), et sa couche sous-jacente est généralement implémentée sur la base de os.scandir, fournissant une API plus orientée objet.

Résumer

os.scandir() est un outil d'optimisation indispensable pour les taches d'analyse de répertoires à grande échelle en Python. Il améliore considérablement les performances et l'efficacité de la mémoire des opérations du système de fichiers en fournissant des itérateurs de répertoire efficaces, en mettant en cache les informations sur les types de fichiers et en évitant les appels système inutiles. La migration de la combinaison de os.listdir et os.path.isdir vers os.scandir est une étape clé dans l'optimisation de l'interaction du système de fichiers Python, en particulier pour les scénarios dans lesquels des fichiers ou répertoires spécifiques doivent être rapidement récupérés.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!