Lesen Sie die Streaming-Eingabe von subprocess.communicate ()

Ich verwende Pythons subprocess.communicate(), um stdout aus einem Prozess zu lesen, der ungefähr eine Minute lang ausgeführt wird.

Wie kann ich jede Zeile dieses Prozesses stdoutin Streaming- Form ausdrucken , damit ich die Ausgabe so sehen kann, wie sie generiert wurde, aber trotzdem den Prozess blockieren kann, bevor ich fortfahre?

subprocess.communicate() scheint alle Ausgaben auf einmal zu geben.

Bitte beachten Sie, dass ich die Methode von JF Sebastian (unten) für besser halte .

Hier ist ein einfaches Beispiel (ohne Überprüfung auf Fehler):

import subprocess
proc = subprocess.Popen('ls',
                       shell=True,
                       stdout=subprocess.PIPE,
                       )
while proc.poll() is None:
    output = proc.stdout.readline()
    print output,

Wenn es lszu schnell endet, endet die while-Schleife möglicherweise, bevor Sie alle Daten gelesen haben.

Sie können den Rest in stdout folgendermaßen abfangen:

output = proc.communicate()[0]
print output,

So erhalten Sie die Ausgabe des Unterprozesses zeilenweise, sobald der Unterprozess seinen Standardpuffer geleert hat:

#!/usr/bin/env python2
from subprocess import Popen, PIPE

p = Popen(["cmd", "arg1"], stdout=PIPE, bufsize=1)
with p.stdout:
    for line in iter(p.stdout.readline, b''):
        print line,
p.wait() # wait for the subprocess to exit

iter()wird verwendet, um Zeilen zu lesen, sobald sie geschrieben wurden, um den Read-Ahead-Fehler in Python 2 zu umgehen .

Wenn stdout des Unterprozesses im nicht interaktiven Modus eine Blockpufferung anstelle einer Zeilenpufferung verwendet (was zu einer Verzögerung der Ausgabe führt, bis der Puffer des Kindes voll ist oder vom Kind explizit geleert wird), können Sie versuchen, eine ungepufferte Ausgabe mit zu erzwingen pexpect, ptyModule oder unbuffer, stdbuf, scriptDienstprogramme , siehe F: Warum nicht einfach ein Rohr verwenden (popen ())?

Hier ist Python 3-Code:

#!/usr/bin/env python3
from subprocess import Popen, PIPE

with Popen(["cmd", "arg1"], stdout=PIPE, bufsize=1,
           universal_newlines=True) as p:
    for line in p.stdout:
        print(line, end='')

Hinweis: Im Gegensatz zu Python 2, das die Bytestrings des Unterprozesses unverändert ausgibt. Python 3 verwendet den Textmodus (die Ausgabe von cmd wird mithilfe der locale.getpreferredencoding(False)Codierung dekodiert ).

Ich glaube, der einfachste Weg, die Ausgabe eines Prozesses auf Streaming-Weise zu sammeln, ist folgender:

import sys
from subprocess import *
proc = Popen('ls', shell=True, stdout=PIPE)
while True:
    data = proc.stdout.readline()   # Alternatively proc.stdout.read(1024)
    if len(data) == 0:
        break
    sys.stdout.write(data)   # sys.stdout.buffer.write(data) on Python 3.x

Die Funktion readline()oder read()sollte nur eine leere Zeichenfolge in EOF zurückgeben, nachdem der Prozess beendet wurde. Andernfalls wird sie blockiert, wenn nichts zu lesen ist ( readline()einschließlich der neuen Zeile. Bei leeren Zeilen wird "\ n" zurückgegeben). Dies vermeidet die Notwendigkeit eines umständlichen letzten communicate()Aufrufs nach der Schleife.

Bei Dateien mit sehr langen Zeilen ist es read()möglicherweise vorzuziehen, die maximale Speichernutzung zu reduzieren. Die an sie übergebene Anzahl ist willkürlich. Wenn Sie sie jedoch ausschließen, wird die gesamte Pipe-Ausgabe auf einmal gelesen, was wahrscheinlich nicht wünschenswert ist.

Wenn Sie einen nicht blockierenden Ansatz wünschen, verwenden Sie ihn nicht process.communicate(). Wenn Sie das subprocess.Popen()Argument stdoutauf setzen PIPE, können Sie aus lesen process.stdoutund prüfen, ob der Prozess noch mit ausgeführt wird process.poll().

Wenn Sie einfach versuchen, die Ausgabe in Echtzeit weiterzuleiten, ist es schwierig, einfacher zu werden:

import subprocess

# This will raise a CalledProcessError if the program return a nonzero code.
# You can use call() instead if you don't care about that case.
subprocess.check_call(['ls', '-l'])

Siehe die Dokumente für subprocess.check_call () .

Wenn Sie die Ausgabe verarbeiten müssen, führen Sie eine Schleife durch. Aber wenn Sie dies nicht tun, halten Sie es einfach.

Bearbeiten: JF Sebastian weist darauf hin, dass die Standardeinstellungen für die Parameter stdout und stderr an sys.stdout und sys.stderr übergeben werden und dass dies fehlschlägt, wenn sys.stdout und sys.stderr ersetzt wurden (z. B. zum Erfassen der Ausgabe in) Tests).

myCommand="ls -l"
cmd=myCommand.split()
# "universal newline support" This will cause to interpret \n, \r\n and \r     equally, each as a newline.
p = subprocess.Popen(cmd, stderr=subprocess.PIPE, universal_newlines=True)
while True:    
    print(p.stderr.readline().rstrip('\r\n'))