- À propos de Path.mkdir()
- Syntaxe de Path.mkdir()
- Créer un dossier simple
- Créer un dossier dans un emplacement précis
- Créer plusieurs niveaux de dossiers avec parents=True
- Éviter une erreur avec exist_ok=True
- Combiner parents=True et exist_ok=True
- Vérifier l'existence avant de créer un dossier
- Créer plusieurs dossiers
- Créer une arborescence de projet
- Gérer les erreurs lors de la création
- Résumé
1. À propos de Path.mkdir()
Le module pathlib permet de manipuler les fichiers et les dossiers en utilisant une approche orientée objet. La méthode Path.mkdir() permet de créer un nouveau dossier à partir d'un objet Path.
Cette méthode constitue une alternative moderne à os.mkdir() et os.makedirs(). Elle permet notamment de créer un dossier simple, une arborescence complète ou d'éviter une erreur lorsque le dossier existe déjà.
Le programme suivant importe la classe Path du module pathlib afin de pouvoir l'utiliser.
1 2 3 | from pathlib import Path print("Path est disponible.") |
Sortie :
1 | Path est disponible. |
2. Syntaxe de Path.mkdir()
La méthode mkdir() s'applique à un objet Path représentant le dossier que nous souhaitons créer. Sa syntaxe générale est la suivante.
1 | chemin.mkdir(mode=0o777, parents=False, exist_ok=False) |
Sortie :
1 | Aucune valeur n'est affichée lorsque la création réussit. |
Les principaux paramètres de mkdir() sont les suivants :
- mode : indique les permissions demandées pour le nouveau dossier, en tenant compte du système et de son masque de permissions.
- parents : avec la valeur True, crée également les dossiers parents manquants.
- exist_ok : avec la valeur True, évite l'exception normalement provoquée lorsqu'un dossier de même nom existe déjà.
Dans sa forme la plus simple, il suffit de créer un objet Path puis d'appeler sa méthode mkdir().
1 2 3 4 | from pathlib import Path dossier = Path("documents") dossier.mkdir() |
Sortie :
1 | Aucune sortie. Le dossier documents est créé. |
3. Créer un dossier simple
Pour créer un dossier simple, nous définissons son chemin avec Path() puis nous appelons la méthode mkdir(). Le dossier est créé dans le répertoire courant lorsque nous utilisons un chemin relatif simple.
Le programme suivant crée un dossier nommé python.
1 2 3 4 5 6 | from pathlib import Path dossier = Path("python") dossier.mkdir() print("Dossier créé :", dossier) |
Sortie :
1 | Dossier créé : python |
Si nous exécutons une deuxième fois ce programme alors que le dossier python existe déjà, mkdir() provoque normalement une exception FileExistsError.
1 2 3 4 | from pathlib import Path dossier = Path("python") dossier.mkdir() |
Sortie possible si le dossier existe déjà :
1 | FileExistsError: [Errno 17] File exists: 'python' |
4. Créer un dossier dans un emplacement précis
La classe Path permet de construire facilement un chemin avec l'opérateur /. Nous pouvons ainsi créer un dossier à l'intérieur d'un autre dossier existant.
Supposons que le dossier documents existe déjà. Le programme suivant crée le sous-dossier python à l'intérieur de celui-ci.
1 2 3 4 5 6 | from pathlib import Path dossier = Path("documents") / "python" dossier.mkdir() print("Dossier créé :", dossier) |
Sortie :
1 | Dossier créé : documents/python |
Nous pouvons également construire le même chemin en passant plusieurs parties à Path().
1 2 3 4 5 6 | from pathlib import Path dossier = Path("documents", "images") dossier.mkdir() print(dossier) |
Sortie :
1 | documents/images |
5. Créer plusieurs niveaux de dossiers avec parents=True
Par défaut, mkdir() ne crée pas les dossiers parents manquants. Pour créer toute une arborescence en une seule opération, nous utilisons le paramètre parents=True.
Le programme suivant crée les dossiers projet/python/exercices, même si les dossiers projet et python n'existent pas encore.
1 2 3 4 5 6 | from pathlib import Path dossier = Path("projet/python/exercices") dossier.mkdir(parents=True) print("Arborescence créée :", dossier) |
Sortie :
1 | Arborescence créée : projet/python/exercices |
Sans parents=True, la création échoue si un dossier parent nécessaire n'existe pas.
1 2 3 4 | from pathlib import Path dossier = Path("cours/python/debutant") dossier.mkdir() |
Sortie possible si cours/python n'existe pas :
1 | FileNotFoundError: [Errno 2] No such file or directory: 'cours/python/debutant' |
6. Éviter une erreur avec exist_ok=True
Lorsque le dossier à créer existe déjà, mkdir() déclenche normalement une exception FileExistsError. Le paramètre exist_ok=True permet d'éviter cette erreur lorsque le chemin existant correspond à un dossier.
Le programme suivant peut être exécuté plusieurs fois sans provoquer d'erreur si documents est déjà un dossier.
1 2 3 4 5 6 | from pathlib import Path dossier = Path("documents") dossier.mkdir(exist_ok=True) print("Le dossier est disponible.") |
Sortie :
1 | Le dossier est disponible. |
Le paramètre exist_ok=True ne signifie pas que toutes les erreurs sont ignorées. Par exemple, si documents existe mais correspond à un fichier ordinaire, la création ne peut pas être considérée comme réussie.
7. Combiner parents=True et exist_ok=True
Dans de nombreux programmes, les paramètres parents=True et exist_ok=True sont utilisés ensemble. Cette combinaison permet de créer les dossiers parents manquants tout en acceptant les dossiers déjà présents.
Le programme suivant crée une arborescence destinée à stocker des fichiers d'un projet Python.
1 2 3 4 5 6 | from pathlib import Path dossier = Path("projet/python/fichiers") dossier.mkdir(parents=True, exist_ok=True) print("Dossier disponible :", dossier) |
Sortie :
1 | Dossier disponible : projet/python/fichiers |
Le programme peut être exécuté à nouveau : si les dossiers existent déjà, exist_ok=True évite l'exception liée à leur existence.
8. Vérifier l'existence avant de créer un dossier
Une autre possibilité consiste à utiliser la méthode exists() avant d'appeler mkdir(). Cette approche est utile lorsque nous souhaitons exécuter des traitements différents selon que le chemin existe ou non.
Le programme suivant vérifie l'existence du dossier documents avant de le créer.
1 2 3 4 5 6 7 8 9 | from pathlib import Path dossier = Path("documents") if dossier.exists(): print("Le chemin existe déjà.") else: dossier.mkdir() print("Le dossier a été créé.") |
Sortie possible :
1 | Le dossier a été créé. |
Si nous voulons nous assurer que le chemin existant est réellement un dossier, nous pouvons utiliser is_dir().
1 2 3 4 5 6 7 8 9 10 11 | from pathlib import Path dossier = Path("documents") if dossier.is_dir(): print("Le dossier existe déjà.") elif dossier.exists(): print("Le chemin existe mais ce n'est pas un dossier.") else: dossier.mkdir() print("Le dossier a été créé.") |
Sortie possible :
1 | Le dossier existe déjà. |
9. Créer plusieurs dossiers
Pour créer plusieurs dossiers, nous pouvons placer leurs noms dans une liste puis utiliser une boucle for. Chaque nom est transformé en objet Path avant l'appel de mkdir().
Le programme suivant crée trois dossiers : images, documents et videos.
1 2 3 4 5 6 7 | from pathlib import Path dossiers = ["images", "documents", "videos"] for nom in dossiers: Path(nom).mkdir(exist_ok=True) print("Dossier disponible :", nom) |
Sortie :
1 2 3 | Dossier disponible : images Dossier disponible : documents Dossier disponible : videos |
Nous pouvons également créer plusieurs sous-dossiers dans un dossier principal en combinant un objet Path avec l'opérateur /.
1 2 3 4 5 6 7 8 | from pathlib import Path racine = Path("mon_projet") dossiers = ["images", "documents", "sources"] for nom in dossiers: (racine / nom).mkdir(parents=True, exist_ok=True) print("Créé :", racine / nom) |
Sortie :
1 2 3 | Créé : mon_projet/images Créé : mon_projet/documents Créé : mon_projet/sources |
10. Créer une arborescence de projet
La méthode Path.mkdir() est particulièrement pratique pour préparer automatiquement la structure d'un projet. Nous pouvons définir plusieurs chemins puis les créer avec une boucle.
Le programme suivant construit une petite arborescence contenant des dossiers pour les sources, les images, les documents et les tests.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | from pathlib import Path racine = Path("projet_python") dossiers = [ racine / "src", racine / "images", racine / "documents", racine / "tests" ] for dossier in dossiers: dossier.mkdir(parents=True, exist_ok=True) print("Dossier :", dossier) |
Sortie :
1 2 3 4 | Dossier : projet_python/src Dossier : projet_python/images Dossier : projet_python/documents Dossier : projet_python/tests |
Nous pouvons également créer une arborescence comportant plusieurs niveaux de sous-dossiers.
1 2 3 4 5 6 7 8 9 10 11 12 13 | from pathlib import Path dossiers = [ Path("projet/src/python"), Path("projet/data/images"), Path("projet/data/documents"), Path("projet/tests") ] for dossier in dossiers: dossier.mkdir(parents=True, exist_ok=True) print("Arborescence créée.") |
Sortie :
1 | Arborescence créée. |
11. Gérer les erreurs lors de la création
La création d'un dossier peut échouer pour différentes raisons : le dossier existe déjà, un dossier parent est absent ou le programme ne possède pas les permissions nécessaires. Nous pouvons gérer ces situations avec try...except.
Le programme suivant intercepte l'exception FileExistsError lorsqu'un élément de même nom existe déjà.
1 2 3 4 5 6 7 8 9 | from pathlib import Path dossier = Path("documents") try: dossier.mkdir() print("Dossier créé.") except FileExistsError: print("Le chemin existe déjà.") |
Sortie possible :
1 | Le chemin existe déjà. |
Une erreur de permission peut être interceptée avec l'exception PermissionError. Cela permet au programme d'afficher un message explicite au lieu de s'arrêter brutalement.
1 2 3 4 5 6 7 8 9 10 11 | from pathlib import Path dossier = Path("nouveau_dossier") try: dossier.mkdir() print("Dossier créé.") except PermissionError: print("Permission refusée.") except FileExistsError: print("Le dossier existe déjà.") |
Sortie possible :
1 | Dossier créé. |
12. Résumé
La méthode Path.mkdir() du module pathlib permet de créer facilement des dossiers en Python en utilisant des objets Path.
- Path("dossier").mkdir() crée un dossier simple.
- parents=True crée également les dossiers parents manquants.
- exist_ok=True évite l'exception lorsque le dossier existe déjà.
- parents=True, exist_ok=True constitue une combinaison pratique pour créer une arborescence.
- exists() permet de vérifier si un chemin existe.
- is_dir() permet de vérifier si le chemin représente un dossier.
- L'opérateur / permet de construire facilement les chemins des sous-dossiers.
- Une boucle for permet de créer plusieurs dossiers.
- try...except permet de gérer les erreurs de création.
Le programme suivant résume une utilisation courante de Path.mkdir() en créant plusieurs niveaux de dossiers tout en acceptant une arborescence déjà existante.
1 2 3 4 5 6 7 8 | from pathlib import Path dossier = Path("projet") / "python" / "exercices" dossier.mkdir(parents=True, exist_ok=True) print("Chemin :", dossier) print("Existe :", dossier.exists()) print("Est un dossier :", dossier.is_dir()) |
Sortie :
1 2 3 | Chemin : projet/python/exercices Existe : True Est un dossier : True |
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/
