Quiero capturar y registrar excepciones sin salir, por ejemplo,

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

Quiero imprimir exactamente el mismo resultado que se imprime cuando se genera la excepción sin que try/except intercepte la excepción, y lo hago no quiero que salga de mi programa.

traceback.format_exc() o sys.exc_info() dará más información si eso es lo que quieres.

import traceback
import sys

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

Alguna otra respuesta ya ha señalado el rastrear módulo.

Tenga en cuenta que con print_exc, en algunos casos de esquina, no obtendrá lo que esperaría. En Python 2.x:

import traceback

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

    traceback.print_exc()

… mostrará el rastreo de la último excepción:

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

Si realmente necesita acceder al original rastrear una solución es almacenar en caché el información de excepción como regresado de exc_info en una variable local y mostrarlo usando 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

Productor:

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

Sin embargo, algunas trampas con esto:

• Del documento de sys_info:

  Asignar el valor de retorno de rastreo a una variable local en una función que está manejando una excepción causará una referencia circular. Esto evitará que cualquier elemento referenciado por una variable local en la misma función o por el rastreo sea recolectado como basura. […] Si necesita el rastreo, asegúrese de eliminarlo después de usarlo (es mejor hacerlo con un intento… finalmente declaración)

• pero, del mismo documento:

  A partir de Python 2.2, dichos ciclos se recuperan automáticamente cuando la recolección de basura está habilitada y se vuelven inalcanzables, pero sigue siendo más eficiente para evitar la creación de ciclos.

---

Por otro lado, al permitirle acceder al rastreo asociado con una excepción, Python 3 produce un resultado menos sorprendente:

import traceback

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

    traceback.print_tb(err.__traceback__)

… mostrará:

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

Si está depurando y solo quiere ver el seguimiento de la pila actual, simplemente puede llamar:

traceback.print_stack()

No es necesario generar manualmente una excepción solo para volver a detectarla.

¿Cómo imprimir el rastreo completo sin detener el programa?

Cuando no desea detener su programa por un error, debe manejar ese error con un intento/excepto:

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

Para extraer el rastreo completo, usaremos el traceback módulo de la biblioteca estándar:

import traceback

Y para crear un stacktrace decentemente complicado para demostrar que obtenemos el stacktrace completo:

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

def do_something_that_might_error():
    raise_error()

Impresión

A imprimir el rastreo completo, use el traceback.print_exc método:

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

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

Mejor que imprimir, iniciar sesión:

Sin embargo, una mejor práctica es tener un registrador configurado para su módulo. Sabrá el nombre del módulo y podrá cambiar los niveles (entre otros atributos, como los controladores)

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

En cuyo caso, querrá el logger.exception función en su lugar:

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

Que registra:

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!

O tal vez solo quiera la cuerda, en cuyo caso, querrá la traceback.format_exc función en su lugar:

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

Que registra:

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!

Conclusión

Y para las tres opciones, vemos que obtenemos el mismo resultado que cuando tenemos un error:

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

cual usar

Las preocupaciones de rendimiento no son importantes aquí, ya que IO suele dominar. Preferiría, ya que hace precisamente lo que se solicita de una manera compatible con versiones posteriores:

logger.exception(error)

Los niveles de registro y las salidas se pueden ajustar, lo que facilita el apagado sin tocar el código. Y, por lo general, hacer lo que se necesita directamente es la forma más eficiente de hacerlo.

Primero, no use prints para el registro, existe un estable, probado y bien pensado stdlib módulo para hacer eso: logging. Tu definitivamente debería úsalo en su lugar.

En segundo lugar, no caiga en la tentación de hacer una desorden con herramientas no relacionadas cuando existe un enfoque nativo y simple. Aquí lo tienes:

log = logging.getLogger(__name__)

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

Eso es todo. Ya has terminado.

Explicación para cualquiera que esté interesado en cómo funcionan las cosas debajo del capó

Qué log.exception lo que realmente está haciendo es solo una llamada a log.error (es decir, evento de registro con nivel ERROR) y imprima el rastreo entonces.

¿Por qué es mejor?

Bueno, aquí hay algunas consideraciones:

• es sólo bien;
• es sencillo;
• Es simple.

¿Por qué nadie debería usar traceback o registrador de llamadas con exc_info=True o ensuciarse las manos con sys.exc_info?

Bueno, ¡solo porque sí! Todos ellos existen para diferentes propósitos. Por ejemplo, traceback.print_excLa salida de es un poco diferente de los rastreos producidos por el propio intérprete. Si lo usa, confundirá a cualquiera que lea sus registros, se golpeará la cabeza contra ellos.

Paso exc_info=True registrar llamadas es simplemente inapropiado. Peroes útil cuando detecta errores recuperables y desea registrarlos (utilizando, por ejemplo, INFO nivel) con trazabilidades también, porque log.exception produce registros de un solo nivel – ERROR.

Y definitivamente deberías evitar jugar con sys.exc_info tanto como puedas. Simplemente no es una interfaz pública, es una interfaz interna: usted poder utilícelo si definitivamente sabe lo que está haciendo. No está diseñado solo para imprimir excepciones.

traceback.format_exception(exception_object)

Si solo tiene el objeto de excepción, puede obtener el rastreo como una cadena desde cualquier punto del código en Python 3 con:

import traceback

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

Ejemplo completo:

#!/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)

Producción:

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

Documentación: https://docs.python.org/3.9/library/traceback.html#traceback.format_exception

Ver también: Extraer información de rastreo de un objeto de excepción

Probado en Python 3.9

Además de la respuesta de Aaron Hall, si está iniciando sesión, pero no quiere usar logging.exception() (dado que se registra en el nivel de ERROR), puede usar un nivel más bajo y pasar exc_info=True. p.ej

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