Using a contextmanager You could use a custom contextmanager, for example: class DidWeRaise: __slots__ = (‘exception_happened’, ) # instances will take less memory def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): # If no exception happened the `exc_type` is None self.exception_happened = exc_type is not None And then use that inside the try: try: … Read more
Why not look at what you actually get? Here is a simple chunk of code in C#: static void Main(string[] args) { int i = 0; try { i = 1; Console.WriteLine(i); return; } finally { Console.WriteLine(“finally.”); } } And here is the resulting IL in the debug build: .method private hidebysig static void Main(string[] … Read more
These are two different things: The catch block is only executed if an exception is thrown in the try block. The finally block is executed always after the try(-catch) block, if an exception is thrown or not. In your example you haven’t shown the third possible construct: try { // try to execute this statements… … Read more
From the Python documentation A finally clause is always executed before leaving the try statement, whether an exception has occurred or not. When an exception has occurred in the try clause and has not been handled by an except clause (or it has occurred in a except or else clause), it is re-raised after the … Read more
If any of the code in the try block can throw a checked exception, it has to appear in the throws clause of the method signature. If an unchecked exception is thrown, it’s bubbled out of the method. The finally block is always executed, whether an exception is thrown or not.
Finally always executes. That’s what it’s for, which means its return value gets used in your case. You’ll want to change your code so it’s more like this: function example() { var returnState = false; // initialization value is really up to the design try { returnState = true; } catch { returnState = false; … Read more
The try block completes with the execution of the return statement and the value of s at the time the return statement executes is the value returned by the method. The fact that the finally clause later changes the value of s (after the return statement completes) does not (at that point) change the return … Read more
It doesn’t run forever. Each stack overflow causes the code to move to the finally block. The problem is that it will take a really, really long time. The order of time is O(2^N) where N is the maximum stack depth. Imagine the maximum depth is 5 foo() calls foo() calls foo() calls foo() calls … Read more
It makes a difference if you return early: try: run_code1() except TypeError: run_code2() return None # The finally block is run before the method returns finally: other_code() Compare to this: try: run_code1() except TypeError: run_code2() return None other_code() # This doesn’t get run if there’s an exception. Other situations that can cause differences: If an … Read more