Qual é a maneira correta de declarar classes de exceção personalizadas no Python moderno? Meu principal objetivo é seguir o padrão de outras classes de exceção, para que (por exemplo) qualquer sequência extra que eu inclua na exceção seja impressa por qualquer ferramenta capturada pela exceção.

Por "Python moderno", quero dizer algo que será executado no Python 2.5, mas será "correto" para a maneira de fazer as coisas do Python 2.6 e do Python 3. *. Por "personalizado", quero dizer um objeto Exception que pode incluir dados extras sobre a causa do erro: uma string, talvez também algum outro objeto arbitrário relevante para a exceção.

Fui enganado pelo seguinte aviso de reprovação no Python 2.6.2:

>>> class MyError(Exception):
...     def __init__(self, message):
...         self.message = message
... 
>>> MyError("foo")
_sandbox.py:3: DeprecationWarning: BaseException.message has been deprecated as of Python 2.6

Parece loucura que BaseExceptiontem um significado especial para os atributos nomeados message. Pelo PEP-352, entendo que esse atributo tinha um significado especial no 2.5 que eles estão tentando depreciar, então acho que esse nome (e somente esse) agora é proibido? Ugh.

Também estou ciente de que Exceptiontem algum parâmetro mágico args, mas nunca soube usá-lo. Nem tenho certeza de que é o caminho certo para fazer as coisas daqui para frente; muitas discussões que encontrei on-line sugeriam que eles estavam tentando acabar com os argumentos do Python 3.

Atualização: duas respostas sugeriram a substituição __init__e __str__/ __unicode__/ __repr__. Parece muita digitação, é necessário?

Talvez eu tenha perdido a pergunta, mas por que não:

class MyException(Exception):
    pass

Edit: para substituir algo (ou passar argumentos extras), faça o seguinte:

class ValidationError(Exception):
    def __init__(self, message, errors):

        # Call the base class constructor with the parameters it needs
        super(ValidationError, self).__init__(message)

        # Now for your custom code...
        self.errors = errors

Dessa forma, você pode passar o dict de mensagens de erro para o segundo parâmetro e acessá-lo mais tarde com e.errors

Atualização do Python 3: No Python 3+, você pode usar este uso um pouco mais compacto de super():

class ValidationError(Exception):
    def __init__(self, message, errors):

        # Call the base class constructor with the parameters it needs
        super().__init__(message)

        # Now for your custom code...
        self.errors = errors

Com exceções Python modernos, você não precisa de abuso .messageou substituição .__str__()ou .__repr__()ou nada disso. Se tudo o que você deseja é uma mensagem informativa quando sua exceção é gerada, faça o seguinte:

class MyException(Exception):
    pass

raise MyException("My hovercraft is full of eels")

Isso dará um retorno final com MyException: My hovercraft is full of eels.

Se você quiser mais flexibilidade com a exceção, pode passar um dicionário como argumento:

raise MyException({"message":"My hovercraft is full of animals", "animal":"eels"})

No entanto, obter esses detalhes em um exceptbloco é um pouco mais complicado. Os detalhes são armazenados no argsatributo, que é uma lista. Você precisaria fazer algo assim:

try:
    raise MyException({"message":"My hovercraft is full of animals", "animal":"eels"})
except MyException as e:
    details = e.args[0]
    print(details["animal"])

Ainda é possível passar vários itens para a exceção e acessá-los por meio de índices de tupla, mas isso é altamente desencorajado (e foi planejado para desaprovação há algum tempo). Se você precisar de mais do que uma única informação e o método acima não for suficiente para você, você deve subclassificar Exceptionconforme descrito no tutorial .

class MyError(Exception):
    def __init__(self, message, animal):
        self.message = message
        self.animal = animal
    def __str__(self):
        return self.message

"Maneira correta de declarar exceções personalizadas no Python moderno?"

Isso é bom, a menos que sua exceção seja realmente um tipo de exceção mais específica:

class MyException(Exception):
    pass

Ou melhor (talvez perfeito), em vez de passdar uma sequência de caracteres:

class MyException(Exception):
    """Raise for my specific kind of exception"""

Subclasses de exceção de subclasse

Dos documentos

Exception

Todas as exceções integradas que não saem do sistema são derivadas dessa classe. Todas as exceções definidas pelo usuário também devem ser derivadas dessa classe.

Isso significa que, se sua exceção for um tipo de exceção mais específica, subclasse essa exceção em vez da genérica Exception(e o resultado será o de que você ainda deriva, Exceptionconforme recomendado pela documentação). Além disso, você pode pelo menos fornecer uma string de documento (e não ser forçado a usar a passpalavra - chave):

class MyAppValueError(ValueError):
    '''Raise when my specific value is wrong'''

Defina os atributos que você mesmo cria com um costume __init__. Evite passar um ditado como argumento posicional, os futuros usuários do seu código agradecerão. Se você usar o atributo de mensagem descontinuada, atribuir você mesmo evitará DeprecationWarning:

class MyAppValueError(ValueError):
    '''Raise when a specific subset of values in context of app is wrong'''
    def __init__(self, message, foo, *args):
        self.message = message # without this you may get DeprecationWarning
        # Special attribute you desire with your Error, 
        # perhaps the value that caused the error?:
        self.foo = foo         
        # allow users initialize misc. arguments as any other builtin Error
        super(MyAppValueError, self).__init__(message, foo, *args) 

Não há realmente nenhuma necessidade de escrever o seu próprio __str__ou __repr__. Os embutidos são muito legais e sua herança cooperativa garante que você o use.

Crítica da resposta principal

Talvez eu tenha perdido a pergunta, mas por que não:

class MyException(Exception):
    pass

Novamente, o problema com o exposto acima é que, para capturá-lo, você precisará nomeá-lo especificamente (importando-o se criado em outro lugar) ou capturar Exception (mas você provavelmente não está preparado para lidar com todos os tipos de exceções, e você só deve pegar as exceções que está preparado para lidar). Críticas semelhantes às abaixo, mas, além disso, não é assim que se inicializa via super, e você receberá uma DeprecationWarningse acessar o atributo de mensagem:

Edit: para substituir algo (ou passar argumentos extras), faça o seguinte:

class ValidationError(Exception):
    def __init__(self, message, errors):

        # Call the base class constructor with the parameters it needs
        super(ValidationError, self).__init__(message)

        # Now for your custom code...
        self.errors = errors

Dessa forma, você pode passar o dict de mensagens de erro para o segundo parâmetro e acessá-lo mais tarde com e.errors

Também requer exatamente dois argumentos a serem passados ​​(além do self.) Nem mais, nem menos. Essa é uma restrição interessante que os usuários futuros podem não apreciar.

Ser direto - viola a substituibilidade de Liskov .

Vou demonstrar os dois erros:

>>> ValidationError('foo', 'bar', 'baz').message

Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    ValidationError('foo', 'bar', 'baz').message
TypeError: __init__() takes exactly 3 arguments (4 given)

>>> ValidationError('foo', 'bar').message
__main__:1: DeprecationWarning: BaseException.message has been deprecated as of Python 2.6
'foo'

Comparado com:

>>> MyAppValueError('foo', 'FOO', 'bar').message
'foo'

veja como as exceções funcionam por padrão se um vs mais atributos forem usados ​​(rastreamentos omitidos):

>>> raise Exception('bad thing happened')
Exception: bad thing happened

>>> raise Exception('bad thing happened', 'code is broken')
Exception: ('bad thing happened', 'code is broken')

então você pode querer ter uma espécie de " modelo de exceção ", funcionando como uma exceção em si, de maneira compatível:

>>> nastyerr = NastyError('bad thing happened')
>>> raise nastyerr
NastyError: bad thing happened

>>> raise nastyerr()
NastyError: bad thing happened

>>> raise nastyerr('code is broken')
NastyError: ('bad thing happened', 'code is broken')

isso pode ser feito facilmente com esta subclasse

class ExceptionTemplate(Exception):
    def __call__(self, *args):
        return self.__class__(*(self.args + args))
# ...
class NastyError(ExceptionTemplate): pass

e se você não gostar da representação padrão de tupla, adicione __str__ método à ExceptionTemplateclasse, como:

    # ...
    def __str__(self):
        return ': '.join(self.args)

e você terá

>>> raise nastyerr('code is broken')
NastyError: bad thing happened: code is broken

A partir do Python 3.8 (2018, https://docs.python.org/dev/whatsnew/3.8.html ), o método recomendado ainda é:

class CustomExceptionName(Exception):
    """Exception raised when very uncommon things happen"""
    pass

Não se esqueça de documentar por que uma exceção personalizada é necessária!

Se você precisar, este é o caminho a seguir para exceções com mais dados:

class CustomExceptionName(Exception):
    """Still an exception raised when uncommon things happen"""
    def __init__(self, message, payload=None):
        self.message = message
        self.payload = payload # you could add more args
    def __str__(self):
        return str(self.message) # __str__() obviously expects a string to be returned, so make sure not to send any other data types

e buscá-los como:

try:
    raise CustomExceptionName("Very bad mistake.", "Forgot upgrading from Python 1")
except CustomExceptionName as error:
    print(str(error)) # Very bad mistake
    print("Detail: {}".format(error.payload)) # Detail: Forgot upgrading from Python 1

payload=Noneé importante torná-lo em decapagem. Antes de descartá-lo, você deve ligar paraerror.__reduce__() . O carregamento funcionará conforme o esperado.

Talvez você deva investigar para encontrar uma solução usando a returninstrução pythons se precisar de muitos dados a serem transferidos para alguma estrutura externa. Isso parece ser mais claro / mais pitônico para mim. Exceções avançadas são muito usadas em Java, que às vezes pode ser irritante ao usar uma estrutura e ter que detectar todos os erros possíveis.

Você deve substituir __repr__ou__unicode__ métodos, em vez de usar a mensagem, os argumentos que você fornece ao construir a exceção estarão no argsatributo do objeto de exceção.

Não, "mensagem" não é proibida. É apenas obsoleto. Seu aplicativo funcionará bem com o uso da mensagem. Mas você pode se livrar do erro de descontinuação, é claro.

Quando você cria classes Exception personalizadas para seu aplicativo, muitas delas não são subclasses apenas de Exception, mas de outras, como ValueError ou similar. Então você tem que se adaptar ao uso de variáveis.

E se você tiver muitas exceções em seu aplicativo, geralmente é uma boa ideia ter uma classe base personalizada comum para todos eles, para que os usuários de seus módulos possam fazer

try:
    ...
except NelsonsExceptions:
    ...

E nesse caso, você pode fazer o __init__ and __str__ necessário lá, para não precisar repeti-lo para todas as exceções. Mas simplesmente chamar a variável de mensagem de algo mais do que a mensagem funciona.

De qualquer forma, você só precisa __init__ or __str__se fizer algo diferente do que a própria exceção faz. E, se a depreciação for necessária, você precisará das duas ou receberá um erro. Não é necessário muito código extra por classe. ;)

Veja um artigo muito bom " O guia definitivo para exceções do Python ". Os princípios básicos são:

• Sempre herde de (pelo menos) Exceção.
• Sempre chame BaseException.__init__com apenas um argumento.
• Ao criar uma biblioteca, defina uma classe base herdada de Exception.
• Forneça detalhes sobre o erro.
• Herdar de tipos de exceções integradas quando faz sentido.

Há também informações sobre organização (em módulos) e exceções de empacotamento, recomendo a leitura do guia.

Tente este exemplo

class InvalidInputError(Exception):
    def __init__(self, msg):
        self.msg = msg
    def __str__(self):
        return repr(self.msg)

inp = int(input("Enter a number between 1 to 10:"))
try:
    if type(inp) != int or inp not in list(range(1,11)):
        raise InvalidInputError
except InvalidInputError:
    print("Invalid input entered")

Para definir corretamente suas próprias exceções, existem algumas práticas recomendadas que você precisa seguir:

• Defina uma classe base herdada de Exception. Isso permitirá capturar quaisquer exceções relacionadas ao projeto (exceções mais específicas devem herdar dele):

  class MyProjectError(Exception):
      """A base class for MyProject exceptions."""

  Organizar essas classes de exceção em um módulo separado (por exemplo exceptions.py) geralmente é uma boa ideia.

• Para criar uma exceção personalizada, subclasse a classe de exceção base.

• Para adicionar suporte a argumentos extras a uma exceção personalizada, defina um __init__()método personalizado com um número variável de argumentos. Chame a classe base __init__(), passando quaisquer argumentos posicionais para ela (lembre-se de que BaseException/Exception espera qualquer número de argumentos posicionais ):

  class CustomError(MyProjectError):
      def __init__(self, *args, **kwargs):
          super(CustomError, self).__init__(*args)
          self.foo = kwargs.get('foo')

  Para gerar essa exceção com um argumento extra, você pode usar:

  raise CustomError('Something bad happened', foo='foo')

Esse design segue o princípio de substituição de Liskov , pois você pode substituir uma instância de uma classe de exceção base por uma instância de uma classe de exceção derivada. Além disso, permite criar uma instância de uma classe derivada com os mesmos parâmetros que o pai.