import ftplib
import urllib2
import os
import logging
logger = logging.getLogger('ftpuploader')
hdlr = logging.FileHandler('ftplog.log')
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
hdlr.setFormatter(formatter)
logger.addHandler(hdlr)
logger.setLevel(logging.INFO)
FTPADDR = "some ftp address"

def upload_to_ftp(con, filepath):
    try:
        f = open(filepath,'rb')                # file to send
        con.storbinary('STOR '+ filepath, f)         # Send the file
        f.close()                                # Close file and FTP
        logger.info('File successfully uploaded to '+ FTPADDR)
    except, e:
        logger.error('Failed to upload to ftp: '+ str(e))

Esto no parece funcionar, me sale un error de sintaxis, ¿cuál es la forma correcta de hacerlo para registrar todo tipo de excepciones en un archivo?

Debe definir qué tipo de excepción desea capturar. Por lo tanto, escriba en except Exception, e:lugar de except, e:una excepción general (que se registrará de todos modos).

Otra posibilidad es escribir todo el código try / except de esta manera:

try:
    with open(filepath,'rb') as f:
        con.storbinary('STOR '+ filepath, f)
    logger.info('File successfully uploaded to '+ FTPADDR)
except Exception, e: # work on python 2.x
    logger.error('Failed to upload to ftp: '+ str(e))

en Python 3.xy las versiones modernas de Python 2.x usan en except Exception as elugar de except Exception, e:

try:
    with open(filepath,'rb') as f:
        con.storbinary('STOR '+ filepath, f)
    logger.info('File successfully uploaded to '+ FTPADDR)
except Exception as e: # work on python 3.x
    logger.error('Failed to upload to ftp: '+ str(e))

La sintaxis ya no es compatible con Python 3. Utilice lo siguiente en su lugar.

try:
    do_something()
except BaseException as e:
    logger.error('Failed to do something: ' + str(e))

Actualizando esto a algo más simple para logger (funciona tanto para python 2 como para 3). No necesita el módulo de rastreo.

import logging

logger = logging.Logger('catch_all')

def catchEverythingInLog():
    try:
        ... do something ...
    except Exception as e:
        logger.error(e, exc_info=True)
        ... exception handling ...

Esta es ahora la forma antigua (aunque todavía funciona):

import sys, traceback

def catchEverything():
    try:
        ... some operation(s) ...
    except:
        exc_type, exc_value, exc_traceback = sys.exc_info()
        ... exception handling ...

exc_value es el mensaje de error.

Hay algunos casos en los que puede usar el mensaje electrónico o los mensajes electrónicos . Pero no funciona en todos los casos. De todos modos, lo más seguro es usar el str (e)

try:
  ...
except Exception as e:
  print(e.message)

Si desea la clase de error, el mensaje de error y el seguimiento de la pila (o algunos de esos), use sys.exec_info().

Código de trabajo mínimo con algún formato:

import sys
import traceback

try:
    ans = 1/0
except BaseException as ex:
    # Get current system exception
    ex_type, ex_value, ex_traceback = sys.exc_info()

    # Extract unformatter stack traces as tuples
    trace_back = traceback.extract_tb(ex_traceback)

    # Format stacktrace
    stack_trace = list()

    for trace in trace_back:
        stack_trace.append("File : %s , Line : %d, Func.Name : %s, Message : %s" % (trace[0], trace[1], trace[2], trace[3]))

    print("Exception type : %s " % ex_type.__name__)
    print("Exception message : %s" %ex_value)
    print("Stack trace : %s" %stack_trace)

Lo que da el siguiente resultado:

Exception type : ZeroDivisionError
Exception message : division by zero
Stack trace : ['File : .\\test.py , Line : 5, Func.Name : <module>, Message : ans = 1/0']

La función sys.exc_info () le brinda detalles sobre la excepción más reciente. Devuelve una tupla de (type, value, traceback).

tracebackes una instancia de objeto de rastreo. Puede formatear la traza con los métodos proporcionados. Se puede encontrar más en la documentación de rastreo .

Puede usar logger.exception("msg")para registrar excepciones con rastreo:

try:
    #your code
except Exception as e:
    logger.exception('Failed: ' + str(e))

Después de python 3.6, puede usar cadenas formateadas literales. ¡Está ordenado! ( https://docs.python.org/3/whatsnew/3.6.html#whatsnew36-pep498 )

try
 ...
except Exception as e:
    logger.error(f"Failed to upload to ftp: {e}")

Puede intentar especificar el tipo BaseException explícitamente. Sin embargo, esto solo capturará derivados de BaseException. Si bien esto incluye todas las excepciones proporcionadas por la implementación, también es posible generar clases arbitrarias de estilo antiguo.

try:
  do_something()
except BaseException, e:
  logger.error('Failed to do something: ' + str(e))

Use str (ex) para imprimir la ejecución

try:
   #your code
except ex:
   print(str(ex))

Para los futuros luchadores, en Python 3.8.2 (y quizás algunas versiones anteriores), la sintaxis es

except Attribute as e:
    print(e)

Usando str(e)o repr(e)para representar la excepción, no obtendrá el seguimiento real de la pila, por lo que no es útil encontrar dónde está la excepción.

Después de leer otras respuestas y el documento del paquete de registro, las siguientes dos formas funcionan muy bien para imprimir el seguimiento real de la pila para una depuración más fácil:

usar logger.debug()con parámetroexc_info

try:
    # my code
exception SomeError as e:
    logger.debug(e, exc_info=True)

utilizar logger.exception()

o podemos usar directamente logger.exception()para imprimir la excepción.

try:
    # my code
exception SomeError as e:
    logger.exception(e)