subprocess – lancer des processus externes avec Python

Subprocess est un module Python intégré qui peut être utilisé pour créer de nouveaux processus et interagir avec leurs flux de données d’entrée et de sortie.

Le module de subprocess est pratique lorsque nous voulons exécuter et contrôler d’autres programmes que nous pouvons également exécuter avec la ligne de commande. Cela nous permet d’intégrer des programmes externes dans du code Python.

En fait, vous pouvez utiliser le module subprocess pour exécuter des commandes shell et exécuter des binaires exécutables.

Chaque système d’exploitation essai de répartir équitablement les processus, tout en restant performant. Donc, il faut garder une trace de tous les processus en cours, en donnant à chacun un peu de temps pour s’exécuter, avant de passer au suivant.

Le module subprocess est utilisé pour exécuter de nouveaux programmes en créant un nouveau processus qui aide à obtenir des canaux d’entrée ou de sortie ou d’erreur, ainsi que le code de sortie de diverses commandes.

Un sous-processus s’exécute en même temps que le processus d’origine. Autrement dit, le processus qui a créé le sous-processus peut continuer à travailler sur d’autres choses pendant que le sous-processus effectue son propre travail en arrière plan.

Vous allez dire, pourquoi ne pas utiliser le module os. os.system() peut nous aider à exécuter les commandes shell du programme python, mais le problème est que nous ne pouvons pas récupérer la sortie de la commande exécutée dans notre programme python.

subprocess.run

La fonction run n’a été ajoutée au module de subprocess que dans les versions récentes de Python (3.5). C’est la méthode recommandée pour générer des processus et devrait couvrir les cas d’utilisation les plus courants. Avant tout, voyons son utilisation la plus simple. Supposons que nous voulions exécuter la commande linux ls -al dans un shell Python.

import subprocess
process = subprocess.run(['ls', '-l', '-a'])

total 56
drwxrwxr-x  4 henke henke  4096 mars  21 21:24 .
drwxr-xr-x 54 henke henke 16384 mars  21 19:59 ..
-rw-r--r--  1 henke henke  8192 mars  15 21:49 database.db
-rw-rw-r--  1 henke henke    38 mars  21 19:59 data.txt
[...]

Nous allons afficher le contenu d’un fichier «data.txt», en supposant qu’il contient la phrase « Je suis le contenu du fichier data.txt ».

import subprocess
subprocess.run(["cat", "data.txt"])

L’exécution du code.

Je suis le contenu du fichier data.txt

La méthode call()

Cette fonction est utilisée pour exécuter une commande du shell ou du terminal à partir d’un code Python .

import subprocess
subprocess.call('ls',shell=True)

Lorsque nous définissons le shell sur True, la fonction traite cela comme une commande et l’exécute. En fait, ls est une commande qui répertorie tous les fichiers et les dossiers du répertoire actuel.

import subprocess
print(subprocess.call(["pwd", "-P"]))

L’exécution du code retourne le répertoire de travail actuel.

/home/henke

Le premier élément des arguments est le programme que nous voulons appeler. Tout le reste sont des arguments que nous voulons transmettre au programme.

Notez que dans les systèmes basés sur POSIX, un code qui retourne 0 indique un code sans erreur et de 1 à 255 est pour tout le reste. Ces codes de sortie sont interprétés par des scripts machine pour évaluer les événements de réussite et d’échec.

Vous pouvez également exécuter le programme précédent dans le shell du système d’exploitation. Cela ajoute un niveau d’abstraction au processus et soulève la possibilité de problèmes de sécurité. Voici l’avertissement officiel de la documentation Python à ce sujet :
« L’exécution de commandes shell qui intègrent une entrée non analysée à partir d’une source non approuvée rend un programme vulnérable ». Pour cette raison, l’utilisation de shell = True est fortement déconseillée dans les cas où la commande vient d’une entrée externe.

Par conséquent, il est recommandé de ne pas l’utiliser si un processus ou une personne externe peut modifier les arguments. Si vous codez vous-même quelque chose en dur, cela n’a pas autant d’importance.

check_call ()

Cette fonction fonctionne comme call(), mais s’il y avait une erreur lors de l’exécution de la commande spécifiée, elle lève une CalledProcessErrorexception.

import subprocess
print(subprocess.check_call("false"))

L’exécution du code avec false retournera une erreur.

raise CalledProcessError(retcode, cmd)
subprocess.CalledProcessError: Command 'false' returned non-zero exit status 1.

check_output ()

Lorsque nous utilisons la méthode call() pour exécuter une commande, la sortie est liée au processus parent et n’est pas récupérable pour le programme appelant. Nous pouvons utiliser la fonction check_output() pour capturer la sortie pour une utilisation ultérieure.

import subprocess
output = subprocess.check_output('ls')
print("Output is {} bytes long.".format(len(output)))

L’exécution du code.

Output is 1420 bytes long.

communicate()

La fonction communicate() lit l’entrée et la sortie du processus lui-même. stdout est la sortie du processus et stderr est renseignée en cas d’erreur.

import subprocess
process = subprocess.Popen(
    ['cat', 'hello.py'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
stdout, stderr = process.communicate()
print(stdout)

Notez que nous avons un script hello.py qui contient le code print("Hello").