In liên tục đầu ra Sub process trong khi process đang chạy

Để khởi chạy các chương trình từ tập lệnh Python của tôi, tôi đang sử dụng phương pháp sau:

def execute(command):
    process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    output = process.communicate()[0]
    exitCode = process.returncode

    if (exitCode == 0):
        return output
    else:
        raise ProcessException(command, exitCode, output)

Vì vậy, khi tôi khởi chạy một quá trình như Process.execute("mvn clean install") , chương trình của tôi sẽ đợi cho đến khi quá trình kết thúc và chỉ sau đó tôi mới nhận được đầu ra hoàn chỉnh của chương trình. Điều này thật khó chịu nếu tôi đang chạy một quá trình mất một lúc để hoàn thành.

Tôi có thể để chương trình của mình viết dòng đầu ra của quy trình theo từng dòng không, bằng cách bỏ phiếu đầu ra quy trình trước khi nó kết thúc trong một vòng lặp hoặc một cái gì đó?

** [EDIT] Xin lỗi tôi đã không tìm kiếm rất tốt trước khi đăng câu hỏi này. Threading thực sự là chìa khóa. Tìm thấy một ví dụ ở đây chỉ ra cách thực hiện: ** Python Sub Process.Popen từ một luồng

Bạn có thể sử dụng iter để xử lý các dòng ngay khi lệnh xuất chúng : lines = iter(fd.readline, ""). Dưới đây là một ví dụ đầy đủ cho thấy trường hợp sử dụng điển hình (cảm ơn @jfs đã giúp đỡ):

from __future__ import print_function # Only Python 2.x
import subprocess

def execute(cmd):
    popen = subprocess.Popen(cmd, stdout=subprocess.PIPE, universal_newlines=True)
    for stdout_line in iter(popen.stdout.readline, ""):
        yield stdout_line 
    popen.stdout.close()
    return_code = popen.wait()
    if return_code:
        raise subprocess.CalledProcessError(return_code, cmd)

# Example
for path in execute(["locate", "a"]):
    print(path, end="")

Ok tôi quản lý để giải quyết nó mà không có chủ đề (bất kỳ đề xuất nào tại sao sử dụng chủ đề sẽ được đánh giá cao hơn) bằng cách sử dụng một đoạn trích từ câu hỏi này Chặn stdout của một quy trình con trong khi nó đang chạy

def execute(command):
    process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

    # Poll process for new output until finished
    while True:
        nextline = process.stdout.readline()
        if nextline == '' and process.poll() is not None:
            break
        sys.stdout.write(nextline)
        sys.stdout.flush()

    output = process.communicate()[0]
    exitCode = process.returncode

    if (exitCode == 0):
        return output
    else:
        raise ProcessException(command, exitCode, output)

Để in từng dòng đầu ra của quy trình con ngay khi bộ đệm xuất chuẩn của nó được xóa trong Python 3:

from subprocess import Popen, PIPE, CalledProcessError

with Popen(cmd, stdout=PIPE, bufsize=1, universal_newlines=True) as p:
    for line in p.stdout:
        print(line, end='') # process line here

if p.returncode != 0:
    raise CalledProcessError(p.returncode, p.args)

Lưu ý: bạn không cần p.poll()- vòng lặp kết thúc khi đạt đến eof. Và bạn không cần iter(p.stdout.readline, '')- lỗi đọc trước được sửa trong Python 3.

Xem thêm, Python: đọc đầu vào truyền phát từ sub process.c truyền thông () .

Thực sự có một cách thực sự đơn giản để làm điều này khi bạn chỉ muốn in đầu ra:

import subprocess
import sys

def execute(command):
    subprocess.check_call(command, stdout=sys.stdout, stderr=subprocess.STDOUT)

Ở đây chúng tôi chỉ đơn giản là trỏ quy trình con vào thiết bị xuất chuẩn của riêng mình và sử dụng api thành công hoặc ngoại lệ hiện có.

@tokland

đã thử mã của bạn và sửa nó cho 3,4 và windows dir.cmd là một lệnh dir đơn giản, được lưu dưới dạng tệp cmd

import subprocess
c = "dir.cmd"

def execute(command):
    popen = subprocess.Popen(command, stdout=subprocess.PIPE,bufsize=1)
    lines_iterator = iter(popen.stdout.readline, b"")
    while popen.poll() is None:
        for line in lines_iterator:
            nline = line.rstrip()
            print(nline.decode("latin"), end = "\r\n",flush =True) # yield line

execute(c)

Trong trường hợp ai đó muốn đọc từ cả hai stdoutvà stderrcùng lúc sử dụng các chủ đề, đây là những gì tôi nghĩ ra:

import threading
import subprocess
import Queue

class AsyncLineReader(threading.Thread):
    def __init__(self, fd, outputQueue):
        threading.Thread.__init__(self)

        assert isinstance(outputQueue, Queue.Queue)
        assert callable(fd.readline)

        self.fd = fd
        self.outputQueue = outputQueue

    def run(self):
        map(self.outputQueue.put, iter(self.fd.readline, ''))

    def eof(self):
        return not self.is_alive() and self.outputQueue.empty()

    @classmethod
    def getForFd(cls, fd, start=True):
        queue = Queue.Queue()
        reader = cls(fd, queue)

        if start:
            reader.start()

        return reader, queue


process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(stdoutReader, stdoutQueue) = AsyncLineReader.getForFd(process.stdout)
(stderrReader, stderrQueue) = AsyncLineReader.getForFd(process.stderr)

# Keep checking queues until there is no more output.
while not stdoutReader.eof() or not stderrReader.eof():
   # Process all available lines from the stdout Queue.
   while not stdoutQueue.empty():
       line = stdoutQueue.get()
       print 'Received stdout: ' + repr(line)

       # Do stuff with stdout line.

   # Process all available lines from the stderr Queue.
   while not stderrQueue.empty():
       line = stderrQueue.get()
       print 'Received stderr: ' + repr(line)

       # Do stuff with stderr line.

   # Sleep for a short time to avoid excessive CPU use while waiting for data.
   sleep(0.05)

print "Waiting for async readers to finish..."
stdoutReader.join()
stderrReader.join()

# Close subprocess' file descriptors.
process.stdout.close()
process.stderr.close()

print "Waiting for process to exit..."
returnCode = process.wait()

if returnCode != 0:
   raise subprocess.CalledProcessError(returnCode, command)

Tôi chỉ muốn chia sẻ điều này, vì tôi đã kết thúc câu hỏi này khi cố gắng làm điều gì đó tương tự, nhưng không có câu trả lời nào giải quyết được vấn đề của tôi. Hy vọng nó sẽ giúp được ai đó!

Lưu ý rằng trong trường hợp sử dụng của tôi, một quy trình bên ngoài sẽ giết chết quy trình mà chúng ta Popen().

Đối với bất kỳ ai đang thử các câu trả lời cho câu hỏi này để nhận được thiết bị xuất chuẩn từ tập lệnh Python lưu ý rằng Python đệm thiết bị xuất chuẩn của nó, và do đó có thể mất một lúc để xem thiết bị xuất chuẩn.

Điều này có thể được sửa chữa bằng cách thêm vào sau đây sau mỗi lần ghi xuất chuẩn trong tập lệnh đích:

sys.stdout.flush()

Trong Python> = 3.5 sử dụng subprocess.runcông việc cho tôi:

import subprocess

cmd = 'echo foo; sleep 1; echo foo; sleep 2; echo foo'
subprocess.run(cmd, shell=True)

(nhận đầu ra trong khi thực thi cũng hoạt động mà không có shell=True) https: //docs.python.org/3/l Library / sub process.html # sub process.run

Để trả lời câu hỏi ban đầu, cách tốt nhất IMO chỉ là chuyển hướng stdouttrực tiếp quy trình con đến chương trình của bạn stdout(tùy chọn, điều tương tự có thể được thực hiện stderr, như trong ví dụ dưới đây)

p = Popen(cmd, stdout=sys.stdout, stderr=sys.stderr)
p.communicate()

PoC này liên tục đọc đầu ra từ một quá trình và có thể được truy cập khi cần. Chỉ giữ lại kết quả cuối cùng, tất cả các đầu ra khác bị loại bỏ, do đó ngăn PIPE phát triển ra khỏi bộ nhớ:

import subprocess
import time
import threading
import Queue


class FlushPipe(object):
    def __init__(self):
        self.command = ['python', './print_date.py']
        self.process = None
        self.process_output = Queue.LifoQueue(0)
        self.capture_output = threading.Thread(target=self.output_reader)

    def output_reader(self):
        for line in iter(self.process.stdout.readline, b''):
            self.process_output.put_nowait(line)

    def start_process(self):
        self.process = subprocess.Popen(self.command,
                                        stdout=subprocess.PIPE)
        self.capture_output.start()

    def get_output_for_processing(self):
        line = self.process_output.get()
        print ">>>" + line


if __name__ == "__main__":
    flush_pipe = FlushPipe()
    flush_pipe.start_process()

    now = time.time()
    while time.time() - now < 10:
        flush_pipe.get_output_for_processing()
        time.sleep(2.5)

    flush_pipe.capture_output.join(timeout=0.001)
    flush_pipe.process.kill()

print_date.py

#!/usr/bin/env python
import time

if __name__ == "__main__":
    while True:
        print str(time.time())
        time.sleep(0.01)

đầu ra: Bạn có thể thấy rõ rằng chỉ có đầu ra từ khoảng ~ 2,5 giây không có gì ở giữa.

>>>1520535158.51
>>>1520535161.01
>>>1520535163.51
>>>1520535166.01

Điều này hoạt động ít nhất trong Python3.4

import subprocess

process = subprocess.Popen(cmd_list, stdout=subprocess.PIPE)
for line in process.stdout:
    print(line.decode().strip())

Không có câu trả lời nào ở đây giải quyết tất cả các nhu cầu của tôi.

1. Không có chủ đề cho thiết bị xuất chuẩn (không có Hàng đợi, v.v.)
2. Không chặn vì tôi cần kiểm tra những thứ khác đang diễn ra
3. Sử dụng PIPE khi tôi cần để thực hiện nhiều việc, ví dụ đầu ra luồng, ghi vào tệp nhật ký và trả về một bản sao chuỗi của đầu ra.

Một chút nền tảng: Tôi đang sử dụng một ThreadPoolExecutor để quản lý một nhóm các luồng, mỗi luồng khởi chạy một tiến trình con và chạy chúng đồng thời. (Trong Python2.7, nhưng điều này cũng sẽ hoạt động trong 3.x mới hơn). Tôi không muốn sử dụng các luồng chỉ để thu thập đầu ra vì tôi muốn càng nhiều càng tốt cho các thứ khác (một nhóm gồm 20 quy trình sẽ sử dụng 40 luồng chỉ để chạy; 1 cho luồng xử lý và 1 cho đầu ra ... và nhiều hơn nữa nếu bạn muốn stderr tôi đoán)

Tôi đang gỡ lại rất nhiều ngoại lệ và như vậy ở đây vì vậy điều này dựa trên mã hoạt động trong sản xuất. Hy vọng tôi đã không làm hỏng nó trong bản sao và dán. Ngoài ra, thông tin phản hồi rất hoan nghênh!

import time
import fcntl
import subprocess
import time

proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

# Make stdout non-blocking when using read/readline
proc_stdout = proc.stdout
fl = fcntl.fcntl(proc_stdout, fcntl.F_GETFL)
fcntl.fcntl(proc_stdout, fcntl.F_SETFL, fl | os.O_NONBLOCK)

def handle_stdout(proc_stream, my_buffer, echo_streams=True, log_file=None):
    """A little inline function to handle the stdout business. """
    # fcntl makes readline non-blocking so it raises an IOError when empty
    try:
        for s in iter(proc_stream.readline, ''):   # replace '' with b'' for Python 3
            my_buffer.append(s)

            if echo_streams:
                sys.stdout.write(s)

            if log_file:
                log_file.write(s)
    except IOError:
        pass

# The main loop while subprocess is running
stdout_parts = []
while proc.poll() is None:
    handle_stdout(proc_stdout, stdout_parts)

    # ...Check for other things here...
    # For example, check a multiprocessor.Value('b') to proc.kill()

    time.sleep(0.01)

# Not sure if this is needed, but run it again just to be sure we got it all?
handle_stdout(proc_stdout, stdout_parts)

stdout_str = "".join(stdout_parts)  # Just to demo

Tôi chắc chắn có thêm chi phí được thêm vào đây nhưng nó không phải là vấn đề đáng lo ngại trong trường hợp của tôi. Về mặt chức năng nó làm những gì tôi cần. Điều duy nhất tôi chưa giải quyết được là tại sao điều này hoạt động hoàn hảo cho các thông điệp tường trình nhưng tôi thấy một số printtin nhắn xuất hiện sau đó và tất cả cùng một lúc.

Trong Python 3.6 tôi đã sử dụng điều này:

import subprocess

cmd = "command"
output = subprocess.call(cmd, shell=True)
print(process)