Disabilita il buffering di output

Il buffering dell'output è abilitato di default nell'interprete di Python per sys.stdout?

Se la risposta è positiva, quali sono tutti i modi per disabilitarla?

Suggerimenti finora:

1. Utilizzare l' -uopzione della riga di comando
2. Avvolgere sys.stdoutin un oggetto che arrossisce dopo ogni scrittura
3. Set PYTHONUNBUFFEREDenv var
4. sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)

C'è un altro modo per impostare un flag globale in sys/ sys.stdoutprogrammaticamente durante l'esecuzione?

Da Magnus Lycka rispondi a una mailing list :

Puoi saltare il buffering per un intero processo di Python usando "python -u" (o #! / Usr / bin / env python -u etc) o impostando la variabile d'ambiente PYTHONUNBUFFERED.

Puoi anche sostituire sys.stdout con qualche altro flusso come wrapper che esegue un flush dopo ogni chiamata.

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'

Preferirei inserire la mia risposta in Come svuotare l'output della funzione di stampa? o nella funzione di stampa di Python che svuota il buffer quando viene chiamato? , ma poiché sono stati contrassegnati come duplicati di questo (ciò che non sono d'accordo), risponderò qui.

Da Python 3.3, print () supporta la parola chiave argomento "flush" ( vedi documentazione ):

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)

Riconoscimenti: "Sebastian", da qualche parte nella mailing list di Python.

Sì.

Puoi disabilitarlo dalla riga di comando con l'opzione "-u".

In alternativa, puoi chiamare .flush () su sys.stdout ad ogni scrittura (o avvolgerlo con un oggetto che lo fa automaticamente)

Ciò si riferisce alla risposta di Cristóvão D. Sousa, ma non ho ancora potuto commentare.

Un modo semplice di usare l' flushargomento keyword di Python 3 per avere sempre un output senza buffer è:

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

in seguito, la stampa annulla sempre direttamente l'output (tranne quando flush=Falseviene fornito).

Si noti, (a) che questo risponde alla domanda solo parzialmente in quanto non reindirizza tutto l'output. Ma immagino printsia il modo più comune per creare output in stdout/ stderrin Python, quindi queste 2 righe coprono probabilmente la maggior parte dei casi d'uso.

Si noti (b) che funziona solo nel modulo / script in cui è stato definito. Questo può essere utile quando si scrive un modulo in quanto non si scherza con sys.stdout.

Python 2 non fornisce l' flushargomento, ma è possibile emulare una printfunzione di tipo Python 3 come descritto qui 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"])

Senza salvare il vecchio sys.stdout, disable_stdout_buffering () non è idempotente e più chiamate comporteranno un errore come questo:

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

Un'altra possibilità è:

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)

(L'aggiunta a gc.garbage non è una buona idea perché è dove vengono inseriti i cicli non graditi, e potresti volerli verificare.)

I seguenti lavori in Python 2.6, 2.7 e 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ì, è abilitato per impostazione predefinita. È possibile disabilitarlo utilizzando l'opzione -u sulla riga di comando quando si chiama python.

Puoi anche eseguire Python con l' utilità stdbuf :

stdbuf -oL python <script>

In Python 3, è possibile eseguire il patch di scimmia della funzione di stampa, per inviare sempre flush = True:

_orig_print = print

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

Come sottolineato in un commento, puoi semplificarlo vincolando il parametro flush a un valore, tramite functools.partial:

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

Puoi anche usare fcntl per cambiare i flag di file in volo.

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)

È possibile sovrascrivere solo il write metodo di sys.stdoutcon uno che chiama flush. L'implementazione del metodo suggerito è di seguito.

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

Il valore predefinito wdell'argomento manterrà il writeriferimento al metodo originale . Dopo aver write_flush definito, l'originale writepotrebbe essere ignorato.

stdout.write = write_flush

Il codice presuppone che stdoutsia importato in questo modo from sys import stdout.

È possibile creare un file senza buffer e assegnare questo file a sys.stdout.

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

Non è possibile modificare magicamente lo stdout fornito dal sistema; poiché viene fornito al tuo programma python dal sistema operativo.

Variante che funziona senza crash (almeno su win32; python 2.7, ipython 0.12) quindi chiamata successivamente (più volte):

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)

(Ho pubblicato un commento, ma si è perso in qualche modo. Quindi, ancora :)

1. Come ho notato, CPython (almeno su Linux) si comporta diversamente a seconda di dove va l'output. Se va a tty, l'output viene scaricato dopo ogni ' \n'
   Se va a una pipe / processo, viene bufferizzato e puoi usare le flush()soluzioni basate o l' opzione -u raccomandata sopra.

2. Leggermente correlato al buffering dell'output:
   se si scorre le righe nell'input con

   for line in sys.stdin:
   ...

quindi l' implementazione for in CPython raccoglierà l'input per un po 'e quindi eseguirà il corpo del ciclo per un gruppo di righe di input. Se lo script sta per scrivere l'output per ogni riga di input, potrebbe sembrare un buffering dell'output, ma in realtà è un batch, e quindi nessuna delle flush()tecniche, ecc. Lo aiuterà. È interessante notare che non hai questo comportamento in pypy . Per evitarlo, puoi usare

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

Un modo per ottenere un output senza buffer sarebbe usare sys.stderrinvece di sys.stdouto semplicemente chiamare sys.stdout.flush()per forzare esplicitamente una scrittura.

Puoi reindirizzare facilmente tutto ciò che è stato stampato facendo:

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

O per reindirizzare solo per una printdichiarazione particolare :

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

Per resettare stdout puoi semplicemente fare:

sys.stdout = sys.__stdout__