Imprimer le retraçage complet en python (sans arrêter le programme)

Question

Je suis en train d'écrire un programme qui analyse les 10 sites internet, qui localise les fichiers de données, enregistre les fichiers, puis analyse pour rendre les données qui peuvent être facilement utilisés dans numpy. Il y a des TONNES d'erreurs de ce fichier des rencontres par le biais de mauvais liens, mal formé xml, des entrées manquantes, et d'autres choses que j'ai encore à catégoriser. J'ai d'abord fait ce programme pour gérer les erreurs de ce type:

try:
    do_stuff()
except:
    pass

Mais maintenant, je veux du journal des erreurs.

try:
    do_stuff()
except Exception, err:
    print Exception, err

Remarque c'est l'impression dans un fichier journal pour l'examiner plus tard. Ce imprime généralement très de données inutiles. Ce que je veux, c'est d'imprimer exactement les mêmes lignes imprimées lorsque l'erreur, déclenche sans l'essayer-à l'exception de l'interception de l'exception, mais je n'en veux pas à arrêter mon programme car elle est imbriquée dans une série de boucles que j'aimerais voir à la fin.

Answer 1

``ou `` donnera plus d’informations si c’est ce que vous voulez.

Answer 2

Une autre réponse ont déjà souligné la traçabilité en amont du module.

Veuillez noter qu'avec print_exc, dans certains cas du coin, vous ne serez pas obtenir ce que vous attendez. En Python 2.x:

import traceback

try:
    raise TypeError("Oups!")
except Exception, err:
    try:
        raise TypeError("Again !?!")
    except:
        pass

    traceback.print_exc()

...affiche la traçabilité en amont de la dernière exception:

Traceback (most recent call last):
  File "e.py", line 7, in <module>
    raise TypeError("Again !?!")
TypeError: Again !?!

Si vous avez vraiment besoin d'accéder à l'original traceback une solution consiste à mettre en cache l' exception des infos tel que retourné à partir de exc_info dans une variable et de l'afficher à l'aide de print_exception:

import traceback
import sys

try:
    raise TypeError("Oups!")
except Exception, err:
    try:
        exc_info = sys.exc_info()

        # do you usefull stuff here
        # (potentially raising an exception)
        try:
            raise TypeError("Again !?!")
        except:
            pass
        # end of usefull stuff


    finally:
        # Display the *original* exception
        traceback.print_exception(*exc_info)
        del exc_info

Production de:

Traceback (most recent call last):
  File "t.py", line 6, in <module>
    raise TypeError("Oups!")
TypeError: Oups!

Quelques pièges à cela:

• À partir de la doc de l' sys_info:

  L'attribution de la traçabilité en amont de la valeur de retour d'une variable locale dans une fonction qui est de la gestion d'une exception sera la cause d'une référence circulaire. Cela permettra d'empêcher quoi que ce soit référencé par une variable locale dans la même fonction ou par le traceback d'être nettoyée. [...] Si vous avez besoin de la traçabilité en amont, assurez-vous de le supprimer après l'utilisation (de préférence avec une instruction try ... finally)

• mais, à partir de la même doc:

  Début avec Python 2.2, ces cycles sont automatiquement récupérés lors de la collecte des ordures est activé et qu'ils deviennent inaccessibles, mais il reste bien plus efficace pour éviter la création de cycles.

---

D'autre part, en vous permettant d'accéder à la traçabilité en amont associé à une exception, Python 3 produire moins un résultat surprenant:

import traceback

try:
    raise TypeError("Oups!")
except Exception as err:
    try:
        raise TypeError("Again !?!")
    except:
        pass

    traceback.print_tb(err.__traceback__)

... s'affiche:

  File "e3.py", line 4, in <module>
    raise TypeError("Oups!")

Answer 3

Vous aurez besoin de mettre à l’essai / sauf à l’intérieur le plus innerloop où l’erreur peut se produire, c'est-à-dire

... et ainsi de suite

En d’autres termes, vous devez encapsuler des déclarations qui peuvent échouer dans try / except aussi précis que possible, dans la boucle la plus intérieure que possible.

Answer 4

Vous souhaitez que le module de retraçage . Il vous permettra d’imprimer des vidages de pile comme Python fait normalement. En particulier, la fonction print_last s’imprimera la dernière exception et une trace de la pile.

Answer 5

Utiliser traceback.extract_stack() si vous voulez un accès pratique à, des modules de fonction des noms et des numéros de ligne.

Utiliser ''.join(traceback.format_stack()) si vous voulez juste une chaîne qui ressemble à de la traceback.print_stack() de la production.

Remarquez que même avec ''.join() , vous obtiendrez un multi-ligne de chaîne, depuis les éléments d' format_stack() contiennent \n. Voir sortie ci-dessous.

N'oubliez pas de import traceback.

Voici la sortie d' traceback.extract_stack(). Mise en forme ajoutés pour des raisons de lisibilité.

>>> traceback.extract_stack()
[
   ('<string>', 1, '<module>', None),
   ('C:\\Python\\lib\\idlelib\\run.py', 126, 'main', 'ret = method(*args, **kwargs)'),
   ('C:\\Python\\lib\\idlelib\\run.py', 353, 'runcode', 'exec(code, self.locals)'),
   ('<pyshell#1>', 1, '<module>', None)
]

Voici la sortie d' ''.join(traceback.format_stack()). Mise en forme ajoutés pour des raisons de lisibilité.

>>> ''.join(traceback.format_stack())
'  File "<string>", line 1, in <module>\n
   File "C:\\Python\\lib\\idlelib\\run.py", line 126, in main\n
       ret = method(*args, **kwargs)\n
   File "C:\\Python\\lib\\idlelib\\run.py", line 353, in runcode\n
       exec(code, self.locals)\n  File "<pyshell#2>", line 1, in <module>\n'