finally and else in Exception Handling

The else clause runs only when the try block succeeded. The finally clause runs no matter what happened.

def parse(text):
    try:
        value = int(text)
    except ValueError:
        return "not a number"
    else:
        return f"number: {value}"
    finally:
        print(f"parsed {text!r}")


print(parse("42"))      # parsed '42'   then  number: 42
print(parse("abc"))     # parsed 'abc'  then  not a number

Look at the order of the output. The finally line always prints first, because the finally clause runs as the try statement is unwinding, before the function actually returns its value. The return in the else clause has already computed its result by then.

The distinction is worth being precise about. The else clause covers the success path — the code that should only run when the risky operation worked. Putting it there, rather than at the bottom of the try block, means a failure in the try block cannot accidentally skip it.

The finally clause is the cleanup path. It runs whether the try block succeeded, whether an except clause handled the error, or whether the exception is still on its way out. That makes it the right place for releasing a lock, closing a connection or rolling something back.

The else clause runs when the try block completes without raising. It is the success path, and it exists so that code depending on the result of the risky operation is not accidentally skipped when that operation fails.

The finally clause always runs. It executes whether the try block succeeded, whether an except clause handled an exception, or whether the exception is still propagating out of the function. That guarantee is what makes it the place for cleanup that must happen regardless.

The order is fixed. The try block runs first. If it raises and an except clause matches, that clause runs next. Otherwise the else clause runs. And the finally clause runs last in every case, just before control leaves the try statement — which is why the printed line appears before the function's return value in the example.

Two edge cases to know. If an except clause re-raises, the finally clause still runs, and the re-raised exception continues on its way. And if the finally block itself raises, that new exception replaces whatever was in flight, which can hide the original failure — so a finally block should not raise.

For an interview, the practical summary is that finally is the guarantee and else is the success path. And in real code the with statement is usually a better tool than a bare finally for cleanup, because it also closes the resource at the end of the block rather than at the end of the function.