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

我想subprocess.Popen()在Windows中使用rsync.exe，并在Python中打印标准输出。

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

既然我听说使用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()

一些经验法则subprocess。

• 切勿使用shell=True。它不必要地调用额外的shell进程来调用您的程序。
• 调用进程时，参数作为列表传递。sys.argv在python中是一个列表，argv在C中也是如此。因此，您将列表传递给Popen来调用子流程，而不是字符串。
• 不阅读时不要重定向stderr到a 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。

我知道这是一个老话题，但是现在有一个解决方案。使用--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())

在Linux上，我有摆脱缓冲的同样问题。我最终使用了“ stdbuf -o0”（或从期望中取消缓冲）来摆脱PIPE缓冲。

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

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

另请参阅/unix/25372/

根据使用情况，您可能还希望禁用子流程本身中的缓冲。

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

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

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

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

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

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

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

当子进程关闭其标准输出或退出时，将保留while循环。 read()/read(-1)将阻塞，直到子进程关闭其标准输出或退出。

您的问题是：

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

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

尝试这样做：

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

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

将stdout重定向到未缓冲的sterr。 '<cmd> 1>&2'应该这样做。按如下所示打开过程：myproc = subprocess.Popen('<cmd> 1>&2', stderr=subprocess.PIPE)
您无法与stdout或stderr区分开，但是会立即获得所有输出。

希望这对解决这个问题的任何人有帮助。

将rsync进程中的stdout更改为未缓冲。

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)

为了避免缓存输出，您可以尝试使用pexpect，

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

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

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

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

我在python中为rsync编写GUI，并且具有相同的探针。这个问题困扰了我好几天，直到我在pyDoc中找到它为止。

如果Universal_newlines为True，则在通用换行模式下，文件对象stdout和stderr将作为文本文件打开。行可以由Unix行尾约定“ \ n”，旧的Macintosh约定“ \ r”或Windows约定“ \ r \ n”中的任何一个终止。所有这些外部表示在Python程序中都被视为“ \ n”。

似乎在进行翻译时rsync将输出“ \ r”。

我注意到，没有提到将临时文件用作中间文件。以下内容通过输出到临时文件来解决缓冲问题，并允许您解析来自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...

如果您在线程中运行类似的东西，并将ffmpeg_time属性保存在方法的属性中，以便您可以访问它，那将非常 有用。

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('\d\d:\d\d:\d\d', line)
    ffmpeg_time = reg.group(0) if reg else ''
    print(ffmpeg_time)

在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