`traceback` — Imprimir o recuperar un seguimiento de pila¶

Código fuente: Lib/traceback.py

Este módulo brinda una interfaz estándar para extraer, formatear y mostrar trazas de pilas de programas de Python. Dicho módulo copia el comportamiento del intérprete de Python cuando muestra una traza de pila. Es útil a la hora de querer mostrar trazas de pilas bajo el control del programa, como si de un wrapper alrededor del intérprete se tratara.

El módulo utiliza objetos traceback — Este es el tipo de objeto que se almacena en la variable sys.last_traceback y es retornada como el tercer elemento de sys.exc_info().

El módulo define las siguientes funciones:

traceback.print_tb(tb, limit=None, file=None)¶: Muestra hasta limit entradas de trazas de pila desde el objeto traceback tb (empezando desde el marco de la llamada) si limit es positivo. De lo contrario, muestra las últimas abs(limit) entradas. Si limit es omitido o None, todas las entradas se muestran. Si file es omitido o None, la salida va a sys.stderr; de lo contrario, debería ser un archivo o un objeto de tipo similar a un archivo para recibir la salida.

Distinto en la versión 3.5: Soporte para limit negativo añadido

traceback.print_exception(etype, value, tb, limit=None, file=None, chain=True)¶

Muestra información de excepciones y entradas de trazas de pila desde el objeto traceback tb a file. Esto difiere de print_tb() de las siguientes maneras:

si tb no es None, muestra una cabecera Traceback (most recent call last):
muestra la excepción etype y value después de la traza de pila

si type(value) es SyntaxError y value tiene el formato apropiado, muestra la línea donde el error sintáctico ha ocurrido con un cursor indicando la posición aproximada del error.

El argumento opcional limit tiene el mismo significado que para print_tb(). Si chain es verdad (por defecto), entonces excepciones encadenadas (__cause__ o __context__ atributos de la excepción) también se imprimirán, como lo hace el propio intérprete al imprimir una excepción no controlada.

Distinto en la versión 3.5: El argumento etype es ignorado e infiere desde el tipo de value.

traceback.print_exc(limit=None, file=None, chain=True)¶: Esto es un atajo para print_exception(*sys.exc_info(), limit, file, chain).

traceback.print_last(limit=None, file=None, chain=True)¶: Esto es un atajo para print_exception(sys.last_type, sys.last_value, sys.last_traceback, limit, file, chain). En general, solo funciona después de que una excepción ha alcanzado un promt interactivo (ver sys.last_type).

traceback.print_stack(f=None, limit=None, file=None)¶: Muestra hasta limit entradas de trazas de pila (empezando desde el punto de invocación) si limit es positivo. De lo contrario, muestra las últimas abs(limit) entradas. Si limit es omitido o None, todas las entradas se muestran. El argumento opcional f puede ser usado para especificar un marco de pila alternativo para empezar. El argumento opcional file tiene el mismo significado que para print_tb().

Distinto en la versión 3.5: Soporte para limit negativo añadido

traceback.extract_tb(tb, limit=None)¶: Retorna un objeto StackSummary representando una lista de entradas de trazas de pila «pre-procesadas» extraídas del objeto traceback tb. Esto es útil para el formateo alternativo de trazas de pila. El argumento opcional limit tiene el mismo significado que para print_tb(). Una entrada de traza de pila «pre-procesada» es un objeto FrameSummary que contiene los atributos filename, lineno, name, y line representando la información que normalmente es mostrada por una traza de pila. El atributo line es una cadena con espacios en blanco iniciales y finales stripped; si la fuente no está disponible, es None.

traceback.extract_stack(f=None, limit=None)¶: Extrae el seguimiento de pila crudo desde el marco de pila actual. El valor retornado tiene el mismo formato que para extract_tb(). Los argumentos opcionales f y limit tienen el mismo significado que para print_stack().

traceback.format_list(extracted_list)¶: Dada una lista de tuplas u objetos FrameSummary según lo retornado por extract_tb() o extract_stack(), retorna una lista de cadenas preparadas para ser mostradas. Cada cadena en la lista resultante corresponde con el elemento con el mismo índice en la lista de argumentos. Cada cadena finaliza en una nueva línea; las cadenas pueden contener nuevas líneas internas también, para aquellos elementos cuya línea de texto de origen no es None.

traceback.format_exception_only(etype, value)¶: Formatea la parte de excepción de un seguimiento de pila. Los argumentos son el tipo de excepción y el valor como los dados por sys.last_type y sys.last_value. El valor retornado es una lista de cadenas, acabando cada una en una nueva línea. Normalmente, la lista contiene una sola cadena; sin embargo, para las excepciones SyntaxError, esta lista contiene múltiples líneas que (cuando se muestran), imprimen información detallada sobre dónde ha ocurrido el error sintáctico. El mensaje indicador de qué excepción ha ocurrido es siempre la última cadena de la lista.

traceback.format_exception(etype, value, tb, limit=None, chain=True)¶: Formatea una traza de pila y la información de la excepción. Los argumentos tienen el mismo significado que los argumentos correspondientes a print_exception(). El valor retornado es una lista de cadenas, acabando cada una en una nueva línea y algunas contienen nuevas líneas internas. Cuando estas líneas son concatenadas y mostradas, exactamente el mismo texto es mostrado como hace print_exception().

Distinto en la versión 3.5: El argumento etype es ignorado e infiere desde el tipo de value.

traceback.format_exc(limit=None, chain=True)¶: Esto es como print_exc(limit) pero retorna una cadena en lugar de imprimirlo en un archivo.

traceback.format_tb(tb, limit=None)¶: Un atajo para format_list(extract_tb(tb, limit)).

traceback.format_stack(f=None, limit=None)¶: Un atajo para format_list(extract_stack(f, limit)).

traceback.clear_frames(tb)¶: Limpia las variables locales de todos los marcos de pila en un seguimiento de pila tb llamando al método clear() de cada objeto de marco.

Nuevo en la versión 3.4.

traceback.walk_stack(f)¶: Recorre una pila siguiendo f.f_back desde el marco dado, produciendo el marco y el número de línea de cada marco. Si f es None, la pila actual es usada. Este auxiliar es usado con StackSummary.extract().

Nuevo en la versión 3.5.

traceback.walk_tb(tb)¶: Recorre un seguimiento de pila siguiendo tb_next produciendo el marco y el número de línea de cada marco. Este auxiliar es usado con StackSummary.extract().

Nuevo en la versión 3.5.

El módulo también define las siguientes clases:

Objetos `TracebackException`¶

Nuevo en la versión 3.5.

Los objetos TracebackException son creados a partir de excepciones reales para capturar datos para su posterior impresión de una manera ligera.

class traceback.TracebackException(exc_type, exc_value, exc_traceback, *, limit=None, lookup_lines=True, capture_locals=False)¶

Captura una excepción para su posterior procesado. limit, lookup_lines y capture_locals son como para la clase StackSummary.

Tenga en cuenta que cuando se capturan locales, también se muestran en el rastreo.

__cause__¶: Una clase TracebackException del original __cause__.

__context__¶: Una clase TracebackException del original __context__.

__suppress_context__¶: El valor __suppress_context__ de la excepción original.

stack¶: Una clase StackSummary representando el seguimiento de pila.

exc_type¶: La clase del seguimiento de pila original.

filename¶: Para errores sintácticos - el nombre del archivo donde el error ha ocurrido.

lineno¶: Para errores sintácticos - el número de línea donde el error ha ocurrido.

text¶: Para errores sintácticos - el texto donde el error ha ocurrido.

offset¶: Para errores sintácticos - el offset en el texto donde el error ha ocurrido.

msg¶: Para errores sintácticos - el mensaje de error del compilador.

classmethod from_exception(exc, *, limit=None, lookup_lines=True, capture_locals=False)¶

Captura una excepción para su posterior procesado. limit, lookup_lines y capture_locals son como para la clase StackSummary.

Tenga en cuenta que cuando se capturan locales, también se muestran en el rastreo.

format(*, chain=True)¶

Formatea la excepción.

Si chain no es True, __cause__ y __context__ no serán formateados.

El valor retornado es un generador de cadenas, donde cada una acaba en una nueva línea y algunas contienen nuevas líneas internas. print_exception() es un contenedor alrededor de este método que simplemente muestra las líneas de un archivo.

El mensaje que indica qué excepción ocurrió siempre es la última cadena en la salida.

format_exception_only()¶

Formatea la parte de la excepción de un seguimiento de pila.

El valor retornado es un generador de cadenas, donde cada una acaba en una nueva línea.

Normalmente, el generador emite una sola cadena, sin embargo, para excepciones SyntaxError, este emite múltiples líneas que (cuando son mostradas) imprimen información detallada sobre dónde ha ocurrido el error sintáctico.

El mensaje que indica qué excepción ocurrió siempre es la última cadena en la salida.

Objetos `StackSummary`¶

Nuevo en la versión 3.5.

Los objetos StackSummary representan una pila de llamadas lista para formatear.

class traceback.StackSummary¶

classmethod extract(frame_gen, *, limit=None, lookup_lines=True, capture_locals=False)¶

Construye un objeto StackSummary desde un generador de marcos (tal como es retornado por walk_stack() o walk_tb()).

Si limit es suministrado, solo esta cantidad de cuadros son tomados de frame_gen. Si lookup_lines es False, los objeto FrameSummary retornados aún no han leído sus líneas, lo que hace que el costo de crear StackSummary será más barato (lo que puede ser valioso si no se formatea). Si capture_locals es True, las variables locales en cada FrameSummary son capturadas como representaciones de objetos.

classmethod from_list(a_list)¶: Construye un objeto StackSummary desde una lista suministrada de objetos FrameSummary o una lista antigua de tuplas. Cada tupa debe ser una 4-tupla con nombre de archivo, número de líneas, nombre, línea como los elementos.

format()¶

Retorna una lista de cadenas lista para mostrarse. Cada cadena en la lista resultante corresponde a un único marco de la pila. Cada cadena termina en una nueva línea;las cadenas también pueden contener nuevas líneas internas, para aquellos elementos con líneas de texto fuente.

Para secuencias largas del mismo marco y línea, se muestran las primeras repeticiones, seguidas de una línea de resumen que indica el número exacto de repeticiones adicionales.

Distinto en la versión 3.6: Las secuencias largas de cuadros repetidos ahora se abrevian.

Objetos `FrameSummary`¶

Nuevo en la versión 3.5.

Los objetos FrameSummary representan un único marco en el seguimiento de pila.

class traceback.FrameSummary(filename, lineno, name, lookup_line=True, locals=None, line=None)¶: Representa un único marco en el seguimiento de pila o pila que es formateado o mostrado. Opcionalmente, puede tener una versión en cadena de los marcos locales incluidos en él. Si lookup_line es False, el código fuente no se busca hasta que FrameSummary tenga el atributo line accedido (lo que también sucede cuando lo conviertes en una tupla). line puede proporcionarse directamente y evitará que se realicen búsquedas de línea. locals es un diccionario de variables locales opcional y, si se proporciona, las representaciones de variables se almacenan en el resumen para su posterior visualización.

Ejemplos de seguimiento de pila¶

Este ejemplo sencillo implementa un bucle de lectura, evaluación e impresión básico, similar a (pero menos útil) el bucle del intérprete interactivo estándar de Python. Para una implementación más completa del bucle del intérprete, ir al módulo code

import sys, traceback

def run_user_code(envdir):
    source = input(">>> ")
    try:
        exec(source, envdir)
    except Exception:
        print("Exception in user code:")
        print("-"*60)
        traceback.print_exc(file=sys.stdout)
        print("-"*60)

envdir = {}
while True:
    run_user_code(envdir)

El siguiente ejemplo demuestra las diferentes manera para mostrar y formatear la excepción y el seguimiento de pila:

import sys, traceback

def lumberjack():
    bright_side_of_death()

def bright_side_of_death():
    return tuple()[0]

try:
    lumberjack()
except IndexError:
    exc_type, exc_value, exc_traceback = sys.exc_info()
    print("*** print_tb:")
    traceback.print_tb(exc_traceback, limit=1, file=sys.stdout)
    print("*** print_exception:")
    # exc_type below is ignored on 3.5 and later
    traceback.print_exception(exc_type, exc_value, exc_traceback,
                              limit=2, file=sys.stdout)
    print("*** print_exc:")
    traceback.print_exc(limit=2, file=sys.stdout)
    print("*** format_exc, first and last line:")
    formatted_lines = traceback.format_exc().splitlines()
    print(formatted_lines[0])
    print(formatted_lines[-1])
    print("*** format_exception:")
    # exc_type below is ignored on 3.5 and later
    print(repr(traceback.format_exception(exc_type, exc_value,
                                          exc_traceback)))
    print("*** extract_tb:")
    print(repr(traceback.extract_tb(exc_traceback)))
    print("*** format_tb:")
    print(repr(traceback.format_tb(exc_traceback)))
    print("*** tb_lineno:", exc_traceback.tb_lineno)

La salida para el ejemplo podría ser similar a esto:

*** print_tb:
  File "<doctest...>", line 10, in <module>
    lumberjack()
*** print_exception:
Traceback (most recent call last):
  File "<doctest...>", line 10, in <module>
    lumberjack()
  File "<doctest...>", line 4, in lumberjack
    bright_side_of_death()
IndexError: tuple index out of range
*** print_exc:
Traceback (most recent call last):
  File "<doctest...>", line 10, in <module>
    lumberjack()
  File "<doctest...>", line 4, in lumberjack
    bright_side_of_death()
IndexError: tuple index out of range
*** format_exc, first and last line:
Traceback (most recent call last):
IndexError: tuple index out of range
*** format_exception:
['Traceback (most recent call last):\n',
 '  File "<doctest...>", line 10, in <module>\n    lumberjack()\n',
 '  File "<doctest...>", line 4, in lumberjack\n    bright_side_of_death()\n',
 '  File "<doctest...>", line 7, in bright_side_of_death\n    return tuple()[0]\n',
 'IndexError: tuple index out of range\n']
*** extract_tb:
[<FrameSummary file <doctest...>, line 10 in <module>>,
 <FrameSummary file <doctest...>, line 4 in lumberjack>,
 <FrameSummary file <doctest...>, line 7 in bright_side_of_death>]
*** format_tb:
['  File "<doctest...>", line 10, in <module>\n    lumberjack()\n',
 '  File "<doctest...>", line 4, in lumberjack\n    bright_side_of_death()\n',
 '  File "<doctest...>", line 7, in bright_side_of_death\n    return tuple()[0]\n']
*** tb_lineno: 10

El siguiente ejemplo muestra las diferentes maneras de imprimir y formatear la pila:

>>> import traceback
>>> def another_function():
...     lumberstack()
...
>>> def lumberstack():
...     traceback.print_stack()
...     print(repr(traceback.extract_stack()))
...     print(repr(traceback.format_stack()))
...
>>> another_function()
  File "<doctest>", line 10, in <module>
    another_function()
  File "<doctest>", line 3, in another_function
    lumberstack()
  File "<doctest>", line 6, in lumberstack
    traceback.print_stack()
[('<doctest>', 10, '<module>', 'another_function()'),
 ('<doctest>', 3, 'another_function', 'lumberstack()'),
 ('<doctest>', 7, 'lumberstack', 'print(repr(traceback.extract_stack()))')]
['  File "<doctest>", line 10, in <module>\n    another_function()\n',
 '  File "<doctest>", line 3, in another_function\n    lumberstack()\n',
 '  File "<doctest>", line 8, in lumberstack\n    print(repr(traceback.format_stack()))\n']

Este último ejemplo demuestra las últimas funciones de formateo:

>>> import traceback
>>> traceback.format_list([('spam.py', 3, '<module>', 'spam.eggs()'),
...                        ('eggs.py', 42, 'eggs', 'return "bacon"')])
['  File "spam.py", line 3, in <module>\n    spam.eggs()\n',
 '  File "eggs.py", line 42, in eggs\n    return "bacon"\n']
>>> an_error = IndexError('tuple index out of range')
>>> traceback.format_exception_only(type(an_error), an_error)
['IndexError: tuple index out of range\n']

`traceback` — Imprimir o recuperar un seguimiento de pila¶

Objetos `TracebackException`¶

Objetos `StackSummary`¶

Objetos `FrameSummary`¶

Ejemplos de seguimiento de pila¶

Tabla de contenido

Tema anterior

Próximo tema

Esta página

traceback — Imprimir o recuperar un seguimiento de pila¶

Objetos TracebackException¶

Objetos StackSummary¶

Objetos FrameSummary¶

Ejemplos de seguimiento de pila¶

`traceback` — Imprimir o recuperar un seguimiento de pila¶

Objetos `TracebackException`¶

Objetos `StackSummary`¶

Objetos `FrameSummary`¶