六、异常处理

Python的异常机制主要依赖try、except、else、finally、raise五个关键字，其中在try关键字后缩进的代码块简称try块，里面放置的是可能引发异常的代码；在except后对应的是异常类型和一个代码块，用于表明该except块处理的这种类型的代码块；在多个except后可以放一个else块，表明程序不出现异常时需要在执行else部分；最后添加finally块，总被执行；raise用于引发一个实际的异常，raise可以单独作为语句使用，引发一个具体的异常对象。

1、异常概述

错误处理机制两大缺点：

1. 无法穷举所有的异常情况；
2. 错误处理代码和业务实现代码混杂；

2、异常处理机制

2.1、使用try…except捕获

try:
	# 业务实现代码
except (Error1, Error2, ... ): as e:
	alert 输入不合法
	goto retry	

• 1
• 2
• 3
• 4
• 5

如果在执行try块里的业务逻辑代码时出现异常，系统自动生成一个异常对象，该异常对象被提交给Python解释器，过程被称之为引发异常。
当Python解释器收到异常对象时，会寻找能处理该异常对象的except块，如果找到合适的except块，则把该异常对象交给该except块处理，过程被称之为捕获异常。
如果无法捕获异常，则运行时环境终止，Python解释器退出。

InputInt = input("请输入整型数据：\n")
try:
    if int(InputInt) >= 18:
        print('成年！')
    else:
        print("未成年！")
except:
    print('输入数据类型有误，请重新输入')

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

2.2、异常类的继承体系

当Python解释器接收到异常对象后，会依次判断该异常对象是否是except块后的异常类或其子类的实例，如果是，Python解释器将调用该except块来处理该异常；否则，再次拿该异常对象和下一个except块里的异常类进行比较。
Python捕获异常的流程图：

try:
	statement1
	statement1    # 出现异常生成异常对象ex
	...
except Exception1:instance(ex, Exception1)
	exception handler statement1	
	...
except Exception2:instance(ex, Exception2)
	exception handler statement1	
	...

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

import sys
try:
    a = int(sys.argv[1])
    b = int(sys.argv[2])
    c = a / b
    print('两数相除的结果是：{0}'.format(c))
except IndexError:
    print("索引错误，运行程序时输入的参数个数不够")
except ValueError:
    print("数值错误，程序运行只能接受整数")
except ArithmeticError:
    print("算数错误")
except Exception:
    print("未知错误")

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

IndexError：输入的参数不够，将会发生索引错误；
ValueError：输入的参数不是数字，而是字母等，将会发生数值错误；
ArithmeticError：除0异常，将会发生算数错误；
Exception：其他异常；

2.3、多异常捕获

Python的一个except块可以捕获多种类型的异常。
在使用一个except块捕获多种类型的异常时，只要将多个异常类用圆括号括起来，中间用逗号隔开即可（构建多个异常类的元组）。

import sys
try:
    a = int(sys.argv[1])
    b = int(sys.argv[2])
    c = a / b
    print('两数相除的结果是：{0}'.format(c))
except (IndexError, ValueError, ArithmeticError):
    print("索引错误/数值错误/算法错误")
except Exception:
    print("未知错误")

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

2.4、访问异常信息

在except块中访问异常对象的相关信息，通过为异常对象声明变量来实现。

1. args：该属性返回异常的错误编号和描述字符串；
2. errno：返回异常的错误编号；
3. strerror：返回异常的描述字符串；
4. with_traceback()：通过该方法可处理异常的传播轨迹信息；

def foo():
    try:
        fis = open("a.txt")
    except Exception as e:
        print(e.args)
foo()       # (2, 'No such file or directory')

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

2.5、else块

当try没有出现异常时，程序会执行else块

s = input("请输入除数：\n")
try:
    result = 20 / int(s)
    print(result)
except ValueError:
    print("输入数值错误")
else:
    print('无异常')

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

2.6、使用finally回收资源

finally总会被执行，切必须放在所有except块之后。

s = '12'
try:
    result = 20 / int(s)
    print(result)
except ValueError:
    print("输入数值错误")
else:
    print('无异常')
finally:
    print('结束')

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

2.7、异常处理嵌套

在finally块中包含了一个完整的异常处理流程

import os
def test():
    fis = None
    try:
        fis = open("a.txt")
    except OSError as e:
        print(e.strerror)
        return
    finally:
        if fis is not None:
            try:
                fis.close()
            except OSError as ioe:
                print(ioe.strerror)
            print("资源回收")
test()      # No such file or directory

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

3、使用raise引发异常

当程序出现错误时，系统会自动引发异常。之外Python可以使用raise自行引发异常。

3.1、引发异常

系统需要引发异常，可能需要根据应用业务需求来决定，如果程序中的数据、执行与既定的业务需求不符，则为一种异常。由于与业务需求不符的异常，需要自行引发异常。
自行引发异常：raise语句

1. raise：单独一个raise。该语句引发当前上下文中捕获异常（比如在except块中）或者默认引发RunnerTime异常。
2. raise异常类：raise后带一个异常类。该语句引发指定类的默认实例；
3. raise异常对象：引发指定的异常对象；

上面三种方法最终都是要引发一个异常实例，且每次只能引发一个异常实例。

3.2、自定义异常类

class AuctionExpection(Exception):
    pass

• 1
• 2

3.3、except和raise同时使用

在异常出现的当前方法中，程序只对异常部分进行处理，还有些处理需要在该方法的调用者中才能完成。应再次引发异常，让该方法的调用者也能够捕获异常。

class AuctionExpection(Exception):
    pass
class AutionTest:
    def __init__(self, init_price):
        self.init_price = init_price
    def bid(self, bid_price):
        d = 0.0
        try:
            d = float(bid_price)
        except Exception as e:
            print(e)
            raise AuctionExpection("AAA")
        if self.init_price > d:
            raise AuctionExpection("BBB")
        initPrice = d
def main():
    at = AutionTest(20.4)
    try:
        at.bid("df")
    except AuctionExpection as ae:
        print(ae)
main()

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22

3.4、raise不需要参数

在使用raise语句时不带参数，此事raise处于except块中，将自动引发当前上下文激活的异常。

4、Python的异常传播轨迹

异常对象提供了一个with_traceback用于处理异常的传播轨迹，查看异常的传播轨迹可跟踪异常触发的源头，也可看到异常一路触发的轨迹。

class SelfException(Exception):
    pass
def main():
    firstMethod()
def firstMethod():
    secondMethod()
def secondMethod():
    thirdMethod()
def thirdMethod():
    raise SelfException("自定义异常信息")
main()

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

Traceback (most recent call last):
  File "G:\AAA\111.py", line 123, in <module>
    main()
  File "G:\AAA\111.py", line 116, in main
    firstMethod()
  File "G:\AAA\111.py", line 118, in firstMethod
    secondMethod()
  File "G:\AAA\111.py", line 120, in secondMethod
    thirdMethod()
  File "G:\AAA\111.py", line 122, in thirdMethod
    raise SelfException("自定义异常信息")
__main__.SelfException: 自定义异常信息

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

异常从发生异常的函数或方法逐渐向外传播，首先传给该函数或方法的调用者，该函数或方法的调用者再传递给其他调用者…直至传递到Python解释器，此时Python解释器会中止该程序，并打印异常的传播轨迹信息。
Python提供了traceback模块来处理异常传播轨迹，使用traceback可以方便地处理Python的异常传播轨迹、导入traceback模块后，traceback提供了如下两个方法：

1. traceback.print_exc()：将异常传播轨迹输出到控制台或指定文件中；
2. format_exc()：将异常传播信息转换成字符串；
3. etype：指定异常类型；
4. value：指定异常值；
5. tb：指定异常的traceback信息；
6. limit：用于限制显示异常传播的层数；
7. file：指定将异常传播轨迹信息输出到指定文件中；

import traceback
class SelfException(Exception):
    pass
def main():
    firstMethod()
def firstMethod():
    secondMethod()
def secondMethod():
    thirdMethod()
def thirdMethod():
    raise SelfException("自定义异常信息")
try:
    main()
except:
    traceback.print_exc()
    traceback.print_exc(file=open('log.txt', 'a', encoding='utf-8'))

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

5、异常处理规则

议程处理目标点：

1. 使程序代码混乱最小化；
2. 捕获并保留诊断信息；
3. 通知合适的人员；
4. 采用合适的方式结束异常活动；

5.1、不要过度使用异常

过度使用异常主要表现在两个方面：

1. 把异常和普通错误混在一起，不再编写错误处理代码，简单地引发异常来代替所有的错误处理
2. 使用异常处理来代替流程控制

5.2、不要使用过于庞大的try块

5.3、不要忽略捕获到的异常

1. 处理异常
2. 重新引发异常
3. 在合适的层处理异常

七、Python类的特殊方法

在Python类中有些方法名、属性名的前后都添加了双下划线，这种方法、属性通常都属于Python的特殊方法和特殊属性。

1、常见的特殊方法（需要进一步研究学习）

1.1、重写__repr__方法

当程序需要将任何对象与字符串进行连接时，都可先调用__repr__()方法将对象转换成字符串，然后将两个字符串连接在一起。

im_str = im.__repr__() +  " "

• 1

class Item:
    def __init__(self, name, price):
        self.name = name
        self.price = price
Im = Item('手机', 5890)
print(Im)               # <__main__.Item object at 0x0000019A265CCFD0>
print(Im.__repr__())    # <__main__.Item object at 0x0000019A265CCFD0>

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

repr()是一个非常特殊的方法，是一个“自我描述”的方法，实现功能：直接打印该对象时，系统将会输出该对象的“自我描述”信息，用来告诉外界该对象的状态信息。返回值：“类名+object at + 内存地址”

类名[field1=值1, field2=值2, ... ]

• 1

class Item:
    def __init__(self, name, price):
        self.name = name
        self.price = price
    def __repr__(self):
        return "Item[name=" + self.name + ", price = " + str(self.price) + "]"
Im = Item('手机', 5890)
print(Im)       # Item[name=手机, price = 5890]

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

1.2、析构方法：del

init()方法用于初始化Python对象，而__del__()则用于销毁Python对象—-任何Python对象将要被系统回收之时，系统都会自动调用该对象的__del__()方法。
只有当对象的引用计数变成0时，该对象才会被回收。如果一个对象有多个变量引用，那么del其中一个变量是不会回收该对象的。

class Item:
    def __init__(self, name, price):
        self.name = name
        self.price = price
    # 定义析构函数
    def __del__(self):
        print("del删除对象")
Im = Item('手机', 5890)
# X = Im
del Im
print('------')

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

1.3、__dir__方法

对象的__dir__()方法用于列出该对象内部的所有属性（包括方法）名，该方法将会返回包含所有属性（方法）名的序列。

class Item:
    def __init__(self, name, price):
        self.name = name
        self.price = price
    def info(self):
        pass
Im = Item('手机', 5890)
print(Im.__dir__())
print(dir(Im))

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

[‘name’, ‘price’, ‘module’, ‘init’, ‘info’, ‘dict’, ‘weakref’, ‘doc’, ‘repr’, ‘hash’, ‘str’, ‘getattribute’, ‘setattr’, ‘delattr’, ‘lt’, ‘le’, ‘eq’, ‘ne’, ‘gt’, ‘ge’, ‘new’, ‘reduce_ex’, ‘reduce’, ‘subclasshook’, ‘init_subclass’, ‘format’, ‘sizeof’, ‘dir’, ‘class’]

[‘class’, ‘delattr’, ‘dict’, ‘dir’, ‘doc’, ‘eq’, ‘format’, ‘ge’, ‘getattribute’, ‘gt’, ‘hash’, ‘init’, ‘init_subclass’, ‘le’, ‘lt’, ‘module’, ‘ne’, ‘new’, ‘reduce’, ‘reduce_ex’, ‘repr’, ‘setattr’, ‘sizeof’, ‘str’, ‘subclasshook’, ‘weakref’, ‘info’, ‘name’, ‘price’]

1.4、__dict__属性

__dict__属性用于查看对象内部存储的所有属性名和属性值组成的字典，通常程序直接使用该属性。

class Item:
    def __init__(self, name, price):
        self.name = name
        self.price = price
    def info(self):
        pass
Im = Item('手机', 5890)
print(Im.__dict__)          # {'name': '手机', 'price': 5890}
print(Im.__dict__['name'])  # 手机

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

1.5、getattr/__setattr__等

当程序操作（包括访问、设置、删除）对象的属性时：

1. getattribute(self, name)：当程序访问对象的name属性时被自动调用
2. getattr(self, name)：当程序访问对象的name属性且该属性不存在时被自动调用
3. setattr(self, name)：当程序对对象的name属性赋值时被自动调用
4. delattr(self, name)：当程序删除对象的name属性时被自动调用

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height
    def __setattr__(self, name, value):
        print("----设置%s属性----" % name)
        if name == 'size':
            self.width, self.height = value
        else:
            self.__dict__[name] = value

    def __getattr__(self, name):
        print("----读取%s属性----" % name)
        if name == 'size':
            return self.width, self.height
        else:
            raise AttributeError
    def __delattr__(self, name):
        print("----删除%s属性----" % name)
        if name == 'size':
            self.__dict__['width'] = 0
            self.__dict__['height'] = 0

rect = Rectangle(3, 4)
print(rect.size)
rect.size = 6, 8
print(rect.width)
del rect.size
print(rect.size)

• 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

----设置width属性----
----设置height属性----
----读取size属性----
(3, 4)
----设置size属性----
----设置width属性----
----设置height属性----
6
----删除size属性----
----读取size属性----
(0, 0)

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

2、与反射相关的属性和方法

程序在运行过程中要动态判断是否包含某个属性（包括方法），设置要动态设置某个属性值，则可以通过Python的反射支持来实现。

2.1、动态操作属性

1. hasattr(obj, name)：检查obj对象是否包含名为name的属性或方法
2. getsttr(object, name[, default])：获取object对象中名为name的属性的属性值
3. setattr(obj, name, value, /)：将obj对象的name属性设置为value

class Comment:
    def __init__(self, detail, view_times):
        self.detail = detail
        self.view_times = view_times
    def info(self):
        print("一条简单的评论，内容是：%s" % self.detail)

c = Comment("疯狂Python讲义", 20)
# 判断是否包含指定的属性/方法
print(hasattr(c, 'detail'))         # True
print(hasattr(c, 'view_times'))     # True
print(hasattr(c, 'info'))           # True
# 获取指定的属性值
print(getattr(c, 'detail'))         # 疯狂Python讲义
# 为指定属性设置默认值
setattr(c, 'detail', 'AAA')
print(getattr(c, 'detail'))         # AAA
# 设置不存在的属性值，即为对象添加属性
setattr(c, 'new_attr', 'BBB')
print(getattr(c, 'new_attr'))       # BBB

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

hasattr()函数可以判断属性/方法、getattr()函数则只能获取属性值。设置不存在的属性值，即为对象添加属性。

2.2、__call__属性

使用__hasattr__()函数可判断指定属性（或方法）是否存在，但到底是属性还是方法，则需要进一步判断是否可调用。程序可通过判断该属性（方法）是否包含__call__属性来判断是否可调用。

class User:
    def __init__(self, name, password):
        self.name = name
        self.password = password
    def validLogin(self):
        print("验证%s的登录" % self.name)
user = User('AlySam', '123456')
print(hasattr(user.name, '__call__'))       # False
print(hasattr(user.validLogin, '__call__')) # True

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

3、与序列相关的特殊方法

3.1、序列相关方法

1. len(self)：返回值决定序列中元素的个数
2. getitem(self, key)：获取指定索引对应的元素，该方法的key应该是整数值或slice对象，否则会引发KeyValue异常
3. contains(self, item)：判断序列是否包含指定元素
4. setitem(self, key, value)：设置指定索引对应的元素
5. delitem(self, key)：删除指定索引对应的元素

3.2、实现迭代器

实现迭代器，实现如下两个方法：
iter(self)：该方法返回一个迭代器（iterator），迭代器必须包含一个__next__()方法，该方法返回迭代器的下一个元素
reversed(self)：该方法主要为内建的reversed()反转函数提供支持
举例：斐波那契数列

class Fibs:
    def __init__(self, len):
        self.first = 0
        self.second = 1
        self.__len = len
    # 定义迭代器所需的__next__方法
    def __next__(self):
        # 如果__len__属性为0，结束迭代
        if self.__len == 0:
            raise StopIteration
        # 数列计算
        self.first, self.second = self.second, self.first + self.second
        # 数列长度减一
        self.__len -= 1
        return self.first
    def __iter__(self):
        return self
fibs = Fibs(10)
# 获取迭代器的下一个元素
# print(next(fibs))
for el in fibs:
    print(el, end=' ')
# 1 1 2 3 5 8 13 21 34 55 

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23

4、生成器（后续学习）

八、模块和包

1、模块化编程

1.1、导入模块的语法

1. import 模块名1[as 别名1], 模块名2[as 别名2],…整个模块
2. from 模块名 import 成员名1[as 别名1], 成员名1[as 别名1], … 导入模块中指定成员

# 导入整个sys模块
import sys
# 导入整个sys模块并指定别名为s
import sys as s
# 一次导入多个模块，多个模块使用逗号隔开
import sys, os
# 导入多个模块并设置别名
import sys as s, os as o
# 导入sys模块中的argv成员
from sys import argv
# 使用导入成员的语法，直接使用成员名进行访问
print(argv[0])
# 导入sys模块中的argv成员，并指定别名
from sys import argv as v
# 使用导入成员的语法，直接使用成员的别名进行访问
# 导入多个成员
from sys import argv, winver
# 同时导入多个模块成员并指定其别名
from sys import argv as v, winver as w
# 一次导入指定模块内的所有成员
from sys impor *

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

1.2、定义模块

模块就是Python程序，模块文件的文件名就是它的模块名

1.3、为模块编写说明文档

在模块开始处定义一个字符串直接量

"""
这是某个模块：实现xxx功能
User：代表用户的类
info（）：信息函数
"""

• 1
• 2
• 3
• 4
• 5

2、加载模块

1. 使用环境变量
2. 将模块放在默认的模块加载路径下

2.1、使用环境变量

Python会根据PYTHONPATH环境变量的值来确定到哪里去加载模块。PYTHONPATH环境变量的值是多个路径的集合。
1、windows环境
2、Linux环境
3、Mac OS X环境

2.2、默认的模块加载路径

2.3、导入模块的本质

2.4、模块的__all__变量

有时候模块中虽然包含很多成员，但并不希望每个成员都被暴露出来供外界使用，此时可借助于模块的__all__变量，将变量的值设置为一个列表，只有该列表中的程序单元才会被显示出来。

def hello():
    print("hello world")
def world():
    print("Python")
def test():
    print("----测试----")
__all__ = ['hello', 'test']

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

all 变量指定该模块默认只被导入hello、test两个程序单元。

3、使用包

3.1、什么是包

1. 从物理上看，包就是一个文件夹，在该文件夹下包含了一个__init__.py文件
2. 从逻辑上看，包的本质依然是模块

包的作用是包含多个模块，但包的本质依然是模块，因此包也可用于包含包

3.2、定义包

3. 创建一个文件夹，该文件夹的名称就是该包的包名
4. 在该文件夹内添加一个__init__.py文件

3.3、导入包内成员

4、查看模块内容

4.1、模块包含什么

1. 使用dir()函数
2. 使用模块本身提供的__all__变量

import string
print(dir(string))

• 1
• 2

[‘Formatter’, ‘Template’, ‘_ChainMap’, ‘all’, ‘builtins’, ‘cached’, ‘doc’, ‘file’, ‘loader’, ‘name’, ‘package’, ‘spec’, ‘_re’, ‘_sentinel_dict’, ‘_string’, ‘ascii_letters’, ‘ascii_lowercase’, ‘ascii_uppercase’, ‘capwords’, ‘digits’, ‘hexdigits’, ‘octdigits’, ‘printable’, ‘punctuation’, ‘whitespace’]

4.2、使用__doc__属性查看文档

import string
print(string.capwords.__doc__)

• 1
• 2

capwords(s [,sep]) -> string

    Split the argument into words using split, capitalize each
    word using capitalize, and join the capitalized words using
    join.  If the optional second argument sep is absent or None,
    runs of whitespace characters are replaced by a single space
    and leading and trailing whitespace are removed, otherwise
    sep is used to split and join the words.

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

4.3、使用__file__属性查看模块的源文件路径

import string
print(string.__file__)		# F:\Python3.9\lib\string.py

• 1
• 2