一、抛出一个错误码

在程序运行的过程中,如果发生了错误,可以事先约定返回一个错误代码,这样,就可以知道是否有错,以及出错的原因。在操作系统提供

的调用中,返回错误码非常常见。比如打开文件的函数     open()     ,成功时返回文件描述符(就是一个整数),出错时返回  -1。

用错误码来表示是否出错十分不便,因为函数本身应该返回的正常结果和错误码混在一起,造成调用者必须用大量

的代码来判断是否出错:一旦出错,还要一级一级上报,直到某个函数可以处理该错误(比如,给用户输出一个错误信息)。

所以高级语言通常都内置了一套     try...except...finally...     的错误处理机制,Python也不例外。

二、try...except...finally

1、初识

让我们用一个例子来看看try的工作机制：

1. try:

2. a = 3

3. c = [1,2,3,4]

4. print(c[2])

5. print(b)

6. except (NameError, IndexError) as e:

7. print(e)

8. print('hello_01')

很明显我们在输出“b”时没有定义，错误很明显，这时候try登场了，我们这样理解：尝试着去运行下面的代码，如果有错误那么except将会捕获错误，并且不影响下面的代码正常运行。运行结果如下：

当我们认为某些代码可能会出错时,就可以用try来运行这段代码,如果执行出错,则后续代码不会继续执行,而是直接

跳转至错误处理代码,即except 语句块,执行完except后,如果有finally语句块,则执行finally语句块,至此,执行完毕。

例如：当然我们对文件处理有with...as语句，帮助我们安全的打开文件

1. try:

2. f = open('/tmp/passwd', 'r')

3. print(a)

4. f.close()

5. except NameError as e:

6. pass

7. finally:

8. f.close()

9.  

10. print(f.closed)

即使前面的代码出现了错误，如果有finally语句块,则执行finally语句块。最后我们查看文件的关闭状态：

由于没有错误发生,所以except语句块不会被执行,但是finally如果有,则一定会被执行(可以没有finally语句)。

2、捕获多种类型的错误

错误应该有很多种类,如果发生了不同类型的错误,应该由不同的except语句块处理。没错,可以有多个except来捕获不同类型的错误:

1. try:

2. print('try...')

3. r = 10 / int('2')

4. print('result:', r)

5. except ValueError as e:

6. print('ValueError:', e)

7. except ZeroDivisionError as e:

8. print('ZeroDivisionError:', e)

9. else:

10. print('no error!')

11. finally:

12. print('finally...')

13. print('END')

int()函数可能会抛出ValueError ,所以我们用一个except捕获ValueError,用另一个except捕获ZeroDivisionError。此外,如果没有错误发

生,可以在except语句块后面加一个else,当没有错误发生时,会自动执行else语句。

3、

Python的错误其实也是class,所有的错误类型都继承自     BaseException     ,所以在使用     except     时需要注意的是,它不但捕获该类

型的错误,还把其子类也“一网打尽”。其实捕获异常也是一个类：

他们最终都会去找到baseexception的那里，所以如果你不知道你将来可能是什么错误，那就用这个最大类的捕获你的错误

我们还用上面的例字：

1. try:

2. f = open('/tmp/passwd', 'r')

3. print(a)

4. f.close()

5. except BaseException as e:

6. print(e)

7. finally:

8. f.close()

9.  

10. print(f.closed)

 

同样可以捕获到你的错误，岂不美哉！

4、多层捕获

使用 try...except捕获错误还有一个巨大的好处,就是可以跨越多层调用,比如函数main() 调用 foo() ,foo()调用bar() ,结果bar()出错了,这

时,只要main()捕获到了,就可以处理:

1. def foo(s):

2. return 10 / int(s)

3.  

4. def bar(s):

5. return foo(s) * 2

6.  

7. def main():

8. try:

9. bar('0')

10. except Exception as e:

11. print('Error:', e)

12. finally:

13. print('finally...')

14.  

15. main()

也就是说,不需要在每个可能出错的地方去捕获错误,只要在合适的层次去捕获错误就可以了。这样一来,就大大减少了写    

 try...except...finally     的麻烦。

三、抛出异常

1、初识

因为错误是class,捕获一个错误就是捕获到该class的一个实例。因此,错误并不是凭空产生的,而是有意创建并抛出的。Python的内置函

数会抛出很多类型的错误,我们自己编写的函数也可以抛出错误。如果要抛出错误,首先根据需要,可以定义一个错误的class,选择好继

承关系,然后,用     raise     语句抛出一个错误的实例:

1. class AgeError(BaseException):

2. pass

3.  

4.  # 抛出异常

5. age = int(input("Age:"))

6. if 0<age<100:

7. print(age)

8. else:

9. raise AgeError("年龄不合法")

只有在必要的时候才定义我们自己的错误类型。如果可以选择Python已有的内置的错误类型(比如ValueError  , TypeError ),

尽量使用Python内置的错误类型。

2、另一种错误处理的方式:

 

1. def foo(s):

2. n = int(s)

3. if n==0:

4. raise ValueError('invalid value: %s' % s)

5. return 10/n

6. def bar():

7. try:

8. foo('0')

9. except ValueError as e:

10. print('ValueError!')

11. raise

12. bar()

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

其实这种错误处理方式不但没病,而且相当常见。捕获错误目的只是记录一下,便于后续追踪。但是,由于当前函数不知道应该怎么处理

该错误,所以,最恰当的方式是继续往上抛,让顶层调用者去处理。好比一个员工处理不了一个问题时,就把问题抛给他的老板,如果他的

老板也处理不了,就一直往上抛,最终会抛给CEO去处理。

raise     语句如果不带参数,就会把当前错误原样抛出。