迭代器 生成器 枚举

迭代器

一、迭代器概念
　　器：包含了多个值的容器 
　　迭代：循环反馈（一次从容器中取出一个值） 
　　迭代器：从装有多个值的容器中一次取出一个值给外界（不需要索引的取值方式）

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

    #无序容器 st={1, 2, 3, 4, 5}   dic={'x':1, 'y':2, 'z':3}    

二、可迭代对象
　　对象：python中的一个对象(装有地址的变量) 　　
　　可迭代对象：该对象有__iter__()方法

[].__iter__()  
().__iter__()  
{}.__iter__()  
{1,}.__iter__() 
可迭代对象通过调用__iter__()方法得到迭代器对象

三、迭代器对象 
　　迭代器对象:可以不依赖索引取值（一次从容器中取出一个值） 
　　迭代器对象:都有__next__()方法，且通过该方法获取容器中的值，获取规则，从前往后一次一个

# 可迭代对象
st1 = {3, 5, 7, 1, 9}

# 迭代器对象
iter_obj = st1.__iter__()
print(iter_obj)              # <set_iterator object at 0x0000026E0BF3B510>
print([1, 2, 3].__iter__())  # <list_iterator object at 0x0000026E0BFF8320>

# 迭代器对象取一个值就少一个值
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对异常进行捕获并处理


===============================================
iter_obj = st1.__iter__()  # 上一个迭代器对象迭代取值完毕后，就取空了，如果要再次取值，要重新生成迭代器对象

# 迭代器对象不能求长度(内部值的个数)
while True:
    try:
        ele = iter_obj.__next__()
        print(ele)
    except StopIteration:
        # print("取完了")
        break

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

st1 = {3, 5, 7, 1, 9}
iter_obj = st1.__iter__()
for ele in iter_obj:
    print(ele)


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

总结： 
可迭代对象：有__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__()得到的就是迭代器对象本身

# 可迭代对象
for v in 'abc'.__iter__():
    print(v)


for k, v in {'a': 1, 'b': 2}.items():  # keys() | values() | items()
    print(k)

r_obj = range(10)
for v in r_obj:
    print(v)

with open('abc.txt', 'r', encoding='utf-8') as f:
    for line in f:
        print(line)


# 迭代器对象
with open('abc.txt', 'r', encoding='utf-8') as f:
    print(f.__next__())
    print(f.__next__())
    print(f.__next__())

生成器

　　就是一个迭代器对象
　　包含yield关键字的函数就是生成器
　　该函数名()得到的是生成器对象，且不会执行函数体

def fn():
    print('我是生成器')
    return 1
fn()
print(type(fn))
print(type(fn()))
# >>>:
#     我是生成器
#     
#     <class 'function'>
# 
#     我是生成器
#     <class 'int'>


+++++++++++++++++++++++++++++++++++++++++++++++
def fn1():
    print('我是生成器')
    yield 'God'

generator_obj=fn1()
print(generator_obj)
print(type(generator_obj))

# >>>:
# <generator object fn1 at 0x0000021D6602EFC0>
# <class 'generator'>


fn1()
print(type(fn1))
print(type(fn1()))

# >>>:
#             (空)
#     <class 'function'>
#     <class 'generator'>

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

def g_fn():
    print(111111111111111)
    yield '结果1'
    print(222222222222222)
    yield '结果2'
    print(333333333333333)
    yield '结果3'
    print(444444444444444)
    yield '结果4'
    print(555555555555555)
    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()
# print(range_obj.__next__())
# print(range_obj.__next__())
# ？？倒序遍历
range_obj = my_range(5, 10, 2)
for i in range_obj:
    print(i)

枚举对象

通过for迭代器 循环遍历 可迭代对象，需要知道迭代的索引

count = 0
for v in ls:
     print(count, v)
    count += 1

for i, v in enumerate(ls):
    print(i, v)
>>>:
0 1
1 3
2 5
3 7
4 9

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