Вимкнути вихідну буферизацію

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

Якщо відповідь позитивна, які існують способи її відключення?

Поки що пропозиції:

1. Використовуйте -uперемикач командного рядка
2. Загорніть sys.stdoutу предмет, який змивається після кожного запису
3. Встановити PYTHONUNBUFFEREDenv var
4. sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)

Чи є якийсь інший спосіб встановити якийсь глобальний прапор в sys/ sys.stdoutпрограмно під час виконання?

Від Magnus Lycka відповідь на список розсилки :

Ви можете пропустити буферизацію для всього процесу 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)

після цього друк завжди буде прямо вимикати висновки (крім flush=Falseвказаного).

Зауважте, (а), що це відповідає на питання лише частково, оскільки не перенаправляє весь результат. Але я здогадуюсь, printце найпоширеніший спосіб створення виводу в stdout/ stderrу python, тому ці 2 рядки охоплюють, мабуть, більшість випадків використання.

Зауважте (б), що він працює лише в модулі / скрипті, де ви його визначили. Це може бути добре при написанні модуля, оскільки він не псується з 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, enable_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)

Як зазначено в коментарі, ви можете спростити це, прив’язавши параметр флеш до значення за допомогою 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

Ви не можете чарівно змінити поданий системою stdout; оскільки він постачається до вашої програми 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 деякий час буде збирати вхід, а потім виконувати тіло циклу для куки вхідних рядків. Якщо ваш сценарій збирається записати вихід для кожного рядка введення, це може виглядати як буферизація вихідних даних, але насправді це пакетне завантаження, і, отже, жодна із 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!"

Щоб скинути stdout, ви можете просто зробити:

sys.stdout = sys.__stdout__