Python-生成器generator| “朝闻道”知识分享大赛

[小年华°Moon]

这是我参加朝闻道知识分享大赛的第33篇文章。

(1) 定义：能够动态(循环一次计算一次返回一次)提供数据的可迭代对象。

(2) 作用：在循环过程中，按照某种算法推算数据，不必创建容器存储完整的结果，从而节省内存空间。数据量越大，优势越明显。以上作用也称之为延迟操作或惰性操作，通俗的讲就是在需要的时候才计算结果，而不是一次构建出所有结果。

生成器函数

class StudentController:
    def __init__(self):
        self.list_student = []

    def __iter__(self):
        # 生成迭代器代码的大致规则:
        # 1. 将yield以前的代码作为__next__方法体
        # 2. 将yield以后的数据作为__next__返回值
        index = 0
        yield self.list_student[index]

        index += 1
        yield self.list_student[index]

        index += 1
        yield self.list_student[index]

        # raise StopIteration()

controller = StudentController()
controller.list_student.append("吉宇轩")
controller.list_student.append("周字华")
controller.list_student.append("涂洋涛")
iterator = controller.__iter__()
while True:
    try:
        item = iterator.__next__()
        print(item)
    except StopIteration:
        break

def my_range(stop):
    number = 0
    while number < stop:
        yield number
        number += 1

# 循环一次,计算一次,返回一次
# for number in MyRange(5):
#     print(number)# 0 1 2 3 4
obj = my_range(5) # 返回生成器对象
iterator = obj.__iter__()
while True:
    try:
        item = iterator.__next__()
        print(item)
    except StopIteration:
        break

(1) 定义：含有yield语句的函数，返回值为生成器对象。

(2) 语法

# 创建：
def 函数名():
    …
    yield 数据
    …

# 调用：
for 变量名 in 函数名():
    语句

(3) 说明：

-- 调用生成器函数将返回一个生成器对象，不执行函数体。

-- yield翻译为”产生”或”生成”

(4) 执行过程：

a. 调用生成器函数会自动创建迭代器对象。

b. 调用迭代器对象的__next__()方法时才执行生成器函数。

c. 每次执行到yield语句时返回数据，暂时离开。

d. 待下次调用__next__()方法时继续从离开处继续执行。

(5) 原理：生成迭代器对象的大致规则如下

a. 将yield关键字以前的代码放在next方法中。

b. 将yield关键字后面的数据作为next方法的返回值。

class generator: # 生成器 = 可迭代对象+迭代器
    def __iter__(self): # 可迭代对象
        return self
    
    def __next__(self): # 迭代器
        计算数据
        return 数据 

# 创建函数,在列表中查找大于10的所有数据.
# 传统思想:创建容器存储所有结果
# 缺点:占用内存太多
def find_all_gt_10():
    result = []
    for item in list01:
        if item > 10:
            result.append(item)
    return result

data = find_all_gt_10()
for item in data:
    print(item)


# 生成器思想:几乎不占内存
def find_all_gt_10():
    for item in list01:
        if item > 10:
            yield item


data = find_all_gt_10()
for item in data:
    print(item)
# 生成器只能用一次
for item in data:
    print(item)
# 解决方案:
data = list(find_all_gt_10())
for item in data:
    print(item)
for item in data:
    print(item)

内置生成器

枚举函数enumerate

(1) 语法：

快捷键：iter + 回车

快捷键：itere + 回车

for 变量 in enumerate(可迭代对象):（把索引和元素组成元组导出）
    语句

for 索引, 元素in enumerate(可迭代对象):（把索引和元素分别导出）
    语句

(2) 作用：遍历可迭代对象时，可以将索引与元素组合为一个元组。

(3) 演示：

list01 = [43, 43, 54, 56, 76]
# 从头到尾读          -- 读取数据
for item in list01:
    print(item)

# 非从头到尾读        -- 修改数据
for i in range(len(list01)):
    if list01[i] % 2 == 0:
        list01[i] += 1

for i, item in enumerate(list01):  # -- 读写数据
    if item % 2 == 0:
        list01[i] += 1

元素合并zip

(1) 语法：

for item in zip(可迭代对象1, 可迭代对象2):
    语句

(2) 作用：将多个可迭代对象中对应的元素组合成一个个元组，生成的元组个数由最小的可迭代对象决定。

(3) 演示：

list_name = ["悟空", "八戒", "沙僧"]
list_age = [22, 26, 25]

# for 变量 in zip(可迭代对象1,可迭代对象2)
for item in zip(list_name, list_age):
    print(item)
# ('悟空', 22)
# ('八戒', 26)
# ('沙僧', 25)

# 应用:矩阵转置
map = [
    [2, 0, 0, 2],
    [4, 2, 0, 2],
    [2, 4, 2, 4],
    [0, 4, 0, 4]
]

# new_map = []
# for item in zip(map[0],map[1],map[2],map[3]): ==> for item in zip(*map):
#     new_map.append(list(item))

new_map = [list(item) for item in zip(*map)]
# [[2, 4, 2, 0], [0, 2, 4, 4], [0, 0, 2, 0], [2, 2, 4, 4]]

生成器表达式

(1) 定义：用推导式形式创建生成器对象。(把列表推导式的[]改成())节省内存

(2) 语法：

变量 = (表达式 for 变量 in 可迭代对象 if 条件)

列表
    优点:操作数据方便
    缺点:占用内存较多
生成器
    优点:占用内存较少
    缺点:操作数据不方便
        (不能使用索引/切片,不能删除修改,只能使用一次)
    适用性:从头到尾读取一次
          (优先)
    解决:转换为列表
        list(生成器)
        tuple(生成器)
        set(生成器)