python基础——9（迭代器、生成器）

一、迭代器

1、概念

器：包含了多个值的容器

迭代：循环反馈（一次从容器中取出一个值）

迭代器：从装有多个值的容器中一次取出一个值给外界

s = 'abcdef'
ls = [1,2,3,4,5]
遍历：被遍历的对象必须是有序容器
i = 0
while i < len(ls):
    print(ls[i])
    i += 1

st = {1,2,3,4,5}
dic = {"a":1,"b":2,"c":3}

通过迭代器取值优缺点：

优点：不依赖索引，完成取值

缺点：不能计算长度，不能指定位取值(只能从前往后逐一取值)

2、可迭代对象

对象：装有地址的变量

可迭代对象：该对象有__iter()__方法,通过调用该方法可以得到迭代器对象

包含：str | list | tuple | dict | set | range() | file | 迭代器对象 | enumerate() | 生成器

[].__iter__()
().__iter__()
{}.__iter__()
{1,}.__iter__()

3、迭代器对象

迭代器对象就可以做到不依赖索引取值（一次从容器中取出一个值）

迭代器对象都有__next()__方法，且通过该方法获取容器中的值，获取规则：从前往后一次一个

# 可迭代对象
st1 = {3,5,7,1,9}
# 迭代器对象
iter_obj = st1.__iter__()
print(iter_obj)  # 获得一个地址

# 迭代器对象取一个值就少一个值
print(iter_obj.__next__())  # 1
print(iter_obj.__next__())  # 3
print(iter_obj.__next__())  # 5
print(iter_obj.__next__())  # 7
print(iter_obj.__next__())  # 9
# print(iter_obj.__next__())  # 抛异常 StopIteration, 可以通过try对异常进行捕获并处理
print('===============================================')

# 上一个迭代器对象迭代取值完毕后，就取空了，如果要再次取值，就要重新生成迭代器对象
iter_obj = st1.__iter__()
# 迭代器对象不能求长度（内部值的个数）
# 通过异常捕获可以避免多取值的异常
while True:
    try:
        ele = iter_obj.__next__()
        print(ele)
    except StopIteration as e:
        print("取完了",e)
        break

4、for循环迭代器：自带异常处理的while循环，自动获取被迭代的对象的迭代器对象

iter_obj = st1.__iter__()
for ele in iter_obj:
    print(ele)
print('===============================================')
for ele in st1:  # 1.自动完成 for ele in st1.__iter__():  2.自动完成异常处理
    print(ele)

5、总结：

可迭代对象：有__iter()__方法的对象，调用该方法返回迭代器对象

迭代器对象：有__next()__方法的对象，也就是用该方法一次从迭代器对象中获取一个值，取出一个少一个

for循环迭代器：

    --1、自动获取被迭代对象的迭代器对象

    --2、在内部一次一次调用__next()__方法取值

    --3、自动完成异常处理

obj = [1,2,3].__iter__()
for v in obj:
    print(v)
    if v == 2:
        break
print(obj.__iter__().__iter__().__iter__().__next__())
# print(obj.__iter__().__iter__().__iter__() is obj)  # True
# 可迭代对象.__iter__()得到的是该对象的迭代器对象
# 迭代器对象.__iter__().__iter__()得到的就是迭代器对象本身

二、生成器

生成器就是一个可迭代对象

包含yield关键字的函数就是生成器

该函数名()得到的是生成器对象，且不会执行函数体

def fn():
    print("生成器")
    yield 'God'
generator_obj = fn()
print(generator_obj)  # <generator object fn at 0x0000007BE3332C00>
print(type(generator_obj)) # <class 'generator'>

# generator_obj.__iter__()  # 可迭代对象
# generator_obj.__next__()  # 迭代器对象

def g_fn():
    print(1111111111)
    yield '结果1'
    print(2222222222)
    yield '结果2'
    print(3333333333)
    yield '结果3'
    print(4444444444)
    yield '结果4'
    print(5555555555)
    yield '结果5'
g_obj = g_fn()

# 在函数内部执行一次，在遇到下一个yield时停止，且可以拿到yield的返回值
r1 = g_obj.__next__()
print(r1)
# 从上一次停止的位置紧着往下走，在再遇到下一个yield时停止，且可以拿到yield的返回值
r2 = g_obj.__next__()
print(r2)
# 生成器可以被for循环迭代
for v in g_obj:
    print(v)

# 生成器的应用案例
# 当访问的数据资源过大，可以将数据用生成器处理，一次只获取所有内容的一条资源
def my_range(min,max=0,step=1):
    if max == 0:
        min,max = max,min
    tag = min
    while True:
        if tag >= max:
            break
        yield tag
        tag += step
# range_obj = my_range(1,10,1)
# print(range_obj.__next__())
# print(range_obj.__next__())
range_obj = my_range(5, 10, 2)
for i in range_obj:
    print(i)

三、枚举对象（enumerate）

ls = [1,3,5,7,9]

通过for迭代器 循环遍历 可迭代对象，需要知道迭代的索引
count = 0
for v in ls:
    print(count, v)
    count += 1

for i, v in enumerate(ls):
    print(i, v)

for i, v in enumerate('abc'): # 生成迭代器对象：[(0, 'a'),(1, 'b'), (2, 'c')]
    print(i, v)