迭代器、生成器

【一】迭代器

【1】介绍

• 迭代器即用来迭代取值的工具，而迭代是重复反馈的过程的活动
  • 其目的通常是为了逼近所需的目标或结果，每一次对过程的重复称为一次”迭代“
  • 而每一次迭代得到的结果会作为下一次迭代的初始值，单纯的重复并不是迭代

while True:
    msg = input('>>: ').strip()
    print(msg)

# 获取到返回值
num_list = [0, 1, 2, 3, 4, 5]
count = 0
while count < len(num_list):
    # 每一次使用的索引位置就是上一次 +1 后的索引位置
    print(num_list[count])
    count += 1

【二】可迭代对象

【1】什么是可迭代对象

• 从语法上讲，内置有 __ iter __ 方法的对象都是可迭代对象

【2】八大基本数据类型

# 【1】数字类型
# 【1.1】整数类型 --- 不是
num = 1
print(num.__iter__)
'''
Traceback (most recent call last):
  File "E:\PythonProjects\迭代器.py", line 10, in <module>
    print(num.__iter__)
AttributeError: 'int' object has no attribute '__iter__'. Did you mean: '__str__'?
'''

# 【1.2】浮点类型 --- 不是
num_float = 1.0
print(num_float.__iter__())
'''
Traceback (most recent call last):
  File "E:\PythonProjects\迭代器.py", line 20, in <module>
    print(num_float.__iter__)
AttributeError: 'float' object has no attribute '__iter__'. Did you mean: '__str__'?
'''

# 【2】字符串类型
name = 'chosen'
print(name.__iter__)
# <method-wrapper '__iter__' of str object at 0x000002498B9E22B0>
print(name.__iter__())
# <str_iterator object at 0x000001F6CFED9660>

# 【3】布尔类型
is_right = False
print(is_right.__iter__)
'''
Traceback (most recent call last):
  File "E:\PythonProjects\迭代器.py", line 37, in <module>
    print(is_right.__iter__)
AttributeError: 'bool' object has no attribute '__iter__'. Did you mean: '__str__'?
'''

# 【4】列表类型
name_list = [1, 2, 3]
print(name_list.__iter__)
# <method-wrapper '__iter__' of list object at 0x0000024C3FA25300>
print(name_list.__iter__())
# <list_iterator object at 0x0000024C3FA7B9A0>

# 【5】字典类型
info_dict = {"name": "chosen"}
print(info_dict.__iter__)
# <method-wrapper '__iter__' of dict object at 0x000002827A692180>
print(info_dict.__iter__())
# <dict_keyiterator object at 0x000002D5DCB9EFC0>

# 【6】元祖类型
num_tuple = (1,)
print(num_tuple.__iter__)
# <method-wrapper '__iter__' of tuple object at 0x00000172CCD9B940>
print(num_tuple.__iter__())
# <tuple_iterator object at 0x00000172CCDDB9A0>

# 【7】集合类型
num_set = {1}
print(num_set.__iter__)
# <method-wrapper '__iter__' of set object at 0x0000027260D06CE0>
print(num_set.__iter__())
# <set_iterator object at 0x0000027260D1B880>

【3】总结

• 非可迭代对象
  • 整数类型
  • 浮点类型
  • 布尔类型
• 可迭代类型
  • 字符串类型
  • 列表类型
  • 字典类型
  • 元组类型
  • 集合类型

【三】迭代器对象

【1】什么是迭代器对象

• 调用obj.__iter__()方法返回的结果就是一个迭代器对象(Iterator)。
• 迭代器对象是内置有 iter 和 next 方法的对象，打开的文件本身就是一个迭代器对象
  • 执行迭代器对象.iter()方法得到的仍然是迭代器本身
  • 而执行迭代器.next()方法就会计算出迭代器中的下一个值。
• 迭代器是Python提供的一种统一的、不依赖于索引的迭代取值方式，只要存在多个“值”，无论序列类型还是非序列类型都可以按照迭代器的方式取值

【2】八大基本数据类型

# 【1】字符串类型
name_str = 'chosen'
name_iter = name_str.__iter__()
name_iter_two = iter(name_str)
print(name_iter)
print(name_iter_two)
# <str_iterator object at 0x00000176CD599660>
# <str_iterator object at 0x00000176CD59B190>
print(name_iter.__next__())
# c
print(next(name_iter))
# h

# 【2】列表类型
name_list = [1, 2, 3]
name_list_iter = iter(name_list)
print(name_list_iter)
# <list_iterator object at 0x0000021C9E813F10>
print(name_list_iter.__next__())
# 1
print(next(name_list_iter))
# 2

# 【3】字典类型
info_dict = {"name": "chosen", "age": 18}
info_dict_iter = iter(info_dict)
print(info_dict_iter)
# <dict_keyiterator object at 0x000001E2A8E3EFC0>
print(info_dict_iter.__next__())
# name
print(next(info_dict_iter))
# age

# 【4】元祖类型
num_tuple = (1, 2)
num_tuple_iter = iter(num_tuple)
print(num_tuple_iter)
# <tuple_iterator object at 0x00000222615D3EE0>
print(num_tuple_iter.__next__())
# 1
print(next(num_tuple_iter))
# 2

# 【5】集合类型
num_set = {1, 2, 3}
num_set_iter = iter(num_set)
print(num_set_iter)
# <set_iterator object at 0x000002CCB2B50EC0>
print(num_set_iter.__next__())
# 1
print(next(num_set_iter))
# 2

【3】总结

# 具有 __iter__() 和 __next__() 的对象就是迭代器对象
# 在八大基本数据类型中
# 除了 整数、浮点数、布尔
# 其他的都是迭代器对象

# 迭代器对象一定是可迭代对象

# 可迭代对象是 具有 __iter__() 的对象 ---> 生成一个可迭代对象
# 迭代器对象是 具有 __iter__()  和 __next__() 的对象 --> 调用上面可迭代对象的 next 方法

【四】迭代器的优缺点

【1】优点

• 为序列和非序列类型提供了一种统一的迭代取值方式
• 不使用索引进行取值
• 取到值的时候会保存到当前的状态，下一次从这个位置开始向下取值

【2】缺点

• 除非取尽，否则无法获取迭代器的长度
• 只能取下一个值，不能回到开始，更像是’一次性‘的，迭代器产生后的唯一目标就是重复执行next方法直到值取尽，否则就会停留在某个位置，等待下一次调用next；
• 若是要再次迭代同个对象，你只能重新调用iter方法去创建一个新的迭代器对象，如果有两个或者多个循环使用同一个迭代器，必然只会有一个循环能取到值。

【五】什么是生成器

• 通过生成器，可以逐个生成序列中的元素，而无需一次性生成整个序列
• 生成器在处理大数据集时，具有节省内存、提高效率的特点。

# 假设一个数据库里 表里面存了1亿条数据
# 读数据时---> 使用 read() 内存会直接爆满导致电脑卡死
# 使用生成器--->一次取100行进行处理 ---->再取100行进行处理，以此类推

【六】生成器的创建方式

【1】列表推导式

• 使用列表推导式时，可以将列表推导式的方括号改为圆括号，即可创建一个生成器。

# 列表生成式生成列表
start_list = [x * 2 for x in range(5)]

print(start_list)
# [0, 2, 4, 6, 8]

# 将列表改成元祖，看起来像元祖推导式，其实是一个生成器对象
G = (x * 2 for x in range(5))

print(G)
# <generator object <genexpr> at 0x000001873491CC80>

# 生成器对象可以强转成列表
print(list(G))
# [0, 2, 4, 6, 8]

【2】yield关键字

• 使用yield关键字定义一个生成器函数时，生成器函数中的yield语句会暂停函数执行并返回一个值，下一次调用该函数时会继续执行并返回下一个值。

def my_generator():
    yield 1
    yield 2
    yield 3

g = my_generator()
print(next(g))  # 输出：1
print(next(g))  # 输出：2
print(next(g))  # 输出：3

【七】生成器案例

def eater():
    print('开始吃饭 ovo ')
    while True:
        food = yield
        print(f'得到的食物是 :>>>> {food}, 开始吃饭喽 :>>>> {food}')

【1】调用函数

res = eater()
print(res)  # <generator object eater at 0x000002094832AAC0>
print(res.__next__())
# 打印开始吃饭
# None   原因就是在生成器内部的 yield 中没有返回值
print(res.__next__())
# 打印 得到的食物是 :>>>> None, 开始吃饭喽 :>>>> None
# None  原因就是在生成器内部的走完了上面的 又回到了 yield 中结果 yield 没有返回值

【2】向生成器中传值

res = eater()
print(res)  # <generator object eater at 0x000002094832AAC0>
print(res.__next__())
res.send("鱼香肉丝") #得到的食物是 :>>>> 鱼香肉丝, 开始吃饭喽 :>>>> 鱼香肉丝 # 想yield 传值并且让生成器向下走一下
print(res.__next__()) #得到的食物是 :>>>> None, 开始吃饭喽 :>>>> None
print(res.send("宫保鸡丁")) #得到的食物是 :>>>> 宫保鸡丁, 开始吃饭喽 :>>>> 宫保鸡丁
#None

【八】装饰器 + 生成器

def init_iter(func):
    # func 我的生成器函数
    def inner(*args, **kwargs):
        # g 得到的生成器对象
        g = func(*args, **kwargs)
        # 调用自己生成器向下走
        next(g)
        # 走回来的返回值返回出去
        return g

    return inner

@init_iter
def eater():
    print('开始吃饭 ovo ')
    while True:
        food = yield
        print(f'得到的食物是 :>>>> {food}, 开始吃饭喽 :>>>> {food}')

res = eater()
res.send("鱼香肉丝")
res.send("宫保鸡丁")

【九】生成器内部修改可变数据类型

def init_iter(func):
    # func 我的生成器函数
    def inner(*args, **kwargs):
        # g 得到的生成器对象
        g = func(*args, **kwargs)
        # 调用自己生成器向下走
        next(g)
        # 走回来的返回值返回出去
        return g

    return inner


@init_iter
def eater():
    print('开始吃饭 ovo ')
    food_list = []
    while True:
        food = yield
        food_list.append(food)
        print(f'得到的食物是 :>>>> {food}, 开始吃饭喽 :>>>> {food}')
        print(f'当前后厨已经做好了 :>>>> {food_list}')


res = eater()
res.send("鱼香肉丝")
res.send("宫保鸡丁")
# 输出结果:
开始吃饭 ovo 
得到的食物是 :>>>> 鱼香肉丝, 开始吃饭喽 :>>>> 鱼香肉丝
当前后厨已经做好了 :>>>> ['鱼香肉丝']
得到的食物是 :>>>> 宫保鸡丁, 开始吃饭喽 :>>>> 宫保鸡丁
当前后厨已经做好了 :>>>> ['鱼香肉丝', '宫保鸡丁']

【十】yield + next搭配着使用

def my_range(start, stop, step):
    '''

    :param start: 0
    :param stop: 5
    :param step: 1
    :return:
    '''
    print("start")
    while start < stop:
        yield start
        start += step
    print("end")


res = my_range(0, 5, 1)
print(res)  # <generator object my_range at 0x0000023DE2CC6490>
print(res.__next__()) # 0
print(res.__next__()) # 1
print(res.__next__()) # 2 
print(res.__next__()) # 3
print(res.__next__()) # 4
# 这里会报错 ---》 把我掏空了 --- 没有可迭代的值可以被获取了
print(res.__next__())  # StopIteration

def init_iter(func):
    def inner(*args, **kwargs):
        try:
            generator = func(*args, **kwargs)
            next(generator)
            return generator
        except StopIteration:
            pass

    return inner

def range_(start, stop, step):
    while start < stop:
        yield start
        start += step

# for 循环内部做了异常捕获
for i in range_(0,5,1):
    print(i)

def my_range(start, stop, step):
    def range_(start, stop, step):
        while start < stop:
            yield start
            start += step

    res = range_(start, stop, step)
    while True:
        try:
            print(res.__next__())
        except StopIteration:
            break

res = my_range(start=1, stop=5, step=1)
res

#输出结果
0
1
2
3
4
1
2
3
4