转 Python3 错误和异常/ Python学习之错误调试和测试

########sample 0

https://www.cnblogs.com/Simon-xm/p/4073028.html

except: #捕获所有异常

except: <异常名>: #捕获指定异常

except:<异常名1，异常名2):捕获异常1或者异常2

except:<异常名>,<数据>:捕获指定异常及其附加的数据

except:<异常名1,异常名2>:<数据>:捕获异常名1或者异常名2,及附加的数据库

常用异常名：

异常名    描述
AttributeError 调用不存在的方法引发的异常
EOFError     遇到文件末尾引发的异常
ImportError 导入模块出错引发的异常
IndexError     列表越界引发的异常
IOError     I/O操作引发的异常，如打开文件出错等
KeyError   使用字典中不存在的关键字引发的异常
NameError 使用不存在的变量名引发的异常
TabError 语句块缩进不正确引发的异常
ValueError 搜索列表中不存在的值引发的异常
ZeroDivisionError   除数为零引发的异常

使用raise 引发异常几种方式：

raise 异常名
raise 异常名,附加数据
raise 类名

assert 简化了raise语句：
需要注意的是，assert语句一般用于开发时对程序条件的验证，只有当内置_debug_为True时，assert语句才有效。当Python脚本以-O选项编译成为字节码文件时，assert 语句将被移除。
但与raise语句不同的是，assert语句是在条件测试为假时，才引发异常。assert语言的一般形式如下：

assert <条件测试>,<异常附加数据> #其中异常附加数据是可选的

python编程_Python异常机制try: 代码段 except 异常类型,e: 异常处理代码段，如果不知道异常类型，可以使用try: 代码段 except Except,e:异常处理代码段；Except是通用异常类型

一个Python异常实例

一个简单的异常例子，打开一个不存在的文件，引发异常：

#!/usr/local/bin/python3.2    

try:

    f = open("file-not-exists", "r")  

except IOError,e:

    print("open exception: %s: %s\n" %(e.errno, e.strerror)) 

与Python异常相关的关键字：

关键字          关键字说明

raise           抛出/引发异常

try/except      捕获异常并处理

pass            忽略异常

as              定义异常实例(except IOError as e)

finally         无论是否出现异常，都执行的代码

else            如果try中的语句没有引发异常，则执行else中的语句

except

老版本的Python，except语句写作"except Exception, e"，Python 2.6后应写作"except Exception as e"。

使用
except
而不带任何异常类型：

try:

      do something

except:

      handle except

    会捕获所有异常，包括键盘中断和程序退出请求（用sys.exit()就无法退出程序了，因为异常被捕获了），因此慎用。

使用
except Exception as e
可以捕获除与程序退出sys.exit()相关之外的所有异常。

else与finally

else表示如果try中的代码没有引发异常，则会执行else：

try:

    f = open("foo", "r")

except IOError as e:

    ...

else:

    data = f.read()

finally表示无论是否有异常，都将被执行：

try:

    f = open("foo", "r")

except IOError as e:

    ...

finally:

    f.close()

#!/usr/bin/python

import traceback
try:
 1/0
#except Exception,e:
# print traceback.format_exc()
 
except Exception as e:
 print e

#!/usr/bin/python
import traceback
try:
 1/0
#except Exception,e:
# print traceback.format_exc()
 
except Exception , e:
 print e

Python的异常处理能力是很强大的，可向用户准确反馈出错信息。在Python中，异常也是对象，可对它进行操作。所有异常都是基类 Exception的成员。所有异常都从基类Exception继承，而且都在exceptions模块中定义。Python自动将所有异常名称放在内建 命名空间中，所以程序不必导入exceptions模块即可使用异常。一旦引发而且没有捕捉SystemExit异常，程序执行就会终止。如果交互式会话 遇到一个未被捕捉的SystemExit异常，会话就会终止。

方式一:try语句:

1使用try和except语句来捕获异常

try:
   block
except [exception,[data…]]:
   block

try:
block
except [exception,[data...]]:
   block
else:
   block

该种异常处理语法的规则是：

·   执行try下的语句，如果引发异常，则执行过程会跳到第一个except语句。

·   如果第一个except中定义的异常与引发的异常匹配，则执行该except中的语句。

·   如果引发的异常不匹配第一个except，则会搜索第二个except，允许编写的except数量没有限制。

·   如果所有的except都不匹配，则异常会传递到下一个调用本代码的最高层try代码中。

·   如果没有发生异常，则执行else块代码。

例:

try:

f = open(“file.txt”,”r”)
except IOError, e:
   print e

捕获到的IOError错误的详细原因会被放置在对象e中,然后运行该异常的except代码块

捕获所有的异常

try:
   a=b
   b=c
except Exception,ex:
   print Exception,":",ex

使用except子句需要注意的事情，就是多个except子句截获异常时，如果各个异常类之间具有继承关系，则子类应该写在前面，否则父类将会直接截获子类异常。放在后面的子类异常也就不会执行到了。

2 使用try跟finally:

语法如下:

try:
   block
finally:
   block

该语句的执行规则是：

·   执行try下的代码。

·   如果发生异常，在该异常传递到下一级try时，执行finally中的代码。

·   如果没有发生异常，则执行finally中的代码。

第二种try语法在无论有没有发生异常都要执行代码的情况下是很有用的。例如我们在python中打开一个文件进行读写操作，我在操作过程中不管是否出现异常，最终都是要把该文件关闭的。

这两种形式相互冲突，使用了一种就不允许使用另一种，而功能又各异

2. 用raise语句手工引发一个异常:

raise [exception[,data]]

在Python中，要想引发异常，最简单的形式就是输入关键字raise，后跟要引发的异常的名称。异常名称标识出具体的类：Python异常是那些类的 对象。执行raise语句时，Python会创建指定的异常类的一个对象。raise语句还可指定对异常对象进行初始化的参数。为此，请在异常类的名称后 添加一个逗号以及指定的参数（或者由参数构成的一个元组）。

例:

try:
    raise MyError #自己抛出一个异常
except MyError:
    print 'a error'

raise ValueError,’invalid argument’
捕捉到的内容为:

type = VauleError
message = invalid argument

3.   采用traceback(跟踪)模块查看异常

发生异常时，Python能“记住”引发的异常以及程序的当前状态。Python还维护着traceback（跟踪）对象，其中含有异常发生时与函数调用 堆栈有关的信息。记住，异常可能在一系列嵌套较深的函数调用中引发。程序调用每个函数时，Python会在“函数调用堆栈”的起始处插入函数名。一旦异常 被引发，Python会搜索一个相应的异常处理程序。如果当前函数中没有异常处理程序，当前函数会终止执行，Python会搜索当前函数的调用函数，并以 此类推，直到发现匹配的异常处理程序，或者Python抵达主程序为止。这一查找合适的异常处理程序的过程就称为“堆栈辗转开解”（Stack Unwinding）。解释器一方面维护着与放置堆栈中的函数有关的信息，另一方面也维护着与已从堆栈中“辗转开解”的函数有关的信息。

格式:

try:
block
except:
   traceback.print_exc()

示例:…excpetion/traceback.py

4. 采用sys模块回溯最后的异常              (重要)

import sys
try:
   block
except:
   info=sys.exc_info()
   print info[0],":",info[1]

或者以如下的形式:

import sys
    tp,val,td = sys.exc_info()

sys.exc_info()的返回值是一个tuple, (type, value/message, traceback)

这里的type ---- 异常的类型

value/message ---- 异常的信息或者参数

traceback ---- 包含调用栈信息的对象。

从这点上可以看出此方法涵盖了traceback.

5. 异常处理的一些其它用途

除了处理实际的错误条件之外，对于异常还有许多其它的用处。在标准 Python 库中一个普通的用法就是试着导入一个模块，然后检查是否它能使用。导入一个并不存在的模块将引发一个 ImportError 异常。你可以使用这种方法来定义多级别的功能――依靠在运行时哪个模块是有效的，或支持多种平台 (即平台特定代码被分离到不同的模块中)。

你也能通过创建一个从内置的 Exception 类继承的类定义你自己的异常，然后使用 raise 命令引发你的异常。如果你对此感兴趣，请看进一步阅读的部分。

下面的例子演示了如何使用异常支持特定平台功能。代码来自 getpass 模块，一个从用户获得口令的封装模块。获得口令在 UNIX、Windows 和 Mac OS 平台上的实现是不同的，但是这个代码封装了所有的不同之处。

例支持特定平台功能

# Bind the name getpass to the appropriate function

try:
      import termios, TERMIOS                   
except ImportError:
      try:
          import msvcrt                         
      except ImportError:
          try:
              from EasyDialogs import AskPassword
          except ImportError:
              getpass = default_getpass         
          else:                                 
              getpass = AskPassword
      else:
          getpass = win_getpass
else:
      getpass = unix_getpass

termios 是 UNIX 独有的一个模块，它提供了对于输入终端的底层控制。如果这个模块无效 (因为它不在你的系统上，或你的系统不支持它)，则导入失败，Python 引发我们捕捉的 ImportError 异常。

OK，我们没有 termios，所以让我们试试 msvcrt，它是 Windows 独有的一个模块，可以提供在 Microsoft Visual C++ 运行服务中的许多有用的函数的一个API。如果导入失败，Python 会引发我们捕捉的 ImportError 异常。

如果前两个不能工作，我们试着从 EasyDialogs 导入一个函数，它是 Mac OS 独有的一个模块，提供了各种各样类型的弹出对话框。再一次，如果导入失败，Python 会引发一个我们捕捉的 ImportError 异常。

这些平台特定的模块没有一个有效 (有可能，因为 Python 已经移植到了许多不同的平台上了)，所以我们需要回头使用一个缺省口令输入函数 (这个函数定义在 getpass 模块中的别的地方)。注意我们在这里所做的：我们将函数 default_getpass 赋给变量 getpass。如果你读了官方 getpass 文档，它会告诉你 getpass 模块定义了一个 getpass 函数。它是这样做的：通过绑定 getpass 到正确的函数来适应你的平台。然后当你调用 getpass 函数时，你实际上调用了平台特定的函数，是这段代码已经为你设置好的。你不需要知道或关心你的代码正运行在何种平台上；只要调用 getpass，则它总能正确处理。

一个 try...except 块可以有一条 else 子句，就像 if 语句。如果在 try 块中没有异常引发，然后 else 子句被执行。在本例中，那就意味着如果 from EasyDialogs import AskPassword 导入可工作，所以我们应该绑定 getpass 到 AskPassword 函数。其它每个 try...except 块有着相似的 else 子句，当我们发现一个 import 可用时，就绑定 getpass 到适合的函数。

#########

https://www.cnblogs.com/technologylife/p/5628585.html

1、tuple特性

tuple是另一种有序的列表，中文翻译为“ 元组 ”。tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了。

 >>> t = ('Adam', 'Lisa', 'Bart') 

创建tuple和创建list唯一不同之处是用( )替代了[ ]。

现在，这个 t 就不能改变了，tuple没有 append()方法，也没有insert()和pop()方法。所以，新元素没法直接往 tuple 中添加，在 tuple删除元素 也不行。

获取 tuple 元素的方式和 list 是一模一样的，可以正常使用 t[0]，t[-1]等索引方式访问元素，但是不能赋值成别的元素。

 >>> t[0] = 'Paul'

 Traceback (most recent call last):

 File "", line 1, in

 TypeError: 'tuple' object does not support item assignment

2、创建单元素tuple

包含 0 个元素的 tuple，也就是空tuple，直接用 ()表示：

 >>> t = ()

 >>> print t

 ()

创建包含1个元素的 tuple 呢？来试试：

 >>> t = (1)

 >>> print t

 1

因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果 (1) 被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。

正是因为用()定义单元素的tuple有歧义，所以 Python 规定，单元素 tuple 要多加一个逗号“,”，这样就避免了歧义：

 >>> t = (1,)

 >>> print t

 (1,)

Python在打印单元素tuple时，也自动添加了一个“,”，为了更明确地告诉你这是一个tuple。

3、"可变”的tuple

tuple也是“可变”的，如：

 >>> t = ('a', 'b', ['A', 'B'])

注意到 t 有 3 个元素：'a'，'b'和一个list：['A', 'B']。list作为一个整体是tuple的第3个元素。list对象可以通过 t[2] 拿到：

 >>> L = t[2]

然后，我们把list的两个元素改一改：

 >>> L[0] = 'X'

 >>> L[1] = 'Y'

再看看tuple的内容：

 >>> print t

 ('a', 'b', ['X', 'Y'])

表面上看，tuple的元素确实变了，但其实变的不是 tuple 的元素，而是list的元素。
tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！
理解了“指向不变”后，要创建一个内容也不变的tuple怎么做？那就必须保证tuple的每一个元素本身也不能

############sample 1

Python学习之错误调试和测试

https://baijiahao.baidu.com/s?id=1603758921183499330&wfr=spider&for=pc

在程序运行过程中，总会遇到各种各样的错误，Python内置了一套异常处理机制，来帮助我们进行错误处理。

错误处理

在程序运行的过程中，如果发生了错误，可以事先约定返回一个错误代码，这样，就可以知道是否有错，以及出错的原因。在操作系统提供的调用中，返回错误码非常常见。比如打开文件的函数open()，成功时返回文件描述符（就是一个整数），出错时返回-1。

用错误码来表示是否出错十分不便，因为函数本身应该返回的正常结果和错误码混在一起，造成调用者必须用大量的代码来判断是否出错，所以高级语言通常都内置了一套try...except...finally...的错误处理机制，Python也不例外。

try

当我们认为某些代码可能会出错时，就可以用try来运行这段代码，如果执行出错，则后续代码不会继续执行，而是直接跳转至错误处理代码，即except语句块，执行完except后，如果有finally语句块，则执行finally语句块，至此，执行完毕。

Python的错误其实也是class，所有的错误类型都继承自BaseException，所以在使用except时需要注意的是，它不但捕获该类型的错误，还把其子类也“一网打尽”。

调用栈

如果错误没有被捕获，它就会一直往上抛，最后被Python解释器捕获，打印一个错误信息，然后程序退出。来看看err.py：

执行，结果如下：

我们从上往下可以看到整个错误的调用函数链。

记录错误

如果不捕获错误，自然可以让Python解释器来打印出错误堆栈，但程序也被结束了。既然我们能捕获错误，就可以把错误堆栈打印出来，然后分析错误原因，同时，让程序继续执行下去。

Python内置的logging模块可以非常容易地记录错误信息：

执行上述模块：

抛出错误

因为错误是class，捕获一个错误就是捕获到该class的一个实例。因此，错误并不是凭空产生的，而是有意创建并抛出的。Python的内置函数会抛出很多类型的错误，我们自己编写的函数也可以抛出错误。

如果要抛出错误，首先根据需要，可以定义一个错误的class，选择好继承关系，然后，用raise语句抛出一个错误的实例：

执行，可以最后跟踪到我们自己定义的错误：

最后，我们来看另一种错误处理的方式：

在bar()函数中，我们明明已经捕获了错误，但是，打印一个ValueError!后，又把错误通过raise语句抛出去了，这不有病么？

其实这种错误处理方式不但没病，而且相当常见。捕获错误目的只是记录一下，便于后续追踪。但是，由于当前函数不知道应该怎么处理该错误，所以，最恰当的方式是继续往上抛，让顶层调用者去处理。好比一个员工处理不了一个问题时，就把问题抛给他的老板，如果他的老板也处理不了，就一直往上抛，最终会抛给CEO去处理。

raise语句如果不带参数，就会把当前错误原样抛出。此外，在except中raise一个Error，还可以把一种类型的错误转化成另一种类型：

调试

程序能一次写完并正常运行的概率很小，基本不超过1%。总会有各种各样的bug需要修正。有的bug很简单，看看错误信息就知道，有的bug很复杂，我们需要知道出错时，哪些变量的值是正确的，哪些变量的值是错误的，因此，需要一整套调试程序的手段来修复bug。

print()

用print()把可能有问题的变量打印出来看看。

断言

assert的意思是，表达式n != 0应该是True，否则，根据程序运行的逻辑，后面的代码肯定会出错。

如果断言失败，assert语句本身就会抛出AssertionError。

logging

logging允许你指定记录信息的级别，有debug，info，warning，error等几个级别，当我们指定level=INFO时，logging.debug就不起作用了。同理，指定level=WARNING后，debug和info就不起作用了。这样一来，你可以放心地输出不同级别的信息，也不用删除，最后统一控制输出哪个级别的信息。

logging的另一个好处是通过简单的配置，一条语句可以同时输出到不同的地方，比如console和文件。

pdb

Python的调试器pdb，让程序以单步方式运行，可以随时查看运行状态。我们先准备好程序：

然后启动：

以参数-m pdb启动后，pdb定位到下一步要执行的代码-> s = '0'。输入命令l来查看代码：

输入命令n可以单步执行代码。

pdb.set_trace()

这个方法也是用pdb，但是不需要单步执行，我们只需要import pdb，然后，在可能出错的地方放一个pdb.set_trace()，就可以设置一个断点：

运行代码，程序会自动在pdb.set_trace()暂停并进入pdb调试环境，可以用命令p查看变量，或者用命令c继续运行。

IDE

目前比较好的Python IDE有：

isual Studio Code：code.visualstudio.com/，需要安装Python插件。

PyCharm：

另外，Eclipse加上pydev插件也可以调试Python程序。

单元测试

单元测试是用来对一个模块、一个函数或者一个类来进行正确性检验的测试工作。

文档测试

如果你经常阅读Python的官方文档，可以看到很多文档都有示例代码。

可以把这些示例代码在Python的交互式环境下输入并执行，结果与文档中的示例代码显示的一致。

这些代码与其他说明可以写在注释中，然后，由一些工具来自动生成文

############

http://www.runoob.com/python3/python3-errors-execptions.html

Python3 错误和异常

作为Python初学者，在刚学习Python编程时，经常会看到一些报错信息，在前面我们没有提及，这章节我们会专门介绍。

Python有两种错误很容易辨认：语法错误和异常。

语法错误

Python 的语法错误或者称之为解析错，是初学者经常碰到的，如下实例

>>>while True print('Hello world') File "<stdin>", line 1, in ? while True print('Hello world') ^ SyntaxError: invalid syntax

这个例子中，函数 print() 被检查到有错误，是它前面缺少了一个冒号（:）。

语法分析器指出了出错的一行，并且在最先找到的错误的位置标记了一个小小的箭头。

异常

即便Python程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常。

大多数的异常都不会被程序处理，都以错误信息的形式展现在这里:

>>>10 * (1/0) Traceback (most recent call last): File "<stdin>", line 1, in ? ZeroDivisionError: division by zero >>> 4 + spam*3 Traceback (most recent call last): File "<stdin>", line 1, in ? NameError: name 'spam' is not defined >>> '2' + 2 Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: Can't convert 'int' object to str implicitly

异常以不同的类型出现，这些类型都作为信息的一部分打印出来: 例子中的类型有 ZeroDivisionError，NameError 和 TypeError。

错误信息的前面部分显示了异常发生的上下文，并以调用栈的形式显示具体信息。

异常处理

以下例子中，让用户输入一个合法的整数，但是允许用户中断这个程序（使用 Control-C 或者操作系统提供的方法）。用户中断的信息会引发一个 KeyboardInterrupt 异常。

>>>while True: try: x = int(input("Please enter a number: ")) break except ValueError: print("Oops! That was no valid number. Try again ")

try语句按照如下方式工作；

• 首先，执行try子句（在关键字try和关键字except之间的语句）
• 如果没有异常发生，忽略except子句，try子句执行后结束。
• 如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的except子句将被执行。最后执行 try 语句之后的代码。
• 如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中。

一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。

处理程序将只针对对应的try子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。

一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组，例如:

except (RuntimeError, TypeError, NameError): pass

最后一个except子句可以忽略异常的名称，它将被当作通配符使用。你可以使用这种方法打印一个错误信息，然后再次把异常抛出。

import sys try: f = open('myfile.txt') s = f.readline() i = int(s.strip()) except OSError as err: print("OS error: {0}".format(err)) except ValueError: print("Could not convert data to an integer.") except: print("Unexpected error:", sys.exc_info()[0]) raise

try except 语句还有一个可选的else子句，如果使用这个子句，那么必须放在所有的except子句之后。这个子句将在try子句没有发生任何异常的时候执行。例如:

for arg in sys.argv[1:]: try: f = open(arg, 'r') except IOError: print('cannot open', arg) else: print(arg, 'has', len(f.readlines()), 'lines') f.close()

使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到的、而except又没有捕获的异常。

异常处理并不仅仅处理那些直接发生在try子句中的异常，而且还能处理子句中调用的函数（甚至间接调用的函数）里抛出的异常。例如:

>>>def this_fails(): x = 1/0 >>> try: this_fails() except ZeroDivisionError as err: print('Handling run-time error:', err) Handling run-time error: int division or modulo by zero

---

抛出异常

Python 使用 raise 语句抛出一个指定的异常。例如:

>>>raise NameError('HiThere') Traceback (most recent call last): File "<stdin>", line 1, in ? NameError: HiThere

raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。

如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。

>>>try: raise NameError('HiThere') except NameError: print('An exception flew by!') raise An exception flew by! Traceback (most recent call last): File "<stdin>", line 2, in ? NameError: HiThere

---

用户自定义异常

你可以通过创建一个新的异常类来拥有自己的异常。异常类继承自 Exception 类，可以直接继承，或者间接继承，例如:

>>>class MyError(Exception): def __init__(self, value): self.value = value def __str__(self): return repr(self.value) >>> try: raise MyError(2*2) except MyError as e: print('My exception occurred, value:', e.value) My exception occurred, value: 4 >>> raise MyError('oops!') Traceback (most recent call last): File "<stdin>", line 1, in ? __main__.MyError: 'oops!'

在这个例子中，类 Exception 默认的 __init__() 被覆盖。

<p异常的类可以像其他的类一样做任何事情，但是通常都会比较简单，只提供一些错误相关的属性，并且允许处理异常的代码方便的获取这些信息。< p="" data-filtered="filtered">

当创建一个模块有可能抛出多种不同的异常时，一种通常的做法是为这个包建立一个基础异常类，然后基于这个基础类为不同的错误情况创建不同的子类:

class Error(Exception): """Base class for exceptions in this module.""" pass class InputError(Error): """Exception raised for errors in the input. Attributes: expression -- input expression in which the error occurred message -- explanation of the error """ def __init__(self, expression, message): self.expression = expression self.message = message class TransitionError(Error): """Raised when an operation attempts a state transition that's not allowed. Attributes: previous -- state at beginning of transition next -- attempted new state message -- explanation of why the specific transition is not allowed """ def __init__(self, previous, next, message): self.previous = previous self.next = next self.message = message

大多数的异常的名字都以"Error"结尾，就跟标准的异常命名一样。

---

定义清理行为

try 语句还有另外一个可选的子句，它定义了无论在任何情况下都会执行的清理行为。 例如:

>>>try: ... raise KeyboardInterrupt ... finally: ... print('Goodbye, world!') ... Goodbye, world! Traceback (most recent call last): File "<stdin>", line 2, in <module> KeyboardInterrupt

以上例子不管 try 子句里面有没有发生异常，finally 子句都会执行。

如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 except 把它截住，那么这个异常会在 finally 子句执行后再次被抛出。

下面是一个更加复杂的例子（在同一个 try 语句里包含 except 和 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 ? File "<stdin>", line 3, in divide TypeError: unsupported operand type(s) for /: 'str' and 'str'

---

预定义的清理行为

一些对象定义了标准的清理行为，无论系统是否成功的使用了它，一旦不需要它了，那么这个标准的清理行为就会执行。

这面这个例子展示了尝试打开一个文件，然后把内容打印到屏幕上:

for line in open("myfile.txt"): print(line, end="")

以上这段代码的问题是，当执行完毕后，文件会保持打开状态，并没有被关闭。

关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法:

with open("myfile.txt") as f: for line in f: print(line, end="")

以上这段代码执行完毕后，就算在处理过程中出问题了，文件 f 总是会关闭。