带预抛出钩子的自定义异常？

Question

I want an Exception class that "does something" when it is thrown. Dummy example:

class BrowserEatRamError(Exception):
    def __raise__(self):
        os.system('Killall -9 chrome')
        super(BrowserEatRamError, self).__raise__()

When I throw it using:

raise BrowserEatRamError('Chrome is eating all ram')

Chrome should be closed before the exception is thrown. Is there a magic method which can achieve it? If not, what is the most elegant way to achieve similar behavior?

EDIT:

I prefer not to use init because init would be invoked even if the Exception is raised inside a try cache.

Answer 1

No such special method exists. All of these are documented in the Data model .

Assuming you are using the (relatively good) practice of creating and initializing errors and then raising them, ie,

raise Error(args)

instead of:

err = Error(args)
# Somewhere else
raise err

You can simply overload the __intit__ method (Called to initialise it).

You can also put it in a try / except. If you do this often, you can use a context manager.

try:
     # ...
except Exception as e:
    # Reraise if the exception doesn't have a `.on_raise()` method
    # Or that method returns a falsey value.
    if not hasattr(e, 'on_raise') or not e.on_raise():
        raise

class CustomRaiseAction(object):
    def __enter__(self):
        return
    def __exit__(exception_type, exception_value, traceback):
        if hasattr(exception_type, 'on_raise'):
            return exception_type.on_raise(exception_value)
custom_raise_action = CustomRaiseAction()

with custom_raise_action:
    # ...

In both of these ways, if the on_raise method returns True , the exception will stop propogating. If it returns False (Or other falsey values, like None ), it will be thrown further.

You can also do this without a context manager, by overwriting sys.excepthook . This is like an __exit__ for the whole program, and is called when the program is about the end, and by default, displays the error. Note that this won't work if another program overrides it, and applies in all situations, including other modules, which may cause unexpected behaviour.

import sys

old_excepthook = sys.excepthook
def new_excepthook(exception_type, exception_value, traceback):
    if hasattr(exception_type, 'on_raise'):
        exception_type.on_raise(exception_value)
    old_excepthook(exception_type, exception_value, traceback)
sys.excepthook = new_excepthook

And also, you cannot stop the exception and continue.