Le module shutil fournit la fonction shutil.rmtree() permettant de supprimer récursivement un dossier, c'est-à-dire de supprimer le dossier avec tous les fichiers et sous-dossiers qu'il contient. Cette fonction est particulièrement utile pour nettoyer automatiquement des dossiers temporaires, supprimer des sauvegardes ou réinitialiser une arborescence.
1. À propos de shutil.rmtree()
La fonction shutil.rmtree() appartient au module shutil de la bibliothèque standard de Python. Elle permet de supprimer une arborescence complète, c'est-à-dire un dossier, ses fichiers et tous ses sous-dossiers.
Le module shutil étant inclus avec Python, aucune installation avec pip n'est nécessaire. Il suffit de l'importer avant d'utiliser rmtree().
1 2 | import shutil print("Module shutil chargé") |
Sortie :
1 | Module shutil chargé |
Syntaxe de shutil.rmtree()
Dans sa forme la plus simple, rmtree() reçoit le chemin du dossier à supprimer. Cette opération supprime récursivement tout le contenu de l'arborescence.
1 | shutil.rmtree("mon_dossier") |
Sortie :
1 | Aucune sortie si la suppression réussit. |
Contrairement à certaines fonctions Python, shutil.rmtree() ne retourne pas de message confirmant la suppression. Nous pouvons donc ajouter nous-mêmes un print() si nous souhaitons informer l'utilisateur.
2. Supprimer un dossier et son contenu
L'intérêt principal de shutil.rmtree() est de pouvoir supprimer un dossier même lorsqu'il contient des fichiers et des sous-dossiers. Il n'est pas nécessaire de supprimer chaque élément manuellement.
Supprimer un dossier simple
Supposons qu'un dossier nommé temp contienne plusieurs fichiers. Le programme suivant supprime entièrement ce dossier.
1 2 3 | import shutil shutil.rmtree("temp") print("Dossier supprimé") |
Sortie :
1 | Dossier supprimé |
Le dossier temp ainsi que tous les éléments qu'il contenait sont supprimés.
Supprimer une arborescence complète
Si un dossier contient plusieurs niveaux de sous-dossiers, rmtree() les parcourt automatiquement. La suppression est donc récursive.
Supposons par exemple que nous disposions de l'arborescence projet/cache/images. Nous pouvons supprimer l'ensemble du dossier projet en une seule instruction.
1 2 3 | import shutil shutil.rmtree("projet") print("Arborescence projet supprimée") |
Sortie :
1 | Arborescence projet supprimée |
Les dossiers projet, cache et images, ainsi que les fichiers qu'ils contiennent, sont supprimés.
Créer puis supprimer un dossier de test
Pour expérimenter sans risquer de supprimer un dossier important, nous pouvons créer une petite arborescence de test puis la supprimer avec rmtree().
1 2 3 4 5 6 | import os import shutil os.makedirs("test/dossier1/dossier2", exist_ok=True) print("Dossier créé") shutil.rmtree("test") print("Dossier supprimé") |
Sortie :
1 2 | Dossier créé Dossier supprimé |
Cette méthode permet de comprendre le fonctionnement de rmtree() sans manipuler des données importantes.
3. Vérifier l'existence du dossier avant sa suppression
Si le dossier indiqué à shutil.rmtree() n'existe pas, Python peut déclencher une exception FileNotFoundError. Il est donc souvent préférable de vérifier son existence avant de tenter la suppression.
Utiliser os.path.exists()
La fonction os.path.exists() permet de vérifier si un chemin existe. Nous pouvons l'utiliser avant d'appeler rmtree().
1 2 3 4 5 6 7 8 | import os import shutil dossier = "temp" if os.path.exists(dossier): shutil.rmtree(dossier) print("Dossier supprimé") else: print("Le dossier n'existe pas") |
Sortie possible :
1 | Le dossier n'existe pas |
Cette vérification évite de demander à Python de supprimer un chemin inexistant.
Vérifier qu'il s'agit réellement d'un dossier
La fonction os.path.isdir() est encore plus précise lorsque nous voulons vérifier que le chemin correspond réellement à un dossier.
1 2 3 4 5 6 7 8 | import os import shutil dossier = "cache" if os.path.isdir(dossier): shutil.rmtree(dossier) print("Dossier supprimé") else: print("Ce dossier n'existe pas") |
Sortie possible :
1 | Dossier supprimé |
os.path.isdir() est particulièrement utile car rmtree() est destinée à supprimer des arborescences de dossiers et non un simple fichier ordinaire.
4. Gérer les erreurs avec rmtree()
Une suppression peut échouer pour différentes raisons : le dossier n'existe pas, certains fichiers sont protégés ou l'utilisateur ne possède pas les permissions nécessaires. Les blocs try et except permettent de traiter ces situations proprement.
Gérer FileNotFoundError
Si le dossier demandé n'existe pas, nous pouvons intercepter l'exception FileNotFoundError et afficher un message adapté.
1 2 3 4 5 6 | import shutil try: shutil.rmtree("temp") print("Dossier supprimé") except FileNotFoundError: print("Le dossier est introuvable") |
Sortie possible :
1 | Le dossier est introuvable |
Le programme continue ainsi normalement au lieu de s'interrompre brutalement.
Gérer PermissionError
Si Python ne dispose pas des droits nécessaires pour supprimer un fichier ou un dossier, une exception PermissionError peut être déclenchée.
1 2 3 4 5 6 | import shutil try: shutil.rmtree("dossier_protege") print("Dossier supprimé") except PermissionError: print("Permission refusée") |
Sortie possible :
1 | Permission refusée |
Dans cette situation, il faut vérifier les droits d'accès au dossier et aux fichiers qu'il contient.
Gérer plusieurs erreurs
Dans un programme réel, il est souvent préférable de prévoir plusieurs types d'exceptions afin de distinguer les différentes causes possibles d'échec.
1 2 3 4 5 6 7 8 9 10 | import shutil try: shutil.rmtree("temp") print("Suppression réussie") except FileNotFoundError: print("Dossier introuvable") except PermissionError: print("Permission refusée") except OSError as erreur: print("Erreur système :", erreur) |
Sortie possible :
1 | Suppression réussie |
L'exception OSError permet de traiter d'autres erreurs liées au système de fichiers qui ne correspondent pas aux deux cas précédents.
5. Options et gestion des erreurs de suppression
shutil.rmtree() possède plusieurs paramètres permettant d'adapter son comportement. Parmi eux, ignore_errors permet d'ignorer les erreurs rencontrées pendant la suppression.
Utiliser ignore_errors=True
Lorsque ignore_errors=True est utilisé, les erreurs rencontrées pendant l'opération sont ignorées. Le programme ne s'arrête donc pas à cause de ces erreurs.
1 2 3 | import shutil shutil.rmtree("temp", ignore_errors=True) print("Opération terminée") |
Sortie :
1 | Opération terminée |
Cette option doit être utilisée avec prudence, car elle peut masquer la raison pour laquelle certains éléments n'ont pas été supprimés.
Utiliser onexc dans les versions récentes de Python
Dans les versions récentes de Python, le paramètre onexc permet de fournir une fonction appelée lorsqu'une erreur se produit pendant la suppression. Il permet ainsi de personnaliser la gestion des exceptions sans ignorer silencieusement les problèmes.
L'exemple suivant définit une fonction qui affiche le chemin ayant provoqué l'erreur ainsi que l'exception rencontrée.
1 2 3 4 5 6 | import shutil def erreur_suppression(fonction, chemin, exception): print("Impossible de supprimer :", chemin) print("Erreur :", exception) shutil.rmtree("temp", onexc=erreur_suppression) print("Opération terminée") |
Sortie possible :
1 2 3 | Impossible de supprimer : temp/fichier.txt Erreur : Permission denied Opération terminée |
La sortie exacte dépend naturellement de l'erreur rencontrée. onexc est utile lorsque nous voulons enregistrer, afficher ou traiter précisément les erreurs de suppression.
Attention à ignore_errors
Le paramètre ignore_errors=True ne signifie pas que la suppression réussira nécessairement. Il signifie simplement que les erreurs seront ignorées. Il est donc préférable d'utiliser une gestion explicite des exceptions lorsque la réussite de la suppression est importante.
6. Différences entre rmtree(), os.remove() et os.rmdir()
Python propose plusieurs fonctions de suppression. Il est important de distinguer shutil.rmtree(), os.remove() et os.rmdir(), car elles ne servent pas au même usage.
Supprimer un fichier avec os.remove()
La fonction os.remove() sert à supprimer un fichier. Elle n'est pas destinée à supprimer une arborescence de dossiers.
1 2 3 | import os os.remove("document.txt") print("Fichier supprimé") |
Sortie :
1 | Fichier supprimé |
Pour supprimer un simple fichier, os.remove() est donc plus appropriée que shutil.rmtree().
Supprimer un dossier vide avec os.rmdir()
La fonction os.rmdir() permet de supprimer un dossier vide. Elle échoue si le dossier contient encore des fichiers ou des sous-dossiers.
1 2 3 | import os os.rmdir("dossier_vide") print("Dossier vide supprimé") |
Sortie :
1 | Dossier vide supprimé |
os.rmdir() constitue donc une bonne solution lorsque nous voulons supprimer uniquement un dossier dont nous savons qu'il est vide.
Supprimer un dossier non vide avec shutil.rmtree()
Lorsque le dossier contient des fichiers ou des sous-dossiers, nous pouvons utiliser shutil.rmtree() pour supprimer toute l'arborescence.
1 2 3 | import shutil shutil.rmtree("dossier_non_vide") print("Dossier et contenu supprimés") |
Sortie :
1 | Dossier et contenu supprimés |
En résumé, os.remove() supprime un fichier, os.rmdir() supprime un dossier vide et shutil.rmtree() supprime récursivement un dossier avec son contenu.
7. Exemples & Remarques
Supprimer un dossier de cache
Une utilisation courante de rmtree() consiste à supprimer automatiquement un dossier de cache. Le programme suivant vérifie d'abord que le dossier existe avant de le supprimer.
1 2 3 4 5 6 7 8 | import os import shutil cache = "__pycache__" if os.path.isdir(cache): shutil.rmtree(cache) print("Cache supprimé") else: print("Aucun cache à supprimer") |
Sortie possible :
1 | Cache supprimé |
Cette technique peut être utilisée dans un script de nettoyage d'un projet Python.
Supprimer plusieurs dossiers temporaires
Nous pouvons utiliser shutil.rmtree() dans une boucle afin de supprimer plusieurs dossiers temporaires. Une vérification avec os.path.isdir() évite de tenter de supprimer les dossiers absents.
1 2 3 4 5 6 7 | import os import shutil dossiers = ["temp", "cache", "backup_temp"] for dossier in dossiers: if os.path.isdir(dossier): shutil.rmtree(dossier) print(dossier, "supprimé") |
Sortie possible :
1 2 3 | temp supprimé cache supprimé backup_temp supprimé |
Cette méthode permet de créer facilement un script de nettoyage automatique.
Demander une confirmation avant la suppression
Comme rmtree() peut supprimer une grande quantité de données, il peut être judicieux de demander une confirmation à l'utilisateur avant d'effectuer une suppression importante.
1 2 3 4 5 6 7 8 | import shutil dossier = "ancien_projet" reponse = input("Supprimer définitivement " + dossier + " ? (oui/non) : ") if reponse.lower() == "oui": shutil.rmtree(dossier) print("Dossier supprimé") else: print("Suppression annulée") |
Sortie possible :
1 2 | Supprimer définitivement ancien_projet ? (oui/non) : oui Dossier supprimé |
Cette précaution réduit le risque de supprimer accidentellement un dossier important.
Précautions importantes
shutil.rmtree() est une fonction destructive. Elle doit être utilisée avec prudence, car les éléments supprimés ne sont généralement pas envoyés dans la corbeille du système.
Avant une suppression, vérifiez toujours le chemin du dossier. Une erreur dans une variable contenant le chemin peut entraîner la suppression d'une arborescence différente de celle prévue.
Pour les scripts importants, il est conseillé de vérifier le chemin avec os.path.abspath() ou pathlib.Path.resolve(), de contrôler l'existence du dossier et éventuellement de demander une confirmation avant la suppression.
Conclusion
La fonction shutil.rmtree() constitue une solution simple pour supprimer récursivement un dossier en Python. Contrairement à os.rmdir(), elle peut supprimer un dossier contenant des fichiers et plusieurs niveaux de sous-dossiers.
Elle est particulièrement utile pour supprimer des dossiers temporaires, des caches, d'anciennes sauvegardes ou des arborescences générées automatiquement. En raison de son caractère destructif, il est cependant essentiel de vérifier soigneusement le chemin avant chaque suppression et de prévoir une gestion des erreurs adaptée.
Auteur : Younes Derfoufi Lieu de travail : CRMEF OUJDA Site Web : www.tresfacile.net Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile Me contacter : https://www.tresfacile.net/me-contacter/
