Đọc đầu vào phát trực tuyến từ subprocess.communicate ()

Tôi đang sử dụng Python subprocess.communicate()để đọc stdout từ một quy trình chạy trong khoảng một phút.

Làm cách nào tôi có thể in ra từng dòng của quy trình đó stdouttheo kiểu truyền trực tuyến, để tôi có thể thấy đầu ra khi nó được tạo, nhưng vẫn bị chặn khi quá trình kết thúc trước khi tiếp tục?

subprocess.communicate() xuất hiện để cung cấp tất cả các đầu ra cùng một lúc.

Xin lưu ý, tôi nghĩ rằng phương pháp của JF Sebastian (bên dưới) là tốt hơn.

Đây là một ví dụ đơn giản (không kiểm tra lỗi):

import subprocess
proc = subprocess.Popen('ls',
                       shell=True,
                       stdout=subprocess.PIPE,
                       )
while proc.poll() is None:
    output = proc.stdout.readline()
    print output,

Nếu lskết thúc quá nhanh, thì vòng lặp while có thể kết thúc trước khi bạn đọc tất cả dữ liệu.

Bạn có thể lấy phần còn lại trong stdout theo cách này:

output = proc.communicate()[0]
print output,

Để nhận từng dòng đầu ra của quy trình con ngay khi quy trình con xóa bộ đệm stdout của nó:

#!/usr/bin/env python2
from subprocess import Popen, PIPE

p = Popen(["cmd", "arg1"], stdout=PIPE, bufsize=1)
with p.stdout:
    for line in iter(p.stdout.readline, b''):
        print line,
p.wait() # wait for the subprocess to exit

iter()được sử dụng để đọc các dòng ngay khi chúng được viết để giải quyết lỗi đọc trước trong Python 2 .

Nếu stdout của quy trình con sử dụng bộ đệm khối thay vì bộ đệm dòng ở chế độ không tương tác (dẫn đến sự chậm trễ trong đầu ra cho đến khi bộ đệm của trẻ đầy hoặc được xóa rõ ràng bởi trẻ) thì bạn có thể cố gắng buộc đầu ra không có bộ đệm bằng cách sử dụng pexpect, ptymodule hay unbuffer, stdbuf, scripttiện ích , xem Q: Tại sao không chỉ cần sử dụng một ống (popen ())?

Đây là mã Python 3:

#!/usr/bin/env python3
from subprocess import Popen, PIPE

with Popen(["cmd", "arg1"], stdout=PIPE, bufsize=1,
           universal_newlines=True) as p:
    for line in p.stdout:
        print(line, end='')

Lưu ý: Không giống như Python 2 xuất ra các bytestrings của quy trình con như nguyên trạng; Python 3 sử dụng chế độ văn bản (đầu ra của cmd được giải mã bằng cách sử dụng locale.getpreferredencoding(False)mã hóa).

Tôi tin rằng cách đơn giản nhất để thu thập đầu ra từ một quy trình theo kiểu phát trực tuyến là như sau:

import sys
from subprocess import *
proc = Popen('ls', shell=True, stdout=PIPE)
while True:
    data = proc.stdout.readline()   # Alternatively proc.stdout.read(1024)
    if len(data) == 0:
        break
    sys.stdout.write(data)   # sys.stdout.buffer.write(data) on Python 3.x

Hàm readline()or read()chỉ nên trả về một chuỗi trống trên EOF, sau khi quá trình kết thúc - nếu không nó sẽ chặn nếu không có gì để đọc ( readline()bao gồm cả dòng mới, vì vậy đối với các dòng trống, nó trả về "\ n"). Điều này tránh cần phải có một communicate()cuộc gọi cuối cùng khó xử sau vòng lặp.

Trên các tệp có dòng rất dài read()có thể thích hợp hơn để giảm mức sử dụng bộ nhớ tối đa - số lượng được truyền vào nó là tùy ý, nhưng việc loại trừ nó dẫn đến việc đọc toàn bộ đầu ra đường ống cùng một lúc, điều này có lẽ không mong muốn.

Nếu bạn muốn một cách tiếp cận không chặn, đừng sử dụng process.communicate(). Nếu bạn đặt subprocess.Popen()đối số stdoutthành PIPE, bạn có thể đọc từ đó process.stdoutvà kiểm tra xem quá trình có còn chạy hay không process.poll().

Nếu bạn chỉ đơn giản là cố gắng chuyển đầu ra trong thời gian thực, thì thật khó để đơn giản hơn thế này:

import subprocess

# This will raise a CalledProcessError if the program return a nonzero code.
# You can use call() instead if you don't care about that case.
subprocess.check_call(['ls', '-l'])

Xem tài liệu cho subprocess.check_call () .

Nếu bạn cần xử lý đầu ra, chắc chắn, hãy lặp lại nó. Nhưng nếu bạn không, chỉ cần giữ nó đơn giản.

Chỉnh sửa: JF Sebastian chỉ ra rằng cả mặc định cho các tham số stdout và stderr đều chuyển qua sys.stdout và sys.stderr, và điều này sẽ không thành công nếu sys.stdout và sys.stderr đã được thay thế (giả sử, để bắt đầu ra trong thử nghiệm).

myCommand="ls -l"
cmd=myCommand.split()
# "universal newline support" This will cause to interpret \n, \r\n and \r     equally, each as a newline.
p = subprocess.Popen(cmd, stderr=subprocess.PIPE, universal_newlines=True)
while True:    
    print(p.stderr.readline().rstrip('\r\n'))

Thêm một giải pháp python3 khác với một vài thay đổi nhỏ:

1. Cho phép bạn bắt mã thoát của quy trình trình bao (Tôi đã không thể lấy mã thoát khi sử dụng with cấu trúc)
2. Ngoài ra các ống dẫn ra trong thời gian thực

import subprocess
import sys
def subcall_stream(cmd, fail_on_error=True):
    # Run a shell command, streaming output to STDOUT in real time
    # Expects a list style command, e.g. `["docker", "pull", "ubuntu"]`
    p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, bufsize=1, universal_newlines=True)
    for line in p.stdout:
        sys.stdout.write(line)
    p.wait()
    exit_code = p.returncode
    if exit_code != 0 and fail_on_error:
        raise RuntimeError(f"Shell command failed with exit code {exit_code}. Command: `{cmd}`")
    return(exit_code)