Python offre diverses méthodes pour interagir avec le système d'exploitation et exécuter des programmes ou des commandes shell externes. Comprendre les nuances de ces approches est essentiel pour des tâches telles que l'automatisation, l'intégration de systèmes ou la gestion de processus. Cet article explore les principales fonctions et modules disponibles pour exécuter des commandes externes en Python, en soulignant leurs caractéristiques spécifiques et leurs cas d'utilisation.

1. Exécution simple avec os.system()

La fonction os.system() est l'une des manières les plus directes d'exécuter une commande shell. Elle est conçue pour des opérations simples où la sortie de la commande peut être directement affichée à l'utilisateur.

• Mode bloquant : L'exécution du script Python est suspendue jusqu'à ce que la commande externe se termine.
• Sortie directe : L'affichage standard (stdout) et l'erreur standard (stderr) de la commande sont directement imprimés sur la console du programme Python.
• Valeur de retour : Renvoie le code de sortie numérique de la commande, où 0 indique généralement un succès et toute autre valeur une erreur.

Exemple 1: Lancement de commandes séquentielles

import os

print("--- Démarrage de l'exécution os.system ---")

# Exécution d'une commande système pour lister le contenu d'un répertoire
status_ls = os.system("ls -l /tmp") # Ou "dir C:\Temp" sur Windows
print(f"Code de statut pour 'ls': {status_ls}")

# Exécution d'une commande pour afficher la version de Java (si installée)
status_java = os.system("java -version")
print(f"Code de statut pour 'java -version': {status_java}")

print("--- Fin de l'exécution os.system ---")

Comme démontré, le script Python attend la complétion de la commande ls -l avant de passer à java -version, illustrant le comportement bloquant.

2. Récupération de la sortie avec os.popen()

La fonction os.popen() offre un contrôle plus fin sur la sortie d'une commande externe en la renvoyant sous la forme d'un objet de type fichier. Cela permet de lire et de traiter la sortie programmatiquement.

• Contrôle de l'affichage : La sortie de la commande n'est pas automatiquement imprimée sur la console.
• Objet fichier : Retourne un objet fichier qui peut être lu (par exemple, avec read() ou readlines()) pour récupérer le flux de sortie standard.
• Comportement : L'exécution peut sembler non-bloquante si la sortie n'est pas lue immédiatement. Cependant, la lecture effective de l'objet fichier rend le processus bloquant jusqu'à ce que la sortie soit entièrement consommée ou que le processus se termine.

Exemple 2: Lecture de la sortie d'une commande

import os

print("--- Démarrage de l'exécution os.popen ---")

# Exécution et lecture de la version de Python
with os.popen("python --version") as flux_version:
   version_output = flux_version.read().strip()
   print(f"Version de Python: {version_output}")

# Exécution et lecture des informations sur le système d'exploitation
with os.popen("uname -a") as flux_systeme: # 'systeminfo' sur Windows
   system_info = flux_systeme.read()
   print(f"\nInformations système:\n{system_info.strip()}")

print("--- Fin de l'exécution os.popen ---")

L'utilisation d'un bloc with est recommandée pour s'assurer que l'objet fichier est correctement fermé après utilisation.

3. Le module commands (Déprécié - Python 2.x)

Le module commands était une solution courante dans Python 2.x pour exécuter des commandes shell et récupérer leur statut ainsi que leur sortie. Ce module est officiellement déprécié depuis Python 2.6 et n'est plus disponible dans Python 3. Pour toute nouvelle application ou migration, il est impératif d'utiliser le module subprocess.

En Python 2, commands.getstatusoutput(cmd) renvoyait un tuple (statut, sortie).

4. Le module subprocess (Recommandé pour Python 3)

Le module subprocess est la solution moderne et la plus complète pour lancer de nouveaux processus et gérer leurs communications. Il remplace toutes les fonctions précédentes (os.system(), os.popen(), etc.) et offre une flexibilité et un contrôle inégalés sur les processus enfants.

4.1. subprocess.Popen: La fondation

Popen est la classe de base du module subprocess. Elle permet de créer et de gérer un processus enfant avec un contrôle très fin sur ses entrées, sorties et erreurs, ainsi que son cycle de vie.

• Contrôle détaillé : Permet de configurer les flux d'entrée/sortie/erreur, l'environnement, le répertoire de travail, etc.
• Exécution asynchrone : Peut lancer un processus et permettre au script Python de continuer son exécution en parallèle.
• Communication : Offre des méthodes pour attendre la fin du processus, le terminer ou lui envoyer des signaux.

Exemple 3: Lancement et gestion de processus asynchrones

import subprocess
import time

print("--- Démarrage avec subprocess.Popen ---")

# Lancer un processus qui exécute une commande de pause
print("Lancement de 'sleep 4' en arrière-plan...")
# Note: Sur Windows, utilisez ['timeout', '/t', '4']
processus_pause = subprocess.Popen(["sleep", "4"])

print("Le programme Python continue son travail pendant l'attente...")
time.sleep(1.5) # Simule une autre tâche

# Attendre que le processus de pause se termine
print("Attente de la fin du processus de pause...")
code_final = processus_pause.wait()
print(f"Processus 'sleep' terminé avec le code: {code_final}")

print("\nExécution immédiate d'une commande 'hostname'...")
processus_hote = subprocess.Popen(["hostname"])
processus_hote.wait() # Attendre sa fin

print("--- Fin avec subprocess.Popen ---")

4.2. Redirection des sorties vers des fichiers

Popen permet de rediriger la sortie standard (stdout) et l'erreur standard (stderr) du processus enfant vers des descripteurs de fichiers, y compris des fichiers sur le système de fichiers.

Exemple 4: Redirection vers des fichiers log

import subprocess

print("--- Redirection de sortie de processus ---")

# Rediriger la sortie de 'ls -la /' vers un fichier
with open("liste_racine.txt", "w") as fichier_racine:
   proc_list = subprocess.Popen(["ls", "-la", "/"], stdout=fichier_racine, stderr=subprocess.PIPE, text=True)
   _stdout, err_data = proc_list.communicate() # communicate() est recommandé pour éviter les deadlocks
   if err_data:
       print(f"Erreur de 'ls -la /': {err_data.strip()}")

print("La liste du répertoire racine a été écrite dans liste_racine.txt")

# Rediriger la sortie d'erreur (si elle existe) de 'grep' vers un fichier de log
with open("grep_errors.log", "w") as fichier_erreurs:
   proc_grep = subprocess.Popen(
       ["grep", "mot_absent", "/etc/fstab"], # Tente de chercher un mot dans un fichier qui n'existe peut-être pas ou n'a pas le mot
       stdout=subprocess.PIPE,
       stderr=fichier_erreurs,
       text=True
   )
   stdout_data, _stderr = proc_grep.communicate()
   if stdout_data:
       print(f"Sortie de 'grep': {stdout_data.strip()}")

print("Les erreurs de 'grep' ont été (potentiellement) écrites dans grep_errors.log")
print("--- Fin de la redirection ---")

4.3. Capture de la sortie et des erreurs (PIPE)

Pour capturer la sortie et les erreurs directement dans le programme Python, utilisez subprocess.PIPE pour les arguments stdout et stderr. La méthode .communicate() est alors essentielle pour lire ces flux de manière sûre, évitant les problèmes d'interblocage (deadlocks).

Exemple 5: Capture de sortie avec PIPE

import subprocess

print("--- Capture de sortie et erreurs avec PIPE ---")

# Exécuter une commande qui pourrait échouer et capturer ses sorties
commande_echec = ["ls", "/chemin/totalement/impossible"]
proc_capture_fail = subprocess.Popen(
   commande_echec,
   stdout=subprocess.PIPE,
   stderr=subprocess.PIPE,
   text=True # Pour obtenir des chaînes de caractères au lieu de bytes
)

# .communicate() attend la fin du processus et renvoie un tuple (stdout_data, stderr_data)
stdout_fail, stderr_fail = proc_capture_fail.communicate(timeout=10) # Avec un timeout optionnel
code_retour_fail = proc_capture_fail.returncode

print(f"Commande: {' '.join(commande_echec)}")
print(f"Code de retour: {code_retour_fail}")
if stdout_fail:
   print(f"Sortie standard:\n{stdout_fail.strip()}")
if stderr_fail:
   print(f"Erreur standard:\n{stderr_fail.strip()}")

# Exécuter une commande réussie et capturer sa sortie
commande_succes = ["echo", "Opération réussie par subprocess!"]
proc_capture_ok = subprocess.Popen(
   commande_succes,
   stdout=subprocess.PIPE,
   stderr=subprocess.PIPE,
   text=True
)
stdout_ok, stderr_ok = proc_capture_ok.communicate()
code_retour_ok = proc_capture_ok.returncode

print(f"\nCommande: {' '.join(commande_succes)}")
print(f"Code de retour: {code_retour_ok}")
if stdout_ok:
   print(f"Sortie standard:\n{stdout_ok.strip()}")
if stderr_ok:
   print(f"Erreur standard:\n{stderr_ok.strip()}")

print("--- Fin de la capture ---")

4.4. Fonctions d'aide de haut niveau

Le module subprocess propose également des fonctions de commodité qui encapsulent des cas d'utilisation courants de Popen.

subprocess.call()

Cette fonction exécute une commande, attend sa fin et renvoie son code de sortie. C'est un remplacement moderne pour os.system(), offrant plus d'options pour la configuration du processus.

import subprocess

print("\n--- Utilisation de subprocess.call() ---")
# Exécution d'une commande ping
# Sur Linux/macOS: ['ping', '-c', '2', 'localhost']
# Sur Windows: ['ping', 'localhost', '-n', '2']
code_ping = subprocess.call(["ping", "-c", "2", "localhost"])
print(f"Code de retour de 'ping': {code_ping}")

# Tentative d'exécution d'une commande inexistante
code_inconnu = subprocess.call("commande_non_existante", shell=True) # shell=True peut être utile pour des commandes simples
print(f"Code de retour d'une commande inconnue: {code_inconnu}")
print("--- Fin de subprocess.call() ---")

subprocess.check_call()

Similaire à call(), mais lève une exception CalledProcessError si la commande retourne un code de sortie non nul. Cela est utile pour les scripts qui doivent échouer de manière explicite si une étape critique échoue.

import subprocess

print("\n--- Utilisation de subprocess.check_call() ---")
try:
   subprocess.check_call(["ls", "-a", "/"]) # Commande qui devrait réussir
   print("La commande 'ls -a /' a réussi.")

   subprocess.check_call(["ls", "/chemin/qui/n_existe/pas"]) # Commande qui échouera
except subprocess.CalledProcessError as e:
   print(f"Erreur détectée par check_call: {e}")
print("--- Fin de subprocess.check_call() ---")

subprocess.check_output()

Cette fonction exécute la commande, vérifie son code de sortie (lève une CalledProcessError si non nul) et renvoie la sortie standard de la commande sous forme de bytes (ou de chaîne si text=True).

import subprocess

print("\n--- Utilisation de subprocess.check_output() ---")
try:
   # Récupérer le répertoire de travail actuel
   pwd_output = subprocess.check_output(["pwd"], text=True) # ou "cd" sur Windows
   print(f"Répertoire courant: {pwd_output.strip()}")

   # Tenter de récupérer la sortie d'une commande qui échoue
   failed_command_output = subprocess.check_output(
       ["find", "/non/existent/path"],
       text=True,
       stderr=subprocess.PIPE # Permet de capturer stderr en cas d'échec
   )
   print(f"Sortie de commande échouée: {failed_command_output}")
except subprocess.CalledProcessError as e:
   print(f"Erreur lors de la capture de sortie: {e}")
   print(f"Sortie standard d'erreur (si capturée): {e.stdout.strip() if e.stdout else 'N/A'}")
   print(f"Erreur standard d'erreur (si capturée): {e.stderr.strip() if e.stderr else 'N/A'}")
print("--- Fin de subprocess.check_output() ---")

subprocess.run() (Python 3.5+)

La fonction subprocess.run() est l'interface recommandée pour exécuter des processus externes dans les versions modernes de Python (3.5 et ultérieures). Elle encapsule la plupart des fonctionnalités des autres fonctions de haut niveau et renvoie un objet CompletedProcess.

import subprocess

print("\n--- Utilisation de subprocess.run() (Python 3.5+) ---")

# Exécuter une commande simple et capturer la sortie
resultat_succes = subprocess.run(
   ["echo", "Hello from subprocess.run!"],
   capture_output=True, # Équivalent à stdout=PIPE, stderr=PIPE
   text=True # Décode la sortie en string
)
print(f"Statut: {resultat_succes.returncode}, Sortie: {resultat_succes.stdout.strip()}")

# Exécuter une commande qui échoue et gérer l'exception
try:
   resultat_echec = subprocess.run(
       ["false"], # Une commande qui renvoie un code de sortie non-zéro
       capture_output=True,
       text=True,
       check=True # Lève une CalledProcessError si le code de retour est non-zéro
   )
   print(f"Statut: {resultat_echec.returncode}, Sortie: {resultat_echec.stdout.strip()}, Erreur: {resultat_echec.stderr.strip()}")
except subprocess.CalledProcessError as e:
   print(f"Commande 'false' a échoué comme prévu: {e}")
   print(f"Sortie: {e.stdout.strip()}, Erreur: {e.stderr.strip()}")

print("--- Fin de subprocess.run() ---")

Considérations importantes pour le module subprocess

• Arguments en liste vs. chaîne : Il est fortement recommandé de passer la commande et ses arguments sous forme de liste (par exemple, ["ls", "-l"]) plutôt qu'une chaîne unique, car cela évite le besoin d'un shell intermédiaire et gère mieux les espaces ou caractères spéciaux dans les arguments.
• shell=True : Si vous devez exécuter une commande complexe nécessitant les fonctionnalités du shell (redirection, pipes, wildcards), utilisez shell=True. Soyez conscient des risques de sécurité potentiels si la commande inclut des entrées non fiables, car cela peut entraîner des injections de commandes.
• Prévention des interblocages : Lorsque vous utilisez subprocess.PIPE avec Popen, utilisez toujours .communicate() pour échanger des données et attendre la fin du processus, car la lecture directe des flux (stdout.read()) peut provoquer des interblocages si les tampons se remplissent et que le programme parent ne les vide pas.
• capture_output=True : Pour subprocess.run() (Python 3.7+), préférez capture_output=True plutôt que stdout=subprocess.PIPE, stderr=subprocess.PIPE pour une gestion sécurisée et pratique de la capture des sorties.

En résumé, le module subprocess est l'outil de référence en Python pour toute interaction avec des processus système, offrant une robustesse et une polyvalence indispensables pour la programmation moderne.