从子进程实时捕获标准输出

问题描述：

我想subprocess.Popen()在 Windows 中运行 rsync.exe，并在 Python 中打印 stdout。

我的代码可以运行，但直到文件传输完成它才会捕获进度！我想实时打印每个文件的进度。

现在使用 Python 3.1，因为我听说它可以更好地处理 IO。

import subprocess, time, os, sys

cmd = "rsync.exe -vaz -P source/ dest/"
p, line = True, 'start'


p = subprocess.Popen(cmd,
                     shell=True,
                     bufsize=64,
                     stdin=subprocess.PIPE,
                     stderr=subprocess.PIPE,
                     stdout=subprocess.PIPE)

for line in p.stdout:
    print(">>> " + str(line.rstrip()))
    p.stdout.flush()

解决方案 1：

一些经验法则subprocess。

• 切勿使用shell=True。它会不必要地调用额外的 shell 进程来调用你的程序。

• 调用进程时，参数以列表的形式传递。sys.argv在 python 中是一个列表，在 C 中也是argv一个列表。因此，您传递一个列表来Popen调用子进程，而不是字符串。

• 当您没有阅读时，请不要重定向stderr到。PIPE

• stdin当您没有写入内容时请不要重定向。

例子：

import subprocess, time, os, sys
cmd = ["rsync.exe", "-vaz", "-P", "source/" ,"dest/"]

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

for line in iter(p.stdout.readline, b''):
    print(">>> " + line.rstrip())

也就是说，当 rsync 检测到它连接到的是管道而不是终端时，它很可能会缓冲其输出。这是默认行为 - 当连接到管道时，程序必须明确刷新 stdout 以获得实时结果，否则标准 C 库将缓冲。

为了测试这一点，请尝试运行以下命令：

cmd = [sys.executable, 'test_out.py']

并创建一个test_out.py文件，内容如下：

import sys
import time
print ("Hello")
sys.stdout.flush()
time.sleep(10)
print ("World")

执行该子进程应该会返回“Hello”，然后等待 10 秒再返回“World”。如果上面的 Python 代码出现这种情况，而没有出现这种情况rsync，则意味着rsync它本身正在缓冲输出，所以你运气不好。

一种解决方案是直接连接到pty，使用类似的东西pexpect。

解决方案 2：

我知道这是一个老话题，但现在有一个解决方案。使用选项 --outbuf=L 调用 rsync。示例：

cmd=['rsync', '-arzv','--backup','--outbuf=L','source/','dest']
p = subprocess.Popen(cmd,
                     stdout=subprocess.PIPE)
for line in iter(p.stdout.readline, b''):
    print '>>> {}'.format(line.rstrip())

解决方案 3：

根据使用情况，您可能还想禁用子进程本身的缓冲。

如果子进程是 Python 进程，则可以在调用之前执行以下操作：

os.environ["PYTHONUNBUFFERED"] = "1"

或者将其作为env参数传递给Popen。

否则，如果您使用的是 Linux/Unix，则可以使用该stdbuf工具。例如：

cmd = ["stdbuf", "-oL"] + cmd

另请参阅此处或stdbuf其他选项。

解决方案 4：

在 Linux 上，我遇到了同样的问题，无法摆脱缓冲。我最终使用“stdbuf -o0”（或 unbuffer from expect）来摆脱 PIPE 缓冲。

proc = Popen(['stdbuf', '-o0'] + cmd, stdout=PIPE, stderr=PIPE)
stdout = proc.stdout

然后我可以在标准输出上使用 select.select。

另请参阅https://unix.stackexchange.com/questions/25372/

解决方案 5：

for line in p.stdout:
  ...

总是阻塞直到下一次换行。

对于“实时”行为你必须做这样的事情：

while True:
  inchar = p.stdout.read(1)
  if inchar: #neither empty string nor None
    print(str(inchar), end='') #or end=None to flush immediately
  else:
    print('') #flush for implicit line-buffering
    break

当子进程关闭其 stdout 或退出时，while 循环将终止。
read()/read(-1)将阻塞直到子进程关闭其 stdout 或退出。

解决方案 6：

你的问题是：

for line in p.stdout:
    print(">>> " + str(line.rstrip()))
    p.stdout.flush()

迭代器本身具有额外的缓冲。

尝试这样做：

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

解决方案 7：

    p = subprocess.Popen(command,
                                bufsize=0,
                                universal_newlines=True)

我正在用 python 为 rsync 编写 GUI，也遇到了同样的问题。这个问题困扰了我好几天，直到我在 pyDoc 中找到了它。

如果 universal_newlines 为 True，则文件对象 stdout 和 stderr 将以通用换行符模式作为文本文件打开。行可以以 '\n'（Unix 行尾约定）、'\r'（旧 Macintosh 约定）或 '\r\n'（Windows 约定）中的任何一个结束。所有这些外部表示都被 Python 程序视为 '\n'。

看起来，当进行翻译时，rsync 将输出‘\r’。

解决方案 8：

为了避免缓存输出，你可能想尝试 pexpect，

child = pexpect.spawn(launchcmd,args,timeout=None)
while True:
    try:
        child.expect('
')
        print(child.before)
    except pexpect.EOF:
        break

附言：我知道这个问题已经很老了，但仍然提供对我有用的解决方案。

PPS：从另一个问题得到这个答案

解决方案 9：

您无法让 stdout 无缓冲地打印到管道（除非您可以重写打印到 stdout 的程序），所以这是我的解决方案：

将 stdout 重定向到未缓冲的 sterr。 '<cmd> 1>&2'应该可以做到。打开进程如下：myproc = subprocess.Popen('<cmd> 1>&2', stderr=subprocess.PIPE)

您无法区分 stdout 或 stderr，但您会立即获得所有输出。

希望这可以帮助任何人解决这个问题。

解决方案 10：

如果你在线程中运行类似的东西并将 ffmpeg_time 属性保存在方法的属性中以便你可以访问它，它会工作得很好我得到这样的输出：
输出就像你在 tkinter 中使用线程一样

input = 'path/input_file.mp4'
output = 'path/input_file.mp4'
command = "ffmpeg -y -v quiet -stats -i \"" + str(input) + "\" -metadata title=\"@alaa_sanatisharif\" -preset ultrafast -vcodec copy -r 50 -vsync 1 -async 1 \"" + output + "\""
process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True, shell=True)
for line in self.process.stdout:
    reg = re.search('dd:dd:dd', line)
    ffmpeg_time = reg.group(0) if reg else ''
    print(ffmpeg_time)

解决方案 11：

将 rsync 进程的标准输出更改为无缓冲。

p = subprocess.Popen(cmd,
                     shell=True,
                     bufsize=0,  # 0=unbuffered, 1=line-buffered, else buffer-size
                     stdin=subprocess.PIPE,
                     stderr=subprocess.PIPE,
                     stdout=subprocess.PIPE)

解决方案 12：

我注意到没有提到使用临时文件作为中间文件。下面的方法通过输出到临时文件来解决缓冲问题，并允许您解析来自 rsync 的数据而无需连接到 pty。我在 Linux 机器上测试了以下内容，rsync 的输出往往因平台而异，因此解析输出的正则表达式可能会有所不同：

import subprocess, time, tempfile, re

pipe_output, file_name = tempfile.TemporaryFile()
cmd = ["rsync", "-vaz", "-P", "/src/" ,"/dest"]

p = subprocess.Popen(cmd, stdout=pipe_output, 
                     stderr=subprocess.STDOUT)
while p.poll() is None:
    # p.poll() returns None while the program is still running
    # sleep for 1 second
    time.sleep(1)
    last_line =  open(file_name).readlines()
    # it's possible that it hasn't output yet, so continue
    if len(last_line) == 0: continue
    last_line = last_line[-1]
    # Matching to "[bytes downloaded]  number%  [speed] number:number:number"
    match_it = re.match(".* ([0-9]*)%.* ([0-9]*:[0-9]*:[0-9]*).*", last_line)
    if not match_it: continue
    # in this case, the percentage is stored in match_it.group(1), 
    # time in match_it.group(2).  We could do something with it here...

解决方案 13：

在 Python 3 中，有一个解决方案，它从命令行获取命令并在接收到命令时提供实时解码的字符串。

接收者 （receiver.py）：

import subprocess
import sys

cmd = sys.argv[1:]
p = subprocess.Popen(cmd, stdout=subprocess.PIPE)
for line in p.stdout:
    print("received: {}".format(line.rstrip().decode("utf-8")))

可以生成实时输出的简单程序示例（dummy_out.py）：

import time
import sys

for i in range(5):
    print("hello {}".format(i))
    sys.stdout.flush()  
    time.sleep(1)

输出：

$python receiver.py python dummy_out.py
received: hello 0
received: hello 1
received: hello 2
received: hello 3
received: hello 4