Puoi creare un subprocesso python come output in subprocess come al solito, ma anche catturare l'output come una stringa?

Question

Possible Duplicate:
Wrap subprocess' stdout/stderr

In this question, hanan-n chiesto se era possibile avere un sottoprocesso pitone che emette a stdout pur mantenendo l'uscita in una stringa per successive elaborazioni. La soluzione in questo caso è stato quello di un ciclo su ogni linea di uscita e stampare manualmente:

output = [] 
p = subprocess.Popen(["the", "command"], stdout=subprocess.PIPE) 
for line in iter(p.stdout.readline, ''): 
    print(line) 
    output.append(line) 

Tuttavia, questa soluzione non fa generalizzare al caso in cui si vuole fare questo per entrambe stdout e stderr, soddisfacendo la seguente:

• l'output output/error dovrebbe andare al processo padre output/error rispettivamente
• l'uscita dovrebbe essere fatto in tempo reale il più possibile (ma ho solo bisogno di accedere alle corde a la fine)
• la o rder tra le righe stdout e stderr non dovrebbe essere modificato (non sono abbastanza sicuro di come funzionerebbe anche se il sottoprocesso cancella le sue cache stdout e stderr a intervalli diversi; Supponiamo per ora che otteniamo tutto in blocchi belle che contengono le linee complete?)

ho guardato attraverso il subprocess documentation, ma non ho trovato nulla che possa raggiungere questo obiettivo. Il più vicino che ho trovato è quello di aggiungere stderr=subprocess.stdout e utilizzare la stessa soluzione di cui sopra, ma poi perdiamo la distinzione tra output regolari ed errori. Qualche idea? Immagino che la soluzione, se ce ne sarà una, implicherà letture asincrone su p.stdout e p.stderr.

Ecco un esempio di quello che vorrei fare:

p = subprocess.Popen(["the", "command"]) 
p.wait() # while p runs, the command's stdout and stderr should behave as usual 
p_stdout = p.stdout.read() # unfortunately, this will return '' unless you use subprocess.PIPE 
p_stderr = p.stderr.read() # ditto 
[do something with p_stdout and p_stderr] 

Answer 1

Questo esempio sembra funzionare per me:

# -*- Mode: Python -*- 
# vi:si:et:sw=4:sts=4:ts=4 

import subprocess 
import sys 
import select 

p = subprocess.Popen(["find", "/proc"], 
    stdout=subprocess.PIPE, stderr=subprocess.PIPE) 

stdout = [] 
stderr = [] 

while True: 
    reads = [p.stdout.fileno(), p.stderr.fileno()] 
    ret = select.select(reads, [], []) 

    for fd in ret[0]: 
     if fd == p.stdout.fileno(): 
      read = p.stdout.readline() 
      sys.stdout.write('stdout: ' + read) 
      stdout.append(read) 
     if fd == p.stderr.fileno(): 
      read = p.stderr.readline() 
      sys.stderr.write('stderr: ' + read) 
      stderr.append(read) 

    if p.poll() != None: 
     break 

print 'program ended' 

print 'stdout:', "".join(stdout) 
print 'stderr:', "".join(stderr) 

In generale, tutte le situazioni in cui si desidera fare cose con più descrittori di file allo stesso tempo e si don Non so quale avrà delle cose da leggere, dovresti usare select o qualcosa di equivalente (come un reattore Twisted).

Answer 2

Creare due lettori di cui sopra, uno per uno per stdoutstderr e iniziare ciascuno in un nuovo thread. Ciò si aggiungerebbe alla lista approssimativamente nello stesso ordine in cui erano stati emessi dal processo. Mantenere due liste separate se lo si desidera.

cioè,

p = subprocess.Popen(["the", "command"]) 
t1 = thread.start_new_thread(func,stdout) # create a function with the readers 
t2 = thread.start_new_thread(func,stderr) 
p.wait() 
# your logic here 

Answer 3

per stampare su console e la cattura in una stringa di output/error di un sottoprocesso in maniera portatile:

from StringIO import StringIO 

fout, ferr = StringIO(), StringIO() 
exitcode = teed_call(["the", "command"], stdout=fout, stderr=ferr) 
stdout = fout.getvalue() 
stderr = ferr.getvalue() 

dove teed_call() è definito in Python subprocess get children's output to file and terminal?

È possibile utilizzare qualsiasi oggetto di file-like (Metodo .write()).