Deaktivieren Sie die Ausgabepufferung

Ist die Ausgabepufferung im Python-Interpreter für standardmäßig aktiviert sys.stdout?

Wenn die Antwort positiv ist, wie können Sie sie deaktivieren?

Bisherige Vorschläge:

1. Verwenden Sie den -uBefehlszeilenschalter
2. Wickeln Sie sys.stdoutein Objekt ein, das nach jedem Schreibvorgang gelöscht wird
3. Setze PYTHONUNBUFFEREDenv var
4. sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)

Gibt es eine andere Möglichkeit, während der Ausführung ein globales Flag in sys/ sys.stdoutprogrammgesteuert zu setzen?

Von Magnus Lycka Antwort auf eine Mailingliste :

Sie können die Pufferung für einen gesamten Python-Prozess mit "python -u" (oder #! / Usr / bin / env python -u usw.) oder durch Setzen der Umgebungsvariablen PYTHONUNBUFFERED überspringen.

Sie können sys.stdout auch durch einen anderen Stream wie den Wrapper ersetzen, der nach jedem Aufruf einen Flush ausführt.

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'

Ich möchte meine Antwort lieber in Wie lösche ich die Ausgabe der Druckfunktion? oder in Pythons Druckfunktion, die den Puffer beim Aufruf leert? , aber da sie als Duplikate von diesem markiert wurden (was ich nicht zustimme), werde ich es hier beantworten.

Seit Python 3.3 unterstützt print () das Schlüsselwortargument "flush" ( siehe Dokumentation ):

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)

Credits: "Sebastian", irgendwo auf der Python-Mailingliste.

Ja, so ist es.

Sie können es in der Befehlszeile mit dem Schalter "-u" deaktivieren.

Alternativ können Sie bei jedem Schreibvorgang .flush () für sys.stdout aufrufen (oder es mit einem Objekt umschließen, das dies automatisch ausführt).

Dies bezieht sich auf die Antwort von Cristóvão D. Sousa, aber ich konnte noch keinen Kommentar abgeben.

Eine einfache Möglichkeit, das flushSchlüsselwortargument von Python 3 zu verwenden, um immer eine ungepufferte Ausgabe zu erhalten, ist:

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

Danach spült der Druck die Ausgabe immer direkt (außer wenn flush=Falseangegeben).

Beachten Sie, (a) dass dies die Frage nur teilweise beantwortet, da nicht die gesamte Ausgabe umgeleitet wird. Aber ich denke, dies printist die häufigste Methode zum Erstellen von Ausgaben für stdout/ stderrin Python. Daher decken diese beiden Zeilen wahrscheinlich die meisten Anwendungsfälle ab.

Beachten Sie (b), dass es nur in dem Modul / Skript funktioniert, in dem Sie es definiert haben. Dies kann beim Schreiben eines Moduls hilfreich sein, da es nicht mit dem Modul in Konflikt gerät sys.stdout.

Python 2 liefert das flushArgument nicht, aber Sie können eine Python 3- printFunktion emulieren, wie hier beschrieben: 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"])

Ohne das Speichern der alten sys.stdout ist disable_stdout_buffering () nicht idempotent, und mehrere Aufrufe führen zu einem Fehler wie dem folgenden:

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

Eine andere Möglichkeit ist:

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)

(Das Anhängen an gc.garbage ist keine so gute Idee, da hier unfrequente Zyklen abgelegt werden und Sie möglicherweise nach diesen suchen möchten.)

Folgendes funktioniert in Python 2.6, 2.7 und 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)

Ja, es ist standardmäßig aktiviert. Sie können es deaktivieren, indem Sie beim Aufrufen von Python die Option -u in der Befehlszeile verwenden.

Sie können Python auch mit dem Dienstprogramm stdbuf ausführen :

stdbuf -oL python <script>

In Python 3 können Sie die Druckfunktion mit einem Affen-Patch versehen, um immer Flush = True zu senden:

_orig_print = print

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

Wie in einem Kommentar erwähnt, können Sie dies vereinfachen, indem Sie den Parameter flush an einen Wert binden, und zwar über functools.partial:

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

Sie können auch fcntl verwenden, um die Dateiflaggen im laufenden Betrieb zu ändern.

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)

Es ist möglich, nur die write Methode von sys.stdoutmit einer aufzurufen, die aufruft flush. Die vorgeschlagene Methodenimplementierung ist unten aufgeführt.

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

Der Standardwert des wArguments behält die ursprüngliche writeMethodenreferenz bei. Nachdem write_flush definiert wurde, wird das Original writemöglicherweise überschrieben.

stdout.write = write_flush

Der Code geht davon aus, dass er auf stdoutdiese Weise importiert wird from sys import stdout.

Sie können eine ungepufferte Datei erstellen und diese Datei sys.stdout zuweisen.

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

Sie können das vom System bereitgestellte Standard nicht auf magische Weise ändern. da es vom Betriebssystem an Ihr Python-Programm geliefert wird.

Variante, die ohne Absturz funktioniert (zumindest unter win32; Python 2.7, Ipython 0.12) und anschließend (mehrmals) aufgerufen wird:

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)

(Ich habe einen Kommentar gepostet, aber er ist irgendwie verloren gegangen. Also nochmal :)

1. Wie ich bemerkt habe, verhält sich CPython (zumindest unter Linux) unterschiedlich, je nachdem, wohin die Ausgabe geht. Wenn es zu einem tty geht, wird die Ausgabe nach jedem 'geleert. \n'
   Wenn es zu einer Pipe / einem Prozess geht, wird es gepuffert und Sie können die oben empfohlenen flush()Lösungen oder die oben empfohlene Option -u verwenden .

2. In geringem Zusammenhang mit der Ausgabepufferung:
   Wenn Sie mit über die Zeilen in der Eingabe iterieren

   for line in sys.stdin:
   ...

Dann sammelt die for- Implementierung in CPython die Eingabe für eine Weile und führt dann den Schleifenkörper für eine Reihe von Eingabezeilen aus. Wenn Ihr Skript im Begriff ist, eine Ausgabe für jede Eingabezeile zu schreiben, sieht dies möglicherweise wie eine Ausgabepufferung aus, es wird jedoch tatsächlich gestapelt, und daher flush()hilft keine der Techniken usw. dabei. Interessanterweise haben Sie dieses Verhalten bei Pypy nicht . Um dies zu vermeiden, können Sie verwenden

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

Eine Möglichkeit, eine ungepufferte Ausgabe zu erhalten, besteht darin, sys.stderranstelle von sys.stdoutoder einfach aufzurufensys.stdout.flush() , um das Schreiben explizit zu erzwingen.

Sie können alles, was gedruckt wurde, leicht umleiten, indem Sie Folgendes tun:

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

Oder um nur für eine bestimmte printAnweisung umzuleiten :

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

Um stdout zurückzusetzen, können Sie einfach Folgendes tun:

sys.stdout = sys.__stdout__