7 façons de vérifier si un fichier ou un dossier existe en Python
Diverses méthodes pour vérifier l'existence de fichiers et répertoires en Python
La richesse de la bibliothèque standard de Python offre aux développeurs un large éventail d'outils pour résoudre une multitude de problèmes. Ce tutoriel explore différentes approches pour déterminer si un fichier ou un répertoire est présent, en utilisant uniquement les modules intégrés à Python.
Dans le développement d'applications CLI (Interface Ligne de Commande), il est essentiel de s'assurer que les fichiers et répertoires nécessaires sont bien en place. L'absence d'un fichier spécifique peut rendre un programme inutilisable.
Nous allons examiner plusieurs façons rapides de vérifier si un fichier ou un dossier existe en Python.
Prérequis
Avant de commencer, assurez-vous que Python 3 est correctement installé sur votre machine. Vous pouvez vérifier cela en ouvrant votre terminal et en saisissant la commande suivante :
python --version # Python 3.9.5 (exemple de résultat)
Si vous utilisez une version 2.x, vous devrez probablement utiliser la commande « python3 ». Pour une installation de Python 3, veuillez vous référer à un guide d'installation approprié.
Dans ce tutoriel, nous allons utiliser des fichiers de test. Veillez donc à créer la structure suivante :
touch testfile.txt mkdir testdirectory/ touch testdirectory/otherfile.txt
Ces commandes créeront un fichier nommé "testfile.txt", un répertoire "testdirectory", et un fichier "otherfile.txt" dans le répertoire "testdirectory". Ces fichiers peuvent être vides, car nous n'aurons pas besoin de lire leur contenu.
Note pour les utilisateurs Windows: Vous pouvez créer cette structure de fichiers simple en utilisant un explorateur de fichiers graphique.
Nous utiliserons Ipython comme shell Python interactif, offrant une interface plus agréable. Bien que ce ne soit pas indispensable, cela facilitera les manipulations.
pip install ipython
Une fois installé, lancez un shell Python amélioré en saisissant "ipython" dans votre terminal.
Maintenant que vous êtes prêt, explorons les différentes façons de vérifier l'existence d'un fichier ou d'un répertoire en Python.
Gestion des exceptions avec try et except
L'approche la plus basique consiste à utiliser un bloc `try...except`. Si l'on tente d'ouvrir un fichier inexistant, Python lèvera une exception FileNotFoundError.
In [1]: open('im-not-here.txt')
---------------------------------------------------------------------------
FileNotFoundError: [Errno 2] No such file or directory: 'im-not-here.txt'
Nous pouvons exploiter cette situation en gérant l'exception si le fichier recherché n'est pas trouvé :
In [2]: try:
...: file = open('im-not-here.txt')
...: print(file) # Affichage du gestionnaire de fichier
...: file.close()
...: except FileNotFoundError:
...: print('Le fichier recherché n\'existe pas.')
...: exit()
...:
Le fichier recherché n'existe pas.
Dans l'exemple ci-dessus, un message personnalisé s'affiche et le programme se termine si le fichier est introuvable.
La fonction `exit()` ne sera exécutée que si une exception se produit. Voici ce qui se passe si le fichier existe :
In [2]: try:
...: file = open('testfile.txt')
...: print(file) # Affichage du gestionnaire de fichier
...: file.close()
...: except FileNotFoundError:
...: print('Le fichier recherché n\'existe pas.')
...: exit()
...:
<_io.TextIOWrapper name="testfile.txt" mode="r" encoding='UTF-8'>
Il est essentiel de fermer le fichier après l'avoir ouvert, comme le souligne la documentation Python.
Omettre l'appel de `file.close()` ou utiliser `file.write()` sans le mot-clé `with` pourrait entraîner une écriture incomplète sur le disque, même si le programme semble s'être exécuté avec succès.
Bien que nous ne modifions pas le fichier, il est recommandé de le fermer pour éviter des problèmes de performances.
Pour automatiser la fermeture des fichiers, on peut utiliser un gestionnaire de contexte `with`. Cela garantit la gestion précise des ressources sans avoir à appeler `file.close()`.
In [3]: try:
...: with open('testfile.txt') as file:
...: print(file)
...: # Pas besoin de fermer le fichier
...: except FileNotFoundError:
...: print('Le fichier recherché n\'existe pas.')
...: exit()
...:
<_io.TextIOWrapper name="testfile.txt" mode="r" encoding='UTF-8'>
Cette méthode est très utile lors de la modification de fichiers, mais peut être excessive pour une simple vérification de leur existence. Explorons d'autres options.
Utilisation de os.path.exists()
Le module os offre plusieurs outils pour interagir avec le système d'exploitation. La fonction `os.path.exists()`, qui prend le chemin d'accès au fichier ou au répertoire comme argument, permet de vérifier l'existence d'un fichier ou d'un dossier et renvoie une valeur booléenne (Vrai ou Faux).
Un chemin est l'emplacement unique d'un fichier ou d'un répertoire au sein d'un système de fichiers.
Le sous-module os.path contient des fonctions spécifiquement conçues pour manipuler les chemins de fichiers. Ces fonctions acceptent des chemins sous forme de chaînes de caractères ou d'octets, et vous pouvez utiliser des chemins absolus, comme ceci :
/home/daniel/.bashrc
Ou des chemins relatifs, en fonction du répertoire dans lequel vous exécutez votre script :
.bashrc # Script exécuté depuis mon répertoire personnel
Voici quelques exemples de l'utilisation de `os.path.exists()` :
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 constater, cette fonction retourne `True` si le fichier ou le répertoire existe, et `False` dans le cas contraire.
Utilisation de os.path.isfile()
Pour vérifier spécifiquement l'existence d'un fichier (et non d'un répertoire), vous pouvez utiliser la fonction `os.path.isfile()`.
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
Sous Unix, les répertoires se terminent généralement par une barre oblique (/), alors que sous Windows, on utilise une barre oblique inversée (\).
Dans l'exemple ci-dessus, `isfile()` retourne `False` dans deux cas. Voici les raisons :
- `testdirectory/` est un répertoire, et non un fichier. Bien que sous Linux, tout soit considéré comme un fichier, Python traite les répertoires différemment pour des raisons de commodité. (Tenter d'ouvrir un répertoire provoquera une `IsADirectoryError`).
- `i-dont-even-exist` fait référence à un fichier qui n'existe pas.
Utilisation de os.path.isdir()
Pour s'assurer qu'un répertoire est présent, il faut utiliser `os.path.isdir()`, qui retourne `True` uniquement si le chemin indiqué 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
Il est important de noter que `isdir()` retourne `False` même si le chemin pointe vers un fichier existant.
Utilisation du module glob
Le module glob fournit des outils pour utiliser les motifs de type shell Unix (cela peut ne pas fonctionner correctement sous Windows). Pour vérifier qu'un fichier correspond à un motif donné dans le répertoire courant, vous pouvez utiliser la fonction `glob.glob()`.
In [1]: import glob
In [2]: glob.glob('testfile.txt')
Out[2]: ['testfile.txt']
In [3]: glob.glob('testdirectory')
Out[3]: ['testdirectory']
Dans l'exemple ci-dessus, le motif passé à `glob` est une simple chaîne de caractères représentant le chemin du fichier ou du répertoire. Puisque les deux chemins existent, la fonction renvoie une liste contenant les noms des chemins correspondants.
Si le motif ne correspond à rien, la fonction retourne une liste vide.
On peut transmettre des motifs plus complexes à la fonction glob, voici quelques exemples :
Le code suivant obtient tous les chemins de fichiers ayant l'extension .txt ou .py :
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']
Utilisation de la classe Path
La classe Path est une manière élégante de travailler avec des chemins, car elle permet de les manipuler comme des objets.
Les instances de la classe Path fournissent des méthodes permettant d'obtenir des informations sur les chemins, avec des fonctionnalités similaires aux options présentées précédemment.
Note : La bibliothèque pathlib est disponible à partir de Python 3.4.
Voici les méthodes Path que nous allons utiliser :
Vérifier l'existence d'un chemin
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
Cette fonction est équivalente à `os.path.exists()`.
Vérifier qu'un chemin pointe vers un fichier
In [5]: Path('testfile.txt').is_file()
Out[5]: True
In [6]: Path('testdirectory').is_file()
Out[6]: False
Cette fonction est équivalente à `os.path.isfile()`.
Vérifier qu'un 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
Cette fonction est équivalente à `os.path.isdir()`.
Utilisation du module subprocess
Si vous êtes à l'aise avec les modules de sous-processus, cette option pourrait vous intéresser. On peut vérifier l'existence d'un fichier ou d'un répertoire en utilisant la commande test.
Note: la commande test fonctionne uniquement sous Unix.
Les drapeaux de test suivants peuvent être utilisés:
- test -e : vérifie l'existence d'un chemin
- test -f : vérifie l'existence d'un fichier
- test -d : vérifie l'existence d'un dossier
Pour plus d'informations sur les drapeaux de test, vous pouvez consulter le manuel en exécutant :
man test
Vérification de l'existence d'un chemin avec subprocess :
Le code suivant détermine si un chemin existe en comparant le code de retour du sous-processus à 0.
Rappel : sous Linux, un processus qui s'est exécuté avec succès retourne la valeur 0, sinon il retourne une autre valeur.
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 l'exemple ci-dessus, nous importons le module subprocess, puis utilisons la fonction run et obtenons son code de retour.
Vérification de l'existence d'un fichier avec subprocess
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 de l'existence d'un répertoire avec subprocess :
In [6]: run(['test', '-d', 'testfile.txt']).returncode == 0 Out[6]: False In [7]: run(['test', '-d', 'testdirectory']).returncode == 0 Out[7]: True
L'utilisation de cette option n'est pas recommandée, car elle consomme plus de ressources sans avantage significatif.
En résumé
Python est un langage de programmation très répandu pour automatiser les tâches en interagissant avec le système d'exploitation. La vérification de l'existence d'un fichier ou d'un dossier est une tâche fréquente.
Les méthodes les plus simples sont :
- L'ouverture immédiate d'un fichier avec gestion des exceptions.
- L'utilisation de la fonction exists() des modules os.path ou pathlib.
Dans ce tutoriel, vous avez appris :
- Comment ouvrir un fichier et gérer les exceptions s'il n'existe pas.
- La signification des chemins.
- 3 fonctions différentes du sous-module os.path pour vérifier l'existence d'un fichier ou d'un dossier.
- Que Unix utilise des barres obliques (/), tandis que Windows utilise des barres obliques inverses (\).
Lecture recommandée : Qu'est-ce qu'un sous-processus en Python ? [5 exemples d'utilisation]