traceback.format_exc() ou sys.exc_info() vai dar mais informações, se é isso que queres.

import traceback
import sys

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

Se está a depurar e só quer ver o traço actual da pilha, pode simplesmente ligar para:

traceback.print_stack()

Como imprimir a localização completa sem parar o programa?

Quando você não quer parar o seu programa com um erro, você precisa lidar com esse erro com uma tentativa / exceto:

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

Para extrair o traceback completo, vamos usar o módulo traceback da biblioteca padrão:

import traceback

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

def do_something_that_might_error():
    raise_error()

Impressão

A imprimir a traceback completo, usar o método traceback.print_exc:

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!

É melhor do que imprimir, registar:

No entanto, uma boa prática é ter um logger configurado para o seu módulo. Ele conhecerá o nome do módulo e será capaz de mudar os níveis (entre outros atributos, como manipuladores)

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

Nesse caso, vais querer a função logger.exception em vez disso:

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

Que registos:

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!

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

Que registos:

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!

Conclusão

E para todas as três opções, vemos que temos a mesma saída que quando temos um erro:

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

Para obter o preciso stack trace, como uma string, que teria sido levantado se nenhuma tentativa / excepto se houvesse para pisar sobre ele, basta colocar isto no bloco excepto que apanha a excepção ofensiva.

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

Aqui está como usá-lo (assumindo que flaky_func está definido, e log chama o seu sistema de Registo favorito):

import traceback
import sys

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

Terá de colocar a tentativa / excepto dentro do mais interior onde o erro possa ocorrer, ou seja

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

... e assim por diante

Em outras palavras, você vai precisar embrulhar declarações que podem falhar em tentativa/exceto o mais específico possível, no mais interior-loop possível.

Para além da resposta de @Aaron Hall, se estiver a registar-se, mas não quiser usar {[[1]} (Dado que se regista no nível de erro), pode usar um nível mais baixo e passar exc_info=True. por exemplo

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

Queres o módulo traceback. Ele vai deixar você imprimir pilha dumps como Python normalmente faz. Em particular, a função print_last irá imprimir a última excepção e um traço de pilha.