python进阶————上下文管理器跟生成器

---

---

前言

• 我们之前学习了文件操作的相关知识，在其中我们拓展了 with open 语法，但是我们没有解释其原理，今天我们就来一起学习他们背后的知识。

---

一、回顾 open 语法

1、简单的读数据的代码

# 文件路径可以用 相对路径 或者 绝对路径
src_f = open('文件路径', 'r', encoding='utf-8')
print(src_f.read())
src_f.close()

2、上述代码存在两个问题.

问题1：有异常(数据源文件可能不存在)，需要解决
问题2：可能会忘记 close()释放资源

# 解决方案: 用 try.except.finally解决.
try:src_f = open('文件路径', 'r', encoding='utf-8')print(src_f.read())
except:print('哎呀, 程序出问题了!')
finally:src_f.close()     # 有可能忘记 关闭资源.pass

3、上述代码虽然解决了异常问题, 但是出现了新的问题：

问题1：上述代码冗余, 阅读性相对较差
问题2：可能会忘记 close()释放资源

# 解决方案: with...open()...  语句
with open('文件路径', 'r', encoding='utf-8') as src_f:print(src_f.read())     # with.oepn()会等待其内部代码执行完毕后, 自动释放资源.

二、自定义上下文管理器

• 为啥 with.open() 会自动释放资源呢？
  • 它的底层原理, 其实就是：上下文管理器对象.

解释

"""
1、怎么辨别上下文管理器1). with ... as ...  会在其内容执行完毕后, 自动使用.2). with ... as ... 功能之所以强大, 背后就是靠 上下文管理器来支撑的.3). 一个类, 只要重写了 __enter__(),  __exit__() 这两个函数, 它就是 上下文管理器.2、特点:1). __enter__() 会在 with语句之前 自动执行.2). __exit__() 会在 with语句之后 自动执行.
"""

代码 演示 自定义上下文管理器.

# 需求: 自定义一个 MyFile类, 实现读写文件的操作.
# 1. 创建自定义类 MyFile
class MyFile(object):# 2. 重写 __init__()函数, 指定: 初始化的属性.def __init__(self, file_name, file_model):self.file_name = file_name      # 要被操作的: 文件名self.file_model = file_model    # 要进行操作的: 模式, r, rb, w, wb...self.fp = None                  # file path = open(....)  就是1个文件对象.# 3. 重写 __enter__(), 它会在with之前自动执行.def __enter__(self):# 3.1 获取具体的文件对象, 赋值给 fp对象.self.fp = open(self.file_name, self.file_model, encoding='utf-8')# 3.2 返回 文件对象.return self.fp      # fp 就是 文件对象. 即: open() 文件对象# 返回类对象  返回的是: MyFile()# return self     # 实际开发中, 更推荐直接返回 文件对象(MyFile)# 4. 重写 __exit__(), 它会在with之后自动执行, 一般: 释放资源.def __exit__(self, exc_type, exc_val, exc_tb):# 4.1 具体的释放资源的动作.self.fp.close()# 4.2 打印提示语句, 告知: 释放资源了.print('释放资源成功!')# 5. 在main函数中测试调用.
if __name__ == '__main__':# 如果 MyFile类, 返回的是: self.fp, 即: open() 文件对象.  写法如下.with MyFile('文件路径', 'r') as fp:print(fp.read())  # with.oepn()会等待其内部代码执行完毕后, 自动释放资源.# 如果MyFile类, 返回的是: MyFile(), 我们自定义的文件对象, 写法如下:# with MyFile('./1.txt', 'r') as mf:      # mf = MyFile()对象# print(mf.fp.read())  # with.oepn()会等待其内部代码执行完毕后, 自动释放资源.

三、生成器

• 根据程序员制定的规则循环生成数据，当条件不成立时则生成数据结束。数据不是一次性全部生成出来，而是使用一个，再生成一个，可以节约大量的内存。

3.1 创建生成器的两种方式

3.1.1 生成器推导式

案例1：回顾之前的列表推导式，集合推导式

# 需求: 生成 1 ~ 5 的数据.
my_list = [i for i in range(1, 6)]
print(my_list, type(my_list))   # [1, 2, 3, 4, 5] <class 'list'>my_set = {i for i in range(1, 6)}
print(my_set, type(my_set))     # {1, 2, 3, 4, 5} <class 'set'>

案例2： 演示 生成器写法1，推导式写法

# 尝试写一下, "元组"推导式, 发现打印的结果不是元组, 而是对象, 因为这种写法叫: 生成器.
my_tuple = (i for i in range(1, 6))print(my_tuple)             # <generator object <genexpr> at 0x0000024C90F056D0>    生成器对象
print(type(my_tuple))       # <class 'generator'>       生成器类型
print('-' * 30)# 案例3: 如何从生成器对象中获取数据呢?
# 1. 定义生成器, 获取 1 ~ 5的数字.
my_generator = (i for i in range(1, 6))# 2. 从生成器中获取数据.
# 格式1: for循环遍历 获取全部
for i in my_generator:print(i)# 格式 2: next()函数, 逐个获取.
print(next(my_generator))       # 1
print(next(my_generator))       # 2

3.1.2 yield关键字

代码 演示 yield关键字方式，获取生成器

# 需求: 自定义 get_generator()函数, 获取 包括: 1 ~ 5之间的整数 生成器.
# 1. 定义函数.
def get_generator():"""用于演示 yield关键字的用法:return: 生成器对象."""# 思路1: 自定义列表, 添加指定元素, 并返回.# my_list = []# for i in range(1, 6):#     my_list.append(i)# return my_list# 思路2: yield写法, 即: 如下的代码, 效果同上.for i in range(1, 6):yield i     # yield会记录每个生成的数据, 然后逐个的放到生成器对象中, 最终返回生成器对象.# 在main中测试.
if __name__ == '__main__':# 2. 调用函数, 获取生成器对象.my_generator = get_generator()# 3. 从生成器中获取每个元素.print(next(my_generator))   # 1print(next(my_generator))   # 2print('-' * 30)# 4. 遍历, 获取每个元素.for i in my_generator:print(i)

3.2 使用生成器 生成批次数据

代码用生成器生成批次数据：

# 需求: 读取项目下的  jaychou_lyrics.txt文件(其中有5000多条 歌词数据), 按照8个 / 批次, 获取生成器, 并从中获取数据.
import math# 需求1: 铺垫知识,  math.ceil(数字):  获取指定数字的天花板数(向上取整), 即: 比这个数字大的所有整数中, 最小的哪个整数.
# print(math.ceil(5.1))       # 6
# print(math.ceil(5.6))       # 6
# print(math.ceil(5.0))       # 5# 需求2: 获取生成器对象, 从文件中读数据数据, n条 / 批次
# 1. 定义函数 dataset_loader(batch_size), 表示: 数据生成器, 按照 batch_size条 分批.
def dataset_loader(batch_size):     # 假设: batch_size = 8"""该函数用于获取生成器对象, 每条数据都是一批次的数据. 即: 生成器(8条, 8条, 8条...):param batch_size: 每批次有多少条数据:return: 返回生成器对象."""# 1.1 读取文件, 获取到每条(每行)数据.with open("./jaychou_lyrics.txt", 'r', encoding='utf-8') as f:# 一次读取所有行, 每行封装成字符串, 整体放到列表中.data_lines = f.readlines()      # 结果: [第一行, 第二行, 第三行...]# 1.2 根据上述的数据, 计算出: 数据的总条数(总行数), 假设: 100行(条)line_count = len(data_lines)# 1.3 基于上述的总条数 和 batch_size(每批次的条数), 获取: 批次总数(即: 总共多少批)batch_count = math.ceil(line_count / batch_size)        # 例如: math.ceil(100 / 8) = 13# 1.4 具体的获取每批次数据的动作, 用 yield包裹, 放到生成器中, 并最终返回生成器(对象)即可.for i in range(batch_count):        # batch_count的值: 13,  i的值: 0, 1, 2, 3, 4, 5, .... 12# 1.5 yield会记录每批次数据, 封装到生成器中, 并返回(生成器对象)"""推理过程:i = 0, 代表第1批次数据, 想要 第 1 条   ~~~~  第 8 条数据,    即:  data_lines[0:8]      i = 1, 代表第2批次数据, 想要 第 9 条   ~~~~  第 16 条数据,   即:  data_lines[8:16]      i = 2, 代表第3批次数据, 想要 第 17 条   ~~~~  第 24 条数据,  即:  data_lines[16:24]......      """yield data_lines[i * batch_size: i * batch_size + batch_size]# 在main中, 测试调用
if __name__ == '__main__':# 2. 获取生成器对象.my_generator = dataset_loader(13)# 3. 从生成器中获取第 1 批数据.print(next(my_generator))# 从第一批次中, 获取具体的每一条数据.for line in next(my_generator):print(line, end='')print('-' * 31)# 从第二批次中, 获取具体的每一条数据.for line in next(my_generator):print(line, end='')print('-' * 31)# 4. 查看具体的每一批数据.for batch_data in my_generator:print(batch_data)

四 、property属性

解释

"""
property解释:概述:它表示属性的意思, 可以用来修饰 方法, 修饰之后, 实现: 把 方法 当做 变量来使用.目的:简化开发.用法:格式1: 当做装饰器使用.格式2: 修饰类变量
"""

4.1 充当装饰器用法

格式 ：

"""
property充当装饰器用法, 格式:@property           # 修饰的是 获取值的函数.@方法名.setter       # 修饰的市 设置值的函数, 注意: 这里的方法名 要和 @property修饰的方法名保持一致.
"""

代码演示 Property 属性充当装饰器 ：

# 需求1: 定义Student类, 其中有个私有的属性 name, 定义公共的访问方式, 实现在外界访问该 私有变量.
# 1. 定义学生类.
class Student(object):# 1.1 定义私有变量(属性)def __init__(self):self.__name = '张三'      # 两个下划线_ 表示私有# # 1.2 定义get_xxx(), 获取: 姓名# @property# def get_name(self):#     return self.__name## # 1.3 定义set_xxx(), 修改: 姓名# @get_name.setter# def set_name(self, name):#     self.__name = name# 1.2 定义get_xxx(), 获取: 姓名@propertydef name(self):return self.__name# 1.3 定义set_xxx(), 修改: 姓名@name.setterdef name(self, name):self.__name = name# 2. 在main函数中测试
if __name__ == '__main__':# 场景1: 以前学面向对象时的 普通写法.# # 2.1 创建学生类对象.# s = Student()# # 2.2 打印 name 属性值# print(s.get_name())# # 2.3 设置 name 属性值# s.set_name('李四')# # 2.4 打印 name 属性值# print(s.get_name())# 场景2: 演示: property充当装饰器后的用法.# # 2.1 创建学生类对象.# s = Student()# # 2.2 打印 name 属性值# print(s.get_name)# # 2.3 设置 name 属性值# s.set_name = '李四'# # 2.4 打印 name 属性值# print(s.get_name)# 场景3: 演示: property充当装饰器后的用法, 最终写法# 2.1 创建学生类对象.s = Student()# 2.2 打印 name 属性值print(s.name)     		 # 张三# 2.3 设置 name 属性值s.name = '李四'# 2.4 打印 name 属性值print(s.name)			# 李四

4.2 修饰类变量

格式 ：

"""
修饰类变量:类变量名 = property(get_xxx函数, set_xxx函数), 即: 参1是获取值的, 参2是设置值,  之后就可以直接使用该 类变量了.
"""

代码演示 Property 属性修饰类变量 ：

# 需求1: 定义Student类, 其中有个私有的属性 name, 定义公共的访问方式, 实现在外界访问该 私有变量.
# 1. 定义学生类.
class Student(object):# 1.1 定义私有变量(属性)def __init__(self):self.__name = '张三'      # 两个下划线_ 表示私有# 1.2 定义get_xxx(), 获取: 姓名def get_name(self):return self.__name# 1.3 定义set_xxx(), 修改: 姓名def set_name(self, name):self.__name = name# 1.4. 通过property关键字, 实现: 把 get_name() 和 set_name()函数, 封装成 类属性.# 格式: 类变量名 = property(get_xxx函数, set_xxx函数), 即: 参1是获取值的, 参2是设置值,  之后就可以直接使用该 类变量了.name = property(get_name, set_name)# 2. 在main函数中测试
if __name__ == '__main__':# 演示: property修饰 类属性的用法.# 2.1 创建学生类对象.s = Student()# 2.2 打印 name 属性值print(s.name)			# 张三# 2.3 设置 name 属性值s.name = '李四'# 2.4 打印 name 属性值print(s.name)           # 李四

---

总结

• 以上就是今天内容。