Construire des chemins de manière portable

Le problème des chemins de fichiers non portables

Lorsque vous manipulez des fichiers et des répertoires en Python, vous devez souvent construire des chemins d'accès (par exemple, pour ouvrir un fichier, créer un répertoire, etc.).

Cependant, les différents systèmes d'exploitation utilisent des conventions différentes pour représenter les chemins :

• Windows : Utilise l'antislash (`\`) comme séparateur de répertoire, et les chemins peuvent commencer par une lettre de lecteur (par exemple, `C:\Users\Nom\Documents\fichier.txt`).
• macOS et Linux : Utilisent le slash (`/`) comme séparateur de répertoire, et les chemins commencent par `/` pour les chemins absolus (par exemple, `/home/nom/documents/fichier.txt`).

Si vous écrivez votre code en "durcissant" les séparateurs de répertoire (en utilisant directement `\` ou `/`), votre code ne sera pas portable : il fonctionnera sur un système d'exploitation, mais pas sur les autres.

Exemple (non portable) :

# Ce code fonctionne sur Windows, mais pas sur macOS/Linux
chemin = "C:\\Dossier\\SousDossier\\fichier.txt"

# Ce code fonctionne sur macOS/Linux, mais pas sur Windows
chemin = "/home/user/dossier/fichier.txt"

Pour écrire du code portable, vous devez utiliser des fonctions qui construisent les chemins de manière *indépendante du système d'exploitation*.

os.path.join() : la solution portable

La fonction `os.path.join()` du module `os.path` est la solution recommandée pour construire des chemins de fichiers de manière portable en Python.

Elle prend un nombre variable d'arguments (des chaînes de caractères représentant des parties de chemin) et les concatène en utilisant le séparateur de répertoire approprié pour le système d'exploitation courant.

Syntaxe :

import os

chemin = os.path.join(partie1, partie2, partie3, ...)

Exemple :

import os

dossier = "mon_dossier"
fichier = "mon_fichier.txt"

chemin = os.path.join(dossier, "sous_dossier", fichier)
print(chemin)  # Affiche "mon_dossier/sous_dossier/mon_fichier.txt" sur macOS/Linux
              # Affiche "mon_dossier\\sous_dossier\\mon_fichier.txt" sur Windows

Notez comment `os.path.join()` utilise automatiquement le bon séparateur de répertoire (`/` sur macOS/Linux, `\` sur Windows).

Vous pouvez utiliser `os.path.join()` avec des chemins relatifs ou absolus.

Exemples d'utilisation de os.path.join()

Voici quelques exemples d'utilisation de `os.path.join()` :

• Construire un chemin relatif à partir du répertoire courant :

import os
chemin = os.path.join(".", "dossier", "fichier.txt")  # "." représente le répertoire courant

• Construire un chemin absolu :

import os
chemin_absolu = os.path.abspath("mon_fichier.txt") #Obtention du chemin absolu.
chemin = os.path.join(chemin_absolu, "dossier")

• Combiner des variables et des chaînes littérales :

import os
repertoire_parent = "documents"
nom_fichier = "rapport.docx"
chemin = os.path.join(repertoire_parent, "projet_x", nom_fichier)

• Utiliser `os.path.join()` avec `os.getcwd()` (pour obtenir le répertoire courant) :

import os
chemin = os.path.join(os.getcwd(), "data", "fichier.csv")

Autres fonctions utiles dans os.path

Le module `os.path` contient de nombreuses autres fonctions utiles pour manipuler les chemins de fichiers. En voici quelques-unes :

• `os.path.abspath(path)` : Retourne le chemin absolu correspondant à `path`.
• `os.path.basename(path)` : Retourne le nom de base du fichier (la dernière partie du chemin). Par exemple, `os.path.basename("/dossier/fichier.txt")` retourne `"fichier.txt"`.
• `os.path.dirname(path)` : Retourne le nom du répertoire parent du fichier. Par exemple, `os.path.dirname("/dossier/fichier.txt")` retourne `"/dossier"`.
• `os.path.exists(path)` : Retourne `True` si le chemin `path` correspond à un fichier ou un répertoire existant, `False` sinon.
• `os.path.isfile(path)` : Retourne `True` si le chemin `path` correspond à un fichier existant, `False` sinon.
• `os.path.isdir(path)` : Retourne `True` si le chemin `path` correspond à un répertoire existant, `False` sinon.
• `os.path.split(path)` : Retourne un tuple `(head, tail)` où `tail` est le dernier composant du chemin et `head` est tout ce qui précède. Par exemple, `os.path.split("/dossier/fichier.txt")` retourne `('/dossier', 'fichier.txt')`.
• `os.path.splitext(path)` : Retourne un tuple `(root, ext)` où `root` est le chemin sans l'extension, et `ext` est l'extension du fichier (y compris le point). Par exemple, `os.path.splitext("fichier.txt")` retourne `('fichier', '.txt')`.

Ces fonctions vous permettent de manipuler et d'interroger les chemins de fichiers de manière portable et efficace.

Bonnes pratiques

Quelques bonnes pratiques pour construire des chemins :

• Utilisez toujours `os.path.join()` : Ne concaténez jamais des chemins de fichiers en utilisant directement `+` ou en insérant des séparateurs de répertoire "en dur".
• Utilisez des chemins relatifs si possible : Les chemins relatifs (par exemple, `"data/fichier.txt"`) sont généralement plus portables que les chemins absolus (par exemple, `"/home/user/data/fichier.txt"`).
• Utilisez des variables pour les noms de fichiers et de répertoires : Cela rend le code plus lisible et plus facile à modifier.
• Vérifiez l'existence des fichiers et répertoires si nécessaire : Utilisez `os.path.exists()`, `os.path.isfile()`, ou `os.path.isdir()` avant d'effectuer des opérations sur les fichiers ou répertoires.
• Gérez les exceptions : Utilisez des blocs `try...except` pour gérer les erreurs potentielles (par exemple, `FileNotFoundError`, `PermissionError`).