Python Language
Subprozess-Bibliothek

Syntax

• subprocess.call (args, *, stdin = keine, stdout = keine, stderr = keine, shell = False, timeout = keine)
• subprozess.Popen (args, bufsize = -1, ausführbare Datei = keine, stdin = keine, stdout = keine, stderr = keine, preexec_fn = keine, close_fds = true, shell = false, cwd = none, keine; , startupinfo = Keine, creationflags = 0, restore_signals = True, start_new_session = False, pass_fds = ())

Parameter

Externe Befehle aufrufen

Der einfachste Anwendungsfall ist die Verwendung der Funktion subprocess.call . Es akzeptiert eine Liste als erstes Argument. Das erste Element in der Liste sollte die externe Anwendung sein, die Sie anrufen möchten. Die anderen Elemente in der Liste sind Argumente, die an diese Anwendung übergeben werden.

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

Setzen Sie für shell=True und geben Sie den Befehl als String anstelle einer Liste an.

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

Beachten Sie, dass die beiden obigen Befehle nur den exit status des Unterprozesses zurückgeben. Beachten Sie außerdem bei der Verwendung von shell=True da dies Sicherheitsprobleme verursacht (siehe hier ).

Wenn Sie die Standardausgabe des Subprozesses abrufen möchten, ersetzen Sie subprocess.call durch subprocess.check_output . Weitere Informationen finden Sie hier .

Mehr Flexibilität mit Popen

Mit subprocess.Popen können Sie gestartete Prozesse genauer steuern als subprocess.call .

Subprozess starten

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

Die Signatur für Popen ist sehr ähnlich wie die call Popen kehrt jedoch sofort zurück, anstatt auf den Abschluss des Unterprozesses zu warten, wie dies bei einem call Fall ist.

Warten auf den Abschluss eines Unterprozesses

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

Ausgabe aus einem Unterprozess lesen

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

Interaktiver Zugriff auf laufende Unterprozesse

Sie können stdin und stdout auch dann lesen und schreiben, wenn der Unterprozess noch nicht abgeschlossen ist. Dies kann nützlich sein, wenn Sie die Funktionalität in einem anderen Programm automatisieren.

In einen Teilprozess schreiben

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.

Wenn Sie jedoch nur einen Satz von Eingaben und Ausgaben benötigen, anstatt dynamischer Interaktion, sollten Sie communicate() anstatt direkt auf stdin und stdout zuzugreifen.

Einen Stream aus einem Unterprozess lesen

Wenn Sie die Ausgabe eines Unterprozesses zeilenweise anzeigen möchten, können Sie den folgenden Ausschnitt verwenden:

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

Falls die Unterbefehlsausgabe kein EOL-Zeichen hat, funktioniert das obige Snippet nicht. Sie können die Ausgabe zeichenweise wie folgt lesen:

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

Die als Argument für die read angegebene 1 teilt dem Lesevorgang mit, 1 Zeichen zu lesen. Sie können festlegen, dass beliebig viele Zeichen mit einer anderen Nummer gelesen werden. Eine negative Zahl oder 0 gibt an, dass read bis eine EOF gefunden wird ( siehe hier ).

In beiden der obigen Ausschnitte ist process.poll() None bis der Unterprozess abgeschlossen ist. Dies wird verwendet, um die Schleife zu beenden, wenn keine weitere Ausgabe mehr zum Lesen vorhanden ist.

Dasselbe Verfahren könnte auf den stderr des Unterprozesses angewendet werden.

So erstellen Sie das Befehlslistenargument

Die Unterprozessmethode, die das Ausführen von Befehlen zulässt, erfordert den Befehl in Form einer Liste (zumindest mit shell_mode=True ).

Die Regeln zum Erstellen der Liste sind nicht immer einfach zu befolgen, insbesondere bei komplexen Befehlen. Glücklicherweise gibt es ein sehr hilfreiches Werkzeug, das dies ermöglicht: shlex . Die einfachste Methode zum Erstellen der Liste, die als Befehl verwendet werden soll, ist die folgende:

import shlex
cmd_to_subprocess = shlex.split(command_used_in_the_shell)

Ein einfaches Beispiel:

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

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