Come stampare su stderr in Python?

Esistono diversi modi per scrivere su stderr:

# Note: this first one does not work in Python 3
print >> sys.stderr, "spam"

sys.stderr.write("spam\n")

os.write(2, b"spam\n")

from __future__ import print_function
print("spam", file=sys.stderr)

Questo sembra contraddire lo zen di Python # 13 ^† , quindi qual è la differenza qui e ci sono vantaggi o svantaggi in un modo o nell'altro? Quale modo dovrebbe essere usato?

^† _{Dovrebbe esserci un modo - e preferibilmente solo uno - ovvio per farlo.}

Ho scoperto che questo è l'unico corto + flessibile + portatile + leggibile:

from __future__ import print_function
import sys

def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)

La funzione eprintpuò essere utilizzata allo stesso modo della printfunzione standard :

>>> print("Test")
Test
>>> eprint("Test")
Test
>>> eprint("foo", "bar", "baz", sep="---")
foo---bar---baz

import sys
sys.stderr.write()

È la mia scelta, solo più leggibile e dicendo esattamente cosa intendi fare e portatile tra le versioni.

Modifica: essere 'pythonic' è un terzo pensiero per me sulla leggibilità e le prestazioni ... con queste due cose in mente, con python l'80% del tuo codice sarà pythonic. la comprensione dell'elenco è la "grande cosa" che non viene utilizzata spesso (leggibilità).

print >> sys.stderrè andato in Python3. http://docs.python.org/3.0/whatsnew/3.0.html dice:

Old: print >> sys.stderr, "fatal error"
New: print("fatal error", file=sys.stderr)

Per molti di noi, sembra in qualche modo innaturale relegare la destinazione alla fine del comando. L'alternativa

sys.stderr.write("fatal error\n")

sembra più orientato agli oggetti e va elegantemente dal generico allo specifico. Ma nota che writenon è un sostituto 1: 1 per print.

Nessuno è loggingancora stato menzionato , ma la registrazione è stata creata appositamente per comunicare messaggi di errore. La configurazione di base imposterà un gestore di flusso che scrive su stderr.

Questo script:

# foo.py
import logging

logging.basicConfig(format='%(message)s')
log = logging.getLogger(__name__)
log.warning('I print to stderr by default')
print('hello world')

ha il seguente risultato quando eseguito sulla riga di comando:

$ python3 foo.py > bar.txt
I print to stderr by default

e bar.txt conterrà il 'ciao mondo' stampato su stdout.

Per Python 2 la mia scelta è: print >> sys.stderr, 'spam' perché puoi semplicemente stampare liste / dicts ecc. Senza convertirlo in stringa. print >> sys.stderr, {'spam': 'spam'} invece di: sys.stderr.write(str({'spam': 'spam'}))

Ho fatto quanto segue usando Python 3:

from sys import stderr

def print_err(*args, **kwargs):
    print(*args, file=stderr, **kwargs)

Quindi ora sono in grado di aggiungere argomenti di parole chiave, ad esempio, per evitare il ritorno a capo:

print_err("Error: end of the file reached. The word ", end='')
print_err(word, "was not found")

Direi che il tuo primo approccio:

print >> sys.stderr, 'spam' 

è il "Uno ... ovvio modo di farlo" Gli altri non soddisfano la regola n. 1 ("Bello è meglio del brutto").

Questo imiterà la funzione di stampa standard ma emetterà su stderr

def print_err(*args):
    sys.stderr.write(' '.join(map(str,args)) + '\n')

In Python 3, si può semplicemente usare print ():

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

quasi fuori dalla scatola:

import sys
print("Hello, world!", file=sys.stderr)

o:

from sys import stderr
print("Hello, world!", file=stderr)

Questo è semplice e non ha bisogno di includere altro sys.stderr.

MODIFICA Con il senno di poi, penso che la potenziale confusione con il cambiamento di sys.stderr e il non vedere il comportamento aggiornato rende questa risposta non buona come usare semplicemente una funzione come altri hanno sottolineato.

L'uso parziale consente di salvare solo 1 riga di codice. La potenziale confusione non vale la pena salvare 1 riga di codice.

originale

Per renderlo ancora più semplice, ecco una versione che usa 'parziale', che è di grande aiuto nelle funzioni di wrapping.

from __future__ import print_function
import sys
from functools import partial

error = partial(print, file=sys.stderr)

Quindi lo usi in questo modo

error('An error occured!')

Puoi verificare che stia stampando su stderr e non stdout procedendo come segue (codice di over-riding da http://coreygoldberg.blogspot.com.au/2009/05/python-redirect-or-turn-off-stdout-and .html ):

# over-ride stderr to prove that this function works.
class NullDevice():
    def write(self, s):
        pass
sys.stderr = NullDevice()

# we must import print error AFTER we've removed the null device because
# it has been assigned and will not be re-evaluated.
# assume error function is in print_error.py
from print_error import error

# no message should be printed
error("You won't see this error!")

Il rovescio della medaglia a questo è parziale assegna il valore di sys.stderr alla funzione wrapped al momento della creazione. Che significa, se reindirizzi stderr in seguito non influirà su questa funzione. Se hai intenzione di reindirizzare stderr, usa il metodo ** kwargs menzionato da aaguirre in questa pagina.

Lo stesso vale per stdout:

print 'spam'
sys.stdout.write('spam\n')

Come indicato nelle altre risposte, print offre un'interfaccia carina che è spesso più conveniente (ad esempio per stampare informazioni di debug), mentre la scrittura è più veloce e può anche essere più conveniente quando si deve formattare l'output esattamente in un certo modo. Considererei anche la manutenibilità:

1. In seguito puoi decidere di passare da stdout / stderr a un file normale.

2. La sintassi di print () è cambiata in Python 3, quindi se è necessario supportare entrambe le versioni, write () potrebbe essere migliore.

Sto lavorando in Python 3.4.3. Sto tagliando un po 'di battitura che mostra come sono arrivato qui:

[18:19 jsilverman@JSILVERMAN-LT7 pexpect]$ python3
>>> import sys
>>> print("testing", file=sys.stderr)
testing
>>>
[18:19 jsilverman@JSILVERMAN-LT7 pexpect]$ 

Ha funzionato? Prova a reindirizzare stderr su un file e guarda cosa succede:

[18:22 jsilverman@JSILVERMAN-LT7 pexpect]$ python3 2> /tmp/test.txt
>>> import sys
>>> print("testing", file=sys.stderr)
>>> [18:22 jsilverman@JSILVERMAN-LT7 pexpect]$
[18:22 jsilverman@JSILVERMAN-LT7 pexpect]$ cat /tmp/test.txt
Python 3.4.3 (default, May  5 2015, 17:58:45)
[GCC 4.9.2] on cygwin
Type "help", "copyright", "credits" or "license" for more information.
testing

[18:22 jsilverman@JSILVERMAN-LT7 pexpect]$

Bene, a parte il fatto che la piccola introduzione che ti dà Python è stata trasformata in stderr (dove altro andrebbe?), Funziona.

Se fai un semplice test:

import time
import sys

def run1(runs):
    x = 0
    cur = time.time()
    while x < runs:
        x += 1
        print >> sys.stderr, 'X'
    elapsed = (time.time()-cur)
    return elapsed

def run2(runs):
    x = 0
    cur = time.time()
    while x < runs:
        x += 1
        sys.stderr.write('X\n')
        sys.stderr.flush()
    elapsed = (time.time()-cur)
    return elapsed

def compare(runs):
    sum1, sum2 = 0, 0
    x = 0
    while x < runs:
        x += 1
        sum1 += run1(runs)
        sum2 += run2(runs)
    return sum1, sum2

if __name__ == '__main__':
    s1, s2 = compare(1000)
    print "Using (print >> sys.stderr, 'X'): %s" %(s1)
    print "Using (sys.stderr.write('X'),sys.stderr.flush()):%s" %(s2)
    print "Ratio: %f" %(float(s1) / float(s2))

Scoprirai che sys.stderr.write () è costantemente 1.81 volte più veloce!

Se si desidera uscire da un programma a causa di un errore irreversibile, utilizzare:

sys.exit("Your program caused a fatal error. ... description ...")

e import sysnell'intestazione.

La risposta alla domanda è: Esistono diversi modi per stampare stderr in Python ma ciò dipende da 1.) quale versione di Python stiamo usando 2.) quale output esatto vogliamo.

La differenza tra print e la funzione di scrittura di stderr : stderr : stderr (errore standard) è una pipe integrata in ogni sistema UNIX / Linux, quando il programma si arresta in modo anomalo e stampa informazioni di debug (come un traceback in Python), va allo stderr tubo.

Stampa : print è un wrapper che formatta gli input (l'input è lo spazio tra argomento e la nuova riga alla fine) e quindi chiama la funzione di scrittura di un determinato oggetto, l'oggetto dato di default è sys.stdout, ma possiamo passare un file, cioè possiamo anche stampare l'input in un file.

Python2: Se stiamo usando python2, allora

>>> import sys
>>> print "hi"
hi
>>> print("hi")
hi
>>> print >> sys.stderr.write("hi")
hi

La virgola finale di Python2 è diventata un parametro in Python3, quindi se usiamo le virgole finali per evitare la nuova riga dopo una stampa, in Python3 sembrerà print ('Text to print', end = '') che è un errore di sintassi in Python2 .

http://python3porting.com/noconv.html

Se controlliamo lo stesso sopra sceario in python3:

>>> import sys
>>> print("hi")
hi

In Python 2.6 c'è un'importazione futura per rendere la stampa in una funzione. Quindi, per evitare errori di sintassi e altre differenze, dovremmo iniziare qualsiasi file in cui utilizziamo print () dalla futura import print_function. L' importazione futura funziona solo con Python 2.6 e versioni successive, quindi per Python 2.5 e versioni precedenti hai due opzioni. Puoi convertire la stampa più complessa in qualcosa di più semplice oppure puoi utilizzare una funzione di stampa separata che funziona sia con Python2 che con Python3.

>>> from __future__ import print_function
>>> 
>>> def printex(*args, **kwargs):
...     print(*args, file=sys.stderr, **kwargs)
... 
>>> printex("hii")
hii
>>>

Caso: si noti che sys.stderr.write () o sys.stdout.write () (stdout (output standard) è una pipe integrata in ogni sistema UNIX / Linux) non è un sostituto per la stampa, ma sì possiamo usarlo come alternativa in alcuni casi. Stampa è un wrapper che avvolge l'input con spazio e newline alla fine e utilizza la funzione di scrittura per scrivere. Questo è il motivo per cui sys.stderr.write () è più veloce.

Nota: possiamo anche tracciare ed eseguire il debug utilizzando la registrazione

#test.py
import logging
logging.info('This is the existing protocol.')
FORMAT = "%(asctime)-15s %(clientip)s %(user)-8s %(message)s"
logging.basicConfig(format=FORMAT)
d = {'clientip': '192.168.0.1', 'user': 'fbloggs'}
logging.warning("Protocol problem: %s", "connection reset", extra=d)

https://docs.python.org/2/library/logging.html#logger-objects