Python语法基础之. Task08 异常处理（11/17）

Ivan-Zhang

于 2019-10-29 21:54:01 发布

阅读量132

点赞数

分类专栏： Python 文章标签： Python基础

本文链接：https://blog.csdn.net/weixin_41728431/article/details/102807863

版权

Python 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

Python基础—— Task08 异常处理

写在前面
- 前言
1. 异常处理
2. 抛出错误
3. 用户自定义异常
- 3.1 class+raise 自定义
- 3.2 bar()+raise 自定义
4. 记录错误
5. 其他

写在前面

前言

Python 有两种错误很容易辨认：

语法错误
异常

语法错误：一般会返回SyntaxError: invalid syntax,且编译器一般都会给出提示（位置，出错类型，修改意见）

异常：即便Python程序的语法是正确的，在运行它的时候，也有可能发生错误——运行期检测到的错误被称为异常。大多数的异常都不会被程序处理，都以错误信息的形式展现

一般来说，在程序运行的过程中，如果发生了错误，可以事先约定返回一个错误代码————这样就可以知道是否有错，以及出错的原因。

在操作系统提供的调用中，返回错误码非常常见。比如打开文件的函数open()，成功时返回文件描述符（就是一个整数），出错时返回-1。

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

def foo():
    r = some_function()
    if r==(-1):
        return (-1)
    # do something
    return r

def bar():
    r = foo()
    if r==(-1):
        print('Error')
    else:
        pass

一旦出错，还要一级一级上报，直到某个函数可以处理该错误（比如，给用户输出一个错误信息）

所以我们需要规范的异常/错误处理机制

1. 异常处理

异常处理主要使用try...except...(finally...)进行判断

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

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

举例1：

try:
    print('try...')
    r = 10 / 0
    print('result:', r)
except ZeroDivisionError as e:
    print('except:', e)
finally:
    print('finally...')
print('END')

上面的代码在计算10 / 0时会产生一个除法运算错误：

try...
except: division by zero
finally...
END

从输出可以看到，当错误发生时，后续语句print('result:', r)不会被执行，except由于捕获到ZeroDivisionError，因此被执行。最后，finally语句被执行。然后，程序继续按照流程往下走。

相对的，如果把除数0改成2，则执行结果如下：

try...
result: 5
finally...
END

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

举例2：
多个except来捕获不同类型的错误：
错误应该有很多种类，如果发生了不同类型的错误，应该由不同的except语句块处理：

try:
    print('try...')
    r = 10 / int('a')
    print('result:', r)
except ValueError as e:
    print('ValueError:', e)
except ZeroDivisionError as e:
    print('ZeroDivisionError:', e)
finally:
    print('finally...')
print('END')

其中：int()函数可能会抛出ValueError，所以用一个except捕获ValueError，用另一个except捕获ZeroDivisionError

此外，如果没有错误发生，可以在except语句块后面加一个else，当没有错误发生时，会自动执行else语句：

try:
    print('try...')
    r = 10 / int('2')
    print('result:', r)
except ValueError as e:
    print('ValueError:', e)
except ZeroDivisionError as e:
    print('ZeroDivisionError:', e)
else:
    print('no error!')
finally:
    print('finally...')
print('END')

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

举例3：没有finally语句的形式

try:
    foo()
except ValueError as e:
    print('ValueError')
except UnicodeError as e:
    print('UnicodeError')

第二个except永远也捕获不到UnicodeError，因为UnicodeError是ValueError的子类，如果有，也被第一个except给捕获了。

try...except...finally和try...except的对比

使用try...except捕获错误还有一个巨大的好处，就是可以跨越多层调用

比如函数main()调用foo()，foo()调用bar()，结果bar()出错了，这时，只要main()捕获到了，就可以处理：

def foo(s):
    return 10 / int(s)

def bar(s):
    return foo(s) * 2

def main():
    try:
        bar('0')
    except Exception as e:
        print('Error:', e)
    finally:
        print('finally...')

不需要在每个可能出错的地方去捕获错误，只要在合适的层次去捕获错误就可以了。这样一来，就大大减少了写try...except...finally的麻烦。

异常处理小结

try语句工作方式：

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

一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。
处理程序将只针对对应的try子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。
一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组，例如:

except (RuntimeError, TypeError, NameError):        pass

最后一个except子句可以忽略异常的名称，它将被当作通配符使用——可以使用这种方法打印一个错误信息，然后再次把异常抛出。
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又没有捕获的异常。
1. 异常处理并不仅仅处理那些直接发生在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所有的错误都是从BaseException类派生的，常见的错误类型和继承关系看这里

2. 抛出错误

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

3. 用户自定义异常

3.1 class+raise 自定义

注意：只有在必要的时候才定义我们自己的错误类型！

如果可以选择Python已有的内置的错误类型（比如ValueError，TypeError），尽量使用Python内置的错误类型。

可以通过创建一个新的异常类来拥有自己的异常。异常类继承自 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() 被覆盖。

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

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

上面这个例子比较复杂，下面是一个更直观的例子:

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

# err_raise.py
class FooError(ValueError):
    pass

def foo(s):
    n = int(s)
    if n==0:
        raise FooError('invalid value: %s' % s)
    return 10 / n

foo('0')

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

$ python3 err_raise.py 
Traceback (most recent call last):
  File "err_throw.py", line 11, in <module>
    foo('0')
  File "err_throw.py", line 8, in foo
    raise FooError('invalid value: %s' % s)
__main__.FooError: invalid value: 0

3.2 bar()+raise 自定义

先看例子：

# err_reraise.py

def foo(s):
    n = int(s)
    if n==0:
        raise ValueError('invalid value: %s' % s)
    return 10 / n

def bar():
    try:
        foo('0')
    except ValueError as e:
        print('ValueError!')
        raise

bar()

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

其实这种错误处理方式没有错且相当常见

捕获错误目的只是记录一下，便于后续追踪。但是，由于当前函数不知道应该怎么处理该错误。所以，最恰当的方式是继续往上抛，让顶层调用者去处理

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

try:
    10 / 0
except ZeroDivisionError:
    raise ValueError('input error!')

只要是合理的转换逻辑就可以，

要注意的是：决不应该把一个IOError转换成毫不相干的ValueError

4. 记录错误

我们可以使用python内置的logging模块记录错误信息

# err_logging.py

import logging

def foo(s):
    return 10 / int(s)

def bar(s):
    return foo(s) * 2

def main():
    try:
        bar('0')
    except Exception as e:
        logging.exception(e)

main()
print('END')

同样是出错，但程序打印完错误信息后会继续执行，并正常退出：

$ python3 err_logging.py
ERROR:root:division by zero
Traceback (most recent call last):
  File "err_logging.py", line 13, in main
    bar('0')
  File "err_logging.py", line 9, in bar
    return foo(s) * 2
  File "err_logging.py", line 6, in foo
    return 10 / int(s)
ZeroDivisionError: division by zero
END

小结：logging可以将调用栈的一些错误信息打印出来，并且不会退出程序，会继续执行，正常退出。错误记录到日志文件里，方便事后排查。

5. 其他

调用栈分析错误，就先不展开了；

try语句的另一个可选子句，它的功能是：清理行为

以及，与异常处理密切相关的测试，也没有写到。（参考：廖雪峰——Python测试）

Ivan-Zhang

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python语法基础之. Task08 异常处理（11/17）

Python基础—— Task08 异常处理写在前面前言1. 异常处理2. 抛出错误3. 用户自定义异常3.1 class+raise 自定义3.2 bar()+raise 自定义4. 记录错误5. 其他写在前面前言Python 有两种错误很容易辨认：语法错误异常语法错误：一般会返回SyntaxError: invalid syntax,且编译器一般都会给出提示（位置，出错类型，...
复制链接

扫一扫