Echtzeit-Teilprozess.Popen, die über stdout und PIPE

Ich versuche zu greifen stdout aus einer subprocess.Popen Anruf und ich bin zwar erreichen dies problemlos tun:

cmd = subprocess.Popen('ls -l', shell=True, stdout=PIPE)
for line in cmd.stdout.readlines():
    print line

Ich würde gerne zu greifen stdout in "Echtzeit". Mit der oben beschriebenen Methode, ROHR, der darauf wartet, greifen Sie alle stdout - und dann kehrt er zurück.

Also für logging-Zwecke, diese nicht erfüllen meine Anforderungen (z.B. "sehen", was Los ist, während es geschieht).

Gibt es einen Weg, um Zeile für Zeile, stdout während Sie ausgeführt wird? Oder ist dies eine Einschränkung der subprocess(warten zu müssen, bis die PIPE schließt).

BEARBEITEN
Wenn ich wechseln readlines() für readline() bekomme ich nur die Letzte Zeile der stdout (nicht ideal):

In [75]: cmd = Popen('ls -l', shell=True, stdout=PIPE)
In [76]: for i in cmd.stdout.readline(): print i
....: 
t
o
t
a
l

1
0
4

InformationsquelleAutor der Frage alfredodeza | 2010-01-17

19

Ihre Dolmetscherin ist die Pufferung. Fügen Sie einen Aufruf sys.stdout.flush() nach Ihrer print-Anweisung.

InformationsquelleAutor der Antwort Jeff
12

Tatsächlich, die wirkliche Lösung ist die direkte Umleitung des stdout des Teilprozess des stdout des Prozesses.

In der Tat, mit deiner Lösung, Sie können nur drucken, stdout, nicht stderr, zum Beispiel, zur gleichen Zeit.
```
import sys
from subprocess import Popen
Popen("./slow_cmd_output.sh", stdout=sys.stdout, stderr=sys.stderr).communicate()
```
Den communicate() ist, so zu machen der Aufruf blockiert bis zum Ende des teilprozesses, sonst würde es direkt gehen, um die nächste Zeile und das Programm möglicherweise beenden, bevor Sie den Teilprozess (obwohl die Umleitung auf Ihre stdout wird immer noch funktionieren, selbst nachdem Sie Ihre python-Skript geschlossen hat, habe ich es getestet).

So, zum Beispiel, den Sie umleiten sowohl stdout und stderr, und in absoluter Echtzeit.

Beispielsweise in meinem Fall, die ich getestet habe mit diesem script slow_cmd_output.sh:
```
#!/bin/bash

for i in 1 2 3 4 5 6; do sleep 5 && echo "${i}th output" && echo "err output num ${i}" >&2; done
```
InformationsquelleAutor der Antwort Undo
11

Bekommen Ausgabe "in Echtzeit", subprocess ist ungeeignet, da Sie nicht besiegen kann der andere Prozess die Pufferung Strategien. Das ist der Grund, warum ich immer empfehlen, wenn eine solche "Echtzeit" - Ausgabe greifen gewünscht ist (ganz eine häufige Frage auf stack overflow!), stattdessen verwenden pexpect (überall, aber Windows -- Windows, wexpect).

InformationsquelleAutor der Antwort Alex Martelli
3

Drop die readlines() die Koaleszenz der Ausgabe.
Auch Sie müssen zur Durchsetzung der Linie der Pufferung da die meisten Befehle, da er intern Puffer Ausgabe in eine pipe. Für details siehe: http://www.pixelbeat.org/programming/stdio_buffering/

InformationsquelleAutor der Antwort pixelbeat
3

Als dies ist eine Frage, die ich suchte nach einer Antwort zu Tage, ich wollte das hier für diejenigen, die Folgen. Während es wahr ist, dass subprocess nicht bekämpfen, der andere Prozess ist die Pufferung Strategie, in dem Fall, wo Sie anrufen, eine andere Python-Skript mit subprocess.Popen KÖNNEN Sie sagen, dass es zu Beginn einer ungepufferten python.
```
command = ["python", "-u", "python_file.py"]
p = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

for line in iter(p.stdout.readline, ''):
    line = line.replace('\r', '').replace('\n', '')
    print line
    sys.stdout.flush()
```
Ich habe auch Fälle gesehen, wo die popen Argumente bufsize=1 und universal_newlines=True geholfen haben, mit der Enthüllung der versteckten stdout.

InformationsquelleAutor der Antwort ochawkeye

cmd = subprocess.Popen(["ls", "-l"], stdout=subprocess.PIPE)
for line in cmd.stdout:
    print line.rstrip("\n")

InformationsquelleAutor der Antwort

0

Den Aufruf readlines wartet auf den Prozess zu beenden. Ersetzen Sie diese mit einer Schleife um cmd.stdout.readline() (Hinweis im singular) und alles sollte gut sein.

InformationsquelleAutor der Antwort Jakob Borg

Wie bereits dargelegt, das Problem ist in der stdio-Bibliothek Pufferung der wie printf-Anweisungen, wenn kein Endgerät angeschlossen ist, um den Prozess. Es ist ein Weg, um dies auf der Windows-Plattform sowieso. Möglicherweise gibt es eine ähnliche Lösung auch auf anderen Plattformen.

Unter Windows können Sie erzwingen, erstellen Sie eine neue Konsole bei der prozesserstellung. Das gute ist, das kann verborgen bleiben, so dass Sie nie sehen (dies geschieht durch shell=True innerhalb der Teilprozess-Modul).

cmd = subprocess.Popen('ls -l', shell=True, stdout=PIPE, creationflags=_winapi.CREATE_NEW_CONSOLE, bufsize=1, universal_newlines=True)
for line in cmd.stdout.readlines():
    print line

oder

Eine etwas umfassendere Lösung ist, dass Sie explizit den Wert der STARTUPINFO-params die verhindert, dass die Einführung eines neuen und unnötigen cmd.exe shell-Prozess die shell=True haben.

class PopenBackground(subprocess.Popen):
    def __init__(self, *args, **kwargs):

        si = kwargs.get('startupinfo', subprocess.STARTUPINFO())
        si.dwFlags |= _winapi.STARTF_USESHOWWINDOW
        si.wShowWindow = _winapi.SW_HIDE

        kwargs['startupinfo'] = si
        kwargs['creationflags'] = kwargs.get('creationflags', 0) | _winapi.CREATE_NEW_CONSOLE
        kwargs['bufsize'] = 1
        kwargs['universal_newlines'] = True

        super(PopenBackground, self).__init__(*args, **kwargs)

process = PopenBackground(['ls', '-l'], stdout=subprocess.PIPE)
    for line in cmd.stdout.readlines():
        print line

InformationsquelleAutor der Antwort Chris

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.