pyplot - title matplotlib python




Come svuotare l'output della funzione di stampa? (10)

Come svuotare l'output di stampa Python?

Suggerisco cinque modi per farlo:

  • In Python 3, call print(..., flush=True) (l'argomento flush non è disponibile nella funzione di stampa di Python 2 e non esiste alcun analogo per l'istruzione print).
  • Chiama file.flush() sul file di output (possiamo avvolgere la funzione di stampa di python 2 per fare ciò), ad esempio, sys.stdout
  • applicare questo ad ogni chiamata di funzione di stampa nel modulo con una funzione parziale,
    print = partial(print, flush=True) applicato al modulo global.
  • applicare questo al processo con un flag ( -u ) passato al comando interprete
  • applicalo a ogni processo python nel tuo ambiente con PYTHONUNBUFFERED=TRUE (e disinserisci la variabile per annullarla).

Python 3.3+

Utilizzando Python 3.3 o versioni successive, puoi fornire flush=True come argomento della parola chiave per la funzione di print :

print('foo', flush=True) 

Python 2 (o <3.3)

Non hanno eseguito il backport dell'argomento flush a Python 2.7 Quindi, se stai usando Python 2 (o meno di 3.3) e vuoi un codice compatibile sia con 2 che con 3, posso suggerire il seguente codice di compatibilità. (Nota: l'importazione __future__ deve essere in / molto "vicino alla parte superiore del tuo modulo "):

from __future__ import print_function
import sys

if sys.version_info[:2] < (3, 3):
    old_print = print
    def print(*args, **kwargs):
        flush = kwargs.pop('flush', False)
        old_print(*args, **kwargs)
        if flush:
            file = kwargs.get('file', sys.stdout)
            # Why might file=None? IDK, but it works for print(i, file=None)
            file.flush() if file is not None else sys.stdout.flush()

Il suddetto codice di compatibilità coprirà la maggior parte degli usi, ma per un trattamento molto più approfondito, vedere il modulo six .

In alternativa, puoi chiamare file.flush() dopo la stampa, ad esempio, con l'istruzione print in Python 2:

import sys
print 'delayed output'
sys.stdout.flush()

Modifica del valore predefinito in un modulo per lo flush=True

È possibile modificare l'impostazione predefinita per la funzione di stampa utilizzando functools.partial sull'ambito globale di un modulo:

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

se guardi la nostra nuova funzione parziale, almeno in Python 3:

>>> print = functools.partial(print, flush=True)
>>> print
functools.partial(<built-in function print>, flush=True)

Possiamo vedere che funziona come normale:

>>> print('foo')
foo

E possiamo effettivamente ignorare il nuovo valore predefinito:

>>> print('foo', flush=False)
foo

Nota ancora, questo cambia solo l'ambito globale corrente, perché il nome di stampa sull'attuale ambito globale oscurerà la funzione di print incorporata (o dereferenzia la funzione di compatibilità, se si utilizza Python 2, in questo ambito globale corrente).

Se vuoi farlo all'interno di una funzione anziché sull'ambito globale di un modulo, dovresti dargli un nome diverso, ad esempio:

def foo():
    printf = functools.partial(print, flush=True)
    printf('print stuff like this')

Se lo dichiari globale in una funzione, lo stai modificando nel namespace globale del modulo, quindi dovresti semplicemente inserirlo nello spazio dei nomi globale, a meno che quel comportamento specifico sia esattamente quello che vuoi.

Modifica del valore predefinito per il processo

Penso che l'opzione migliore qui sia usare il flag -u per ottenere un output senza buffer.

$ python -u script.py

o

$ python -um package.module

Dai docs :

Forza lo stdin, lo stdout e lo stderr per essere completamente senza buffer. Sui sistemi dove è importante, metti anche stdin, stdout e stderr in modalità binaria.

Si noti che esiste un buffer interno in file.readlines () e Oggetti file (per riga in sys.stdin) che non è influenzato da questa opzione. Per ovviare a questo, vorrete usare file.readline () all'interno di un while 1: loop.

Modifica del valore predefinito per l'ambiente operativo della shell

È possibile ottenere questo comportamento per tutti i processi python nell'ambiente o negli ambienti che ereditano dall'ambiente se si imposta la variabile di ambiente su una stringa non vuota:

ad esempio, in Linux o OSX:

$ export PYTHONUNBUFFERED=TRUE

o Windows:

C:\SET PYTHONUNBUFFERED=TRUE

dai docs :

PYTHONUNBUFFERED

Se questo è impostato su una stringa non vuota equivale a specificare l'opzione -u.

appendice

Ecco l'aiuto sulla funzione di stampa di Python 2.7.12 - nota che non c'è argomento di flush :

>>> from __future__ import print_function
>>> help(print)
print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout)

    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file: a file-like object (stream); defaults to the current sys.stdout.
    sep:  string inserted between values, default a space.
    end:  string appended after the last value, default a newline.

Come posso forzare la funzione di stampa di Python per l'output sullo schermo?

Questo non è un duplicato di Disabilita buffer di output : la domanda collegata sta tentando l'output senza buffer, mentre questa è più generale. Le risposte migliori in questa domanda sono troppo potenti o coinvolte per questo (non sono buone risposte per questo) e questa domanda può essere trovata su Google da un parente principiante.


Con Python 3.x hanno esteso la funzione print() :

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

Quindi, puoi semplicemente fare:

print("Visiting toilet", flush=True)

Ingresso di documenti Python


Ecco la mia versione, che fornisce anche writelines () e fileno ():

class FlushFile(object):
    def __init__(self, fd):
        self.fd = fd

    def write(self, x):
        ret = self.fd.write(x)
        self.fd.flush()
        return ret

    def writelines(self, lines):
        ret = self.writelines(lines)
        self.fd.flush()
        return ret

    def flush(self):
        return self.fd.flush

    def close(self):
        return self.fd.close()

    def fileno(self):
        return self.fd.fileno()

Eseguendo python -h , vedo un'opzione della riga di comando :

-u: stdout e stderr binari non bufferizzati; anche PYTHONUNBUFFERED = x vedi man page per i dettagli sul buffering interno relativo a '-u'

Ecco il documento pertinente .


Inoltre, come suggerito in questo blog, è possibile riaprire sys.stdout in modalità unbuffered:

sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)

Ogni operazione di stdout.write e di print verrà automaticamente scaricata in seguito.


L'ho fatto in Python 3.4:

'''To write to screen in real-time'''
message = lambda x: print(x, flush=True, end="")
message('I am flushing out now...')

La soluzione di Dan adorata! Per python3 do:

import io,sys
class flushfile:
    def __init__(self, f):
        self.f = f
    def write(self, x):
        self.f.write(x)
        self.f.flush()
sys.stdout = flushfile(sys.stdout)

Perché non provare a utilizzare un file senza buffer?

f = open('xyz.log', 'a', 0)

O

sys.stdout = open('out.log', 'a', 0)

import sys
print 'This will be output immediately.'
sys.stdout.flush()





flush