L'obtention de la sortie en temps réel à l'aide de sous-processus

J'ai essayé cela, et pour quelque raison que ce soit, le code

for line in p.stdout:
  ...

tampons de manière agressive, la variante

while True:
  line = p.stdout.readline()
  if not line: break
  ...

ne le fait pas. Apparemment c'est un bug connu: http://bugs.python.org/issue3907 (La question est maintenant de "Fermé" à compter du 29 Août, 2018)

Vous pouvez essayer ceci:

import subprocess
import sys

process = subprocess.Popen(
    cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
)

while True:
    out = process.stdout.read(1)
    if out == '' and process.poll() != None:
        break
    if out != '':
        sys.stdout.write(out)
        sys.stdout.flush()

Si vous utiliser readline au lieu de lire, il y aura des cas où le message n'est pas imprimé. Essayez avec une commande requiert une ligne d'entrée et de voir par vous-même.

La Streaming sous-processus stdin et stdout avec asyncio en Python blog par Kevin McCarthy montre comment le faire avec asyncio:

import asyncio
from asyncio.subprocess import PIPE
from asyncio import create_subprocess_exec


async def _read_stream(stream, callback):
    while True:
        line = await stream.readline()
        if line:
            callback(line)
        else:
            break


async def run(command):
    process = await create_subprocess_exec(
        *command, stdout=PIPE, stderr=PIPE
    )

    await asyncio.wait(
        [
            _read_stream(
                process.stdout,
                lambda x: print(
                    "STDOUT: {}".format(x.decode("UTF8"))
                ),
            ),
            _read_stream(
                process.stderr,
                lambda x: print(
                    "STDERR: {}".format(x.decode("UTF8"))
                ),
            ),
        ]
    )

    await process.wait()


async def main():
    await run("docker build -t my-docker-image:latest .")


if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())

Temps réel de Sortie résolution du Problème:
Je n'ai rencontré de problème similaire en Python, lors de la capture en temps réel de la sortie d'un programme c. J'ai ajouté "fflush(stdout);" dans mon code C. Il a travaillé pour moi. Voici la capture du code

<< C >>

#include <stdio.h>
void main()
{
    int count = 1;
    while (1)
    {
        printf(" Count  %d\n", count++);
        fflush(stdout);
        sleep(1);
    }
}

<< Programme en Python >>

#!/usr/bin/python

import os, sys
import subprocess


procExe = subprocess.Popen(".//count", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)

while procExe.poll() is None:
    line = procExe.stdout.readline()
    print("Print:" + line)

<< PRODUIT>>
D'Impression: Nombre 1
Impression: Comptez 2
Impression: Compter 3

Espère que cela aide.

~sairam

J'ai utilisé cette solution pour obtenir la sortie en temps réel sur un sous-processus. Cette boucle s'arrêtera dès que le processus se termine en laissant un besoin pour une instruction break ou possible de boucle infinie.

sub_process = subprocess.Popen(my_command, close_fds=True, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

while sub_process.poll() is None:
    out = sub_process.stdout.read(1)
    sys.stdout.write(out)
    sys.stdout.flush()

À l'aide de pexpect [ http://www.noah.org/wiki/Pexpect ] avec les non-bloquant readlines pour résoudre ce problème. Elle vient du fait que les tuyaux sont mises en mémoire tampon, et ainsi, votre application est de sortie est prise en tamponnée par le tuyau, donc vous ne pouvez pas obtenir à la sortie jusqu'à ce que le tampon se remplit ou le processus meurt.

En Python 3.x le processus peut se bloquer parce que la sortie est un tableau d'octets au lieu d'une chaîne. Assurez-vous de le décoder dans une chaîne.

À partir de Python 3.6 vous pouvez le faire en utilisant le paramètre encoding dans Popen Constructeur. L'exemple complet:

process = subprocess.Popen(
    'my_command',
    stdout=subprocess.PIPE,
    stderr=subprocess.STDOUT,
    shell=True,
    encoding='utf-8',
    errors='replace'
)

while True:
    realtime_output = process.stdout.readline()

    if realtime_output == '' and process.poll() is not None:
        break

    if realtime_output:
        print(realtime_output.strip(), flush=True)

Notez que ce code les redirections stderr à stdout et gère les erreurs de sortie.

C'est le squelette de base que j'utilise toujours pour cela. Il le rend facile à mettre en œuvre des délais d'attente et est en mesure de traiter avec, inévitablement, la pendaison de processus.

import subprocess
import threading
import Queue

def t_read_stdout(process, queue):
    """Read from stdout"""

    for output in iter(process.stdout.readline, b''):
        queue.put(output)

    return

process = subprocess.Popen(['dir'],
                           stdout=subprocess.PIPE,
                           stderr=subprocess.STDOUT,
                           bufsize=1,
                           cwd='C:\\',
                           shell=True)

queue = Queue.Queue()
t_stdout = threading.Thread(target=t_read_stdout, args=(process, queue))
t_stdout.daemon = True
t_stdout.start()

while process.poll() is None or not queue.empty():
    try:
        output = queue.get(timeout=.5)

    except Queue.Empty:
        continue

    if not output:
        continue

    print(output),

t_stdout.join()