Odczytaj dane wejściowe przesyłania strumieniowego z subprocess.communicate ()

Używam Pythona subprocess.communicate()do odczytu standardowego wyjścia z procesu, który działa przez około minutę.

Jak mogę wydrukować każdą linię tego procesu stdoutw sposób strumieniowy, aby zobaczyć wynik w postaci, w jakiej jest generowany, ale nadal blokować zakończenie procesu przed kontynuowaniem?

subprocess.communicate() wydaje się dawać wszystkie wyniki naraz.

Uwaga, myślę, że metoda JF Sebastiana (poniżej) jest lepsza.

Oto prosty przykład (bez sprawdzania błędów):

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

Jeśli lszakończy się zbyt szybko, pętla while może zakończyć się przed odczytaniem wszystkich danych.

Możesz złapać resztę w stdout w ten sposób:

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

Aby uzyskać dane wyjściowe podprocesu wiersz po wierszu, gdy tylko podproces opróżni swój standardowy bufor:

#!/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()służy do odczytywania wierszy, gdy tylko zostaną napisane, w celu obejścia błędu odczytu z wyprzedzeniem w Pythonie 2 .

Jeśli standardowe wyjście podprocesu używa buforowania blokowego zamiast buforowania linii w trybie nieinteraktywnym (co prowadzi do opóźnienia w wyjściu do momentu pełnego lub opróżnienia bufora dziecka), można spróbować wymusić niebuforowane wyjście za pomocą pexpect, ptymoduły lub unbuffer, stdbuf, scriptnarzędzia , patrz P: Dlaczego nie wystarczy użyć rury (popen ())?

Oto kod w Pythonie 3:

#!/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='')

Uwaga: W przeciwieństwie do Pythona 2, który generuje bajty podprocesów bez zmian; Python 3 używa trybu tekstowego (wyjście cmd jest dekodowane przy użyciu locale.getpreferredencoding(False)kodowania).

Uważam, że najprostszym sposobem gromadzenia danych wyjściowych z procesu w sposób strumieniowy jest następujący:

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

Funkcja readline()lub read()powinna zwracać pusty ciąg tylko w EOF, po zakończeniu procesu - w przeciwnym razie będzie blokować, jeśli nie ma nic do odczytania ( readline()zawiera znak nowej linii, więc w pustych wierszach zwraca „\ n”). Pozwala to uniknąć niezręcznego końcowego communicate()wywołania po pętli.

W przypadku plików z bardzo długimi wierszami read()może być preferowane zmniejszenie maksymalnego wykorzystania pamięci - przekazywana liczba jest dowolna, ale wykluczenie jej powoduje odczytanie całego potoku na raz, co prawdopodobnie nie jest pożądane.

Jeśli chcesz mieć podejście nieblokujące, nie używaj process.communicate(). Jeśli ustawisz subprocess.Popen()argument stdoutna PIPE, możesz czytać process.stdouti sprawdzać, czy proces nadal działa przy użyciu process.poll().

Jeśli po prostu próbujesz przekazać dane wyjściowe w czasie rzeczywistym, trudno jest uzyskać prostsze niż to:

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'])

Zobacz dokumentację dla subprocess.check_call () .

Jeśli chcesz przetworzyć dane wyjściowe, z pewnością zapętl je. Ale jeśli nie, po prostu nie komplikuj.

Edycja: JF Sebastian zwraca uwagę zarówno na to, że wartości domyślne parametrów stdout i stderr są przekazywane do sys.stdout i sys.stderr, jak i że zakończy się niepowodzeniem, jeśli sys.stdout i sys.stderr zostaną zastąpione (powiedzmy, do przechwytywania danych wyjściowych w testy).

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'))

Dodanie kolejnego rozwiązania Python3 z kilkoma małymi zmianami:

1. Umożliwia przechwycenie kodu zakończenia procesu powłoki (nie udało mi się uzyskać kodu zakończenia podczas korzystania z withkonstrukcji)
2. Wyprowadza również stderr w czasie rzeczywistym

import subprocess
import sys
def subcall_stream(cmd, fail_on_error=True):
    # Run a shell command, streaming output to STDOUT in real time
    # Expects a list style command, e.g. `["docker", "pull", "ubuntu"]`
    p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, bufsize=1, universal_newlines=True)
    for line in p.stdout:
        sys.stdout.write(line)
    p.wait()
    exit_code = p.returncode
    if exit_code != 0 and fail_on_error:
        raise RuntimeError(f"Shell command failed with exit code {exit_code}. Command: `{cmd}`")
    return(exit_code)