Python: posso sovraccaricare la dichiarazione di aumento con def __raise __ (self):?

Question

Ecco la mia classe di eccezione che sta usando aumentare:

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)

Attualmente se alzo questa eccezione senza alcun valore ottengo il traceback seguito da:

__main__.SCE: []

Invece di quello che mi aspettavo che fosse:

raising
>>>

Come si sovraccarica raise?

Answer 1

Come dice l'altra risposta, non c'è no __raise__ Metodo speciale. Nel 2004 c'era un thread su comp.lang.python in cui qualcuno ha suggerito di aggiungere un tale metodo, ma non credo che ci sia stato alcun seguito. L'unico modo in cui mi viene in mente di allevare l'eccezione è patching dell'interprete, o una sorta di riscrittura di origine o bytecode che inserisce una chiamata di funzione accanto all'operazione di sollevamento.

Answer 2

Non esiste un metodo così speciale __raise__ (Almeno nessuno di cui abbia mai sentito parlare o che posso trovare La documentazione di Python).

Perchè vuoi fare questo? Non riesco a pensare a nessun motivo per cui desideri che il codice personalizzato venga eseguito quando viene sollevata l'eccezione (al contrario di entrambi quando l'eccezione è costruita, cosa che puoi fare con il __init__ metodo o quando l'eccezione viene catturata, che puoi fare con un except bloccare). Qual è il tuo caso d'uso per questo comportamento e perché ti aspetti che Python lo supporti?

Answer 3

Come altri hanno affermato, non esiste un tale metodo privato __raise__. Niente impedisce di definirne uno. Per esempio:

#!/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()

Ecco l'output:

$ 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