[Python3学习笔记] 错误和异常

Python

0. 前言

• Python 有很多报错信息，用此篇笔记捋一捋
• 本章内容适用于以下情况：
  
  • 有一类错误是完全无法在程序运行过程中预测的，比如写入文件的时候，磁盘满了，写不进去了，或者从网络抓取数据，网络突然断掉了。这类错误也称为异常，在程序中通常是必须处理的，否则，程序会因为各种问题终止并退出。
  • 跟踪程序的执行，查看变量的值是否正确，这个过程称为调试。Python的pdb可以让我们以单步方式执行代码。
  • 编写测试也很重要。有了良好的测试，就可以在程序修改后反复运行，确保程序输出符合我们编写的测试。
• 参考：
  
  • Python3 菜鸟教程- 错误和异常
  • 廖雪峰的 Python 教程-错误、调试和测试

1. 语法错误和异常

语法错误

• 比如 if/while 语句后漏加“：”，会报SyntaxError: invalid syntax错误

异常

• 除了语法错误，运行期的错误被称为异常
• 大多数异常不会被程序处理，会以错误信息的形式展现在终端里，比如 ZeroDivisionError、NameError、TypeError等。

2. 异常处理

try/except

• 当我们认为某些代码可能会出错时，就可以用try来运行这段代码，如果执行出错，则后续代码不会继续执行，而是直接跳转至错误处理代码，即except语句块，执行完except后，如果有finally语句块，则执行finally语句块，至此，执行完毕。
• 使用try...except捕获错误还有一个巨大的好处，就是可以跨越多层调用，比如函数main()调用bar()，bar()调用foo()，结果foo()出错了，这时，只要main()捕获到了，就可以处理。也就是说，不需要在每个可能出错的地方去捕获错误，只要在合适的层次去捕获错误就可以了。这样一来，就大大减少了写try...except...finally的麻烦。
• 语法示例

import sys
try:
    # 先执行这段代码
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except (RuntimeError, TypeError, NameError):
    pass # 发生异常时执行的代码
except:
    # 打印错误信息，用 raise 把错误抛出
    print("Unexpected error:", sys.exc_info()[0])
    raise

try/except...else

• 可选的else子句放在except子句最后，在try子句没有发生异常的时候执行
• 使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到，而 except 又无法捕获的异常。
• 语法示例

for arg in sys.argv[1:]:
    try:
        # 先执行这里
        f = open(arg, 'r')
    except IOError:
        # try 有IOError异常，执行这里
        print('cannot open', arg)
    else:
        # try 没异常，执行这里
        print(arg, 'has', len(f.readlines()), 'lines')
        f.close()

try-finally

• try-finally中， finally 语句无论是否发生异常都将执行。
• 语法示例

try:
    runoob()
except AssertionError as error:
    print(error)
else:
    try:
        with open('file.log') as file:
            read_data = file.read()
    except FileNotFoundError as fnf_error:
        print(fnf_error)
finally:
    print('这句话，无论异常是否发生都会执行。')

3. 抛出异常

• Python 使用 raise 语句抛出一个指定的异常。
  
  • 语法
    
    • raise [Exception [, args [, traceback]]]
  • 示例

x = 10
if x > 5:
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))

• Python assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常。

4. 用户自定义异常(拓展学习)

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

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

5. 定义清理行为(拓展学习)

• try-finally: try 语句还有另外一个可选的子句，它定义了无论在任何情况下都会执行的清理行为。
• 如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 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'

6. 预定义的清理行为(拓展学习)

• 一些对象定义了标准的清理行为，无论系统是否成功的使用了它，一旦不需要它了，那么这个标准的清理行为就会执行。
• 这个例子展示了尝试打开一个文件，然后把内容打印到屏幕上:

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

• 以上这段代码的问题是，当执行完毕后，文件会保持打开状态，并没有被关闭。
• 关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法:

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

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

7. Debug

• print
  
  • 用print打印所有有可能错误的变量，简单粗暴，但是回头还需要逐一删除
• assert 断言
  
  • 凡是用print来辅助查看的地方，都可以用断言（assert）来替代; 事后运行的时候加上大写字母 -O 参数来关闭 assert。
  • 示例：

def foo(s):
    n = int(s)
    # assert的意思是，表达式n != 0应该是True，否则，根据程序运行的逻辑，后面的代码肯定会出错。
    assert n != 0, 'n is zero!'
    return 10 / n
def main():
    foo('0')
# 断言失败则会报错：
$ python err.py
Traceback (most recent call last):
  ...
AssertionError: n is zero!
# 用 -O 关闭，关闭后，可以把所有的assert语句当成pass来看。
$ python -O err.py
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero

• logging
  
  • 把print()替换为logging是第3种方式，和assert比，logging不会抛出错误，而且可以输出到文件;
  • logging 允许你指定记录信息的级别，有debug，info，warning，error等几个级别，当我们指定level=INFO时，logging.debug就不起作用了。同理，指定level=WARNING后，debug和info就不起作用了。这样一来，你可以放心地输出不同级别的信息，也不用删除，最后统一控制输出哪个级别的信息。另一个好处是通过简单的配置，一条语句可以同时输出到不同的地方，比如console和文件。

import logging
logging.basicConfig(level=logging.INFO)
s = '0'
n = int(s)
logging.info('n = %d' % n)
print(10 / n)

• pdb.set_trace() 断点调试
  
  • 需要import pdb，然后，在可能出错的地方放一个pdb.set_trace()，就可以设置一个断点;
  • 程序会自动在pdb.set_trace()暂停并进入pdb调试环境，可以用命令p查看变量，或者用命令c继续运行

# err.py
import pdb
s = '0'
n = int(s)
pdb.set_trace() # 运行到这里会自动暂停
print(10 / n)
# 调试
$ python err.py 
> /Users/michael/Github/learn-python3/samples/debug/err.py(7)<module>()
-> print(10 / n)
(Pdb) p n
0
(Pdb) c
Traceback (most recent call last):
  File "err.py", line 7, in <module>
    print(10 / n)
ZeroDivisionError: division by zero