Catching an exception caused by 'finally' while raising a preceeding exception - python-3.x

Question

Let's say I have the following code:
def do(i):
try:
1/i
except:
raise
finally:
raise NotImplementedError
It will try to divide 1 by a certain number, and will then in its finally clause, raise an Exception. What if I wanted to handle the exception in finally, but still want exceptions from try to be raised? (Note that I can't change how do works. I need to wrap dowithin my own exception handling logic).
To illustrate, let's try a few things:
do(1)
>>>
---------------------------------------------------------------------------
NotImplementedError Traceback (most recent call last)
<ipython-input-16-bf2a92c9df1e> in <module>
----> 1 do(1)
<ipython-input-14-17793ae783da> in do(i)
5 raise
6 finally:
----> 7 raise NotImplementedError
NotImplementedError:
,
do(0)
>>>
---------------------------------------------------------------------------
ZeroDivisionError Traceback (most recent call last)
<ipython-input-14-17793ae783da> in do(i)
2 try:
----> 3 1/i
4 except:
ZeroDivisionError: division by zero
During handling of the above exception, another exception occurred:
NotImplementedError Traceback (most recent call last)
<ipython-input-17-dcdf66fecd31> in <module>
----> 1 do(0)
<ipython-input-14-17793ae783da> in do(i)
5 raise
6 finally:
----> 7 raise NotImplementedError
NotImplementedError:
,
try:
do(0)
except NotImplementedError:
print("passed")
except:
raise
>>>
passed
So, it is catching the NotImplementedError, which happens while handling the ZeroDivisionError and is therefore not raising ZeroDivisionError .

Answer 1

From the documentation, emphasis is mine:
If finally is present, it specifies a ‘cleanup’ handler. The try
clause is executed, including any except and else clauses. If an
exception occurs in any of the clauses and is not handled, the
exception is temporarily saved. The finally clause is executed. If
there is a saved exception it is re-raised at the end of the finally
clause. If the finally clause raises another exception, the saved
exception is set as the context of the new exception. If the finally
clause executes a return, break or continue statement, the saved
exception is discarded.
My addition to the emphasised part: otherwise the context is set to None.
In other words, the code that calls do(0) can't directly catch ZeroDevisionError since it is being masked by the NotImplementedError raised by the finally block. It will have to explicitly check the context of the NotImplemented exception.
try:
do(0)
except NotImplementedError as e:
print(e.__context__)
print(type(e.__context__))
Outputs
division by zero
<class 'ZeroDivisionError'>
To raise the full error stack only if the catched exception has a context, one could construct something like:
try:
do(0)
except NotImplementedError as e:
if e.__context__:
raise e

Answer 2

As the internal structure of the do() function is outside of your purview, then I would recommend pre-validation in the form of:
if number != 0:
do(number)
else:
raise ZeroDivisionError
It's hard to say for sure without more bits of the puzzle, but hope that helps.