Manipulation de Chemins Python avec pathlib

Introduction

Dans ce laboratoire, vous apprendrez à gérer les chemins de fichiers et de répertoires en Python en utilisant le module moderne pathlib. Bien que l'ancien module os.path soit encore courant, pathlib offre une approche orientée objet qui rend la manipulation des chemins plus intuitive et lisible. Vous apprendrez à créer, inspecter, valider et manipuler des chemins, des fichiers et des répertoires d'une manière qui fonctionne sur différents systèmes d'exploitation tels que Windows, macOS et Linux.

À la fin de ce laboratoire, vous maîtriserez :

La jointure correcte des composants de chemin.
La création et la gestion des répertoires.
La différenciation entre les chemins absolus et relatifs.
La validation de l'existence et du type des chemins.
L'exécution d'opérations courantes sur les fichiers telles que la copie, le déplacement et la suppression.
Le parcours des arborescences de répertoires pour trouver des fichiers et des dossiers.

Opérations de Base sur les Chemins

Dans cette étape, vous apprendrez les fondamentaux de la manipulation des chemins à l'aide du module pathlib. Cela inclut la jointure des composants de chemin, l'obtention du répertoire de travail actuel et la création de nouveaux répertoires.

Le module pathlib fournit une manière élégante et multiplateforme de gérer les chemins du système de fichiers. Sous Windows, les chemins utilisent des barres obliques inverses (\), tandis que sur les systèmes de type Unix (Linux, macOS), ils utilisent des barres obliques (/). L'utilisation de pathlib garantit que votre code fonctionne sur n'importe quelle plateforme sans ajustements manuels.

Note: Si vous n'êtes pas familier avec l'utilisation de WebIDE (similaire à VS Code), veuillez d'abord vous familiariser avec ce laboratoire.

Premièrement, voyons comment joindre des composants de chemin. L'opérateur / est un raccourci intuitif pour joinpath().

Ouvrez le fichier main.py depuis l'explorateur de fichiers à gauche.
Remplacez le contenu de main.py par le code suivant pour joindre des composants de chemin et afficher le résultat.

from pathlib import Path

## Joindre les composants de chemin en utilisant l'opérateur /
my_path = Path('usr') / 'bin' / 'spam'
print(my_path)

Exécutez le script depuis le terminal :

python3 main.py

Vous verrez la sortie suivante, qui démontre comment pathlib forme correctement un chemin de style Unix :

usr/bin/spam

Ensuite, obtenons le répertoire de travail actuel en utilisant Path.cwd().

Remplacez le contenu de main.py par le code suivant (cela remplace le code précédent) :

from pathlib import Path

## Obtenir le répertoire de travail actuel
cwd = Path.cwd()
print(cwd)

Exécutez à nouveau le script :

python3 main.py

La sortie affichera le répertoire de travail actuel, qui est /home/labex/project dans cet environnement :

/home/labex/project

Enfin, créons un nouveau répertoire. Une FileNotFoundError se produit si vous essayez de créer un répertoire dont le répertoire parent n'existe pas. Pour éviter cela, utilisez mkdir(parents=True), qui crée tous les répertoires parents nécessaires.

Remplacez le contenu de main.py par le code suivant pour créer une structure de répertoires imbriqués :

from pathlib import Path

## Obtenir le répertoire de travail actuel
cwd = Path.cwd()

## Définir le chemin pour les nouveaux répertoires imbriqués
new_dirs = cwd / 'delicious' / 'walnut' / 'waffles'

## Créer les répertoires, y compris tous les parents manquants
new_dirs.mkdir(parents=True, exist_ok=True)

print(f"Successfully created: {new_dirs}")

L'argument exist_ok=True empêche une erreur si le répertoire existe déjà. Cela signifie que vous pouvez exécuter le script plusieurs fois sans erreur.

Exécutez le script :

python3 main.py

Le script créera les répertoires imbriqués et affichera un message de confirmation :

Successfully created: /home/labex/project/delicious/walnut/waffles

Vous pouvez vérifier la création du répertoire en exécutant ls -R delicious dans le terminal.

Chemins Absolus vs Chemins Relatifs

Dans cette étape, vous apprendrez à distinguer et à travailler avec les chemins absolus et relatifs.

Un chemin absolu commence à la racine du système de fichiers (par exemple, / sous Linux ou C:\ sous Windows).
Un chemin relatif est défini à partir du répertoire de travail actuel.

pathlib fournit des méthodes pour vérifier si un chemin est absolu, résoudre un chemin vers sa forme absolue et trouver un chemin relatif à partir d'un point de départ.

Premièrement, voyons comment vérifier si un chemin est absolu en utilisant is_absolute().

Remplacez le contenu de main.py par le code suivant :

from pathlib import Path

## Vérifier si les chemins sont absolus
print(f"Path('/') is absolute: {Path('/').is_absolute()}")
print(f"Path('..') is absolute: {Path('..').is_absolute()}")

Exécutez le script :

python3 main.py

La sortie confirme que / est un chemin absolu, tandis que .. (répertoire parent) est relatif.

Path('/') is absolute: True
Path('..') is absolute: False

Ensuite, vous pouvez obtenir le chemin absolu complet d'un chemin relatif en utilisant resolve(). Ceci est utile pour convertir des chemins relatifs comme . (répertoire courant) ou .. (répertoire parent) en leur forme complète et non ambiguë.

Remplacez le contenu de main.py par le code suivant :

from pathlib import Path

## Résoudre un chemin relatif vers sa forme absolue
## '..' fait référence au répertoire parent du répertoire de travail actuel
resolved_path = Path('..').resolve()

print(f"Current working directory: {Path.cwd()}")
print(f"Resolved path of '..': {resolved_path}")

Exécutez le script :

python3 main.py

La sortie affichera le répertoire actuel et le chemin absolu résolu de son parent.

Current working directory: /home/labex/project
Resolved path of '..': /home/labex

Enfin, vous pouvez calculer un chemin relatif d'un chemin à un autre en utilisant relative_to().

Remplacez le contenu de main.py par le code suivant pour calculer un chemin relatif :

from pathlib import Path

## Obtenir un chemin relatif à partir d'un point de départ
## Ceci montre le chemin vers 'passwd' relatif au répertoire racine '/'
relative_path = Path('/etc/passwd').relative_to('/')
print(f"Path to '/etc/passwd' relative to '/': {relative_path}")

Exécutez le script :

python3 main.py

La sortie montre le chemin relatif au répertoire racine :

Path to '/etc/passwd' relative to '/': etc/passwd

Validation et Inspection des Chemins

Dans cette étape, vous apprendrez à vérifier les propriétés d'un chemin, telles que s'il existe et s'il s'agit d'un fichier ou d'un répertoire. Vous apprendrez également à récupérer des métadonnées de fichier comme sa taille.

Une tâche courante consiste à vérifier si un fichier ou un répertoire existe avant d'essayer d'y accéder. La méthode exists() est parfaite pour cela.

Ouvrez main.py et remplacez son contenu par le code suivant. Cela vérifiera l'existence du répertoire courant (.), d'un fichier (setup.py) et d'un fichier inexistant.

from pathlib import Path

## Vérifier si les chemins existent
print(f"Path('.') exists: {Path('.').exists()}")
print(f"Path('setup.py') exists: {Path('setup.py').exists()}")
print(f"Path('nonexistentfile') exists: {Path('nonexistentfile').exists()}")

Exécutez le script :

python3 main.py

La sortie confirmera quels chemins existent :

Path('.') exists: True
Path('setup.py') exists: True
Path('nonexistentfile') exists: False

Vous pouvez également être plus spécifique et vérifier si un chemin pointe vers un fichier avec is_file() ou vers un répertoire avec is_dir().

Remplacez le contenu de main.py par le code suivant pour effectuer ces vérifications :

from pathlib import Path

## Vérifier si un chemin est un fichier
print(f"Path('setup.py').is_file(): {Path('setup.py').is_file()}")
print(f"Path('/home').is_file(): {Path('/home').is_file()}")

## Vérifier si un chemin est un répertoire
print(f"Path('/').is_dir(): {Path('/').is_dir()}")
print(f"Path('setup.py').is_dir(): {Path('setup.py').is_dir()}")

Exécutez le script :

python3 main.py

La sortie identifiera correctement le type de chaque chemin :

Path('setup.py').is_file(): True
Path('/home').is_file(): False
Path('/').is_dir(): True
Path('setup.py').is_dir(): False

Enfin, pour obtenir des informations détaillées sur le fichier, telles que sa taille, vous pouvez utiliser la méthode stat(). Elle renvoie un objet contenant divers attributs, dont st_size pour la taille du fichier en octets.

Remplacez le contenu de main.py par le code suivant pour obtenir la taille d'un fichier système :

from pathlib import Path
import os

## Définir le chemin vers un fichier
file_path = Path('/bin/python3')

## Obtenir les statistiques du fichier
stat_info = file_path.stat()

## Afficher la taille en octets
print(f"File: {file_path}")
print(f"Size: {stat_info.st_size} bytes")

Exécutez le script :

python3 main.py

La sortie affichera la taille de l'exécutable Python en octets. La taille exacte peut varier.

File: /bin/python3
Size: 10024 bytes

Gestion des Fichiers et des Dossiers

Dans cette étape, vous apprendrez à effectuer des opérations courantes sur le système de fichiers telles que copier, déplacer, renommer et supprimer des fichiers et des dossiers en utilisant le module shutil en combinaison avec pathlib.

Le module shutil fournit des fonctions de haut niveau pour les opérations sur les fichiers. Commençons par la copie de fichiers. shutil.copy() copie un seul fichier vers un nouvel emplacement.

Ouvrez le fichier manage_files.py dans l'explorateur de fichiers à gauche.
Remplacez le contenu de manage_files.py par le code suivant. Ceci copiera spam.txt dans le répertoire /tmp/delicious.

import shutil
from pathlib import Path

## Définir la source et la destination
source_file = Path('/tmp/spam.txt')
destination_dir = Path('/tmp/delicious')

## Copier le fichier
shutil.copy(source_file, destination_dir)

print(f"Copied '{source_file}' to '{destination_dir}'")

## Vous pouvez également renommer le fichier lors de la copie
shutil.copy('/tmp/eggs.txt', '/tmp/delicious/eggs2.txt')
print("Copied and renamed 'eggs.txt' to 'eggs2.txt'")

Exécutez le script :

python3 manage_files.py

Pour copier une arborescence de répertoires entière, utilisez shutil.copytree().

Ajoutez les lignes suivantes à la fin de manage_files.py (ajoutez ces lignes après le code existant) :

## Copier une arborescence de répertoires entière
shutil.copytree('/tmp/bacon', '/tmp/bacon_backup')
print("Copied directory '/tmp/bacon' to '/tmp/bacon_backup'")

Note : Si vous exécutez ce script plusieurs fois, shutil.copytree() échouera car le répertoire de destination existe déjà. C'est un comportement attendu. Pour l'instant, exécutez-le une seule fois.

Exécutez à nouveau le script pour le voir en action.

Ensuite, voyons comment déplacer et renommer des fichiers avec shutil.move(). Cette fonction peut soit déplacer un fichier vers un répertoire différent, soit le renommer.

Remplacez l'intégralité du contenu de manage_files.py par le code suivant pour déplacer bacon.txt :

import shutil
from pathlib import Path

## Créer le répertoire de destination s'il n'existe pas
Path('/tmp/eggs').mkdir(parents=True, exist_ok=True)

## Déplacer un fichier vers un répertoire (seulement si la source existe)
bacon_source = Path('/tmp/bacon.txt')
if bacon_source.exists():
    shutil.move('/tmp/bacon.txt', '/tmp/eggs')
    print("Moved '/tmp/bacon.txt' to '/tmp/eggs'")
else:
    print("'/tmp/bacon.txt' not found (may have been moved already)")

## Déplacer et renommer un fichier
## Premièrement, recréons le fichier à déplacer
Path('/tmp/bacon.txt').touch()
shutil.move('/tmp/bacon.txt', '/tmp/eggs/new_bacon.txt')
print("Moved and renamed '/tmp/bacon.txt' to '/tmp/eggs/new_bacon.txt'")

Note : Le code vérifie si le fichier source existe avant de le déplacer, vous pouvez donc exécuter ce script plusieurs fois en toute sécurité. La deuxième partie créera toujours un nouveau fichier et le déplacera.

Exécutez le script.

Enfin, examinons la suppression de fichiers et de dossiers.

Path.unlink() supprime un seul fichier.
Path.rmdir() supprime un répertoire vide.
shutil.rmtree() supprime un répertoire et tout son contenu.

Remplacez l'intégralité du contenu de manage_files.py par ce qui suit :

from pathlib import Path
import shutil

## Créer un fichier à supprimer
file_to_delete = Path('/tmp/deleteme.txt')
file_to_delete.touch()
print(f"Created '{file_to_delete}'")

## Supprimer le fichier
file_to_delete.unlink()
print(f"Deleted '{file_to_delete}'")

## Créer un répertoire à supprimer
dir_to_delete = Path('/tmp/temp_dir')
dir_to_delete.mkdir(exist_ok=True)
## rmdir() ne fonctionne que sur les répertoires vides
dir_to_delete.rmdir()
print(f"Deleted empty directory '{dir_to_delete}'")

## Utiliser shutil.rmtree() pour supprimer un répertoire et son contenu
## Note : Cela échouera si le répertoire n'existe pas, ce qui est acceptable pour cet exemple
if Path('/tmp/bacon_backup').exists():
    shutil.rmtree('/tmp/bacon_backup')
    print("Deleted directory '/tmp/bacon_backup' and all its contents")
else:
    print("Directory '/tmp/bacon_backup' does not exist (may have been deleted already)")

Note : Si vous exécutez ce script plusieurs fois, certaines opérations peuvent échouer car les fichiers ou les répertoires ont déjà été supprimés. C'est normal et démontre que ces opérations ne sont pas idempotentes (elles ne peuvent pas être répétées en toute sécurité).

Exécutez le script pour effectuer les opérations de suppression.

Parcours de Répertoire

Dans cette étape, vous apprendrez comment lister le contenu d'un répertoire et parcourir récursivement une arborescence de répertoires.

Pour lister le contenu d'un répertoire, vous pouvez utiliser la méthode iterdir(), qui retourne un itérateur de tous les éléments (fichiers et répertoires) présents dans le chemin spécifié.

Premièrement, mettons en place une structure de répertoire d'exemple. Exécutez cette commande dans le terminal :

mkdir -p ~/project/data/level1 && touch ~/project/data/file0.txt ~/project/data/level1/file1.txt

Maintenant, ouvrez main.py et remplacez son contenu par le code suivant pour lister le contenu du répertoire /usr/bin.

from pathlib import Path

## Lister le contenu d'un répertoire
print("Contenu de '/usr/bin':")
count = 0
for f in Path('/usr/bin').iterdir():
    if count < 5: ## Afficher les 5 premiers éléments pour garder la sortie courte
        print(f)
        count += 1
    else:
        break

Exécutez le script :

python3 main.py

La sortie affichera les premiers fichiers et répertoires à l'intérieur de /usr/bin. La liste exacte peut varier.

Contents of '/usr/bin':
/usr/bin/[
/usr/bin/addpart
/usr/bin/apt
/usr/bin/apt-cache
/usr/bin/apt-cdrom

Vous pouvez combiner iterdir() avec stat() pour calculer la taille totale de tous les fichiers dans un répertoire.

Remplacez le contenu de main.py par le code suivant. Notez que ce code additionne uniquement les tailles des enfants directs et ne parcourt pas récursivement les sous-répertoires.

from pathlib import Path

total_size = 0
directory = Path('/usr/bin')

for sub_path in directory.iterdir():
    if sub_path.is_file(): ## S'assurer que seule la taille des fichiers est ajoutée
        total_size += sub_path.stat().st_size

print(f"Taille totale des fichiers dans '{directory}': {total_size} octets")

Exécutez le script. Il affichera la taille totale de tous les fichiers directement dans /usr/bin.

Pour des tâches plus complexes, vous pourriez avoir besoin de "parcourir" (walk) une arborescence de répertoires entière, visitant tous les sous-répertoires et fichiers. La méthode rglob() est parfaite pour cela. Elle trouve récursivement tous les chemins correspondant à un motif spécifique. Utiliser * comme motif correspond à tout.

Premièrement, créez une structure de répertoire plus complexe pour cet exemple. Exécutez ceci dans le terminal :

mkdir -p /tmp/delicious/cats /tmp/delicious/walnut/waffles
touch /tmp/delicious/spam.txt /tmp/delicious/cats/catnames.txt /tmp/delicious/walnut/waffles/butter.txt

Note : Vous pouvez exécuter ces commandes plusieurs fois sans risque. La commande mkdir -p n'échouera pas si les répertoires existent déjà, et touch mettra à jour les horodatages des fichiers si les fichiers existent déjà.

Remplacez le contenu de main.py par le code suivant pour parcourir le répertoire /tmp/delicious :

from pathlib import Path

p = Path('/tmp/delicious')
print(f"Parcours de l'arborescence du répertoire pour : {p}")

for i in p.rglob('*'):
    print(i)

Exécutez le script :

python3 main.py

La sortie listera chaque fichier et dossier dans /tmp/delicious et ses sous-répertoires, démontrant comment rglob() parcourt l'arbre entier.

Walking directory tree for: /tmp/delicious
/tmp/delicious/spam.txt
/tmp/delicious/eggs2.txt
/tmp/delicious/cats
/tmp/delicious/walnut
/tmp/delicious/cats/catnames.txt
/tmp/delicious/walnut/waffles
/tmp/delicious/walnut/waffles/butter.txt

Résumé

Félicitations pour avoir terminé ce laboratoire ! Vous avez appris à gérer efficacement les chemins de fichiers et de répertoires en Python en utilisant le module moderne pathlib.

Tout au long de ce laboratoire, vous avez pratiqué :

La création et la jointure de chemins de manière multiplateforme (cross-platform) en utilisant les objets Path et l'opérateur /.
L'obtention du répertoire de travail actuel et la création de répertoires imbriqués avec mkdir(parents=True).
La différenciation entre les chemins absolus et relatifs et la conversion entre eux en utilisant is_absolute(), resolve(), et relative_to().
La validation des chemins avec exists(), is_file(), et is_dir(), et l'inspection des métadonnées des fichiers avec stat().
L'exécution de tâches essentielles de gestion de fichiers telles que copier, déplacer et supprimer avec le module shutil et les méthodes de pathlib.
Le parcours des structures de répertoires pour lister le contenu avec iterdir() et trouver récursivement des éléments avec rglob().

Ces compétences sont fondamentales pour écrire des applications Python robustes et maintenables qui interagissent avec le système de fichiers.

Manipulation des Chemins de Fichiers et de Répertoires en Python