python学习笔记（六）异常处理

左手的ㄟ右手 2023-07-02 03:28 68阅读 0赞

**目录**

（一）了解异常

0）Python异常的类型

1）引发异常

raise语句

assert语句

（二）处理异常

1）try/except

2）try/except...else

3）try-finally 语句

4）用户自定义异常

5）异常的继承架构

6）用到with关键字的上下文管理器

--------------------

异常，是一种语言特性，专门用于处理程序执行期间的不正常情况。任何程序都可能在运行时遭遇错误，异常的最常见用途就是处理程序执行期间出现的错误，但也可以有效用于很多其他目的。Python提供的异常已经很全了，用户还可以根据自己的目的定义新的“异常”。

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

# （一）了解异常 #

为了说明异常的概念，请考虑字处理程序会有把文件写入磁盘的情况，但有可能数据尚未写完就把磁盘空间耗尽了。解决这个问题的方法有很多。

处理磁盘空间问题的最简单方案，就是假定写入任何文件都会有充足的磁盘空间，根本不用去操心。遗憾的是，这几乎之最常用的方案 。对处理少量数据的小型程序而言，一般还说得过去。但对于运行关键任务的程序来说，这是完全不能接受的。

可以不做处理；比不做处理高明一步的错误处理方案，是意识到错误可能会发生，并利用语言提供的标准机制来定义一种检测和处理错误的方案。实现的方式有很多种，典型的方式是让每个函数或过程都返回状态值，标识出这次函数或过程调用是否执行成功。执行成功的结果值，可以通过引用类型的参数回传。

以上这种方式的程序中，绝大部分的错误检查代码显然都是重复的。代码对每次文件写入错误都要进行检查，并在检测到错误时将错误状态消息回传给发起调用的过程。磁盘空间错误仅在最外层的函数中进行处理。也就是说，大部分错误处理代码只是**“管道”**（plumb）代码，用于将引发错误的地方和处理错误的地方打通。

但是真正要做的事情其实是要去掉管道代码，把由系统内置的文件写入函数生成的错误直接传到错误处理函数，交由错误处理代码直接处理。因此，异常机制可以让代码更加清晰，错误处理得更加到位。

总体而言，Python对待错误处理的方式与Java等语言的常见方式不同。那些语言往往是在错误发生之前就尽可能地检查出来，因为在错误发生后再来做处理，往往要付出各种高昂地成本。而Python可能更依赖于“异常”，在错误发生之后再做处理。虽然这种依赖看起来可能会有风险，但如果“异常”能使用得当，代码会更加轻巧，可读性也更好，只有发生错误时才会进行处理。

产生异常的动作被称为**引发**（raise）或**抛出**（throw）异常。异常可以由其他函数引发，或者由自己的代码显式引发。

响应异常的动作被称为**捕获**（catch）异常，处理异常的代码则称为异常处理代码或异常处理程序。

## 0）Python异常的类型 ##

为了能够正确反映引发错误的实际原因，或者需要报告的异常情况，可以生成各种不同类型的异常对象。Python3.6提供的异常对象有很多类型：

BaseException                                       #所有异常的基类
        SystemExit                                      #解释器请求退出
        KeyboardInterrupt
        GeneratorExit
        Exception
            StopIteration
            ArithmeticError
                FloatingPointError
                OverflowError
                ZeroDivisionError
            AssertionError
            AttributeError
            BufferError
            EOFError
            ImportError
                ModuleNotFoundError
                LookupError
                    IndexError
                    KeyError
                MemoryError
                NameError
                    UnboundLocalError
                OSError
                    BlockingIOError
                    ChildProcessError
                    ConnectionError
                        BrokenPipeError
                        ConnectionAbortedError
                        ConnectionRefusedError
                        ConnectionResetError
                    FileExistsError
                    FileNotFoundError
                    InterruptedError
                    IsADirectoryError
                    NotADirectoryError
                    PermissionError
                    ProcessLookupError
                    TimeoutError
                ReferenceError
                RuntimeError
                    NotImplementedError
                    RecursionError
                SystemError
                TypeError
                ValueError
                    UnicodeError
                        UnicodeDecodeError
                        UnicodeEncodeError
                        UnicodeTranslateError
                Warning
                    DeprecationWarning
                    PendingDeprecationWarning
                    RuntimeWarning
                    SyntaxWarning
                    UserWarning
                    FutureWarning
                    ImportWarning
                    UnicodeWarning
                    BytesWarning
                    ResourceWarning

Python的异常第项是按层级构建的，上述异常列表中的缩进关系正说明了这一点。每种异常都是一种Python类，继承自父异常类。

例如，IndexError也是LookupErroor类和Exception（通过继承），且还是BaseException。

这种层次结构是有意为之的，大部分异常都继承自Exception。

## 1）引发异常 ##

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

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

>>>10 * (1/0)             # 0 不能作为除数，触发异常
    Traceback (most recent call last):
      File "<stdin>", line 1, in ?
    ZeroDivisionError: division by zero
    >>> 4 + spam*3             # spam 未定义，触发异常
    Traceback (most recent call last):
      File "<stdin>", line 1, in ?
    NameError: name 'spam' is not defined
    >>> '2' + 2               # int 不能与 str 相加，触发异常
    Traceback (most recent call last):
      File "<stdin>", line 1, in ?
    TypeError: Can't convert 'int' object to str implicitly

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

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

Python 使用 raise 语句抛出一个指定的异常，assert语句是raise语句的特殊形式。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc1NTk2Ng_size_16_color_FFFFFF_t_70][]

### raise语句 ###

raise语法格式如下：

raise [Exception [, args [, traceback]]]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc1NTk2Ng_size_16_color_FFFFFF_t_70 1][]

以下实例如果 x 大于 5 就触发异常:

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

执行以上代码会触发异常：

Traceback (most recent call last):
      File "test.py", line 3, in <module>
        raise Exception('x 不能大于 5。x 的值为: {}'.format(x))
    Exception: x 不能大于 5。x 的值为: 10

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

### assert语句 ###

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

示例：

def test(ex1, ex2):
        assert (ex1 and ex2), "test false"
        return True
    
    if test(True, False):
        print("is true")
    else:
        print("is false")

以上代码将会有以下输出：

>>> 
    ======================= RESTART: D:/python37/assert.py =======================
    Traceback (most recent call last):
      File "D:/python37/assert.py", line 5, in <module>
        if test(True, False):
      File "D:/python37/assert.py", line 2, in test
        assert (ex1 and ex2), "test false"
    AssertionError: test false

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

# （二）处理异常 #

## 1）try/except ##

异常捕捉可以使用 try/except 语句。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc1NTk2Ng_size_16_color_FFFFFF_t_70 2][]

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

while True:
        try:
            x = int(input("请输入一个数字: "))
            break
        except ValueError:
            print("您输入的不是数字，请再次尝试输入！")

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

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

其中except OSError as err:语句中，如果发生了OSError异常，就会创建err变量并且将OSError返回值赋给err变量。

还可以：

def func(num):
        if num < 1:
            raise Exception("Invalid level!", num)
    
    
    try:
        func(0)
    except Exception as err:
        print("No: %s"%(err))
    
    print()
    print()
        
    def div(dividend, divisor):
        try:
            quotient = dividend/divisor
            return quotient
        except ZeroDivisionError as err:
            print("除数不能为零啊，哥！",err)
    
    print("div(4,2) => {}" .format(div(4,2)))
    print("div(4,0) => {}" .format(div(4,0)))

输出：

No: ('Invalid level!', 0)
    
    
    div(4,2) => 2.0
    除数不能为零啊，哥！ division by zero
    div(4,0) => None

## 2）try/except...else ##

try/except 语句还有一个可选的 **else** 子句，如果使用这个子句，那么必须放在所有的 except 子句之后。

else 子句将在 try 子句没有发生任何异常的时候执行。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc1NTk2Ng_size_16_color_FFFFFF_t_70 3][]

以下实例在 try 语句中判断文件是否可以打开，如果打开文件时正常的没有发生异常则执行 else 部分的语句，读取文件内容：

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

## 3）try-finally 语句 ##

try-finally 语句无论是否发生异常都将执行最后的代码。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc1NTk2Ng_size_16_color_FFFFFF_t_70 4][]

以下实例中 finally 语句无论异常是否发生都会执行：

def f1():
        try:
            print(1)
            return 2
        except:
            print(0)
        finally:
            print("这句话，无论异常是否发生都会执行。")
            #return 4
    
    print(f1())
    
    print("-"*24)
    
    def f2():
        try:
            print(1)
            #return 2
        except:
            print(0)
            return(0)
        else:
            print(3)
            return 4
        finally:
            print(5)
            return 6
    
    print(f2())

输出结果：

1
    这句话，无论异常是否发生都会执行。
    2
    ------------------------
    1
    3
    5
    6

## 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

## 5）异常的继承架构 ##

看以下代码：

try:
        body
    except LookupError as err:
        exception code
    except IndexError as err:
        exception code

这里将会捕获LookupError和IndexError这两种异常。正巧IndexError是LookupError的子类。如果body抛出IndexError，那么错误会首先被“except LookupError as err:”这行检测到。因为IndexError继承自LookupError，因此第一条except子句会成功执行，第二局except子句永远不会用到，因为它的运行条件被第一条except子句包含在内了。

相反，将两条except子句的顺序互换一下，可能就有意义了。这样第一条子句将处理IndexError之外的LookupError。

## 6）用到with关键字的上下文管理器 ##

有些操作场景遵循一种可预期的模式，有始必有终，如文件的读取操作。读取文件时，通常只需要打开一次文件，读取数据后关闭文件。按照异常的编程结构，可以将这种文件访问代码编写如下：

try:
        infile = open(filename)
        data = infile.read()
    finally:
        infile.close()

Python3为这种场景提供了一种更加通用的解决方案，即上下文管理器（context manager）。上下文管理器将代码包裹起来，对进入（entry）和离开（departure）代码块时的操作进行集中管理，用with关键字进行标记。文件对象就是一种上下文管理器，可以利用这种能力读取文件：

with open(filename) as infile:
        data = infile.read()

上下文管理器非常适用于资源加/解锁、关闭文件、提交数据库事务之类的操作。更多信息可以查看标准库中contextlib模块的文档，包括如何创建上下文管理器，以及对它的各种操控方式。

**参考：**

1.  [菜鸟教程][Link 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc1NTk2Ng_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200203184317448.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc1NTk2Ng==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc1NTk2Ng_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200203194353108.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc1NTk2Ng==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc1NTk2Ng_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200203193441730.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc1NTk2Ng==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc1NTk2Ng_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200203193918276.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc1NTk2Ng==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc1NTk2Ng_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200203194218890.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc1NTk2Ng==,size_16,color_FFFFFF,t_70
[Link 1]: https://www.runoob.com/python3/python3-errors-execptions.html