上下文管理器与生成器
前言
- 我们之前学习了文件操作的相关知识，在其中我们拓展了 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)) # 1
print(next(my_generator)) # 2
print('-' * 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(), 获取: 姓名
@property
def name(self):
return self.__name
# 1.3 定义set_xxx(), 修改: 姓名
@name.setter
def 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) # 李四
总结
- 以上就是今天内容。