traceback.format_exc() ou sys.exc_info() donnera plus d'information Si c'est ce que vous voulez.

import traceback
import sys

try:
    do_stuff()
except Exception:
    print(traceback.format_exc())
    # or
    print(sys.exc_info()[0])

si vous déboguez et que vous voulez voir la trace de la pile actuelle, vous pouvez simplement appeler:

traceback.print_stack()

il n'est pas nécessaire de soulever manuellement une exception juste pour l'attraper à nouveau.

comment imprimer le traceback complet sans interrompre le programme?

lorsque vous ne voulez pas arrêter votre programme sur une erreur, vous devez gérer cette erreur avec un essai / sauf:

try:
    do_something_that_might_error()
except Exception as error:
    handle_the_error(error)

pour extraire le traceback complet, nous utiliserons le module traceback de la bibliothèque standard:

import traceback

et de créer un stacktrace décemment compliqué pour démontrer que nous obtenons la pleine stacktrace:

def raise_error():
    raise RuntimeError('something bad happened!')

def do_something_that_might_error():
    raise_error()

impression

À imprimer le plein de sperme, utiliser le traceback.print_exc la méthode:

try:
    do_something_that_might_error()
except Exception as error:
    traceback.print_exc()

qui imprime:

Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
  File "<stdin>", line 2, in do_something_that_might_error
  File "<stdin>", line 2, in raise_error
RuntimeError: something bad happened!

mieux que l'impression, la journalisation:

Cependant, une bonne pratique est d'avoir un enregistreur pour votre module. Il connaîtra le nom du module et pourra changer de niveau (entre autres attributs, tels que handlers)

import logging
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)

dans ce cas, vous voulez la fonction logger.exception à la place:

try:
    do_something_that_might_error()
except Exception as error:
    logger.exception(error)

Dont les journaux:

ERROR:__main__:something bad happened!
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
  File "<stdin>", line 2, in do_something_that_might_error
  File "<stdin>", line 2, in raise_error
RuntimeError: something bad happened!

ou peut-être vous voulez juste la chaîne, dans ce cas, vous voulez la fonction traceback.format_exc à la place:

try:
    do_something_that_might_error()
except Exception as error:
    logger.debug(traceback.format_exc())

Dont les journaux:

DEBUG:__main__:Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
  File "<stdin>", line 2, in do_something_that_might_error
  File "<stdin>", line 2, in raise_error
RuntimeError: something bad happened!

Conclusion

et pour tous trois options, nous voyons que nous obtenir le même résultat que lorsque nous avons une erreur:

>>> do_something_that_might_error()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in do_something_that_might_error
  File "<stdin>", line 2, in raise_error
RuntimeError: something bad happened!

pour obtenir la précise trace de pile, comme une chaîne, que aurait ont été soulevées si aucun essai/sauf si étaient là pour le enjamber, placez simplement ceci dans le bloc d'exception qui attrape l'exception offensante.

desired_trace = traceback.format_exc(sys.exc_info())

Voici comment l'utiliser (en supposant que flaky_func est défini, et log appelle votre système de journalisation préféré):

import traceback
import sys

try:
    flaky_func()
except KeyboardInterrupt:
    raise
except Exception:
    desired_trace = traceback.format_exc(sys.exc_info())
    log(desired_trace)

C'est une bonne idée d'attraper et de la relancer KeyboardInterrupt s, de sorte que vous pouvez toujours tuer le programme en utilisant Ctrl-C. journalisation est en dehors de la portée de la question, mais une bonne option est logging . Documentation pour les modules sys et traceback .

vous aurez besoin de mettre l'essai / sauf dans le plus innerloop où l'erreur peut se produire ,i.e.

for i in something:
    for j in somethingelse:
        for k in whatever:
            try:
                something_complex(i, j, k)
            except Exception, e:
                print e
        try:
            something_less_complex(i, j)
        except Exception, e:
            print e

... et ainsi de suite

en d'autres termes, vous devrez envelopper les déclarations qui peuvent échouer dans try/sauf aussi spécifique que possible, dans la boucle la plus interne possible.

en plus de la réponse de @Aaron Hall, si vous êtes connecté, mais ne voulez pas utiliser logging.exception() (puisqu'il se connecte au niveau D'erreur), vous pouvez utiliser un niveau inférieur et passer exc_info=True . par exemple

try:
    do_something_that_might_error()
except Exception:
    logger.info('General exception noted.', exc_info=True)

vous voulez le module traceback . Il vous permettra d'imprimer des dumps de pile comme Python le fait normalement. En particulier, la fonction print_last affichera la dernière exception et une trace de pile.