Désactiver la mise en mémoire tampon de sortie

La mise en mémoire tampon de sortie est-elle activée par défaut dans l'interpréteur Python pour sys.stdout ?

Si la réponse est positive, quelles sont toutes les façons de la désactiver?

Suggestions jusqu'à présent:

1. Utilisez le -ucommutateur de ligne de commande
2. Enveloppez sys.stdoutdans un objet qui se vide après chaque écriture
3. Définir PYTHONUNBUFFEREDenv var
4. sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)

Existe-t-il un autre moyen de définir un indicateur global dans sys/ par sys.stdoutprogramme pendant l'exécution?

De Magnus Lycka répondre sur une liste de diffusion :

Vous pouvez ignorer la mise en mémoire tampon pour un processus python entier en utilisant "python -u" (ou #! / Usr / bin / env python -u etc.) ou en définissant la variable d'environnement PYTHONUNBUFFERED.

Vous pouvez également remplacer sys.stdout par un autre flux comme le wrapper qui effectue un vidage après chaque appel.

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'

Je préfère mettre ma réponse dans Comment vider la sortie de la fonction d'impression? ou dans la fonction d'impression de Python qui vide le tampon quand il est appelé? , mais comme ils ont été marqués comme des doublons de celui-ci (ce que je ne suis pas d'accord), je vais y répondre ici.

Depuis Python 3.3, print () supporte l'argument de mot-clé "flush" ( voir documentation ):

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édits: "Sebastian", quelque part sur la liste de diffusion Python.

Oui, ça l'est.

Vous pouvez le désactiver sur la ligne de commande avec le commutateur "-u".

Alternativement, vous pouvez appeler .flush () sur sys.stdout à chaque écriture (ou l'envelopper avec un objet qui le fait automatiquement)

Cela concerne la réponse de Cristóvão D. Sousa, mais je ne pourrais pas encore commenter.

Une manière simple d'utiliser l' flushargument mot - clé de Python 3 afin d' avoir toujours une sortie sans tampon est:

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

par la suite, l'impression videra toujours directement la sortie (sauf indication contraire flush=False).

Notez, (a) que cela ne répond que partiellement à la question car il ne redirige pas toute la sortie. Mais je suppose que printc'est la façon la plus courante de créer une sortie vers stdout/ stderren python, donc ces 2 lignes couvrent probablement la plupart des cas d'utilisation.

Notez (b) qu'il ne fonctionne que dans le module / script où vous l'avez défini. Cela peut être utile lors de l'écriture d'un module car il ne dérange pas avec le sys.stdout.

Python 2 ne fournit pas l' flushargument, mais vous pouvez émuler une printfonction de type Python 3 comme décrit ici 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"])

Sans enregistrer l'ancien sys.stdout, disable_stdout_buffering () n'est pas idempotent, et plusieurs appels entraîneront une erreur comme celle-ci:

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

Une autre possibilité est:

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'ajout à gc.garbage n'est pas une si bonne idée car c'est là que les cycles non exploitables sont mis en place, et vous voudrez peut-être les vérifier.)

Les travaux suivants dans Python 2.6, 2.7 et 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)

Oui, il est activé par défaut. Vous pouvez le désactiver en utilisant l'option -u sur la ligne de commande lors de l'appel de python.

Vous pouvez également exécuter Python avec l' utilitaire stdbuf :

stdbuf -oL python <script>

En Python 3, vous pouvez patcher la fonction d'impression pour toujours envoyer flush = True:

_orig_print = print

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

Comme indiqué dans un commentaire, vous pouvez simplifier cela en liant le paramètre flush à une valeur, via functools.partial:

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

Vous pouvez également utiliser fcntl pour modifier les indicateurs de fichier à la volée.

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)

Il est possible de remplacer uniquement la write méthode de sys.stdoutcelle qui appelle flush. L'implémentation de méthode suggérée est ci-dessous.

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

La valeur par défaut de l' wargument conservera la writeréférence de méthode d' origine . Une fois write_flush défini, l'original writepeut être remplacé.

stdout.write = write_flush

Le code suppose qu'il stdoutest importé de cette façon from sys import stdout.

Vous pouvez créer un fichier sans tampon et affecter ce fichier à sys.stdout.

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

Vous ne pouvez pas modifier comme par magie la sortie standard fournie par le système; car il est fourni à votre programme python par le système d'exploitation.

Variante qui fonctionne sans planter (au moins sur win32; python 2.7, ipython 0.12) puis appelée par la suite (plusieurs fois):

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)

(J'ai posté un commentaire, mais il s'est perdu d'une manière ou d'une autre. Donc, encore une fois :)

1. Comme je l'ai remarqué, CPython (au moins sous Linux) se comporte différemment selon où va la sortie. S'il va à un tty, la sortie est purgée après chaque ' \n'
   S'il va à un tuyau / processus, alors il est tamponné et vous pouvez utiliser les flush()solutions basées ou l' option -u recommandée ci-dessus.

2. Légèrement lié à la mise en mémoire tampon de sortie:
   si vous parcourez les lignes en entrée avec

   for line in sys.stdin:
   ...

puis pour la mise en œuvre en CPython recueillera l'entrée pendant un certain temps et puis exécutez le corps de la boucle pour une série de lignes d'entrée. Si votre script est sur le point d'écrire la sortie pour chaque ligne d'entrée, cela peut ressembler à une mise en mémoire tampon de sortie, mais il s'agit en fait d'un traitement par lots, et par conséquent, aucune des flush()techniques, etc. n'aidera cela. Fait intéressant, vous n'avez pas ce comportement dans Pypy . Pour éviter cela, vous pouvez utiliser

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

Une façon d'obtenir une sortie non tamponnée serait d'utiliser à la sys.stderrplace de sys.stdoutou d'appeler simplement sys.stdout.flush()pour forcer explicitement l'écriture à se produire.

Vous pouvez facilement rediriger tout ce qui est imprimé en faisant:

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

Ou pour rediriger juste pour une printinstruction particulière :

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

Pour réinitialiser stdout, vous pouvez simplement faire:

sys.stdout = sys.__stdout__