Отключить буферизацию вывода

Включена ли буферизация вывода по умолчанию в интерпретаторе Python для sys.stdout?

Если ответ положительный, какие есть способы его отключения?

Предложения на данный момент:

1. Используйте -uпереключатель командной строки
2. Заворачивать sys.stdoutв объект, который очищается после каждой записи
3. Установить PYTHONUNBUFFEREDenv var
4. sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)

Есть ли другой способ установить какой-либо глобальный флаг в sys/ sys.stdoutпрограммно во время выполнения?

От Магнуса Лицки ответьте на рассылку :

Вы можете пропустить буферизацию для всего процесса python, используя "python -u" (или #! / Usr / bin / env python -u и т. Д.) Или установив переменную окружения PYTHONUNBUFFERED.

Вы также можете заменить 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, которая очищает буфер при вызове? , но так как они были помечены как дубликаты этого (что я не согласен), я отвечу здесь.

Начиная с 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)

Кредиты: «Себастьян», где-то в списке рассылки Python.

Да, это так.

Вы можете отключить его в командной строке с помощью ключа "-u".

В качестве альтернативы, вы можете вызывать .flush () для sys.stdout при каждой записи (или заключать его в объект, который делает это автоматически)

Это относится к ответу Кристована Д. Соузы, но я пока не могу комментировать.

Прямой вперед способ использования flushключевого слова аргумента Python 3 для того , чтобы всегда иметь небуферизованный выход есть:

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

после этого print всегда будет сбрасывать вывод напрямую (за исключением flush=Falseзаданного).

Обратите внимание, (а) что это отвечает на вопрос только частично, так как не перенаправляет весь вывод. Но я думаю, printчто это наиболее распространенный способ создания вывода в stdout/ stderrв Python, поэтому эти 2 строки охватывают, вероятно, большинство случаев использования.

Обратите внимание (б), что он работает только в модуле / скрипте, где вы его определили. Это может быть хорошо при написании модуля, так как он не связывается с sys.stdout.

Python 2 не предоставляет flushаргумент, но вы можете эмулировать функцию Python 3-type, 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)

Да, он включен по умолчанию. Вы можете отключить его, используя опцию -u в командной строке при вызове python.

Вы также можете запустить Python с помощью утилиты stdbuf :

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.stdoutкоторый вызывает flush. Предлагаемый способ реализации приведен ниже.

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:
   ...

затем реализация for в CPython будет некоторое время собирать входные данные, а затем выполнять тело цикла для набора входных строк. Если ваш сценарий собирается записать вывод для каждой строки ввода, это может выглядеть как буферизация вывода, но на самом деле это пакетная обработка, и поэтому ни один из flush()методов и т. Д. Не поможет. Интересно, что у вас нет такого поведения в Pypy . Чтобы избежать этого, вы можете использовать

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__