Desativar buffer de saída

O buffer de saída está ativado por padrão no intérprete do Python para sys.stdout?

Se a resposta for positiva, quais são as formas de desativá-la?

Sugestões até agora:

1. Use a -uopção de linha de comando
2. Envolver sys.stdoutum objeto que libere após cada gravação
3. Definir PYTHONUNBUFFEREDenv var
4. sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)

Existe alguma outra maneira de definir algum sinalizador global sys/ sys.stdoutprogramaticamente durante a execução?

De Magnus Lycka, responda em uma lista de discussão :

Você pode pular o buffer para um processo python inteiro usando "python -u" (ou #! / Usr / bin / env python -u etc) ou configurando a variável de ambiente PYTHONUNBUFFERED.

Você também pode substituir o sys.stdout por algum outro fluxo, como o wrapper, que executa um flush após cada chamada.

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'

Prefiro colocar minha resposta em Como liberar a saída da função de impressão? ou na função de impressão do Python que libera o buffer quando é chamado? , mas como foram marcados como duplicados (o que não concordo), responderei aqui.

Desde o Python 3.3, print () suporta o argumento da palavra-chave "flush" ( consulte a documentação ):

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", em algum lugar da lista de discussão em Python.

Sim, ele é.

Você pode desativá-lo na linha de comando com a opção "-u".

Como alternativa, você pode chamar .flush () no sys.stdout em cada gravação (ou agrupá-lo com um objeto que faça isso automaticamente)

Isso está relacionado à resposta de Cristóvão D. Sousa, mas ainda não pude comentar.

Uma maneira direta de usar o flushargumento de palavra - chave do Python 3 para sempre ter saída sem buffer é:

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

depois, a impressão sempre liberará a saída diretamente (exceto se flush=Falsefor fornecido).

Observe que (a) isso responde apenas parcialmente à pergunta, pois não redireciona toda a saída. Mas eu acho que printé a maneira mais comum de criar saída para stdout/ stderrem python, portanto essas duas linhas cobrem provavelmente a maioria dos casos de uso.

Observe (b) que ele funciona apenas no módulo / script em que você o definiu. Isso pode ser bom ao escrever um módulo, pois não mexe com o sys.stdout.

O Python 2 não fornece o flushargumento, mas você pode emular uma printfunção do tipo Python 3, conforme descrito aqui 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"])

Sem salvar o sys.stdout antigo, disable_stdout_buffering () não é idempotente e várias chamadas resultarão em um erro 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

Outra possibilidade é:

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)

(Anexar ao gc.garbage não é uma boa idéia, pois é onde os ciclos não-viáveis ​​são colocados, e você pode procurar por eles.)

O seguinte funciona no 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)

Sim, está ativado por padrão. Você pode desativá-lo usando a opção -u na linha de comando ao chamar python.

Você também pode executar o Python com o utilitário stdbuf :

stdbuf -oL python <script>

No Python 3, você pode aplicar um patch de macaco na função de impressão, para sempre enviar flush = True:

_orig_print = print

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

Conforme indicado em um comentário, você pode simplificar isso vinculando o parâmetro flush a um valor, via functools.partial:

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

Você também pode usar o fcntl para alterar os sinalizadores de arquivo rapidamente.

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)

É possível substituir apenas o write método de sys.stdoutum que chama flush. A implementação do método sugerido está abaixo.

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

O valor padrão do wargumento manterá a writereferência do método original . Depois de write_flush definido, o original writepode ser substituído.

stdout.write = write_flush

O código assume que stdouté importado dessa maneira from sys import stdout.

Você pode criar um arquivo sem buffer e atribuir esse arquivo a sys.stdout.

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

Você não pode alterar magicamente o stdout fornecido pelo sistema; desde que ele seja fornecido ao seu programa python pelo sistema operacional.

Variante que funciona sem travar (pelo menos no win32; python 2.7, ipython 0.12) e depois chamada posteriormente (várias vezes):

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)

(Eu publiquei um comentário, mas ele se perdeu de alguma forma. Então, novamente :)

1. Como notei, o CPython (pelo menos no Linux) se comporta de maneira diferente, dependendo de onde a saída vai. Se for para tty, a saída será liberada após cada ' \n'
   Se for para um tubo / processo, será armazenada em buffer e você poderá usar as flush()soluções baseadas ou a opção -u recomendada acima.

2. Ligeiramente relacionado ao buffer de saída:
   se você iterar nas linhas na entrada com

   for line in sys.stdin:
   ...

então a implementação for no CPython coletará a entrada por um tempo e, em seguida, executará o corpo do loop para várias linhas de entrada. Se o seu script estiver prestes a gravar a saída para cada linha de entrada, isso pode parecer um buffer de saída, mas na verdade é um lote e, portanto, nenhuma das flush()técnicas etc. ajudará isso. Curiosamente, você não tem esse comportamento no pypy . Para evitar isso, você pode usar

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

Uma maneira de obter saída sem buffer seria usar em sys.stderrvez de sys.stdoutou simplesmente chamar sys.stdout.flush()para forçar explicitamente uma gravação a ocorrer.

Você pode redirecionar facilmente tudo impresso fazendo:

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

Ou para redirecionar apenas para uma printinstrução específica :

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

Para redefinir o stdout, você pode simplesmente fazer:

sys.stdout = sys.__stdout__