Comment rediriger stderr en Python?

Je voudrais connecter la sortie d'un script Python. J'ai essayé:

import sys

log = []

class writer(object):
    def write(self, data):
        log.append(data)

sys.stdout = writer()
sys.stderr = writer()

Maintenant, si j'ai "l'impression" quelque chose "" c'est journalisé. Mais si je fais par exemple erreur de syntaxe, dire "imprimer" quelque chose# ", il l'habitude de se connecté - il aller dans la console à la place.

Comment puis-je capture aussi les erreurs à partir de l'interpréteur Python?

J'ai vu une solution possible ici:

http://www.velocityreviews.com/forums/showpost.php?p=1868822&postcount=3

mais le deuxième exemple logs dans /dev/null - ce n'est pas ce que je veux. Je voudrais l'enregistrer dans une liste comme mon exemple ci-dessus ou StringIO ou tel...

Également, de préférence, je ne veux pas créer un sous-processus (et de lire le stdout et stderr dans le thread séparé).

source d'informationauteur EcirH

  1. 5

    Vous ne pouvez pas faire n'importe quoi dans le code Python qui permet de capturer les erreurs lors de la compilation du même code. Comment pourrait-il? Si le compilateur ne peut pas terminer la compilation du code, il ne sera pas exécuté le code, de sorte que votre redirection n'a pas encore pris effet.

    C'est là que votre (indésirable) sous-processus. Vous pouvez écrire du code Python qui redirige la sortie standard (stdout), puis appelle l'interpréteur Python pour compiler quelque autre morceau de code.

  2. 18

    J'ai un morceau de logiciel que j'ai écrit pour le travail qui capture stderr dans un fichier comme ceci:

    import sys
sys.stderr = open('C:\\err.txt', 'w')

    il est donc certainement possible.

    Je crois que votre problème est que vous êtes la création de deux instances de l'écrivain.

    Peut-être quelque chose de plus comme:

    import sys

class writer(object):
    log = []

    def write(self, data):
        self.log.append(data)

logger = writer()
sys.stdout = logger
sys.stderr = logger
  3. 6

    Je ne pense pas d'une manière facile. Le python standard du processus d'erreur est de vivre sur un niveau inférieur à celui d'un fichier python objet (C ou python).

    Vous pouvez rassembler le script python dans un deuxième script python et utiliser des sous-processus.Popen. Il est également possible de tirer un peu de magie comme cela dans un seul script:

    import os
import subprocess
import sys

cat = subprocess.Popen("/bin/cat", stdin=subprocess.PIPE, stdout=subprocess.PIPE)
os.close(sys.stderr.fileno())
os.dup2(cat.stdin.fileno(), sys.stderr.fileno())

    Et sélectionner.poll() pour vérifier chat.stdout régulièrement pour trouver la sortie.

    Oui, qui semble fonctionner.

    Le problème je pense est que la plupart du temps, quelque chose d'imprimé sur stderr par python indique qu'il est sur le point de quitter. La plus habituelle façon de gérer cela pourrait être par l'intermédiaire des exceptions.

    ---------Edit

    En quelque sorte, j'ai raté l'os.pipe() fonction. 

    import os, sys
r, w = os.pipe()
os.close(sys.stderr.fileno())
os.dup2(w, sys.stderr.fileno())

    Alors de lire à partir de r

  4. 1

    En fait, si vous êtes sous linux/mac os, vous pouvez utiliser le fichier de redirection pour le faire. Par exemple, si vous allez exécuter "une.py" et d'enregistrer tous les messages qu'il va générer dans le fichier "."il serait juste

    python a.py 2>&1 > a.out

    La première partie redirige stderr vers stdout, et la deuxième qui redirige vers un fichier appelé..

    Pour une plus longue liste d'opérateurs de redirection dans Linux/Unix, voir https://askubuntu.com/questions/420981/how-do-i-save-terminal-output-to-a-file

  5. 0
    import sys
import tkinter

# ********************************************

def mklistenconsswitch(*printf: callable) -> callable:
    def wrapper(*fcs: callable) -> callable:
        def newf(data):
            [prf(data) for prf in fcs]
        return newf
    stdoutw, stderrw = sys.stdout.write, sys.stderr.write
    funcs = [(wrapper(sys.stdout.write, *printf), wrapper(sys.stderr.write, *printf)), (stdoutw, stderrw)]
    def switch():
        sys.stdout.write, sys.stderr.write = dummy = funcs[0]
        funcs[0] = funcs[1]
        funcs[1] = dummy
    return switch

# ********************************************

def datasupplier():
    i = 5.5
    while i > 0:
        yield i
        i -= .5

def testloop():
    print(supplier.__next__())
    svvitch()
    root.after(500, testloop)

root = tkinter.Tk()
cons = tkinter.Text(root)
cons.pack(fill='both', expand=True)
supplier = datasupplier()
svvitch = mklistenconsswitch(lambda text: cons.insert('end', text))
testloop()
root.mainloop()