Name: Tremplin Numérique
Price range: $$$

Vous vous inquiétez de créer des programmes indépendants du système d'exploitation dans Python? Le os Le module est la ligne directe de Python vers votre système d'exploitation. Considérez-le comme le couteau suisse pour les tâches quotidiennes liées à votre système. Voyons ce qui trompe le os Le module a dans sa manche.

Sommaire

Manipulation des opérations d'annuaire

Nous téléchargeons souvent rapidement de nombreux articles sur Internet et les stockons tous dans un seul dossier, pour les organiser manuellement plus tard. Peut-être que vous voulez 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 ne le font pas.) Avec des fonctions utiles de Python os Module, vous pouvez automatiser cette organisation à l'aide d'un script.

        import os
if not os.path.exists("pdfs"):
   os.mkdir("pdfs")

os.makedirs("images/2025/events", exist_ok=True)

print("Current directory contents:", os.listdir("."))

os.rmdir("old_folder")

Le os.path.exists("pdfs") Snippet vérifie si le dossier existe déjà, nous ne rencontrons donc pas d'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 exist_ok=True L'indicateur empêche une erreur si le dossier existe déjà. os.listdir(".") répertorie tout dans le dossier actuel ("." signifie répertoire actuel). os.rmdir("old_folder") Supprime un répertoire vide, mais il ne le supprime pas si les fichiers sont toujours à l'intérieur. Avec seulement quelques lignes de code, vous pouvez déjà automatiser les tâches d'organisation de fichiers communes.

Naviguer dans le système de fichiers

Supposons que vous souhaitiez traiter certains fichiers stockés dans un sous-répertoire de votre projet. Au lieu de coder des chemins en dur partout, il est souvent plus propre de naviguer dans ce dossier, de faire votre travail, puis de récupérer. De cette façon, votre script peut être exécuté de n'importe où sans se casser. Le os Le module offre 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 fonctionne actuellement. os.chdir("logs") Déplace le répertoire de travail dans le dossier « Logs / », de sorte que toutes les opérations de fichiers y arriveront par défaut. os.listdir(".") Encore une fois, ce qui est dans le répertoire actuel. Cette fois, le contenu de « Logs / ». Enfin, os.chdir("..") nous fait revenir au répertoire parent.

Ce type de navigation est particulièrement utile lorsque vos scripts doivent traiter les fichiers à partir de différents dossiers, mais vous ne voulez pas jongler avec de longs chemins absolus. Il maintient votre code plus propre et plus flexible.

Gestion des chemins de fichier

Permettez-moi de commencer par une histoire. Je travaillais sur un projet logiciel avec un de mes amis. J'utilisais Linux pendant qu'il était sous Windows. À ce moment-là, je ne savais pas comment utiliser les chemins de fichier pour fonctionner universellement. Ainsi, nous étions tous les deux des chemins de fichier de codage dur de chacun de nos systèmes.

Dites que vous voulez que votre script fonctionne quel que soit le système d'exploitation sur lequel il fonctionne: Windows, MacOS ou Linux. Le problème? Les chemins de fichier sont différents sur chaque système (C: Users … sur Windows vs. / Home / … sur Linux). C'est là que le os.path Les services publics entrent en jeu. Ils gèrent les chemins d'une manière sûre et multiplateforme, vous n'avez donc pas à vous soucier des barres obliques ou des séparateurs. Voici à quoi cela pourrait ressembler dans la pratique:

        import os
folder = "reports"
filename = "summary.txt"
path = os.path.join(folder, filename)
print("Full path:", path)

if not os.path.exists(folder):
   os.mkdir(folder)

print("Absolute path:", os.path.abspath(path))

directory, file = os.path.split(path)
print("Directory:", directory)
print("File:", file)

print("Basename:", os.path.basename(path))

name, ext = os.path.splitext(file)
print("Name:", name)
print("Extension:", ext)

Alors, que se passe-t-il ici?

os.path.join(folder, filename) s'assure que le chemin est correct pour le système. Sur Windows, il utilise des barres à barres (reportssummary.txt)); Sur Linux et MacOS, il utilise des barres obliques (reports/summary.txt).
os.path.exists(folder) vérifie si un dossier ou un fichier est déjà là avant de le créer.
os.path.abspath(path) résout le chemin absolu, qui est utile lorsque vous devez être sûr où votre fichier vivra.
os.path.split(path) Divise le chemin en deux parties: dossier et fichier.
os.path.basename(path) est un raccourci pour obtenir le nom de fichier à partir d'un chemin complet.
os.path.splitext(file) Aide à séparer le nom de l'extension.

La gestion des chemins de cette façon 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 autorisations de fichiers

Imaginez ceci. Vous avez téléchargé un fichier à partir de quelque part, mais lorsque vous essayez de l'ouvrir ou de l'exécuter, vous vous rendez compte qu'il n'a pas les bonnes autorisations. Peut-être que vous souhaitez créer un fichier texte en lecture seule, ou vous assurer qu'un fichier Python est exécutable avant de l'exécuter. C'est là que le module OS vous aide à interagir directement avec les autorisations de fichiers.

Voici un exemple en action.

        import os
import statfile_path = "example.txt"

if os.access(file_path, os.R_OK) and os.access(file_path, os.W_OK):
   print(f"{file_path} is readable and writable")

os.chmod(file_path, stat.S_IREAD)
print(f"{file_path} is now read-only")

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 si c'est écrivative. os.chmod(file_path, stat.S_IREAD) Définit le fichier pour être en lecture seule. Le stat Le module fournit des constantes comme S_IREAD, S_IWRITEet S_IEXEC pour rendre cela plus clair. Vous pouvez combiner des drapeaux avec | (bitwise ou), comme stat.S_IREAD | stat.S_IEXECpour rendre un fichier à la fois lisible et exécutable.

La gestion des autorisations est particulièrement pratique lorsque vous travaillez avec des fichiers provenant de sources externes ou lorsque vous avez besoin d'un contrôle à grain fin qui peut faire quoi avec vos fichiers.

Travailler avec des variables environnementales

Imaginez que vous travaillez sur un projet qui a besoin d'une clé API pour vous connecter à un service. Le codage dur de cette clé dans votre code n'est pas sécurisé. Au lieu de cela, vous devez le stocker dans une variable d'environnement et le récupérer lorsque votre programme s'exécute. Voici un exemple pour le rendre plus clair.

        import os
api_key = os.getenv("API_KEY")
if api_key:
   print("API key found:", api_key(:4) + "****")  
else:
   print("API key not found. Please set it.")

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. S'il n'existe pas, il revient None (ou quel que soit le défaut que vous fournissez). os.environ("MODE") = "development" Définit une variable d'environnement pour la durée de vie de votre programme. Il ne persistera pas après la fin du programme, mais il est utile pour la configuration pendant l'exécution. L'utilisation de variables d'environnement aide à garder les données sensibles à partir de votre code source et vous permet de basculer facilement entre différentes configurations.

Commandes du système en cours d'exécution

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

        import os
os.system("date")

os.system("cls" if os.name == "nt" else "clear")

Maintenant, pour une tâche plus pratique. Dites que vous souhaitez nettoyer les anciens fichiers temporaires à partir d'un dossier spécifique. Bien que vous puissiez le faire avec Pure Python, appeler une commande système comme RM (Linux / MacOS) ou Del (Windows) peut être rapide:

        import os
if os.name == "nt":  
   os.system("del temp\*.tmp")
else:  
   os.system("rm temp/*.tmp")

En utilisant os.system() Dans Python, n'est généralement pas recommandé pour la plupart des cas d'utilisation, en particulier lorsqu'il s'agit de l'entrée des utilisateurs ou des environnements de production. Bien qu'il puisse exécuter des commandes système, il présente plusieurs limitations de sécurité et de fonctionnalité par rapport à la subprocess module.

Obtenir des informations système

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

        import osprint("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())

if hasattr(os, "uname"):
   print("System info:", os.uname())

Avec seulement quelques appels, vous pouvez rendre votre programme plus intelligent sur l'environnement dans lequel il fonctionne, que ce soit pour l'exploitation forestière, le débogage ou le comportement de couture, selon le système.

Traverser un arbre d'annuaire

Supposons que vous souhaitiez rechercher dans un dossier de projet et trouver tous les .log fichiers. Au lieu d'écrire votre propre code récursif pour vérifier chaque sous-répertoire, Python os Le module vous donne os.walk()qui fait le levage 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 le filenames.

        import ossearch_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 caractéristiques les plus pratiques du os module. Que vous étiez traqué des fichiers journaux, que vous scrutiez des images ou que vous collectez des fichiers de données sur les dossiers imbriqués, os.walk Vous évite de réinventer la roue.

Python propose tant de bibliothèques et de modules utiles qui vous aident à effectuer des tâches réelles plus facilement. Il existe des modules pour créer une calculatrice graphique ou même pour le traitement des données.