• Assurez la sécurité des applications de la bonne manière! Détectez, protégez, surveillez, accélérez et plus encore…
  • La bibliothèque standard Python contient la plupart des fonctionnalités dont un développeur aurait besoin pour résoudre un problème. Dans ce didacticiel, vous apprendrez différentes manières de vérifier l'existence d'un fichier ou d'un répertoire en utilisant uniquement des modules intégrés.

    Vérifier si un fichier ou scénario est au bon endroit est crucial pour tout programme CLI. Votre programme pourrait devenir inutile si un fichier spécifique n'est pas en place au moment de l'exécution.

    Dans le didacticiel d'aujourd'hui, vous apprendrez quelques moyens rapides de vérifier si un fichier ou un dossier existe en Python.

    Avant de commencer

    Avant d'exécuter toute commande ci-dessous, assurez-vous que Python 3 est installé sur votre système. Ouvrez votre terminal et tapez la commande suivante :

    python --version
    # Python 3.9.5, my result

    Si vous avez une version 2.x, vous devrez utiliser la commande "python3". Consultez notre Guide d'installation Python si vous n'avez pas installé Python 3.

    Nous utiliserons des fichiers de test avec ce didacticiel, alors assurez-vous de créer les fichiers suivants :

    touch testfile.txt
    mkdir testdirectory/ 
    touch testdirectory/otherfile.txt

    Les commandes ci-dessus créent un fichier avec lequel jouer, un répertoire de test et un autre fichier dans le répertoire de test. Les fichiers peuvent être vides car nous n'aurons pas besoin de lire leur contenu,

    A Noter: Si vous utilisez Windows, configurez cette structure de fichiers simple avec un gestionnaire de fichiers graphique.

    Enfin, nous utiliserons Ipython comme notre shell Python interactif qui donne une jolie interface avec laquelle travailler. Ce n'est qu'une marchandise, donc pas strictement nécessaire.

    pip install ipython

    Après cela, vous aurez accès à un magnifique shell Python simplement en tapant python.

    Shell interactif Ipython exécutant Python 3.9

    Maintenant que vous êtes prêt, découvrons des moyens de vérifier si un dossier ou un fichier existe en Python.

    Try, Open, and Except

    C'est l'option la plus simple. Si vous essayez d'ouvrir un fichier qui n'existe pas, Python lèvera un FileNotFoundError.

    In [1]: open('im-not-here.txt')
    ---------------------------------------------------------------------------
    FileNotFoundError: [Errno 2] No such file or directory: 'im-not-here.txt'
    

    Nous pouvons en profiter et gérer l'exception au cas où le fichier que nous recherchons n'existe pas.

    In [2]: try:
       ...:     file = open('im-not-here.txt')
       ...:     print(file) # File handler
       ...:     file.close()
       ...: except FileNotFoundError:
       ...:     print('Sorry the file we\'re looking for doesn\' exist')
       ...:     exit()
       ...: 
    Sorry the file we're looking for doesn't exist
    

    Dans le code ci-dessus, nous imprimons un message personnalisé et arrêtons l'exécution du programme si le fichier n'existe pas.

    Notez comment le sortie() La fonction ne s'exécutera que si une exception est levée. Voyons ce qui se passe lorsque le fichier que nous recherchons existe réellement.

    In [2]: try:
       ...:     file = open('testfile.txt')
       ...:     print(file) # File handler
       ...:     file.close()
       ...: except FileNotFoundError:
       ...:     print('Sorry the file we\'re looking for doesn\'t exist')
       ...:     exit()
       ...: 
    <_io.TextIOWrapper name='testfile.txt' mode='r' encoding='UTF-8'>

    Notez comment nous fermons le fichier juste après l'avoir ouvert. Elle est considérée comme une bonne pratique selon le Documentation Python.

    appel <span class="pre">file.write()</span> sans utiliser le <span class="pre">with</span> mot-clé ou appel <span class="pre">file.close()</span> pourrait aboutir aux arguments de <span class="pre">file.write()</span> n'étant pas complètement écrit sur le disque, même si le programme se termine avec succès.

    Même si nous n'écrivons pas dans le fichier, il est extrêmement recommandé de fermer le fichier car cela pourrait conduire à plusieurs problèmes de performances.

    Si nous ne voulons pas fermer le fichier par nous-mêmes, nous pouvons utiliser le avec gestionnaire de contexte. Il alloue et libère les ressources avec précision, nous n'aurons donc pas besoin de fermer le fichier.

    In [3]: try:
       ...:     with open('testfile.txt') as file:
       ...:         print(file)
       ...:         # No need to close the file
       ...: except FileNotFoundError:
       ...:     print('Sorry the file we\'re looking for doesn\'t exist')
       ...:     exit()
       ...: 
       ...: 
    <_io.TextIOWrapper name='testfile.txt' mode='r' encoding='UTF-8'>
    

    Cette méthode est extrêmement utile lors de l'écriture dans des fichiers, mais s'avère inefficace si nous voulons seulement vérifier si un fichier existe. Plongeons-nous dans d'autres options pour y parvenir.

    os.path.exists()

    Le module système d'exploitation fournit de multiples fonctions pour interagir avec le système d'exploitation. Pour vérifier si un fichier ou un dossier existe, nous pouvons utiliser le chemin.existe() fonction qui accepte le chemin du fichier ou du répertoire comme argument. Il renvoie un booléen basé sur l'existence du chemin.

    A Noter: Un chemin est l'emplacement unique d'un fichier ou d'un répertoire dans un système de fichiers

    En Python, le chemin.os Le sous-module contient des fonctions exclusivement conçues pour fonctionner avec des chemins de fichiers. Toutes ces fonctions acceptent l'argument path sous forme de chaînes ou d'octets, et vous pouvez décider de travailler avec des chemins absolus, par exemple :

    /home/daniel/.bashrc

    Ou avec des chemins relatifs, selon le répertoire dans lequel vous exécutez le script :

    .bashrc
    # Running the script in my home folder

    Voici plusieurs exemples utilisant le os.path.exists() fonction, s'exécutant dans le répertoire où se trouvent mes fichiers de test :

    In [1]: import os
    
    In [2]: os.path.exists('testfile.txt')
    Out[2]: True
    
    In [3]: os.path.exists('testdirectory')
    Out[3]: True
    
    In [4]: os.path.exists('hey-i-dont-exist')
    Out[4]: False

    Comme vous pouvez le voir, il revient Vrai lors des tests avec le fichiertest.txt fichier et le répertoire de test dossier, et Faux quand le fichier n'existe pas.

    os.path.isfile()

    Si vous vouliez seulement prouver l'existence d'un fichier (pas d'un répertoire), vous appelleriez le os.path.isfile() la fonction.

    In [1]: import os
    
    In [2]: os.path.isfile('testfile.txt')
    Out[2]: True
    
    In [3]: os.path.isfile('testdirectory/')
    Out[3]: False
    
    In [4]: os.path.isfile('i-dont-even-exist')
    Out[4]: False
    
    In [5]: os.path.isfile('testdirectory/otherfile.txt')
    Out[5]: True
    

    A Noter: Sous UNIX, tous les répertoires se terminent par une barre oblique (/), alors que sous Windows, nous utilisons une barre oblique inverse (\).

    Dans le code au dessus du isfile() retour de fonction Faux à deux reprises, voyons pourquoi :

    • testdirectory/ est un répertoire, il n'est donc pas considéré comme un fichier. Ce n'est pas absolument vrai puisque sous Linux tout est un descripteur de fichier, mais Python traite les répertoires différemment juste pour plus de commodité (si vous essayez d'ouvrir un répertoire, vous obtiendrez un EstUneErreurRépertoire)
    • i-dont-even-exist pointe vers un fichier qui, ironiquement, n'existe pas

    os.path.isdir()

    Si vous voulez vérifier qu'un répertoire est au bon endroit, vous devrez utiliser le os.path.isdir() fonction, qui ne renvoie que Vrai si le chemin donné pointe vers un répertoire.

    In [1]: import os
    
    In [2]: os.path.isdir('testfile.txt')
    Out[2]: False
    
    In [3]: os.path.isdir('testdirectory')
    Out[3]: True
    
    In [4]: os.path.isdir('anotherfile.txt')
    Out[4]: False
    

    Notez comment les exemples ci-dessus renvoient Faux même lorsque le chemin pointe vers un fichier qui existe.

    Glob

    Le glob module fournit des fonctions pour travailler avec Motifs de type shell Unix (par conséquent, cela ne fonctionne pas correctement sous Windows). Pour vérifier si un fichier correspond à un modèle dans le répertoire courant, vous pouvez utiliser le glob.glob() la fonction.

    In [1]: import glob
    
    In [2]: glob.glob('testfile.txt')
    Out[2]: ['testfile.txt']
    
    In [3]: glob.glob('testdirectory')
    Out[3]: ['testdirectory']
    

    Dans le code ci-dessus, le modèle transmis à la fonction glob est une chaîne normale qui représente le chemin d'accès au fichier et au répertoire de test. Étant donné que les deux chemins existent, la fonction renvoie une liste avec les noms de chemin correspondants à l'intérieur.

    A Noter: Si le modèle ne correspond pas, vous obtiendrez une liste vide.

    Étant donné que nous pouvons transmettre des modèles à la fonction glob, pourquoi ne pas en tester certains des principaux avantages ?

    Le code ci-dessous obtient tous les chemins de fichiers avec une extension .SMS reçues par les enchanteurs et permettent aussi py respectivement:

    In [4]: glob.glob('*.txt')
    Out[4]: ['testfile.txt']
    
    In [5]: glob.glob('*.py')
    Out[5]: 
    ['pathlib-exists.py',
     'list-dir.py',
     'glob-file.py',
     'open-except.py',
     'subprocess-test.py',
     'isfile.py',
     'exists.py',
     'isdir.py']

    Using the Path Class

    Le Classe de chemin est l'un des meilleurs moyens de travailler avec les chemins car il nous donne une interface propre pour travailler avec les chemins de fichiers en tant qu'objets.

    La cerise sur le gâteau est que les instances Path disposent de toutes les méthodes dont vous avez besoin pour obtenir des informations sur un certain chemin. Cela inclut des fonctionnalités similaires aux options précédentes.

    A Noter: Vous aurez besoin de Python 3.4 ou supérieur pour utiliser la bibliothèque pathlib

    Les méthodes Path que vous utiliserez :

    Vérifier si un chemin existe

    In [1]: from pathlib import Path
    
    In [2]: Path('testfile.txt').exists()
    Out[2]: True
    
    In [3]: Path('im-not-here.txt').exists()
    Out[3]: False
    
    In [4]: Path('testdirectory').exists()
    Out[4]: True
    

    Fonctionne de la même manière que os.path.exists().

    Vérifier si le chemin pointe vers un fichier

    In [5]: Path('testfile.txt').is_file()
    Out[5]: True
    
    In [6]: Path('testdirectory').is_file()
    Out[6]: False
    

    Équivalent à os.path.isfile().

    Vérifiez si le chemin pointe vers un répertoire

    In [7]: Path('testfile.txt').is_dir()
    Out[7]: False
    
    In [8]: Path('testdirectory').is_dir()
    Out[8]: True
    

    Correspond à os.path.isdir().

    subprocess

    Si vous êtes un module de sous-processus amoureux, vous aurez besoin de connaître cette option. Vous pouvez déterminer si un fichier ou un dossier existe en utilisant le commande d'essai.

    A Noter: Le tester La commande ne fonctionne que sous Unix.

    Les indicateurs de test suivants feront le travail :

    • teste -e : Vérifier si un chemin existe
    • test -f : Vérifier si un fichier existe
    • test-d : Vérifier si un dossier existe

    Si vous souhaitez vous plonger dans d'autres indicateurs de test, vous pouvez lire le manuel en exécutant :

    man test

    Vérification d'un chemin avec un sous-processus :

    Le code ci-dessous détermine si un chemin existe en comparant le code de retour du sous-processus à 0.

    Souvenez-vous que sous Linux, si un processus s'est bien passé, il renverra zéro, sinon il renverra n'importe quel autre code.

    In [1]: from subprocess import run
    
    In [2]: run(['test', '-e', 'testfile.txt']).returncode == 0
    Out[2]: True
    
    In [3]: run(['test', '-e', 'im-not-here.txt']).returncode == 0
    Out[3]: False
    

    Dans la première instruction, nous importons le module de sous-processus, puis utilisons le fonction d'exécution et obtenir son code de retour.

    Vérification de l'existence d'un fichier avec sous-processus

    In [4]: run(['test', '-f', 'testfile.txt']).returncode == 0
    Out[4]: True
    
    In [5]: run(['test', '-f', 'testdirectory']).returncode == 0
    Out[5]: False
    

    Vérification d'un répertoire avec un sous-processus :

    In [6]: run(['test', '-d', 'testfile.txt']).returncode == 0
    Out[6]: False
    
    In [7]: run(['test', '-d', 'testdirectory']).returncode == 0
    Out[7]: True
    

    Il n'est pas recommandé d'utiliser cette option car elle consomme plus de ressources et nous n'en tirons aucun avantage.

    Pour résumer

    Python est l'un des plus utilisés langages de programmation pour automatiser les processus en interagissant avec le système d'exploitation. Une chose intéressante que vous pouvez faire avec est de vérifier si un fichier ou un dossier existe.

    Les plus simples à faire sont :

    • Ouverture et gestion immédiate des exceptions de fichiers
    • En utilisant l' existe() fonction de la chemin.os or pathlib modules.

    Dans ce tutoriel, vous avez appris :

    • Comment ouvrir un fichier et gérer les exceptions au cas où il n'existerait pas
    • Le sens des chemins
    • 3 fonctions différentes le chemin.os le sous-module permet de vérifier l'existence d'un fichier ou d'un dossier
    • Unix utilise des barres obliques (/), tandis que Windows utilise des barres obliques inverses (\)

    Prochaine lecture: Qu'est-ce qu'un sous-processus en Python? [5 exemples d'utilisation]