完美的例子如下:

try:
    #x = Hello + 20
    x = 10 + 20 
except:
    print 'I am in except block'
    x = 20 + 30
else:
    print 'I am in else block'
    x += 1
finally:
    print 'Finally x = %s' %(x)

运行这些Python3代码来查看finally的需求:

CASE1:

count = 0
while True:
    count += 1
    if count > 3:
        break
    else:
        try:
            x = int(input("Enter your lock number here: "))

            if x == 586:
                print("Your lock has unlocked :)")

                break
            else:
                print("Try again!!")

                continue

        except:
            print("Invalid entry!!")
        finally:
            print("Your Attempts: {}".format(count))

例2:

count = 0

while True:
    count += 1
    if count > 3:
        break
    else:
        try:
            x = int(input("Enter your lock number here: "))

            if x == 586:
                print("Your lock has unlocked :)")

                break
            else:
                print("Try again!!")

                continue

        except:
            print("Invalid entry!!")

        print("Your Attempts: {}".format(count))

每次尝试以下输入:

随机整数 正确的代码是586(试试这个，你会得到你的答案) 随机字符串

**在学习Python的早期阶段。

如果你早点回来，情况就不一样了:

try:
    run_code1()
except TypeError:
    run_code2()
    return None   # The finally block is run before the method returns
finally:
    other_code()

与此相比:

try:
    run_code1()
except TypeError:
    run_code2()
    return None   

other_code()  # This doesn't get run if there's an exception.

其他可能导致差异的情况:

如果在except块内抛出异常。 如果在run_code1()中抛出异常，但它不是TypeError。 其他控制流语句，如continue和break语句。

试着先运行这段代码，不要使用finally块，

1 / 0导致除零误差。

    try:
        1 / 0    
        print(1)
        
    except Exception as e:
        1 / 0
        print(e)
        

然后尝试运行这段代码，

    try:
        1 / 0    
        print(1)
        
    except Exception as e:
        1 / 0
        print(e)
   
    finally:
        print('finally')

对于第一种情况，你没有finally块， 因此，当在except块中发生错误时，程序执行将停止，并且在except块之后不能执行任何东西。

但对于第二种情况， 错误发生，但在程序停止之前，python先执行finally块，然后导致程序停止。 这就是为什么你要用finally来做真正重要的事情。

它们不相等。最后，不管发生什么，代码都会运行*。 它对于清理必须运行的代码非常有用。

*： 正如Mark Byers所评论的，任何导致进程立即终止的事情也会阻止最终代码的运行。 后者可以是os._exit()。或断电，但无限循环或其他东西也属于这一类。

正如文档中所解释的，finally子句旨在定义在所有情况下都必须执行的清理操作。

如果finally存在，则指定一个' cleanup '处理程序。的尝试 子句，包括except和else子句。如果一个 异常发生在任何子句中而不被处理，则 异常被暂时保存。finally子句被执行。如果 有一个保存的异常，它在finally结束时被重新引发 条款。

一个例子:

>>> def divide(x, y):
...     try:
...         result = x / y
...     except ZeroDivisionError:
...         print("division by zero!")
...     else:
...         print("result is", result)
...     finally:
...         print("executing finally clause")
...
>>> divide(2, 1)
result is 2.0
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'

如您所见，finally子句在任何事件中都被执行。由分隔两个字符串引发的TypeError不由except子句处理，因此在finally子句执行后重新引发。

在实际应用程序中，finally子句用于释放外部资源(例如文件或网络连接)，而不管资源的使用是否成功。