Ich möchte Ausnahmen abfangen und protokollieren, ohne das Programm zu beenden, z. B.

try:
    do_stuff()
except Exception as err:
    print(Exception, err)
    # I want to print the entire traceback here,
    # not just the exception name and details

Ich möchte genau die gleiche Ausgabe drucken, die gedruckt wird, wenn die Ausnahme ausgelöst wird, ohne dass try/exclusive die Ausnahme abfängt, und das tue ich auch nicht Ich möchte, dass es mein Programm beendet.

traceback.format_exc() oder sys.exc_info() wird mehr Informationen liefern, wenn Sie das wollen.

import traceback
import sys

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

Einige andere Antworten haben bereits darauf hingewiesen zurück verfolgen Modul.

Bitte beachten Sie das mit print_excIn einigen Einzelfällen erhalten Sie jedoch nicht das, was Sie erwarten würden. In Python 2.x:

import traceback

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

    traceback.print_exc()

…zeigt den Traceback des an zuletzt Ausnahme:

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

Wenn Sie wirklich auf das Original zugreifen müssen zurück verfolgen Eine Lösung besteht darin, das zwischenzuspeichern Ausnahmeinformationen wie zurückgegeben von exc_info in einer lokalen Variablen und zeigen Sie es mit an 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 useful stuff


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

Produzieren:

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

Dabei gibt es allerdings ein paar Fallstricke:

• Aus dem Dokument von sys_info:

  Das Zuweisen des Traceback-Rückgabewerts zu einer lokalen Variablen in einer Funktion, die eine Ausnahme behandelt, führt zu einem Fehler zirkulärer Verweis. Dadurch wird verhindert, dass alles, was von einer lokalen Variablen in derselben Funktion oder vom Traceback referenziert wird, durch Garbage Collection erfasst wird. […] Wenn Sie den Traceback dennoch benötigen, löschen Sie ihn unbedingt nach der Verwendung (Am besten mit einem Versuch machen … schließlich Aussage)

• aber aus demselben Dokument:

  Ab Python 2.2 werden solche Zyklen automatisch zurückgefordert Wenn die Garbage Collection aktiviert ist und sie nicht mehr erreichbar sind, bleibt es effizienter, die Erstellung von Zyklen zu vermeiden.

Zum anderen, indem wir Ihnen den Zugriff auf das Traceback ermöglichen verknüpft mit Eine Ausnahme liefert Python 3 ein weniger überraschendes Ergebnis:

import traceback

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

    traceback.print_tb(err.__traceback__)

… wird angezeigt:

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

Wenn Sie debuggen und nur den aktuellen Stack-Trace sehen möchten, können Sie einfach Folgendes aufrufen:

traceback.print_stack()

Es ist nicht erforderlich, manuell eine Ausnahme auszulösen, nur um sie erneut abzufangen.

Wie drucke ich den vollständigen Traceback aus, ohne das Programm anzuhalten?

Wenn Sie Ihr Programm bei einem Fehler nicht anhalten möchten, müssen Sie diesen Fehler mit einem Try/Except behandeln:

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

Um den vollständigen Traceback zu extrahieren, verwenden wir die traceback Modul aus der Standardbibliothek:

import traceback

Und um einen einigermaßen komplizierten Stacktrace zu erstellen, um zu zeigen, dass wir den vollständigen Stacktrace erhalten:

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

def do_something_that_might_error():
    raise_error()

Drucken

Zu drucken Den vollständigen Traceback verwenden Sie traceback.print_exc Methode:

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

Was druckt:

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!

Besser als Drucken, Protokollieren:

Eine bewährte Vorgehensweise besteht jedoch darin, einen Logger für Ihr Modul einzurichten. Es kennt den Namen des Moduls und kann Ebenen ändern (neben anderen Attributen, z. B. Handlern).

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

In diesem Fall möchten Sie das logger.exception Funktion stattdessen:

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

Welche Protokolle:

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!

Oder vielleicht möchten Sie einfach nur die Zeichenfolge, in diesem Fall möchten Sie die traceback.format_exc Funktion stattdessen:

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

Welche Protokolle:

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!

Abschluss

Und für alle drei Optionen sehen wir, dass wir die gleiche Ausgabe erhalten wie bei einem Fehler:

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

Was zu verwenden ist

Leistungsbedenken spielen hier keine Rolle, da IO normalerweise dominiert. Ich würde es vorziehen, da es genau das tut, was angefordert wird, und zwar auf vorwärtskompatible Weise:

logger.exception(error)

Protokollierungsstufen und -ausgaben können angepasst werden, sodass das Ausschalten einfach ist, ohne den Code zu berühren. Und normalerweise ist es am effizientesten, das zu tun, was direkt benötigt wird.

Erstens nicht verwenden printFür die Protokollierung gibt es eine stabile, bewährte und durchdachte Lösung stdlib Modul, um das zu tun: logging. Du auf jeden Fall sollen Verwenden Sie es stattdessen.

Zweitens: Lassen Sie sich nicht dazu verleiten Durcheinander mit unabhängigen Tools, wenn es einen nativen und einfachen Ansatz gibt. Hier ist es:

log = logging.getLogger(__name__)

try:
    call_code_that_fails()
except MyError:
    log.exception('Any extra info you want to see in your logs')

Das ist es. Sie sind jetzt fertig.

Erklärung für alle, die sich dafür interessieren, wie die Dinge unter der Haube funktionieren

Was log.exception ist eigentlich nur ein Anruf log.error (d. h. Ereignis mit Level protokollieren ERROR) Und Drucken Sie dann den Traceback aus.

Warum ist es besser?

Nun, hier sind einige Überlegungen:

• es ist nur Rechts;
• es ist unkompliziert;
• es ist einfach.

Warum sollte niemand verwenden traceback oder Logger anrufen mit exc_info=True oder sich die Hände schmutzig machen sys.exc_info?

Naja, einfach so! Sie alle dienen unterschiedlichen Zwecken. Zum Beispiel, traceback.print_excDie Ausgabe unterscheidet sich ein wenig von den vom Interpreter selbst erstellten Tracebacks. Wenn Sie es verwenden, verwirren Sie jeden, der Ihre Protokolle liest, und er wird mit dem Kopf darüber stoßen.

Vorbeigehen exc_info=True Anrufe zu protokollieren ist einfach unangemessen. AberDies ist nützlich, wenn Sie behebbare Fehler erkennen und diese protokollieren möchten (z. B. mithilfe von INFO Ebene) auch mit Tracebacks, weil log.exception erzeugt Protokolle nur einer Ebene – ERROR.

Und Sie sollten es auf jeden Fall vermeiden, sich damit anzulegen sys.exc_info so viel wie du kannst. Es ist einfach keine öffentliche Schnittstelle, sondern eine interne – Sie dürfen Verwenden Sie es, wenn Sie genau wissen, was Sie tun. Es ist nicht nur zum Drucken von Ausnahmen gedacht.

traceback.format_exception(exception_object)

Wenn Sie nur das Ausnahmeobjekt haben, können Sie den Traceback als String von jedem Punkt des Codes in Python 3 abrufen mit:

import traceback

''.join(traceback.format_exception(None, exc_obj, exc_obj.__traceback__))

Vollständiges Beispiel:

#!/usr/bin/env python3

import traceback

def f():
    g()

def g():
    raise Exception('asdf')

try:
    g()
except Exception as e:
    exc_obj = e

tb_str="".join(traceback.format_exception(None, exc_obj, exc_obj.__traceback__))
print(tb_str)

Ausgang:

Traceback (most recent call last):
  File "./main.py", line 12, in <module>
    g()
  File "./main.py", line 9, in g
    raise Exception('asdf')
Exception: asdf

Dokumentation: https://docs.python.org/3.9/library/traceback.html#traceback.format_Exception

Siehe auch: Traceback-Informationen aus einem Ausnahmeobjekt extrahieren

Getestet in Python 3.9

Zusätzlich zur Antwort von Aaron Hall, wenn Sie protokollieren, es aber nicht verwenden möchten logging.exception() (da es auf der ERROR-Ebene protokolliert wird), können Sie eine niedrigere Ebene verwenden und bestehen exc_info=True. z.B

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