Wie drucke ich in Python auf stderr?

Es gibt verschiedene Möglichkeiten, an stderr zu schreiben:

# 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)

Das scheint dem Zen von Python # 13 ^† zu widersprechen. Was ist hier also der Unterschied und gibt es auf die eine oder andere Weise Vor- oder Nachteile? Welcher Weg sollte verwendet werden?

^† _{Es sollte einen - und vorzugsweise nur einen - offensichtlichen Weg geben, dies zu tun.}

Ich fand dies die einzige kurze + flexible + tragbare + lesbare:

from __future__ import print_function
import sys

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

Die Funktion eprintkann auf die gleiche Weise wie die Standardfunktion verwendet printwerden:

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

import sys
sys.stderr.write()

Ist meine Wahl, nur besser lesbar und genau das zu sagen, was Sie vorhaben, und über Versionen hinweg portierbar.

Bearbeiten: "Pythonisch" zu sein, ist für mich ein dritter Gedanke in Bezug auf Lesbarkeit und Leistung. In Anbetracht dieser beiden Aspekte werden bei Python 80% Ihres Codes pythonisch sein. Listenverständnis ist das "große Ding", das nicht so oft verwendet wird (Lesbarkeit).

print >> sys.stderrist in Python3 weg. http://docs.python.org/3.0/whatsnew/3.0.html sagt:

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

Für viele von uns ist es etwas unnatürlich, das Ziel bis zum Ende des Befehls zu verbannen. Die Alternative

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

sieht objektorientierter aus und geht elegant vom Generischen zum Spezifischen. Beachten Sie jedoch, dass dies writekein 1: 1-Ersatz für ist print.

Bisher wurde loggingnoch niemand erwähnt , aber die Protokollierung wurde speziell für die Übermittlung von Fehlermeldungen erstellt. Durch die Grundkonfiguration wird ein Stream-Handler eingerichtet, der in stderr schreibt.

Dieses Skript:

# foo.py
import logging

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

hat das folgende Ergebnis, wenn es in der Befehlszeile ausgeführt wird:

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

und bar.txt enthält die auf stdout gedruckte 'Hallo Welt'.

Für Python 2 habe ich die Wahl: print >> sys.stderr, 'spam' Weil Sie einfach Listen / Diktate usw. drucken können, ohne sie in einen String umzuwandeln. print >> sys.stderr, {'spam': 'spam'} anstatt: sys.stderr.write(str({'spam': 'spam'}))

Ich habe Folgendes mit Python 3 gemacht:

from sys import stderr

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

Jetzt kann ich beispielsweise Schlüsselwortargumente hinzufügen, um Wagenrücklauf zu vermeiden:

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

Ich würde sagen, dass Ihr erster Ansatz:

print >> sys.stderr, 'spam' 

ist der "Eine ... offensichtliche Weg, es zu tun" Die anderen erfüllen Regel 1 nicht ("Schön ist besser als hässlich.")

Dies ahmt die Standarddruckfunktion nach, wird jedoch auf stderr ausgegeben

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

In Python 3 kann man einfach print () verwenden:

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

fast out of the box:

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

oder:

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

Dies ist unkompliziert und muss nichts anderes enthalten sys.stderr.

BEARBEITEN Im Nachhinein denke ich, dass die mögliche Verwechslung mit dem Ändern von sys.stderr und dem Nicht-Aktualisieren des Verhaltens dazu führt, dass diese Antwort nicht so gut ist, wie nur eine einfache Funktion zu verwenden, wie andere darauf hingewiesen haben.

Wenn Sie teilweise verwenden, sparen Sie nur 1 Codezeile. Die mögliche Verwirrung ist es nicht wert, 1 Codezeile zu speichern.

Original

Um es noch einfacher zu machen, gibt es hier eine Version, die 'partiell' verwendet, was eine große Hilfe beim Umschließen von Funktionen ist.

from __future__ import print_function
import sys
from functools import partial

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

Sie verwenden es dann so

error('An error occured!')

Sie können überprüfen, ob es auf stderr und nicht auf stdout gedruckt wird, indem Sie die folgenden Schritte ausführen (übergeordneter Code von 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!")

Der Nachteil ist , teilweise Abtretungs den Wert sys.stderr zur gewickelten Funktion zum Zeitpunkt der Erstellung. Das heißt, wenn Sie stderr später umleiten, wird diese Funktion nicht beeinträchtigt. Wenn Sie stderr umleiten möchten, verwenden Sie die von aaguirre auf dieser Seite erwähnte ** kwargs-Methode .

Gleiches gilt für stdout:

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

Wie in den anderen Antworten angegeben, bietet print eine hübsche Oberfläche, die häufig bequemer ist (z. B. zum Drucken von Debug-Informationen), während das Schreiben schneller ist und auch bequemer sein kann, wenn Sie die Ausgabe auf bestimmte Weise genau formatieren müssen. Ich würde auch die Wartbarkeit in Betracht ziehen:

1. Sie können später entscheiden, zwischen stdout / stderr und einer regulären Datei zu wechseln.

2. Die Syntax von print () hat sich in Python 3 geändert. Wenn Sie also beide Versionen unterstützen müssen, ist write () möglicherweise besser.

Ich arbeite in Python 3.4.3. Ich schneide eine kleine Eingabe aus, die zeigt, wie ich hierher gekommen bin:

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

Hat es funktioniert? Versuchen Sie, stderr in eine Datei umzuleiten, und sehen Sie, was passiert:

[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]$

Nun, abgesehen von der Tatsache, dass die kleine Einführung, die Python Ihnen gibt, in stderr geschlürft wurde (wohin würde es sonst gehen?), Funktioniert es.

Wenn Sie einen einfachen Test durchführen:

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))

Sie werden feststellen, dass sys.stderr.write () durchweg 1,81- mal schneller ist!

Wenn Sie ein Programm aufgrund eines schwerwiegenden Fehlers beenden möchten, verwenden Sie:

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

und import sysin der Kopfzeile.

Die Antwort auf die Frage lautet: Es gibt verschiedene Möglichkeiten, stderr in Python zu drucken, aber das hängt davon ab, 1.) welche Python-Version wir verwenden 2.) welche genaue Ausgabe wir wollen.

Der Unterschied zwischen print und der Schreibfunktion von stderr : stderr : stderr (Standardfehler) ist eine Pipe, die in jedes UNIX / Linux-System integriert ist. Wenn Ihr Programm abstürzt und Debugging-Informationen ausgibt (wie ein Traceback in Python), geht es an stderr Rohr.

print : print ist ein Wrapper, der die Eingaben formatiert (die Eingabe ist das Leerzeichen zwischen Argument und Zeilenumbruch am Ende) und dann die Schreibfunktion eines bestimmten Objekts aufruft. Das angegebene Objekt ist standardmäßig sys.stdout, aber wir können Übergeben Sie eine Datei, dh wir können die Eingabe auch in einer Datei drucken.

Python2: Wenn wir dann Python2 verwenden

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

Das nachgestellte Python2-Komma ist in Python3 zu einem Parameter geworden. Wenn wir also nach dem Drucken nachgestellte Kommas verwenden, um die neue Zeile zu vermeiden, sieht dies in Python3 wie print aus ('Text zum Drucken', end = ''), was unter Python2 ein Syntaxfehler ist .

http://python3porting.com/noconv.html

Wenn wir dasselbe oben in Python3 überprüfen:

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

Unter Python 2.6 gibt es einen zukünftigen Import, um den Druck in eine Funktion zu verwandeln. Um Syntaxfehler und andere Unterschiede zu vermeiden, sollten wir jede Datei, in der wir print () verwenden, mit einer zukünftigen import print_function starten. Der zukünftige Import funktioniert nur unter Python 2.6 und höher. Für Python 2.5 und frühere Versionen stehen Ihnen zwei Optionen zur Verfügung. Sie können entweder den komplexeren Druck in etwas Einfacheres konvertieren oder eine separate Druckfunktion verwenden, die sowohl unter Python2 als auch unter Python3 funktioniert.

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

Fall: Beachten Sie, dass sys.stderr.write () oder sys.stdout.write () (stdout (Standardausgabe) ist eine Pipe, die in jedes UNIX / Linux-System integriert ist) kein Ersatz für print ist, aber ja wir können es in einigen Fällen als Alternative verwenden. Print ist ein Wrapper, der die Eingabe am Ende mit Leerzeichen und Zeilenumbruch umschließt und zum Schreiben die Schreibfunktion verwendet. Dies ist der Grund, warum sys.stderr.write () schneller ist.

Hinweis: Wir können das Protokollieren und Debuggen auch mithilfe der Protokollierung durchführen

#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