traceback.format_exc() lub sys.exc_info() dostarczy więcej informacji, jeśli tego chcesz.

import traceback
import sys

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

Jeśli debugujesz i chcesz zobaczyć bieżący ślad stosu, możesz po prostu wywołać:

traceback.print_stack()

Nie ma potrzeby ręcznie podnosić wyjątku, aby go złapać ponownie.

Jak wydrukować pełny traceback bez zatrzymywania programu?

Jeśli nie chcesz zatrzymać programu na błąd, musisz obsłużyć ten błąd za pomocą try/except:

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

Aby wyodrębnić pełny traceback, użyjemy modułu traceback z biblioteki standardowej:

import traceback

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

def do_something_that_might_error():
    raise_error()

Druk

To print the full traceback, użyj metody traceback.print_exc:

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

Który drukuje:

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!

Lepsze niż drukowanie, logowanie:

Jednak najlepszą praktyką jest skonfigurowanie rejestratora dla Twojego modułu. Będzie znał nazwę modułu i będzie mógł zmieniać poziomy (między innymi atrybuty, takie jak programy obsługi)

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

W takim przypadku będziesz chciał zamiast tego logger.exception funkcji:

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

Który loguje:

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!

A może po prostu chcesz ciąg, w takim przypadku, będziesz chcemy zamiast tego funkcji traceback.format_exc:

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

Który loguje:

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!

Podsumowanie

I dla wszystkich trzech opcji widzimy, że otrzymujemy to samo wyjście, co gdy mamy błąd:

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

Aby uzyskać precyzyjny ślad stosu, jako ciąg znaków, który zostałby podniesiony, gdyby nie było próby/except, po prostu umieść go w bloku except, który wychwytuje obrażający wyjątek.

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

Oto jak go użyć (zakładając, że flaky_func jest zdefiniowany i log wywoła Twój ulubiony system logowania):

import traceback
import sys

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

Dobrym pomysłem jest złapanie i ponowne podbicie KeyboardInterrupt s, aby nadal można było zabić program za pomocą Ctrl-C. Logowanie wykracza poza zakres pytanie, ale dobrym rozwiązaniem jest logowanie . Dokumentacja dla modułów sys i traceback .

Musisz umieścić try / except wewnątrz most innerloop gdzie może wystąpić błąd, tj.

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

... i tak dalej

Innymi słowy, będziesz musiał zawinąć instrukcje, które mogą się nie udać w try / except tak szczegółowe, jak to możliwe, w najbardziej wewnętrznej pętli, jak to możliwe.

Oprócz odpowiedzi @Aaron Hall, jeśli logujesz się, ale nie chcesz używać logging.exception() (ponieważ loguje się na poziomie błędu), możesz użyć niższego poziomu i przekazać exc_info=True. np.

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

Chcesz moduł traceback . Pozwoli Ci to drukować zrzuty stosów, tak jak to zwykle robi Python. W szczególności funkcja print_last wyświetli ostatni wyjątek i ślad stosu.