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

男娘i 2023-06-11 08:22 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`的麻烦。

**异常处理小结**

1.  try语句工作方式：

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

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

except (RuntimeError, TypeError, NameError):        pass

1.  最后一个except子句可以忽略异常的名称，它将被当作通配符使用——可以使用这种方法打印一个错误信息，然后再次把异常抛出。
2.  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`类派生的，常见的错误类型和继承关系看[这里][Link 1]

# 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`语句的另一个可选子句，它的功能是：[清理行为][Link 2]

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

[Link 1]: https://docs.python.org/3/library/exceptions.html#exception-hierarchy
[Link 2]: https://www.runoob.com/python3/python3-errors-execptions.html
[Python]: https://www.liaoxuefeng.com/wiki/1016959663602400/1017602696742912