Desactivar el almacenamiento en memoria intermedia de salida

Question

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

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

Sugerencias hasta ahora:

1. Use el interruptor de la línea -u comando
2. Wrap sys.stdout en un objeto que elimina después de cada escritura
3. Establecer PYTHONUNBUFFERED env var
4. sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)

¿Hay alguna otra manera de establecer un poco de fla mundial g en sys/sys.stdout programmatically durante la ejecución?

Answer 1

De Magnus Lycka answer on a mailing list:

You can skip buffering for a whole python process using "python -u" (or#!/usr/bin/env python -u etc) or by setting the environment variable PYTHONUNBUFFERED.

You could also replace sys.stdout with some other stream like wrapper which does a flush after every call.

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' 

Answer 2

Sí, lo es.

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

Alternativamente, se podría llamar .flush() en sys.stdout en cada escritura (o envolverlo con un objeto que lo hace automáticamente)

Answer 3

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

Answer 4

Una forma de obtener una salida sin búfer sería usar sys.stderr en lugar de sys.stdout o simplemente llamar al sys.stdout.flush() para forzar explícitamente la escritura.

Desde aquí se puede redirigir todo lo impreso por hacer:

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

O para redirigir sólo para un determinado print declaración:

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

Para restablecer la salida estándar sólo se puede hacer:

sys.stdout = sys.__stdout__ 

Answer 5

Puede crear un archivo sin búfer y asignarlo a sys.stdou t.

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

No se puede cambiar mágicamente la salida estándar suministrada por el sistema; ya que el sistema operativo lo proporciona a su programa python.

Answer 6

# reopen stdout file descriptor with write mode 
# and 0 as the buffer size (unbuffered) 
sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0) 

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

Answer 7

También puede usar fcntl para cambiar las banderas del archivo en 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) 

Answer 8

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 los viejos sys.stdout, disable_stdout_buffering() no es idempotente, y múltiples llamadas dará lugar a 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) 

(Al añadir a gc.garbage no es un buen ejemplo . idea porque es donde consiguen puestos ciclos unfreeable, y es posible que desee comprobar para aquellos)

Answer 9

variante que funciona sin que se caiga (por lo menos en win32; Python 2.7, ipython 0,12), entonces llamado 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) 

Answer 10

prefiero poner mi respuesta en How to flush output of Python print? o en Python's print function that flushes the buffer when it's called?, pero desde que fueron marcados como duplicados de éste (lo que no estoy de acuerdo), voy a responder aquí.

Como Python 3.3 print() apoya el argumento de palabra clave "flush" (see documentation):

print('Hello World!', flush=True) 

Answer 11

(He publicado un comentario, pero se perdió alguna manera Así que, de nuevo :)

.

1. Como noté, CPython (al menos en Linux) se comporta de manera diferente dependiendo de a dónde va la salida. Si va a un tty, 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 soluciones flush() o la opción -u -u recomendada anteriormente.

2. ligeramente en relación con el almacenamiento en búfer de salida:
   Si iterar 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 secuencia de comandos está a punto de escribir salida para cada línea de entrada, esto podría parecerse al almacenamiento en búfer de salida, pero en realidad es de procesamiento por lotes, y por lo tanto, ninguna de las técnicas de flush(), etc. lo ayudará. Curiosamente, no tiene este comportamiento en pypy. Para evitar esto, puede utilizar

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

Answer 12

las siguientes obras 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) 

Answer 13

También puede ejecutar Python con stdbuf utilidad:

stdbuf -oL python <script>

Answer 14

Esto se relaciona t o La respuesta de Cristóvão D. Sousa, pero no pude comentar aún.

Una forma recta de avance de la utilización de la flush palabra clave argumento de Python 3 con el fin de siempre tienen salida sin búfer es:

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

después, la impresión siempre enjuagar la salida directa (excepto flush=False es dado).

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

Nota (b) que solo funciona en el módulo/script donde lo definió. Esto puede ser bueno cuando se escribe un módulo, ya que no se mezcla con el sys.stdout.

Python 2 no proporciona el argumento flush, pero se puede emular un pitón de tipo 3 función print como se describe aquí https://stackoverflow.com/a/27991478/3734258.

Answer 15

Es posible anular únicawrite método de sys.stdout con uno que llama flush. La implementación del método sugerido está a continuación.

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

valor predeterminado de w argumento mantendrá referencia original write método. Después de definirwrite_flush, se puede anular el write original.

stdout.write = write_flush 

El código se supone que es importado stdout esta manera from sys import stdout.