tipos - traceback(most recent call last) python

¿Mejores prácticas para excepciones de Python?

Question

¿Cuáles son las mejores prácticas para crear excepciones? Acabo de ver esto, y no sé si debería estar horrorizado o me gusta. Leí varias veces en libros que las excepciones nunca deberían contener una cadena, porque las cuerdas mismas pueden arrojar excepciones. ¿Alguna verdad real a esto?

Básicamente, mi comprensión de los scripts es que esto se hizo para que todas las bibliotecas internas de Python tengan un formato de mensaje de error común (algo que se necesita desesperadamente) para poder entender por qué es una buena idea poner la cadena del mensaje de error. (Casi todos los métodos arrojan excepciones debido a la absoluta necesidad de que nada inválido pueda pasar).

El código en cuestión es el siguiente:

"""
Base Exception, Error
"""
class Error(Exception):
    def __init__(self, message):
        self.message = message

    def __str__(self):
        return "[ERROR] %s/n" % str(self.message)

    def log(self):
        ret = "%s" % str(self.message)
        if(hasattr(self, "reason")):
            return "".join([ret, "/n==> %s" % str(self.reason)])
        return ret

class PCSException(Error):
    def __init__(self, message, reason = None):
        self.message = message
        self.reason = reason
    def __str__(self):
        ret = "[PCS_ERROR] %s/n" % str(self.message)
        if(self.reason != None):
            ret += "[REASON] %s/n" % str(self.reason)
        return ret

Esto es solo la punta del iceberg, pero ¿alguien me puede dar una idea de lo que hace que esta sea una idea terrible? O si hay un proceso / estilo de codificación de excepción mucho mejor.

Answer 1

Leí varias veces en libros que las excepciones nunca deberían contener una cadena, porque las cuerdas mismas pueden arrojar excepciones. ¿Alguna verdad real a esto?

¿Qué?

Proporcione una referencia o un enlace a esto. Es totalmente falso.

Dado que todos los objetos pueden lanzar excepciones, ningún objeto podría estar contenido en una excepción por esa lógica.

No, el "sin ataduras" es simplemente una locura en un contexto de Python. Tal vez lo lees en un contexto de C ++.

Editar

Érase una vez (en los viejos tiempos) se podía plantear una excepción de Python por nombre en lugar de por la clase real.

raise "SomeNameOfAnExceptionClass"

Esto es malo. Pero esto no incluye una cadena dentro de una excepción. Esto está nombrando la excepción con una cadena en lugar del objeto de clase real. En 2.5, esto aún puede funcionar, pero recibe una advertencia de desaprobación.

Tal vez esto es lo que lees "No hagas una excepción con un nombre de cadena"

Answer 2

Creo que el consejo de crear excepciones con una cadena proviene de "Learning Python" (O''Reilly). ¡En una sección titulada Excepciones de cadenas están fuera! , señala la capacidad (ahora eliminada) de crear una excepción directamente con una cadena arbitraria.

El código que da como ejemplo es:

myexc = "My exception string"
try:
    raise myexc
except myexc:
    print (''caught'')

Esto está en la p858 de la Cuarta Edición (edición en rústica).

Answer 3

La primera impresión es que es demasiado código para una excepción.

Las excepciones de formato se deben hacer en la configuración del registrador. Lo mismo aplica para el registro en sí mismo.

También redefine el atributo de mensaje estándar (y obsoleto), y no llama al constructor de la superclase. (Esto podría o no romper el encadenamiento de excepciones de Python 3.0, no lo he intentado porque estoy ejecutando 2.6)

La mayor parte de lo que hace el código extra se puede realizar utilizando BaseException.args, registrando lo siguiente como el "mensaje":

''/n==> ''.join(exception.args)

Argumentaría que si algo se puede hacer usando un mecanismo común / idiomático, se debería hacer especialmente en el manejo de excepciones. (Las excepciones son un mecanismo para señalar algo a través de las capas de aplicación).

Personalmente, trato de evitar cualquier cosa más allá

class SomeException(Exception): pass

(Descargo de responsabilidad: respuesta subjetiva, posiblemente por naturaleza de la pregunta).

Answer 4

Manejo robusto de excepciones (en Python) : una publicación de blog sobre "mejores prácticas para Python exceptions" que escribí hace un tiempo. Lo podrías encontrar útil.

Algunos puntos clave del blog:

Nunca use excepciones para control de flujo

Existen excepciones para situaciones excepcionales: eventos que no son parte de la ejecución normal.

Considere "encontrar" en una cadena que devuelve -1 si no se encuentra el patrón, pero la indexación más allá del final de una cadena genera una excepción. No encontrar la cadena es una ejecución normal.

Maneje excepciones en el nivel que sabe cómo manejarlas

...

El mejor lugar es esa pieza de código que puede manejar la excepción. Para algunas excepciones, como errores de programación (por ejemplo, error de índice, TypeError, NameError, etc.) las excepciones se dejan mejor al programador / usuario, porque "manejarlas" simplemente ocultará errores reales.

Siempre pregunte "¿este es el lugar correcto para manejar esta excepción?" y tenga cuidado con atrapar todas las excepciones.

Documenta las excepciones arrojadas por tu código

...

pensar en las excepciones que su código puede arrojar le ayudará a escribir un código mejor, más seguro y más encapsulado