Comment imprimer sur stderr en Python?

Il y a plusieurs façons d'écrire sur 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)

Cela semble contredire le zen de Python # 13 ^† , alors quelle est la différence ici et y a-t-il des avantages ou des inconvénients d'une manière ou d'une autre? Quelle voie utiliser?

^† _{Il devrait y avoir une - et de préférence une seule - façon évidente de le faire.}

J'ai trouvé que c'était le seul court + flexible + portable + lisible:

from __future__ import print_function
import sys

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

La fonction eprintpeut être utilisée de la même manière que la printfonction standard :

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

import sys
sys.stderr.write()

Est mon choix, juste plus lisible et dit exactement ce que vous avez l'intention de faire et portable sur plusieurs versions.

Edit: être 'pythonic' est une troisième pensée pour moi sur la lisibilité et les performances ... avec ces deux choses à l'esprit, avec python 80% de votre code sera pythonic. la compréhension de la liste étant la «grande chose» qui n'est pas utilisée aussi souvent (lisibilité).

print >> sys.stderrest parti en Python3. http://docs.python.org/3.0/whatsnew/3.0.html dit:

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

Pour beaucoup d'entre nous, il semble quelque peu contre nature de reléguer la destination à la fin de la commande. L'alternative

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

semble plus orienté objet et passe avec élégance du générique au spécifique. Mais notez que ce writen'est pas un remplacement 1: 1 pour print.

Personne n'est loggingencore mentionné , mais la journalisation a été créée spécifiquement pour communiquer les messages d'erreur. La configuration de base mettra en place un gestionnaire de flux écrivant sur stderr.

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

a le résultat suivant lorsqu'il est exécuté sur la ligne de commande:

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

et bar.txt contiendra le «bonjour du monde» imprimé sur stdout.

Pour Python 2, mon choix est le suivant: print >> sys.stderr, 'spam' parce que vous pouvez simplement imprimer des listes / dict, etc. sans les convertir en chaîne. print >> sys.stderr, {'spam': 'spam'} au lieu de: sys.stderr.write(str({'spam': 'spam'}))

J'ai fait ce qui suit en utilisant Python 3:

from sys import stderr

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

Alors maintenant, je peux ajouter des arguments de mots clés, par exemple, pour éviter le retour chariot:

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

Je dirais que votre première approche:

print >> sys.stderr, 'spam' 

est le "Un ... moyen évident de le faire" Les autres ne satisfont pas à la règle n ° 1 ("Beau vaut mieux que laid.")

Cela imitera la fonction d'impression standard mais sortira sur stderr

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

En Python 3, on peut simplement utiliser print ():

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

presque sorti de la boîte:

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

ou:

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

C'est simple et n'a pas besoin d'inclure quoi que ce soit d'autre sys.stderr.

ÉDITER Avec le recul, je pense que la confusion potentielle avec le changement de sys.stderr et le fait de ne pas voir le comportement mis à jour rend cette réponse pas aussi bonne que l'utilisation d'une fonction simple comme d'autres l'ont souligné.

L'utilisation de partiel ne vous fait économiser qu'une ligne de code. La confusion potentielle ne vaut pas la peine d'enregistrer 1 ligne de code.

original

Pour le rendre encore plus facile, voici une version qui utilise «partiel», ce qui est d'une grande aide dans les fonctions d'emballage.

from __future__ import print_function
import sys
from functools import partial

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

Vous l'utilisez ensuite comme ça

error('An error occured!')

Vous pouvez vérifier qu'il imprime sur stderr et non stdout en procédant comme suit (en remplaçant le code de 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!")

L'inconvénient de ceci est partiels ayants la valeur de sys.stderr à la fonction enroulée au moment de la création. Ce qui signifie que si vous redirigez stderr plus tard, cela n'affectera pas cette fonction. Si vous prévoyez de rediriger stderr, utilisez la méthode ** kwargs mentionnée par aaguirre sur cette page.

Il en va de même pour la sortie standard:

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

Comme indiqué dans les autres réponses, l' impression offre une jolie interface qui est souvent plus pratique (par exemple pour imprimer des informations de débogage), tandis que l' écriture est plus rapide et peut également être plus pratique lorsque vous devez formater la sortie exactement d'une certaine manière. Je considérerais également la maintenabilité:

1. Vous pouvez ensuite décider de basculer entre stdout / stderr et un fichier normal.

2. La syntaxe de print () a changé en Python 3, donc si vous avez besoin de prendre en charge les deux versions, write () pourrait être mieux.

Je travaille en python 3.4.3. Je découpe un petit texte qui montre comment je suis arrivé ici:

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

Cela a-t-il fonctionné? Essayez de rediriger stderr vers un fichier et voyez ce qui se passe:

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

Eh bien, à part le fait que la petite introduction que python vous donne a été insinuée dans stderr (où cela irait-il?), Cela fonctionne.

Si vous faites un test simple:

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

Vous constaterez que sys.stderr.write () est toujours 1,81 fois plus rapide!

Si vous souhaitez quitter un programme en raison d'une erreur fatale, utilisez:

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

et import sysdans l'en-tête.

La réponse à la question est: Il existe différentes manières d'imprimer stderr en python mais cela dépend de 1.) quelle version de python nous utilisons 2.) quelle sortie exacte nous voulons.

La différence entre l'impression et la fonction d'écriture de stderr : stderr : stderr (erreur standard) est un canal intégré à chaque système UNIX / Linux, lorsque votre programme se bloque et imprime des informations de débogage (comme une traceback en Python), il va au stderr tuyau.

impression : print est un wrapper qui formate les entrées (l'entrée est l'espace entre l'argument et la nouvelle ligne à la fin) et appelle ensuite la fonction d'écriture d'un objet donné, l'objet donné par défaut est sys.stdout, mais nous pouvons passer un fichier, c'est-à-dire que nous pouvons également imprimer l'entrée dans un fichier.

Python2: Si nous utilisons python2,

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

En Python3, la virgule de fin Python2 est devenue un paramètre, donc si nous utilisons des virgules de fin pour éviter la nouvelle ligne après une impression, cela ressemblera en Python3 à print ('Text to print', end = '') qui est une erreur de syntaxe sous Python2 .

http://python3porting.com/noconv.html

Si nous vérifions le même sceario ci-dessus en python3:

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

Sous Python 2.6, il y a une future importation pour faire de l'impression une fonction. Donc, pour éviter toute erreur de syntaxe et autres différences, nous devons démarrer tout fichier dans lequel nous utilisons print () avec la future import print_function. La future importation ne fonctionne que sous Python 2.6 et versions ultérieures, donc pour Python 2.5 et versions antérieures, vous avez deux options. Vous pouvez soit convertir l'impression plus complexe en quelque chose de plus simple, soit utiliser une fonction d'impression distincte qui fonctionne sous Python2 et Python3.

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

Cas: Il convient de noter que sys.stderr.write () ou sys.stdout.write () (stdout (sortie standard) est un canal intégré à chaque système UNIX / Linux) ne remplace pas l'impression, mais oui nous pouvons l'utiliser comme alternative dans certains cas. Print est un wrapper qui enveloppe l'entrée avec un espace et une nouvelle ligne à la fin et utilise la fonction d'écriture pour écrire. C'est la raison pour laquelle sys.stderr.write () est plus rapide.

Remarque: nous pouvons également tracer et déboguer à l'aide de la journalisation

#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