Python lit les sous-processus stdout et stderr séparément tout en préservant l'ordre

J'ai un python sous-processus que je suis en train de lire la sortie d'erreur et de flux. Actuellement, j'ai ça, mais je suis seulement en mesure de lire le stderr après que j'ai terminé la lecture de stdout. Voici à quoi il ressemble:

process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
stdout_iterator = iter(process.stdout.readline, b"")
stderr_iterator = iter(process.stderr.readline, b"")

for line in stdout_iterator:
    # Do stuff with line
    print line

for line in stderr_iterator:
    # Do stuff with line
    print line

Comme vous pouvez le voir, le stderr pour la boucle ne peut pas commencer jusqu'à ce que le stdout boucle est terminée. Comment puis-je modifier cela pour être en mesure de lire à la fois dans le bon ordre les lignes?

À préciser: j'ai encore besoin d'être capable de dire si une ligne est venu de stdout ou stderr parce qu'ils seront traités différemment dans mon code.

source d'informationauteur Luke Sapan

  1. 13

    Le code dans votre question peut impasse si le processus de l'enfant produit assez de sortie sur la sortie stderr (~100KO sur ma machine Linux).

    Il y a un communicate() méthode qui permet de lire à partir de deux stdout et stderr séparément:

    from subprocess import Popen, PIPE

process = Popen(command, stdout=PIPE, stderr=PIPE)
output, err = process.communicate()

    Si vous avez besoin de lire le flux de tout le processus de l'enfant est toujours en cours d'exécution, puis la solution portable est d'utiliser des threads (pas testé):

    from subprocess import Popen, PIPE
from threading import Thread
from Queue import Queue # Python 2

def reader(pipe, queue):
    try:
        with pipe:
            for line in iter(pipe.readline, b''):
                queue.put((pipe, line))
    finally:
        queue.put(None)

process = Popen(command, stdout=PIPE, stderr=PIPE, bufsize=1)
q = Queue()
Thread(target=reader, args=[process.stdout, q]).start()
Thread(target=reader, args=[process.stderr, q]).start()
for _ in range(2):
    for source, line in iter(q.get, None):
        print "%s: %s" % (source, line),

    Voir:

  2. 3

    L'ordre dans lequel un processus écrit des données dans les différents tuyaux est perdu après l'écriture.

    Il n'y a aucun moyen de savoir si la sortie standard (stdout) a été écrit avant la sortie stderr.

    Vous pouvez essayer de lire des données simultanément à partir de plusieurs descripteurs de fichiers de manière non-bloquante
    dès que les données sont disponibles, mais cela ne ferait que réduire la probabilité que la commande est incorrecte.

    Ce programme doit le démontrer:

    #!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import select
import subprocess
testapps={
'slow': '''
import os
import time
os.write(1, 'aaa')
time.sleep(0.01)
os.write(2, 'bbb')
time.sleep(0.01)
os.write(1, 'ccc')
''',
'fast': '''
import os
os.write(1, 'aaa')
os.write(2, 'bbb')
os.write(1, 'ccc')
''',
'fast2': '''
import os
os.write(1, 'aaa')
os.write(2, 'bbbbbbbbbbbbbbb')
os.write(1, 'ccc')
'''
}
def readfds(fds, maxread):
while True:
fdsin, _, _ = select.select(fds,[],[])
for fd in fdsin:
s = os.read(fd, maxread)
if len(s) == 0:
fds.remove(fd)
continue
yield fd, s
if fds == []:
break
def readfromapp(app, rounds=10, maxread=1024):
f=open('testapp.py', 'w')
f.write(testapps[app])
f.close()
results={}
for i in range(0, rounds):
p = subprocess.Popen(['python', 'testapp.py'], stdout=subprocess.PIPE
, stderr=subprocess.PIPE)
data=''
for (fd, s) in readfds([p.stdout.fileno(), p.stderr.fileno()], maxread):
data = data + s
results[data] = results[data] + 1 if data in results else 1
print 'running %i rounds %s with maxread=%i' % (rounds, app, maxread)
results = sorted(results.items(), key=lambda (k,v): k, reverse=False)
for data, count in results:
print '%03i x %s' % (count, data)
print
print "=> if output is produced slowly this should work as whished"
print "   and should return: aaabbbccc"
readfromapp('slow',  rounds=100, maxread=1024)
print
print "=> now mostly aaacccbbb is returnd, not as it should be"
readfromapp('fast',  rounds=100, maxread=1024)
print
print "=> you could try to read data one by one, and return"
print "   e.g. a whole line only when LF is read"
print "   (b's should be finished before c's)"
readfromapp('fast',  rounds=100, maxread=1)
print
print "=> but even this won't work ..."
readfromapp('fast2', rounds=100, maxread=1)

    et sorties à quelque chose comme ceci:

    => if output is produced slowly this should work as whished
and should return: aaabbbccc
running 100 rounds slow with maxread=1024
100 x aaabbbccc
=> now mostly aaacccbbb is returnd, not as it should be
running 100 rounds fast with maxread=1024
006 x aaabbbccc
094 x aaacccbbb
=> you could try to read data one by one, and return
e.g. a whole line only when LF is read
(b's should be finished before c's)
running 100 rounds fast with maxread=1
003 x aaabbbccc
003 x aababcbcc
094 x abababccc
=> but even this won't work ...
running 100 rounds fast2 with maxread=1
003 x aaabbbbbbbbbbbbbbbccc
001 x aaacbcbcbbbbbbbbbbbbb
008 x aababcbcbcbbbbbbbbbbb
088 x abababcbcbcbbbbbbbbbb
  3. 0

    J'ai écrit quelque chose à ce faire un il y a longtemps. Je n'ai pas encore porté sous Python 3, mais il ne devrait pas être trop difficile (plaques acceptées!)

    Si vous exécutez seul, vous verrez beaucoup de différentes options. Dans tous les cas, il permet de distinguer stdout de stderr.

  4. -2

    Selon python doc

    Popen.stdout
    Si la sortie standard (stdout) argument a été PIPE, cet attribut est un objet de fichier qui fournit la sortie de l'enfant du processus. Sinon, il n'en est pas.

    Popen.stderr
    Si le stderr argument a été PIPE, cet attribut est un objet de fichier qui fournit de l'erreur de sortie de l'enfant du processus. Sinon, il n'en est pas.

    Ci-dessous échantillon pouvez faire ce que vous voulez

    test.py

    print "I'm stdout"
raise Exception("I'm Error")

    printer.py

    import subprocess
p = subprocess.Popen(['python', 'test.py'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
print "Normal"
std_lines = p.stdout.readlines()
for line in std_lines:
print line.rstrip()
print "Error"
stderr_lines = p.stderr.readlines()
for line in stderr_lines:
print line.rstrip()

    De sortie:

    Normal
I'm stdout
Error
Traceback (most recent call last):
File "test.py", line 3, in <module>
raise Exception("I'm Error")
Exception: I'm Error