¿Cómo guardar los valores de traceback / sys.exc_info () en una variable?

Quiero guardar el nombre del error y los detalles de rastreo en una variable. Aquí está mi intento.

import sys
try:
    try:
        print x
    except Exception, ex:
        raise NameError
except Exception, er:
    print "0", sys.exc_info()[0]
    print "1", sys.exc_info()[1]
    print "2", sys.exc_info()[2]

Salida:

0 <type 'exceptions.NameError'>
1 
2 <traceback object at 0xbd5fc8>

Salida deseada:

0 NameError
1
2 Traceback (most recent call last):
  File "exception.py", line 6, in <module>
    raise NameError

PD: Sé que esto se puede hacer fácilmente usando el módulo de rastreo, pero quiero saber el uso del objeto sys.exc_info () [2] aquí.

Así es como lo hago:

>>> import traceback
>>> try:
...   int('k')
... except:
...   var = traceback.format_exc()
... 
>>> print var
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
ValueError: invalid literal for int() with base 10: 'k'

Sin embargo, debe echar un vistazo a la documentación de rastreo , ya que puede encontrar métodos más adecuados, dependiendo de cómo desee procesar su variable después ...

sys.exc_info () devuelve una tupla con tres valores (tipo, valor, rastreo).

1. Aquí el tipo obtiene el tipo de excepción de la excepción que se está manejando
2. valor son los argumentos que se pasan al constructor de la clase de excepción
3. el rastreo contiene la información de la pila, como dónde ocurrió la excepción, etc.

Por ejemplo, en el siguiente programa

try:

    a = 1/0

except Exception,e:

    exc_tuple = sys.exc_info()

Ahora, si imprimimos la tupla, los valores serán este.

1. El valor exc_tuple [0] será " ZeroDivisionError "
2. El valor exc_tuple [1] será " división entera o módulo por cero " (Cadena pasada como parámetro a la clase de excepción)
3. El valor exc_tuple [2] será " objeto trackback en (alguna dirección de memoria) "

Los detalles anteriores también se pueden obtener simplemente imprimiendo la excepción en formato de cadena.

print str(e)

Úselo traceback.extract_stack()si desea un acceso conveniente a los nombres de módulos y funciones y números de línea.

Úselo ''.join(traceback.format_stack())si solo desea una cadena que se parezca a la traceback.print_stack()salida.

Tenga en cuenta que incluso con ''.join()usted obtendrá una cadena de varias líneas, ya que los elementos de format_stack()contienen \n. Ver salida a continuación.

Recuerde import traceback.

Aquí está la salida de traceback.extract_stack(). Formato agregado para facilitar la lectura.

>>> 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)
]

Aquí está la salida de ''.join(traceback.format_stack()). Formato agregado para facilitar la lectura.

>>> ''.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'

Tenga cuidado al sacar el objeto de excepción o el objeto de rastreo del manejador de excepciones, ya que esto causa referencias circulares y gc.collect()no se podrá recopilar. Esto parece ser un problema particular en el entorno portátil ipython / jupyter donde el objeto de rastreo no consigue aclaró en el momento adecuado, e incluso una llamada explícita a gc.collect()en finallyla sección no hace nada. Y ese es un gran problema si tiene algunos objetos enormes que no recuperan su memoria debido a eso (p. Ej., Excepciones de CUDA sin memoria que sin esta solución requieren un reinicio completo del núcleo para recuperarse).

En general, si desea guardar el objeto de rastreo, debe borrarlo de las referencias a locals(), así:

import sys, traceback, gc
type, val, tb = None, None, None
try:
    myfunc()
except:
    type, val, tb = sys.exc_info()
    traceback.clear_frames(tb)
# some cleanup code
gc.collect()
# and then use the tb:
if tb:
    raise type(val).with_traceback(tb)

En el caso del cuaderno jupyter, debe hacerlo al menos dentro del controlador de excepciones:

try:
    myfunc()
except:
    type, val, tb = sys.exc_info()
    traceback.clear_frames(tb)
    raise type(val).with_traceback(tb)
finally:
    # cleanup code in here
    gc.collect()

Probado con python 3.7.

ps el problema con ipython o jupyter notebook env es que tiene %tbmagia que guarda el rastreo y lo hace disponible en cualquier momento posterior. Y como resultado, ninguno locals()de los fotogramas que participan en el rastreo no se liberará hasta que el notebook salga u otra excepción sobrescribirá el rastreo almacenado anteriormente. Esto es muy problemático. No debe almacenar el rastreo sin limpiar sus marcos. Arreglo enviado aquí .

El objeto se puede usar como parámetro en la Exception.with_traceback()función:

except Exception as e:
    tb = sys.exc_info()
    print(e.with_traceback(tb[2]))