Deshabilitar el búfer de salida

¿Está habilitado el almacenamiento en búfer de salida de forma predeterminada en el intérprete de Python sys.stdout?

Si la respuesta es positiva, ¿cuáles son todas las formas de desactivarla?

Sugerencias hasta el momento:

1. Use el -uinterruptor de línea de comando
2. Envuelva sys.stdouten un objeto que se enjuague después de cada escritura
3. Establecer PYTHONUNBUFFEREDenv var
4. sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)

¿Hay alguna otra forma de establecer algún indicador global sys/ sys.stdoutprogramáticamente durante la ejecución?

De la respuesta de Magnus Lycka en una lista de correo :

Puede omitir el almacenamiento en búfer para un proceso completo de python usando "python -u" (o #! / Usr / bin / env python -u, etc.) o configurando la variable de entorno PYTHONUNBUFFERED.

También puede reemplazar sys.stdout con alguna otra secuencia como wrapper que realiza una descarga después de cada llamada.

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'

Prefiero poner mi respuesta en ¿Cómo vaciar la salida de la función de impresión? o en la función de impresión de Python que vacía el búfer cuando se llama? , pero como se marcaron como duplicados de este (lo que no estoy de acuerdo), lo responderé aquí.

Desde Python 3.3, print () admite el argumento de la palabra clave "flush" ( ver documentación ):

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)

Créditos: "Sebastian", en algún lugar de la lista de correo de Python.

Sí lo es.

Puede deshabilitarlo en la línea de comandos con el interruptor "-u".

Alternativamente, puede llamar a .flush () en sys.stdout en cada escritura (o envolverlo con un objeto que lo haga automáticamente)

Esto se relaciona con la respuesta de Cristóvão D. Sousa, pero aún no puedo comentar.

Una forma directa de utilizar el flushargumento de palabra clave de Python 3 para tener siempre una salida sin búfer es:

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

luego, la impresión siempre vaciará la salida directamente (excepto que flush=Falsese indique).

Tenga en cuenta, (a) que esto responde la pregunta solo parcialmente, ya que no redirige toda la salida. Pero supongo que printes la forma más común de crear resultados en stdout/ stderren python, por lo que estas 2 líneas cubren probablemente la mayoría de los casos de uso.

Tenga en cuenta (b) que solo funciona en el módulo / script donde lo definió. Esto puede ser bueno al escribir un módulo, ya que no se mete con el sys.stdout.

Python 2 no proporciona el flushargumento, pero podría emular una printfunción de tipo Python 3 como se describe aquí 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"])

Sin guardar el viejo sys.stdout, disable_stdout_buffering () no es idempotente, y múltiples llamadas resultarán en un error como este:

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

Otra posibilidad es:

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)

(Agregar a gc.garbage no es una buena idea porque es donde se ponen los ciclos no liberables, y es posible que desee verificarlos).

Lo siguiente funciona en Python 2.6, 2.7 y 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)

Sí, está habilitado por defecto. Puede deshabilitarlo utilizando la opción -u en la línea de comando cuando llame a python.

También puede ejecutar Python con la utilidad stdbuf :

stdbuf -oL python <script>

En Python 3, puede parchear la función de impresión para enviar siempre flush = True:

_orig_print = print

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

Como se señaló en un comentario, puede simplificar esto vinculando el parámetro de vaciado a un valor, a través de functools.partial:

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

También puede usar fcntl para cambiar las marcas de archivo al vuelo.

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 posible anular solo el write método de sys.stdoutuno que llame flush. La implementación del método sugerido se encuentra a continuación.

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

El valor predeterminado del wargumento mantendrá la writereferencia del método original . Después de que write_flush se define, el original writepodría ser anulado.

stdout.write = write_flush

El código supone que stdoutse importa de esta manera from sys import stdout.

Puede crear un archivo sin búfer y asignar este archivo a sys.stdout.

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

No puede cambiar mágicamente la salida estándar proporcionada por el sistema; ya que es suministrado a su programa python por el sistema operativo.

Variante que funciona sin fallar (al menos en win32; python 2.7, ipython 0.12) y luego se llama posteriormente (varias veces):

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)

(He publicado un comentario, pero se perdió de alguna manera. Entonces, de nuevo :)

1. Como noté, CPython (al menos en Linux) se comporta de manera diferente dependiendo de dónde vaya la salida. Si va a un tty, entonces la salida se vacía después de cada ' \n'
   Si va a una tubería / proceso, entonces se almacena en búfer y puede usar las flush()soluciones basadas o la opción -u recomendada anteriormente.

2. Ligeramente relacionado con el búfer de salida:
   si itera sobre las líneas en la entrada con

   for line in sys.stdin:
   ...

entonces el para aplicación en CPython recogerá la entrada por un tiempo y luego ejecutar el cuerpo del bucle para un grupo de líneas de entrada. Si su script está a punto de escribir la salida para cada línea de entrada, esto podría parecer un buffer de salida, pero en realidad es un proceso por lotes, y por lo tanto, ninguna de las flush()técnicas, etc., lo ayudará. Curiosamente, no tienes este comportamiento en pypy . Para evitar esto, puede usar

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

Una forma de obtener resultados sin búfer sería usar en sys.stderrlugar de sys.stdouto simplemente llamar sys.stdout.flush()para forzar explícitamente a que ocurra una escritura.

Puede redirigir fácilmente todo lo impreso haciendo:

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

O para redirigir solo para una printdeclaración particular :

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

Para restablecer stdout solo puedes hacer:

sys.stdout = sys.__stdout__