1. 前言

python的异常分为两种.
(1) 内建异常，就是python自己定义的异常。
(2) 不够用，用户自定义异常，
首先看看python的异常继承树

我们可以看到python的异常有个大基类。然后继承的是Exception。所以我们自定义类也必须继承Exception。

程序出现错误，会自动引发异常，Python也允许使用raise语句自行引发异常。

2. 语法

• try/except 语句还有一个可选的 else 子句，如果使用这个子句，那么必须放在所有的 except 子句之后。else 子句将在 try 子句没有发生任何异常的时候执行。
• finally 语句无论是否发生异常都将执行最后的代码。
  
  案例：

try:
    my_func()
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('这句话，无论异常是否发生都会执行。')

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

2. 使用raise引发异常

单独一个raise引发异常，默认引发RuntimeError异常，例：

try:
    print ('正在运行try块...')
    raise
    print ('不再运行...')
except Exception as e:
    print ('正在运行except块...')
 
# 运行结果
正在运行try块...
正在运行except块...

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

raise后带一个异常类，引发指定异常类的默认实例，例：

def test():
    try:
        print ('正在运行try块...')
        raise SyntaxError('引发指定异常...')
        print ('不再运行...')
    except TypeError as e:
        print ('对类型无效的操作...',e)
    except ValueError as e:
        print ('传入无效的参数...',e)
    except SyntaxError as e:
        print ('语法错误...',e)
 
test()
 
# 运行结果
正在运行try块...
语法错误... 引发指定异常...

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

3. 自定义异常

• 你可以通过创建一个新的异常类来拥有自己的异常。异常类继承自 Exception 类，可以直接继承，或者间接继承。
• 大多数的异常的名字都以”Error”结尾，就跟标准的异常命名一样。

3.1 最简单的自定义异常

class FError(Exception):
    pass

• 1
• 2

3.2 抛出异常、用try-except抛出

try:
    raise FError("自定义异常")
except FError as e:
    print(e)

自定义异常    

• 1
• 2
• 3
• 4
• 5
• 6

3.3 一个简单的自定义异常类模版。

class CustomError(Exception):
    def __init__(self,ErrorInfo):
        super().__init__(self)  # 初始化父类
        self.errorinfo=ErrorInfo
    def __str__(self):
        return self.errorinfo

if __name__ == '__main__':
    try:
        raise CustomError('客户异常')
    except CustomError as e:
        print(e)

客户异常

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

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

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

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30

4. 常见的异常总结