Korzystanie z podprocesu.Popen dla procesu o dużej wydajności

wiele wyników jest subiektywnych, więc trochę trudno jest wydać rekomendację. Jeśli wielkość wyjścia jest naprawdę duża, prawdopodobnie nie chcesz przechwytywać wszystkiego jednym wywołaniem read (). Możesz spróbować zapisać wyjście do pliku, a następnie pobrać dane stopniowo w taki sposób:

f=file('data.out','w')
p = subprocess.Popen(cmd, shell=True, stdout=f, stderr=subprocess.PIPE)
errcode = p.wait()
f.close()
if errcode:
    errmess = p.stderr.read()
    log.error('cmd failed <%s>: %s' % (errcode,errmess))
for line in file('data.out'):
    #do something

Glenn Maynard ma rację w swoim komentarzu o impasach. Jednak najlepszym sposobem rozwiązania tego problemu jest utworzenie dwóch wątków, jednego dla stdout i jednego dla stderr, które odczytują odpowiednie strumienie do wyczerpania i robią wszystko, czego potrzebujesz z wyjściem.

Sugestia użycia plików tymczasowych może, ale nie musi, działać dla Ciebie w zależności od wielkości wyjścia itp. i czy trzeba przetworzyć wyjście podprocesu podczas jego generowania.

Jak Heikki Toivonen ma sugerowane, należy spojrzeć na metodę communicate. Jednakże, powoduje to buforowanie stdout/stderr podprocesu w pamięci i otrzymujemy te zwrócone z wywołania communicate - nie jest to idealne rozwiązanie dla niektórych scenariuszy. Ale warto przyjrzeć się źródłu metody komunikacji.

Inny przykład znajduje się w pakiecie, który utrzymuję, python-gnupg, gdzie plik wykonywalny gpg jest wywoływany przez subprocess, aby wykonać ciężkie operacje, a wrapper Pythona wywołuje wątki, aby odczytać stdout i stderr gpg oraz wykorzystaj je, ponieważ dane są wytwarzane przez gpg. Być może będziesz w stanie uzyskać kilka pomysłów, patrząc na źródło tam, jak również. Dane generowane przez gpg zarówno na stdout, jak i stderr mogą być dość duże, w ogólnym przypadku.

Odczyt stdout i stderr niezależnie z bardzo dużym wyjściem (tj. dużą ilością megabajtów) przy użyciu select:

import subprocess, select

proc = subprocess.Popen(cmd, bufsize=8192, shell=False, \
    stdout=subprocess.PIPE, stderr=subprocess.PIPE)

with open(outpath, "wb") as outf:
    dataend = False
    while (proc.returncode is None) or (not dataend):
        proc.poll()
        dataend = False

        ready = select.select([proc.stdout, proc.stderr], [], [], 1.0)

        if proc.stderr in ready[0]:
            data = proc.stderr.read(1024)
            if len(data) > 0:
                handle_stderr_data(data)

        if proc.stdout in ready[0]:
            data = proc.stdout.read(1024)
            if len(data) == 0: # Read of zero bytes means EOF
                dataend = True
            else:
                outf.write(data)

Możesz spróbować się porozumieć i zobaczyć, czy to rozwiąże twój problem. Jeśli nie, przekierowałbym wyjście do pliku tymczasowego.

Miałem ten sam problem. Jeśli musisz obsługiwać duże wyjście, inną dobrą opcją może być użycie pliku dla stdout i stderr i przekazanie tych plików według parametru.

Sprawdź moduł tempfile w Pythonie: https://docs.python.org/2/library/tempfile.html .

Coś takiego może zadziałać

out = tempfile.NamedTemporaryFile(delete=False)

Wtedy zrobiłbyś:

Popen(... stdout=out,...)

Następnie możesz odczytać plik i usunąć go później.

Oto proste podejście, które rejestruje zarówno zwykłe wyjście, jak i wyjście błędów, wszystkie w Pythonie, więc ograniczenia w stdout nie mają zastosowania:

com_str = 'uname -a'
command = subprocess.Popen([com_str], stdout=subprocess.PIPE, shell=True)
(output, error) = command.communicate()
print output

Linux 3.11.0-20-generic SMP Fri May 2 21:32:55 UTC 2014 

I

com_str = 'id'
command = subprocess.Popen([com_str], stdout=subprocess.PIPE, shell=True)
(output, error) = command.communicate()
print output

uid=1000(myname) gid=1000(mygrp) groups=1000(cell),0(root)