禁用输出缓冲

默认情况下，Python的解释器是否启用输出缓冲sys.stdout？

如果答案是肯定的，那么有什么方法可以禁用它？

到目前为止的建议：

1. 使用-u命令行开关
2. 包装sys.stdout每次写入后刷新的对象
3. 设置环境PYTHONUNBUFFERED变量
4. sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)

还有其他方法可以在执行过程中以编程方式在sys/中设置一些全局标志sys.stdout吗？

从Magnus Lycka的邮件列表中答复：

您可以使用“ python -u”（或＃！/ usr / bin / env python -u等）或通过设置环境变量PYTHONUNBUFFERED跳过整个python进程的缓冲。

您还可以将sys.stdout替换为包装器之类的其他流，该流在每次调用后进行刷新。

class Unbuffered(object):
   def __init__(self, stream):
       self.stream = stream
   def write(self, data):
       self.stream.write(data)
       self.stream.flush()
   def writelines(self, datas):
       self.stream.writelines(datas)
       self.stream.flush()
   def __getattr__(self, attr):
       return getattr(self.stream, attr)

import sys
sys.stdout = Unbuffered(sys.stdout)
print 'Hello'

我宁愿把答案 如何刷新打印功能的输出中？还是在Python的print函数中在调用缓冲区时刷新缓冲区？，但由于它们被标记为与此副本的副本（我不同意），因此我将在此处回答。

从Python 3.3开始，print（）支持关键字参数“ flush”（请参阅文档）：

print('Hello World!', flush=True)

# reopen stdout file descriptor with write mode
# and 0 as the buffer size (unbuffered)
import io, os, sys
try:
    # Python 3, open as binary, then wrap in a TextIOWrapper with write-through.
    sys.stdout = io.TextIOWrapper(open(sys.stdout.fileno(), 'wb', 0), write_through=True)
    # If flushing on newlines is sufficient, as of 3.7 you can instead just call:
    # sys.stdout.reconfigure(line_buffering=True)
except TypeError:
    # Python 2
    sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)

鸣谢：“ Sebastian”，在Python邮件列表上的某处。

是的。

您可以使用“ -u”开关在命令行上禁用它。

或者，您可以在每次写入时在sys.stdout上调用.flush（）（或将其包装为自动执行此操作的对象）

这与克里斯托瓦·索萨（CristóvãoD. Sousa）的答案有关，但我无法发表评论。

为了始终具有未缓冲的输出而使用Python 3的flush关键字参数的直接方法是：

import functools
print = functools.partial(print, flush=True)

之后，打印将始终直接刷新输出（flush=False给出的除外）。

请注意，（a）这只能部分回答问题，因为它不会重定向所有输出。但是我想这print是在python中创建输出到stdout/ 的最常见方法stderr，因此这两行可能涵盖了大多数用例。

注意（b）它仅在定义它的模块/脚本中起作用。编写模块时这可能会很好，因为它不会与混淆sys.stdout。

Python 2不提供flush参数，但是您可以仿真Python 3型print函数，如此处https://stackoverflow.com/a/27991478/3734258所述。

def disable_stdout_buffering():
    # Appending to gc.garbage is a way to stop an object from being
    # destroyed.  If the old sys.stdout is ever collected, it will
    # close() stdout, which is not good.
    gc.garbage.append(sys.stdout)
    sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)

# Then this will give output in the correct order:
disable_stdout_buffering()
print "hello"
subprocess.call(["echo", "bye"])

如果不保存旧的sys.stdout，disable_stdout_buffering（）并不是幂等的，并且多次调用将导致如下错误：

Traceback (most recent call last):
  File "test/buffering.py", line 17, in <module>
    print "hello"
IOError: [Errno 9] Bad file descriptor
close failed: [Errno 9] Bad file descriptor

另一种可能性是：

def disable_stdout_buffering():
    fileno = sys.stdout.fileno()
    temp_fd = os.dup(fileno)
    sys.stdout.close()
    os.dup2(temp_fd, fileno)
    os.close(temp_fd)
    sys.stdout = os.fdopen(fileno, "w", 0)

（添加到gc.garbage并不是一个好主意，因为这是放置不可释放的循环的地方，您可能需要检查这些循环。）

以下在Python 2.6、2.7和3.2中有效：

import os
import sys
buf_arg = 0
if sys.version_info[0] == 3:
    os.environ['PYTHONUNBUFFERED'] = '1'
    buf_arg = 1
sys.stdout = os.fdopen(sys.stdout.fileno(), 'a+', buf_arg)
sys.stderr = os.fdopen(sys.stderr.fileno(), 'a+', buf_arg)

是的，默认情况下启用。您可以在调用python时通过在命令行上使用-u选项禁用它。

您还可以使用stdbuf实用程序运行Python ：

stdbuf -oL python <script>

在Python 3中，您可以使用猴子补丁打印功能，以始终发送flush = True：

_orig_print = print

def print(*args, **kwargs):
    _orig_print(*args, flush=True, **kwargs)

如注释中所指出的，您可以通过以下方式将flush参数绑定到一个值来简化此操作functools.partial：

print = functools.partial(print, flush=True)

您也可以使用fcntl即时更改文件标志。

fl = fcntl.fcntl(fd.fileno(), fcntl.F_GETFL)
fl |= os.O_SYNC # or os.O_DSYNC (if you don't care the file timestamp updates)
fcntl.fcntl(fd.fileno(), fcntl.F_SETFL, fl)

可以使用调用的方法仅 覆盖的write方法。建议的方法实现如下。sys.stdoutflush

def write_flush(args, w=stdout.write):
    w(args)
    stdout.flush()

w参数的默认值将保留原始write方法引用。在 write_flush定义之后，原始文件write可能会被覆盖。

stdout.write = write_flush

该代码假定以stdout这种方式导入from sys import stdout。

您可以创建一个无缓冲的文件，并将该文件分配给sys.stdout。

import sys 
myFile= open( "a.log", "w", 0 ) 
sys.stdout= myFile

您无法神奇地更改系统提供的标准输出；因为它是由操作系统提供给您的python程序的。

在不崩溃的情况下起作用的变体（至少在win32上； python 2.7，ipython 0.12）然后随后被调用（多次）：

def DisOutBuffering():
    if sys.stdout.name == '<stdout>':
        sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)

    if sys.stderr.name == '<stderr>':
        sys.stderr = os.fdopen(sys.stderr.fileno(), 'w', 0)

（我发表了评论，但由于某种原因迷失了。因此，再次：）

1. 正如我注意到的那样，CPython（至少在Linux上）的行为取决于输出的位置。如果是tty，则在每个'之后都将刷新输出。\n'
   如果是管道/进程，则将其缓冲，您可以使用flush()基于基础的解决方案或上面建议的-u选项。

2. 与输出缓冲稍微相关：
   如果您使用来遍历输入中的行

   for line in sys.stdin:
   ...

然后在CPython中的for实现将收集输入一段时间，然后对一堆输入行执行循环主体。如果您的脚本要为每条输入行写输出，这可能看起来像输出缓冲，但实际上是批处理，因此，等技术都无法提供帮助。有趣的是，您在pypy中没有这种行为。为了避免这种情况，您可以使用flush()

while True: line=sys.stdin.readline()
...

获得无缓冲输出的一种方法是使用sys.stderr而不是sys.stdout或简单地调用sys.stdout.flush()以显式强制发生写入。

您可以通过执行以下操作轻松重定向所有打印内容：

import sys; sys.stdout = sys.stderr
print "Hello World!"

或仅针对特定print语句进行重定向：

print >>sys.stderr, "Hello World!"

要重置标准输出，您可以执行以下操作：

sys.stdout = sys.__stdout__