Wyłącz buforowanie danych wyjściowych

Czy buforowanie danych wyjściowych jest domyślnie włączone dla interpretera Pythona sys.stdout?

Jeśli odpowiedź jest pozytywna, jakie są wszystkie sposoby jej wyłączenia?

Dotychczasowe sugestie:

1. Użyj -uprzełącznika wiersza polecenia
2. Zawiń sys.stdoutw obiekt, który opróżnia się po każdym zapisie
3. Ustaw PYTHONUNBUFFEREDenv var
4. sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)

Czy jest jakiś inny sposób na ustawienie globalnej flagi sys/ sys.stdoutprogramowo podczas wykonywania?

Od Magnusa Lycki odpowiedź na liście mailingowej :

Możesz pominąć buforowanie dla całego procesu Pythona, używając „python -u” (lub #! / Usr / bin / env python -u itp.) Lub ustawiając zmienną środowiskową PYTHONUNBUFFERED.

Możesz także zastąpić sys.stdout innym strumieniem, takim jak wrapper, który wykonuje flush po każdym wywołaniu.

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'

Wolę umieścić odpowiedź w Jak opróżnić wyjście funkcji drukowania? lub w funkcji drukowania Pythona, która opróżnia bufor, gdy jest wywoływany? , ale ponieważ zostały oznaczone jako duplikaty tego (czego się nie zgadzam), odpowiem tutaj.

Od wersji Python 3.3 print () obsługuje argument słowa kluczowego „flush” ( patrz dokumentacja ):

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)

Kredyty: „Sebastian”, gdzieś na liście dyskusyjnej Python.

Tak to jest.

Możesz go wyłączyć w wierszu polecenia za pomocą przełącznika „-u”.

Alternatywnie możesz wywołać .flush () na sys.stdout przy każdym zapisie (lub owinąć go obiektem, który robi to automatycznie)

Odnosi się to do odpowiedzi Cristóvão D. Sousy, ale nie mogłem jeszcze komentować.

Prosty sposób użycia flushargumentu słowa kluczowego w Pythonie 3 , aby zawsze mieć niebuforowane dane wyjściowe, jest:

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

potem wydruk zawsze będzie bezpośrednio wylewał wydruk (z wyjątkiem tego, że flush=Falsepodano).

Zauważ, (a), że to odpowiada tylko częściowo na pytanie, ponieważ nie przekierowuje wszystkich wyników. Ale przypuszczamprint wydaje jest to najczęstszy sposób tworzenia danych wyjściowych do stdout/ stderrw pythonie, więc te 2 linie obejmują prawdopodobnie większość przypadków użycia.

Uwaga (b), że działa tylko w module / skrypcie, w którym został zdefiniowany. Może to być dobre podczas pisania modułu, ponieważ nie zadziera zsys.stdout .

Python 2 nie podaje flushargumentu, ale możesz emulować funkcję typu Python 3, printjak opisano tutaj 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"])

Bez zapisania starego sys.stdout funkcja disable_stdout_buffering () nie jest idempotentna, a wiele wywołań spowoduje błąd taki jak ten:

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

Inną możliwością jest:

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)

(Dołączanie do gc.garbage nie jest dobrym pomysłem, ponieważ tam umieszczane są cykle niemożliwe do zniesienia i możesz je sprawdzić).

Poniższe działa w Pythonie 2.6, 2.7 i 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)

Tak, jest domyślnie włączony. Możesz go wyłączyć, używając opcji -u w wierszu poleceń podczas wywoływania Pythona.

Możesz również uruchomić Python za pomocą narzędzia stdbuf :

stdbuf -oL python <script>

W Pythonie 3 możesz małpować łatanie funkcji drukowania, aby zawsze wysyłać flush = True:

_orig_print = print

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

Jak wskazano w komentarzu, można to uprościć, wiążąc parametr flush z wartością za pomocą functools.partial:

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

Możesz także użyć fcntl, aby zmienić flagi plików w locie.

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)

Możliwe jest zastąpienie tylko write metody sys.stdoutz tą, która wywołuje flush. Sugerowana implementacja metody znajduje się poniżej.

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

Domyślna wartość wargumentu zachowa oryginalne writeodniesienie do metody. Po write_flush zdefiniowaniu oryginał writemoże zostać zastąpiony.

stdout.write = write_flush

Kod zakłada, że stdoutjest importowany w ten sposób from sys import stdout.

Możesz utworzyć niebuforowany plik i przypisać ten plik do sys.stdout.

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

Nie można magicznie zmienić standardowego wejścia dostarczonego przez system; ponieważ jest dostarczany do twojego programu python przez system operacyjny.

Wariant, który działa bez awarii (przynajmniej w win32; python 2.7, ipython 0.12), a następnie wywoływany (wielokrotnie):

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)

(Opublikowałem komentarz, ale jakoś się zgubił. Więc jeszcze raz :)

1. Jak zauważyłem, CPython (przynajmniej w Linuksie) zachowuje się inaczej w zależności od tego, gdzie idzie wyjście. Jeśli przejdzie do tty, dane wyjściowe są opróżniane po każdym ' \n'
   Jeśli przejdzie do potoku / procesu, jest buforowany i można użyć flush()rozwiązań bazowych lub opcji -u zalecanej powyżej.

2. Nieznacznie związane z buforowaniem danych wyjściowych:
   jeśli iterujesz po liniach wejścia za pomocą

   for line in sys.stdin:
   ...

wówczas za wdrażanie w CPython będzie zbierać dane wejściowe na chwilę, a następnie wykonać ciało pętli za bandą liniach wejściowych. Jeśli twój skrypt ma zamiar zapisać dane wyjściowe dla każdego wiersza wejściowego, może to wyglądać jak buforowanie danych wyjściowych, ale w rzeczywistości jest ono grupowe, a zatem żadna z flush()technik itp. Nie pomoże. Co ciekawe, nie masz takiego zachowania w pypy . Aby tego uniknąć, możesz użyć

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

Jednym ze sposobów uzyskania niebuforowanych danych wyjściowych byłoby użycie sys.stderrzamiast sys.stdoutlub po prostu wywołanie w sys.stdout.flush()celu jawnego wymuszenia zapisu.

Możesz łatwo przekierować wszystko wydrukowane, wykonując:

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

Lub przekierować tylko dla określonej printinstrukcji:

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

Aby zresetować standardowe wyjście, wystarczy:

sys.stdout = sys.__stdout__