Python: posso sobrecarregar a declaração de aumento com def __Reiise __ (self):?

Question

Aqui está minha aula de exceção que está usando levantar:

class SCE(Exception):
    """
    An error while performing SCE functions.
    """
    def __init__(self, value=None):
        """
        Message: A string message or an iterable of strings.
        """
        if value is None:
            self._values = []
        elif isinstance(value, str):
            self._values = [value]
        else:
            self._values = list(value)

    def __raise__(self):
        print('raising')
        if not len(self._values):
            return

    def __str__(self):
        return self.__repr__()

    def __iter__(self):
        return iter(self._values)

    def __repr__(self):
        return repr(self._values)

Atualmente, se eu levantar esta exceção sem valor, recebo traceback seguido por:

__main__.SCE: []

Em vez do que eu esperava qual era:

raising
>>>

Como você sobrecarrega raise?

Answer 1

Como diz a outra resposta, não há __raise__ Método especial. Havia um tópico em 2004 no comp.lang.python, onde alguém sugeriu adicionar esse método, mas não acho que houve nenhum acompanhamento nisso. A única maneira de pensar que o aumento da exceção de conectar é corrigindo o intérprete, ou algum tipo de fonte ou bytecode reescrevendo que insere uma chamada de função ao lado da operação de aumento.

Answer 2

Não existe um método tão especial __raise__ (pelo menos nenhum de que eu já ouvi falar ou que posso encontrar em A documentação do Python).

Por que você quer fazer isso? Não consigo pensar em nenhuma razão pela qual você deseja que o código personalizado seja executado quando a exceção é levantada (em oposição a quando a exceção é construída, o que você pode fazer com o __init__ método, ou quando a exceção é capturada, o que você pode fazer com um except quadra). Qual é o seu caso de uso para esse comportamento e por que você espera que o Python o apóie?

Answer 3

Como outros declararam, não existe um método privado __raise__. Nada impede a definição de um. Por exemplo:

#!/usr/bin/env python3


class MyClass(object):
    def __init__(self, raise_exceptions=False):
        self.raise_exceptions = raise_exceptions

    def __raise__(self, err=None):
        print(err, flush=True)
        if self.raise_exceptions:
            raise err

    def run(self):
        try:
            assert False, 'assertion False'
        except Exception as err:
            self.__raise__(err)


if __name__ == '__main__':
    MyClass(raise_exceptions=False).run()
    MyClass(raise_exceptions=True).run()

Aqui está a saída:

$ python3 my_class.py
assertion False
assertion False
Traceback (most recent call last):
  File "my_class.py", line 22, in <module>
    MyClass(raise_exceptions=True).run()
  File "my_class.py", line 17, in run
    self.__raise__(err)
  File "my_class.py", line 11, in __raise__
    raise err
  File "my_class.py", line 15, in run
    assert False, 'assertion False'
AssertionError: assertion False

Process finished with exit code 1