Python Language
Bibliothèque de sous-processus

Syntaxe

• subprocess.call (args, *, stdin = Aucun, stdout = Aucun, stderr = Aucun, shell = False, timeout = Aucun)
• subprocess.Popen (args, bufsize = -1, exécutable = Aucun, stdin = Aucun, stdout = Aucun, stderr = Aucun, preexec_fn = Aucun, close_fds = True, shell = False, cwd = Aucun, env = Aucun, universal_newlines = False , startupinfo = Aucun, creationflags = 0, restore_signals = True, start_new_session = False, pass_fds = ())

Paramètres

Appeler des commandes externes

Le cas d'utilisation le plus simple consiste à utiliser la fonction subprocess.call . Il accepte une liste comme premier argument. Le premier élément de la liste doit être l'application externe que vous souhaitez appeler. Les autres éléments de la liste sont des arguments qui seront transmis à cette application.

subprocess.call([r'C:\path\to\app.exe', 'arg1', '--flag', 'arg'])

Pour les commandes shell, définissez shell=True et fournissez la commande sous forme de chaîne au lieu d'une liste.

subprocess.call('echo "Hello, world"', shell=True)

Notez que les deux commandes ci-dessus ne renvoient que le exit status de exit status du sous-processus. De plus, faites attention lorsque vous utilisez shell=True car il fournit des problèmes de sécurité (voir ici ).

Si vous voulez pouvoir obtenir la sortie standard du sous-processus, remplacez le subprocess.call par subprocess.check_output . Pour une utilisation plus avancée, reportez-vous à ceci .

Plus de souplesse avec Popen

Utiliser subprocess.Popen donne un contrôle plus fin sur les processus lancés que subprocess.call .

Lancer un sous-processus

process = subprocess.Popen([r'C:\path\to\app.exe', 'arg1', '--flag', 'arg'])

La signature pour Popen est très similaire à la fonction d' call ; Cependant, Popen reviendra immédiatement au lieu d'attendre que le sous-processus se termine comme l' call fait.

En attente d'un sous-processus pour terminer

process = subprocess.Popen([r'C:\path\to\app.exe', 'arg1', '--flag', 'arg'])
process.wait()

Lecture de la sortie d'un sous-processus

process = subprocess.Popen([r'C:\path\to\app.exe'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)

# This will block until process completes
stdout, stderr = process.communicate()
print stdout
print stderr

Accès interactif aux sous-processus en cours d'exécution

Vous pouvez lire et écrire sur stdin et stdout même si le sous-processus n'est pas terminé. Cela pourrait être utile lors de l'automatisation des fonctionnalités dans un autre programme.

Ecrire dans un sous-processus

process = subprocess.Popen([r'C:\path\to\app.exe'], stdout = subprocess.PIPE, stdin = subprocess.PIPE)


process.stdin.write('line of input\n') # Write input

line  = process.stdout.readline() # Read a line from stdout

# Do logic on line read.

Cependant, si vous n'avez besoin que d'un seul ensemble d'entrées et de sorties, plutôt que d'une interaction dynamique, vous devez utiliser communicate() plutôt que d'accéder directement à stdin et stdout .

Lecture d'un flux d'un sous-processus

Si vous souhaitez voir la sortie d'un sous-processus ligne par ligne, vous pouvez utiliser l'extrait suivant:

process = subprocess.Popen(<your_command>, stdout=subprocess.PIPE)
while process.poll() is None:
    output_line = process.stdout.readline()

Dans le cas où la sortie de la sous-commande n'a pas de caractère EOL, l'extrait ci-dessus ne fonctionne pas. Vous pouvez ensuite lire le caractère de sortie par caractère comme suit:

process = subprocess.Popen(<your_command>, stdout=subprocess.PIPE)
while process.poll() is None:
    output_line = process.stdout.read(1)

Le 1 spécifié comme argument à la read méthode demande de lecture pour lire une nature à la fois. Vous pouvez spécifier de lire autant de caractères que vous voulez en utilisant un numéro différent. Le nombre négatif ou 0 indique de read pour lire en tant que chaîne unique jusqu'à ce que l'EOF soit rencontré ( voir ici ).

Dans les deux extraits ci-dessus, process.poll() est None jusqu'à la fin du sous-processus. Ceci est utilisé pour quitter la boucle une fois qu'il n'y a plus de sortie à lire.

La même procédure pourrait être appliquée au stderr du sous-processus.

Comment créer l'argument de la liste de commandes

La méthode de sous-processus qui permet d'exécuter des commandes nécessite la commande sous la forme d'une liste (au moins en utilisant shell_mode=True ).

Les règles pour créer la liste ne sont pas toujours simples à suivre, en particulier avec les commandes complexes. Heureusement, il existe un outil très utile qui permet de le faire: shlex . La manière la plus simple de créer la liste à utiliser comme commande est la suivante:

import shlex
cmd_to_subprocess = shlex.split(command_used_in_the_shell)

Un exemple simple:

import shlex
shlex.split('ls --color -l -t -r')

out: ['ls', '--color', '-l', '-t', '-r']