Python进阶之高级面向对象编程（三）

本篇主要介绍面向对象高级用法、错误处理以及文件读写。

多继承

Python 中继承多个类用逗号隔开，示例如下所示：

class Dog(Animal, Runnable):
    pass

Tips:

多重继承，子类可以获得父类的所有功能;
一般地，Python 中主线都是单一继承，若需要 “额外的功能”，如 Runnable 类似 Java 接口之类的多继承，把这种设计称为 MixIn .
Python 中允许使用多重继承，MixIn 是一种常见的设计。

slots

我们知道 Python 中可以给对象动态添加属性字段，如果要限制实例绑定属性该如何实现呢？使用 _slot_ ，示例代码如下：

class Student(object):
    # 用 tuple 定义允许绑定的属性名称
    __slots__ = ('name', 'age')

几点说明：

定义 class 时使用特殊变量 slots 限制 class 实例能添加的属性；
若给实例动态绑定没在slots 中声明的属性，会抛出异常：AttributeError；
slots 定义的属性仅对当前类的实例起作用，对继承的子类无用；
若在子类中定义 slots ，则子类允许定义的属性就是自身的slots + 父类的slots .

定制类

定义：类似实现len() 方法，让 class 能作用于 len() 函数，像 len() 这样特殊用途的函数，可以定制类。

常见的有如下几种函数来定制类，可当做是重写了 object 父类的一些方法：

定制类函数.png

枚举类

一般地，定义常量可以用大写字母通过整数定义，如：JAN = 1，这种写法简单，但基于类型是 int 型并且仍是变量，值可改变。
未解决上述问题，为上述枚举定义一个 class 类型，每个常量都是 class 的唯一实例。
Python 中提供 Enum 类来实现该功能。
示例代码如下：

from enum import Enum, unique

# 1. 定义 Week 枚举类
Week = Enum('Week', ('Mon', 'Tue', 'Wen', 'Thu', 'Fri', 'Sat', 'Sun'))

# 获取一个常量
# 打印：Week.Mon = Week.Mon 1
print('Week.Mon =', Week.Mon, Week.Mon.value)

# 枚举所有成员
for name, member in Week.__members__.items():
    print(name, '=>', member, ',', member.value)

# 打印结果如下：
# Mon => Week.Mon , 1
# Tue => Week.Tue , 2
# Wen => Week.Wen , 3
# Thu => Week.Thu , 4
# Fri => Week.Fri , 5
# Sat => Week.Sat , 6
# Sun => Week.Sun , 7

# 枚举说明：
# 1) value 属性时自动赋给成员的 int 常量，默认从 1 开始计数；
# 2）若需要更精确地控制枚举类型，可以从 Enum 派生出自定义类。

# 2. 自定义枚举派生类
# 导入 from enum import Enum, unique ，@unique装饰器可以保证无重复值

@unique
class Weekday(Enum):
    Sun = 0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6

# 不通方式获取枚举常量：一是成员名称，二是直接根据 value 值获取。
print('day1 =', Weekday.Mon)             # day1 = Weekday.Mon
print('day2 =', Weekday['Tue'])          # day2 = Weekday.Tue
print('day3 =', Weekday(3))              # day3 = Weekday.Wed
print('day4.value =', Weekday(4).value)  # day4.value = 4
print('day5.value =', Weekday.Fri.value) # day5.value = 5

# 遍历所有枚举值
for name, member in Weekday.__members__.items():
    print(name, '=>', member)

# 打印结果如下：
# Sun => Weekday.Sun
# Mon => Weekday.Mon
# Tue => Weekday.Tue
# Wed => Weekday.Wed
# Thu => Weekday.Thu
# Fri => Weekday.Fri
# Sat => Weekday.Sat

总结： Enum 可以把一组相关常量定义在一个 class 中，且 class 不可变，而且成员可以直接比较。

错误&调试

Python 中使用 try...except...raise...else...finally... 语句进行错误处理。先用一段代码说明如何使用这种错误处理机制。

mport logging

class MyDivideError(ValueError):
    pass

def try_test():
    try:
        print('try...')
        r = 10 / 0
        print('result:', r)
    except ZeroDivisionError as e:
        print('catching error:', e)
        logging.exception(e)
        raise MyDivideError('invalid value: 0')
    else:
        print('no erro ! will be executed when there are no errors!')
    finally:
        print('finally... will always be executed whenever catching errors!')
    
try_test()

# 打印结果如下：
# try...
# catching error: division by zero
# finally... will always be executed whenever catching errors!
# 异常捕获后抛出打印结果：
# __main__.MyDivideError: invalid value: 0

使用说明：
1）try 代码块防止代码出错，出错后使用 except 代码块捕获，若没有错误则执行 else语句；若想将错误抛给外层处理则使用 raise 抛出异常；finally 语句块不管有没有发生错误均会执行该语句块。
2）except 代码块同于 catch，若错误类型包含父子关系，则父类会捕获该错误；所有的错误类型都继承 BaseException。
3）except...else... 发生了错误则执行 except 代码块，否则执行 else 语句；
4）logging.exception(e) 可以记录错误信息，便于事后排查。

单元测试

目前仅以一张简图来展示 Python 中单元测试：

单元测试.png

IO编程

文件读写

背景：在磁盘上读写文件的功能均是由操作系统提供，现代操作系统不允许普通的程序直接操作磁盘。

方式：读写文件就是请求操作系统打开一个文件对象（通常称为文件描述符），然后，通过操作系统提供的接口从这个文件对象中读取数据（读文件），或者把数据写入该文件对象（写文件）。

读文件
方法： Python内置函数 - open(文件名, 标识符['r'只读])
说明：
1）若文件不存在，该函数会抛出 IOError 错误，并且给出错误码和详细信息告知文件不存在；
2）若文件打开成功，使用 read() 函数可一次性读取文件全部内容；
3）Python 把内容读到内存，用一个 str 对象表示。
4）调用 close() 方法关闭文件。
Tips: 文件使用完毕必须关闭，因为文件对象会占用操作系统的资源，并且os同一时间能打开的文件数量是有限的。

# 以下抛出错误：FileNotFoundError: [Errno 2] No such file or directory: 'Users/xss/notfound.txt'
file = open('./channel', 'r')
content = file.read()
file.close()   # 必须关闭文件
print(content) # 打印文件内容（success）

完整定义一个读文件函数：

def readFile(filename):
    try:
        file = open(filename, 'r')
        print(file.read())
    finally:
        if file:
            file.close()

简洁代码写法：

def readFile2(filename):
    with open(filename, 'r') as file:
        print(file.read())

问题：当文件size太大时，一次性读取文件，内存就会爆满，如何解决呢？
方式：保险起见，三种方式：
1）read(size); 每次读取一行内容，每次最多读取 size 个字节的内容；
2）readline(); 每次读取一行内容；
3）readlines(); 一次读取所有内容并按行返回 list.

各方式使用场景：
1）read() 适用于文件很小时一次性读取；
2）无法确定文件大小时，反复调用 read(size) 比较保险；
3）若是配置文件，使用 readlines() 最方便。

def readFileByLine(filename):
    file = open(filename, 'r')
    for line in file.readlines():
        print(line.strip())  # 删除末尾'\n'

文件读取模式

文本文件读取+默认UTF-8： open(filename, 'r') ；
二进制文件读取：open(filename, 'rb') # 二进制文件-图片视频等；
非UTF-8编码文件：open(filename, 'r', encoding='gbk') # 中文。

关于文件编码不规范问题，会抛出 UnicodeDecodeError 非法编码字符，使用如下方式：

# f = open('./channel', 'r')
 # print(f.read())

ff = open('./first.py', 'r', encoding='gbk', errors='ignore')
print(ff.read()) # 忽略非法字符，读取中文乱码（改成 encoding='utf-8'）

写文件
open(filename, 'w' / 'wb') 写文本文件或写二进制文件

filename = './first.py'
f = open(filename, 'w')
f.write('# Hello, world')
f.close()

readFileByLine(filename)

def writeFile():
    with open('./first.py', 'w') as f:
        f.write('Hello, world !')

总结： Python 中，文件读写是通过 open() 函数打开的文件对象完成的。使用 with 语句操作文件 IO 是好习惯。

另外还有 StringIO 、BytesIO，序列化和JSON内置模块使用，暂用一张图展示说明：

IO.png