8 utilisations pratiques du module os en Python

Liens rapides

• Gestion des opérations de répertoire

• Naviguer dans le système de fichiers

• Gestion des chemins de fichiers

• Gestion des permissions de fichiers

• Travailler avec les variables d'environnement

• Exécution des commandes système

• Obtenir des informations système

• Parcourir un arbre de répertoires

Vous vous inquiétez de créer des programmes indépendants du système d'exploitation en Python ? Le module os est la ligne directe de Python avec votre système d'exploitation. Pensez-y comme au couteau suisse pour les tâches quotidiennes liées à votre système. Voyons quelles astuces le module os a dans sa manche.

Gestion des opérations de répertoire

Nous téléchargeons souvent rapidement de nombreux éléments depuis Internet et les stockons tous dans un seul dossier, pour ensuite les organiser manuellement plus tard. Peut-être voulez-vous un dossier pour les PDF, un autre pour les images et un autre pour les fichiers texte. Avant de pouvoir déplacer ces fichiers, vous devez vous assurer que les bons répertoires existent (ou les créer s'ils n'existent pas). Avec quelques fonctions utiles du module os de Python, vous pouvez automatiser cette organisation à l'aide d'un script.

import os
# Create a folder for PDFs if it does not exist
if not os.path.exists("pdfs"):
   os.mkdir("pdfs")
# Create a nested folder structure for images
os.makedirs("images/2025/events", exist_ok=True)
# List the contents of the current directory
print("Current directory contents:", os.listdir("."))
# Remove an empty directory
os.rmdir("old_folder")  # only works if "old_folder" has no files inside
    

Le snippet os.path.exists("pdfs") vérifie si le dossier existe déjà, afin d’éviter des erreurs lors de l’appel à os.mkdir(). os.makedirs(..., exist_ok=True) est un moyen pratique de créer des répertoires imbriqués. Le paramètre exist_ok=True empêche une erreur si le dossier existe déjà. os.listdir(".") liste tout ce qui se trouve dans le dossier actuel ("." signifie répertoire courant). os.rmdir("old_folder") supprime un répertoire vide, mais ne le supprimera pas si des fichiers s’y trouvent encore. Avec seulement quelques lignes de code, vous pouvez déjà automatiser des tâches courantes d’organisation de fichiers.

Naviguer dans le système de fichiers

Supposons que vous souhaitiez traiter des fichiers stockés dans un sous-répertoire de votre projet. Plutôt que de coder en dur les chemins partout, il est souvent plus propre de naviguer dans ce dossier, de faire votre travail, puis de revenir en arrière. De cette manière, votre script peut être exécuté de n'importe où sans se casser. Le module os fournit quelques fonctions pratiques pour cela.

import os
# Show the starting directory
print("Starting directory:", os.getcwd())
# Navigate to the "logs" folder
os.chdir("logs")
print("Now inside:", os.getcwd())
# List files inside "logs"
print("Log files:", os.listdir("."))
# Go back to the original directory
os.chdir("..")
print("Back to:", os.getcwd())

os.getcwd() vous indique où votre script s'exécute actuellement. os.chdir("logs") déplace le répertoire de travail dans le dossier "logs/", donc toutes les opérations sur les fichiers se feront par défaut là-bas. os.listdir(".") liste à nouveau ce qu'il y a dans le répertoire actuel. Cette fois, le contenu de "logs/". Enfin, os.chdir("..") nous ramène au répertoire parent.

Ce type de navigation est particulièrement utile lorsque vos scripts doivent traiter des fichiers provenant de différents dossiers, mais que vous ne voulez pas gérer de longs chemins absolus. Cela rend votre code plus propre et plus flexible.

Gestion des chemins de fichiers

Laissez-moi commencer par une histoire. Je travaillais sur un projet logiciel avec un ami. J'utilisais Linux tandis qu'il était sur Windows. À cette époque, je ne savais pas comment utiliser les chemins de fichiers de manière universelle. Donc, nous codions tous les deux en dur les chemins de fichiers de chacun de nos systèmes.

Supposons que vous vouliez que votre script fonctionne quel que soit le système d'exploitation sur lequel il s'exécute : Windows, macOS ou Linux. Le problème ? Les chemins de fichiers sont différents sur chaque système (C:\Users\... sur Windows contre /home/... sur Linux). C'est là que les utilitaires os.path entrent en jeu. Ils gèrent les chemins d'une manière sécurisée et multiplateforme, de sorte que vous n'avez pas à vous soucier des barres obliques ou des séparateurs. Voici comment cela pourrait se présenter en pratique :

import os
# Build a path to a new report
folder = "reports"
filename = "summary.txt"
path = os.path.join(folder, filename)
print("Full path:", path)
# Check if the folder exists
if not os.path.exists(folder):
   os.mkdir(folder)
# Absolute path (so you know exactly where your file will go)
print("Absolute path:", os.path.abspath(path))
# Split a path into directory and filename
directory, file = os.path.split(path)
print("Directory:", directory)
print("File:", file)
# Get just the filename directly
print("Basename:", os.path.basename(path))
# Split a filename into name and extension
name, ext = os.path.splitext(file)
print("Name:", name)
print("Extension:", ext)
    

Alors, que se passe-t-il ici ?

• os.path.join(folder, filename) garantit que le chemin est correct pour le système. Sous Windows, il utilise des barres obliques inverses (reports\summary.txt) ; sous Linux et macOS, il utilise des barres obliques (reports/summary.txt).
• os.path.exists(folder) vérifie si un dossier ou un fichier existe déjà avant de le créer.
• os.path.abspath(path) renvoie le chemin absolu, ce qui est utile lorsque vous devez être sûr de l'emplacement de votre fichier.
• os.path.split(path) divise le chemin en deux parties : le dossier et le fichier.
• os.path.basename(path) est un raccourci pour obtenir uniquement le nom de fichier à partir d'un chemin complet.
• os.path.splitext(file) aide à séparer le nom de l'extension.

Gérer les chemins de cette manière rend votre code portable et beaucoup moins sujet aux erreurs. Vous n'avez pas à vous soucier de savoir si vous avez tapé la bonne barre oblique.

Gestion des permissions de fichiers

Imaginez ceci. Vous avez téléchargé un fichier depuis quelque part, mais lorsque vous essayez de l'ouvrir ou de l'exécuter, vous réalisez qu'il n'a pas les bonnes autorisations. Peut-être voulez-vous rendre un fichier texte en lecture seule, ou vous assurer qu'un fichier Python est exécutable avant de le lancer. C'est là que le module os vous aide à interagir directement avec les permissions des fichiers.

Voici un exemple en action.

import os
import stat
file_path = "example.txt"
# Check if the file is readable and writable
if os.access(file_path, os.R_OK) and os.access(file_path, os.W_OK):
   print(f"{file_path} is readable and writable")
# Make the file read-only
os.chmod(file_path, stat.S_IREAD)
print(f"{file_path} is now read-only")
# Make the file executable (useful for scripts or binaries)
os.chmod(file_path, stat.S_IREAD | stat.S_IEXEC)
print(f"{file_path} is now executable")
    

os.access(file_path, os.R_OK) vérifie si le fichier est lisible, et os.access(file_path, os.W_OK) vérifie s'il est modifiable. os.chmod(file_path, stat.S_IREAD) rend le fichier en lecture seule. Le module stat fournit des constantes comme S_IREAD, S_IWRITE, et S_IEXEC pour clarifier cela. Vous pouvez combiner les drapeaux avec | (OU binaire), comme stat.S_IREAD | stat.S_IEXEC, pour rendre un fichier à la fois lisible et exécutable.

Gérer les autorisations est particulièrement pratique lorsque l'on travaille avec des fichiers provenant de sources externes ou lorsque vous avez besoin d'un contrôle précis sur qui peut faire quoi avec vos fichiers.

Travailler avec les variables d'environnement

Imaginez que vous travaillez sur un projet qui nécessite une clé API pour se connecter à un service. L'intégrer directement dans votre code n'est pas sécurisé. À la place, vous devriez la stocker dans une variable d'environnement et la récupérer lorsque votre programme s'exécute. Voici un exemple pour clarifier cela.

import os
# Get an environment variable
api_key = os.getenv("API_KEY")
if api_key:
   print("API key found:", api_key[:4] + "****")  # Masking for safety
else:
   print("API key not found. Please set it.")
# Set an environment variable (for current session only)
os.environ["MODE"] = "development"
print("Running in mode:", os.environ["MODE"])
    

os.getenv("API_KEY") récupère la valeur de la variable d'environnement nommée API_KEY. Si elle n'existe pas, elle retourne None (ou toute valeur par défaut que vous fournissez). os.environ["MODE"]="development" définit une variable d'environnement pour la durée de vie de votre programme. Elle ne persistera pas après la fin du programme, mais elle est utile pour la configuration pendant l'exécution. L'utilisation de variables d'environnement aide à garder les données sensibles en dehors de votre code source et permet de passer facilement entre différentes configurations.

Exécution des commandes système

Parfois, Python ne peut pas tout faire directement. D'autres fois, il est simplement plus facile de laisser le système d'exploitation gérer une tâche. Par exemple, vous pourriez vouloir vérifier la date et l'heure actuelles, effacer l'écran ou exécuter un programme utilitaire installé sur votre machine. Le module os offre un moyen rapide de le faire avec os.system(command). Voici un exemple de ce type :

import os
# Show the current date (works differently depending on OS)
os.system("date")
# Clear the terminal screen
# "cls" is for Windows, "clear" is for Linux/macOS
os.system("cls" if os.name == "nt" else "clear")
    

Maintenant, pour une tâche plus pratique. Supposons que vous souhaitiez nettoyer les anciens fichiers temporaires d'un dossier spécifique. Bien que vous puissiez le faire avec Python pur, appeler une commande système comme rm (Linux/macOS) ou del (Windows) peut être rapide :

import os
# Remove all .tmp files in the "temp" folder
if os.name == "nt":  # Windows
   os.system("del temp\\*.tmp")
else:  # Linux / macOS
   os.system("rm temp/*.tmp")
    

Obtenir des informations système

Parfois, vous voulez simplement en savoir un peu plus sur l'environnement dans lequel votre code Python s'exécute. Peut-être êtes-vous curieux de savoir quel utilisateur a lancé le processus, ou vous voulez récupérer l'identifiant du processus (PID) pour aider à la surveillance. Le module os contient des fonctions pour obtenir toutes sortes d'informations système utiles.

import os
print("Operating system:", os.name)
print("Current process ID:", os.getpid())
print("Parent process ID:", os.getppid())
print("Logged in as:", os.getlogin())
print("Number of CPUs:", os.cpu_count())
# Extra details (Unix only)
if hasattr(os, "uname"):
   print("System info:", os.uname())
    

Avec seulement quelques appels, vous pouvez rendre votre programme plus intelligent concernant l'environnement dans lequel il s'exécute, que ce soit pour la journalisation, le débogage ou l'adaptation du comportement selon le système.

Parcourir un arbre de répertoires

Supposons que vous souhaitiez parcourir un dossier de projet et trouver tous les fichiers .log. Au lieu d'écrire votre propre code récursif pour vérifier chaque sous-répertoire, le module os de Python vous offre os.walk(), qui effectue le travail lourd.

os.walk(path) génère une séquence de tuples (dirpath, dirnames, filenames) pour chaque dossier qu'il visite. Pour la plupart des tâches liées aux fichiers, vous vous concentrerez généralement sur les filenames.

import os
search_dir = "project"
target_ext = ".logs"
for dirpath, dirnames, filenames in os.walk(search_dir):
   for file in filenames:
       if file.endswith(target_ext):
           full_path = os.path.join(dirpath, file)
           print("Found:", full_path)
    

C'est l'une des fonctionnalités les plus pratiques du module os. Que vous recherchiez des fichiers journaux, que vous scanniez des images ou que vous collectiez des fichiers de données dans des dossiers imbriqués, os.walk vous évite de réinventer la roue.

Python offre de nombreuses bibliothèques et modules utiles qui vous aident à réaliser des tâches de la vie réelle plus facilement. Il existe des modules pour créer une calculatrice graphique ou même pour le traitement des données.