blocks|key|164075|text|来自Magnus+Lycka在邮件列表上的回答|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|164076|您可以使用python+-u或设置环境变量PYTHONUNBUFFERED跳过整个python进程的缓冲。
您还可以将sys.stdout替换为其他流，比如包装器，它在每次调用后进行刷新。
类Unbuffered(object)：def+__init__(self，stream)：self.stream+=+stream写(self，data)：self.stream.write(data)+self.stream.flush()+def写线(self，datas)：self.stream.writelines(datas)+self.stream.flush()+def+__getattr__(self，attr)：返回getattr(self.stream，(+attr)导入sys+sys.stdout+=+Unbuffered(sys.stdout)打印“Hello”|blockquote|style|CODE|164077|entityMap|0|LINK|mutability|MUTABLE|url|http://mail.python.org/pipermail/tutor/2003-November/026645.html^0|2|L|0|0|5|9|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@$A|V|B|W|G|H]]|9|@]|C|$]]|$1|I|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

From <a href="http://mail.python.org/pipermail/tutor/2003-November/026645.html" rel="nofollow noreferrer">Magnus Lycka answer on a mailing list</a>:
<blockquote>
You can skip buffering for a whole
python process using <code>python -u</code>
or by
setting the environment variable
PYTHONUNBUFFERED.
You could also replace sys.stdout with
some other stream like wrapper which
does a flush after every call.
<pre><code>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'
</code></pre>
</blockquote>

blocks|key|848842|text|是的，是这样的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|848843|您可以在命令行上使用"-u“开关禁用它。|848844|或者，您可以在每次写入时在sys.stdout上调用sys.stdout()(或者用一个自动执行此操作的对象包装它)。|848845|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Yes, it is.

You can disable it on the commandline with the "-u" switch.

Alternatively, you could call .flush() on sys.stdout on every write (or wrap it with an object that does this automatically)

blocks|key|1162997|text|是的，默认情况下是启用的。在调用python时，可以在命令行上使用-u选项来禁用它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1162998|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Yes, it is enabled by default. You can disable it by using the -u option on the command line when calling python.

blocks|key|164167|text|获得未缓冲输出的一种方法是使用sys.stderr而不是sys.stdout，或者简单地调用sys.stdout.flush()来显式强制进行写入。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|164168|您可以通过以下操作轻松地重定向打印的所有内容：|164169|import+sys;+sys.stdout+=+sys.stderr
print+"Hello+World!"|code-block|syntax|javascript|164170|或者仅仅针对特定的print语句重定向：|164171|print+>>sys.stderr,+"Hello+World!"|164172|要重置stdout，只需：|164173|sys.stdout+=+sys.__stdout__|164174|entityMap^0|F|A|S|A|1A|I|0|0|0|9|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|14|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|18|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|19|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|1A|8|@]|D|@]|E|$K|L]]|$1|U|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|V|$]]

One way to get unbuffered output would be to use <code>sys.stderr</code> instead of <code>sys.stdout</code> or to simply call <code>sys.stdout.flush()</code> to explicitly force a write to occur.

You could easily redirect everything printed by doing:

<pre><code>import sys; sys.stdout = sys.stderr
print "Hello World!"
</code></pre>

Or to redirect just for a particular <code>print</code> statement:

<pre><code>print &gt;&gt;sys.stderr, "Hello World!"
</code></pre>

To reset stdout you can just do:

<pre><code>sys.stdout = sys.__stdout__
</code></pre>

blocks|key|1163083|text|您可以创建一个未缓冲的文件并将该文件分配给sys.stdout。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1163084|import+sys+
myFile=+open(+"a.log",+"w",+0+)+
sys.stdout=+myFile|code-block|syntax|javascript|1163085|您不能神奇地更改系统提供的标准输出；因为它是由操作系统提供给您的python程序的。|1163086|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You can create an unbuffered file and assign this file to sys.stdout.

<pre><code>import sys 
myFile= open( "a.log", "w", 0 ) 
sys.stdout= myFile
</code></pre>

You can't magically change the system-supplied stdout; since it's supplied to your python program by the OS.

blocks|key|1163104|text|#+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)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1163105|学分："Sebastian"，Python邮件列表中的某个位置。|unstyled|1163106|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code># 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)
</code></pre>

Credits: "Sebastian", somewhere on the Python mailing list.

blocks|key|848899|text|您还可以使用fcntl在飞行中更改文件标志。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|848900|fl+=+fcntl.fcntl(fd.fileno(),+fcntl.F_GETFL)
fl+%7C=+os.O_SYNC+#+or+os.O_DSYNC+(if+you+don't+care+the+file+timestamp+updates)
fcntl.fcntl(fd.fileno(),+fcntl.F_SETFL,+fl)|code-block|syntax|javascript|848901|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can also use fcntl to change the file flags in-fly.

<pre><code>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)
</code></pre>

blocks|key|164260|text|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"])|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|164261|如果不保存旧的sys.stdout，disable_stdout_buffering()就不是幂等的，多个调用将导致如下错误：|unstyled|164262|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|164263|另一种可能是：|164264|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)|164265|(附加到gc.garbage并不是一个好主意，因为它是放置不可自由循环的地方，您可能需要检查这些循环。)|164266|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$B|C]]|$1|M|3|N|5|F|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|F|7|W|8|@]|9|@]|A|$]]]|P|$]]

<pre><code>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"])
</code></pre>

Without saving the old sys.stdout, disable_stdout_buffering() isn't idempotent, and multiple calls will result in an error like this:

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

Another possibility is:

<pre><code>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)
</code></pre>

(Appending to gc.garbage is not such a good idea because it's where unfreeable cycles get put, and you might want to check for those.)

blocks|key|1163145|text|在不崩溃的情况下工作的变体(至少在win32上；python2.7，IPython0.12)随后调用(多次)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1163146|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)|code-block|syntax|javascript|1163147|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Variant that works without crashing (at least on win32; python 2.7, ipython 0.12) then called subsequently (multiple times):

<pre><code>def DisOutBuffering():
 if sys.stdout.name == '&lt;stdout&gt;':
 sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)

 if sys.stderr.name == '&lt;stderr&gt;':
 sys.stderr = os.fdopen(sys.stderr.fileno(), 'w', 0)
</code></pre>

blocks|key|844784|text|我宁愿将我的答案写在如何冲洗输出的打印功能？或Python的打印函数，当它被调用时会刷新缓冲区？中，但是由于它们被标记为这个副本(我不同意)，我将在这里回答它。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|844785|由于Python3.3，print()支持关键字参数“刷新”(见文件)：|844786|print('Hello+World!',+flush=True)|code-block|syntax|javascript|844787|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/230751/how-to-flush-output-of-python-print|1|https://stackoverflow.com/questions/3895481/pythons-print-function-that-flushes-the-buffer-when-its-called|2|http://docs.python.org/3/library/functions.html?highlight=print#print^0|A|C|0|N|P|1|0|V|3|2|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]|$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|6|7|13|8|@]|9|@$A|14|B|15|1|16]]|C|$]]|$1|F|3|G|5|H|7|17|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]|U|$5|N|O|P|C|$Q|V]]]]

I would rather put my answer in <a href="https://stackoverflow.com/questions/230751/how-to-flush-output-of-python-print">How to flush output of print function?</a> or in <a href="https://stackoverflow.com/questions/3895481/pythons-print-function-that-flushes-the-buffer-when-its-called">Python&#39;s print function that flushes the buffer when it&#39;s called?</a>, but since they were marked as duplicates of this one (what I do not agree), I'll answer it here.

Since Python 3.3, print() supports the keyword argument "flush" (<a href="http://docs.python.org/3/library/functions.html?highlight=print#print" rel="noreferrer">see documentation</a>):

<pre><code>print('Hello World!', flush=True)
</code></pre>

blocks|key|1163252|text|)我发了一条评论，但不知怎么丢了。因此，再一次：)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1163253|正如我注意到的，CPython+(至少在Linux上)的行为因输出的位置而异。如果进入tty，则在每个'\n'‘之后刷新输出
如果它进入管道/进程，则会对其进行缓冲，您可以使用基于flush()的解决方案或上面推荐的-u选项。|ordered-list-item|offset|length|style|CODE|BOLD|1163254|与输出缓冲略有关联：
如果您遍历输入中的行，则
for+line+in+sys.stdin:
..。|1163255|然后，+for+实现在CPython中将收集输入一段时间，然后对一串输入行执行循环体。如果您的脚本要为每个输入行编写输出，这可能看起来像输出缓冲，但实际上它是批处理，因此，没有任何flush()等技术会对此有所帮助。有趣的是，在pypy中没有这种行为。为了避免这种情况，您可以使用|1163256|while+True:++++line=sys.stdin.readline()|1163257|..。|1163258|entityMap^0|0|1G|3|2I|7|30|2|0|O|M|0|3|5|B|7|36|4|2I|7|0|0|14|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|U|8|@$E|V|F|W|G|H]|$E|X|F|Y|G|H]|$E|Z|F|10|G|I]]|9|@]|A|$]]|$1|J|3|K|5|D|7|11|8|@$E|12|F|13|G|H]]|9|@]|A|$]]|$1|L|3|M|5|6|7|14|8|@$E|15|F|16|G|I]|$E|17|F|18|G|I]|$E|19|F|1A|G|I]|$E|1B|F|1C|G|H]]|9|@]|A|$]]|$1|N|3|O|5|6|7|1D|8|@$E|1E|F|1F|G|H]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1G|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|S|$]]

(I've posted a comment, but it got lost somehow. So, again:)

<ol>
<li>As I noticed, CPython (at least on Linux) behaves differently depending on where the output goes. If it goes to a tty, then the output is flushed after each '<code>\n'</code>
 If it goes to a pipe/process, then it is buffered and you can use the <code>flush()</code> based solutions or the -u option recommended above.</li>
<li>Slightly related to output buffering: 
If you iterate over the lines in the input with

<code>for line in sys.stdin:</code>
 ...</li>
</ol>

then the for implementation in CPython will collect the input for a while and then execute the loop body for a bunch of input lines. If your script is about to write output for each input line, this might look like output buffering but it's actually batching, and therefore, none of the <code>flush()</code>, etc. techniques will help that.
Interestingly, you don't have this behaviour in pypy.
To avoid this, you can use

<code>while True:
 line=sys.stdin.readline()</code>
 ...

blocks|key|164380|text|以下是Python2.6、2.7和3.2中的工作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|164381|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%2B',+buf_arg)
sys.stderr+=+os.fdopen(sys.stderr.fileno(),+'a%2B',+buf_arg)|code-block|syntax|javascript|164382|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The following works in Python 2.6, 2.7, and 3.2:

<pre><code>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)
</code></pre>

blocks|key|1163314|text|您还可以使用斯德布夫实用程序运行Python：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1163315|stdbuf+-oL+python+<script>|style|CODE|1163316|entityMap|0|LINK|mutability|MUTABLE|url|https://www.gnu.org/software/coreutils/manual/html_node/stdbuf-invocation.html^0|6|4|0|0|0|Q|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@$A|U|B|V|F|G]]|9|@]|C|$]]|$1|H|3|-4|5|6|7|W|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

You can also run Python with <a href="https://www.gnu.org/software/coreutils/manual/html_node/stdbuf-invocation.html" rel="noreferrer" title="stdbuf">stdbuf</a> utility:

<code>stdbuf -oL python &lt;script&gt;</code>

blocks|key|164457|text|这与克里斯特·奥·苏萨的回答有关，但我还不能发表评论。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|164458|使用Python3的flush关键字参数(为了使始终保持无缓冲输出)的直接方式是：|offset|length|style|CODE|BOLD|164459|import+functools
print+=+functools.partial(print,+flush=True)|code-block|syntax|javascript|164460|之后，print将始终直接刷新输出(除非给出flush=False+)。|164461|注意，(a)这只部分地回答了问题，因为它没有重定向所有输出。但是我想print是在python中为stdout/stderr创建输出的最常用的方法，所以这2行可能涵盖了大部分用例。|164462|注意(b)它只在您定义它的模块/脚本中工作。这在编写模块时是很好的，因为它不会干扰sys.stdout。|164463|Python2没有提供flush参数，但是您可以像这里描述的那样模拟Python3类型的print函数。|164464|entityMap^0|0|A|5|O|4|0|0|M|B|0|Y|5|1D|6|1K|6|0|15|A|0|B|5|18|5|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@$D|Z|E|10|F|G]|$D|11|E|12|F|H]]|9|@]|A|$]]|$1|I|3|J|5|K|7|13|8|@]|9|@]|A|$L|M]]|$1|N|3|O|5|6|7|14|8|@$D|15|E|16|F|G]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|17|8|@$D|18|E|19|F|G]|$D|1A|E|1B|F|G]|$D|1C|E|1D|F|G]]|9|@]|A|$]]|$1|R|3|S|5|6|7|1E|8|@$D|1F|E|1G|F|G]]|9|@]|A|$]]|$1|T|3|U|5|6|7|1H|8|@$D|1I|E|1J|F|G]|$D|1K|E|1L|F|G]]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|W|$]]

This relates to Cristóvão D. Sousa's answer, but I couldn't comment yet.

A straight-forward way of using the <code>flush</code> keyword argument of Python 3 in order to always have unbuffered output is:

<pre><code>import functools
print = functools.partial(print, flush=True)
</code></pre>

afterwards, print will always flush the output directly (except <code>flush=False</code> is given).

Note, (a) that this answers the question only partially as it doesn't redirect all the output. But I guess <code>print</code> is the most common way for creating output to <code>stdout</code>/<code>stderr</code> in python, so these 2 lines cover probably most of the use cases.

Note (b) that it only works in the module/script where you defined it. This can be good when writing a module as it doesn't mess with the <code>sys.stdout</code>.

Python 2 doesn't provide the <code>flush</code> argument, but you could emulate a Python 3-type <code>print</code> function as described here <a href="https://stackoverflow.com/a/27991478/3734258">https://stackoverflow.com/a/27991478/3734258</a> .

blocks|key|844876|text|只可以用调用write的方法覆盖sys.stdout的flush方法。建议的方法实现如下。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|844877|def+write_flush(args,+w=stdout.write):
++++w(args)
++++stdout.flush()|code-block|syntax|javascript|844878|w参数的默认值将保持原始write方法引用。定义write_flush后，可能会重写原始write。|844879|stdout.write+=+write_flush|844880|代码假定stdout是以这种方式导入的，from+sys+import+stdout。|844881|entityMap^0|6|5|G|A|R|5|0|0|0|1|C|5|O|B|18|5|0|0|4|6|K|M|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|R|$]]

It is possible to override only <code>write</code> method of <code>sys.stdout</code> with one that calls <code>flush</code>. Suggested method implementation is below.

<pre><code>def write_flush(args, w=stdout.write):
 w(args)
 stdout.flush()
</code></pre>

Default value of <code>w</code> argument will keep original <code>write</code> method reference. After <code>write_flush</code> is defined, the original <code>write</code> might be overridden.

<pre><code>stdout.write = write_flush
</code></pre>

The code assumes that <code>stdout</code> is imported this way <code>from sys import stdout</code>.

blocks|key|1163462|text|在Python3中，您可以对打印函数进行猴子补丁，以始终发送flush=True：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1163463|_orig_print+=+print

def+print(*args,+**kwargs):
++++_orig_print(*args,+flush=True,+**kwargs)|code-block|syntax|javascript|1163464|正如注释中所指出的，您可以通过通过functools.partial将刷新参数绑定到值来简化这一点。|offset|length|style|CODE|1163465|print+=+functools.partial(print,+flush=True)|1163466|entityMap^0|0|0|H|H|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

In Python 3, you can monkey-patch the print function, to always send flush=True:

<pre><code>_orig_print = print

def print(*args, **kwargs):
 _orig_print(*args, flush=True, **kwargs)
</code></pre>

As pointed out in a comment, you can simplify this by binding the flush parameter to a value, via <code>functools.partial</code>:

<pre><code>print = functools.partial(print, flush=True)
</code></pre>

Is output buffering enabled by default in Python's interpreter for <code>sys.stdout</code>?

If the answer is positive, what are all the ways to disable it?

Suggestions so far:

<ol>
<li>Use the <code>-u</code> command line switch</li>
<li>Wrap <code>sys.stdout</code> in an object that flushes after every write</li>
<li>Set <code>PYTHONUNBUFFERED</code> env var</li>
<li><code>sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)</code></li>
</ol>

Is there any other way to set some global flag in <code>sys</code>/<code>sys.stdout</code> programmatically during execution?

Disable output buffering

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

默认情况下，在Python的sys.stdout解释器中启用输出缓冲吗？如果答案是肯定的，那么禁用它的所有方法是什么？迄今的建议：使用-u命令行开关将sys.stdout包装在一个对象中，该对象在每次写完后都会刷新设置PYTHONUNBUFFERED env varsys.stdout = os.fdopen(sys....

问禁用输出缓冲
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问禁用输出缓冲EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问禁用输出缓冲
EN