Python-19-迭代器和生成器

# 1）下标访问方式--索引
li = [1,2,3,4]
print(li[0])                # 下标访问（索引）

index = 0
while index < len(li):
    print(li[index])
    index += 1


# 2）迭代器协议访问
li = [1,2,3,4]
f = li.__iter__()           # 第一步，先通过内部的_iter_方法，先把对象变成可迭代对象
print(f.__next__())         # 对可迭代对象用_next_方法取值
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())         # StopIteration,超出边界会报错
print(next(f))                # next(f) 就是 f.__next__()
print(next(f))

# 3）for循环访问
li = [1,2,3,4]
for i in li:                # li_iter = li._iter_()
    print(i)                # li_iter._next_

# 4）用while去模拟for循环做的事情
li = [1,2,3,4]
diedai_l=li.__iter__()
while True:
    try:
        print(diedai_l.__next__())
    except StopIteration:
        print(‘迭代完毕了,循环终止了‘)
        break

# 1）三元表达式：
f = result = 值1 if 条件 else 值2      # True 输出值1；False 输出值2.
name = "newmet"
f = "TRUE_1" if name == "newmet" else "FALSE_1"
print(f)

# 2）列表解析：
# s = [三元表达式],列表解析生成的是一个真实存在于内存中的列表，对于比较大的列表，比较耗内存空间
count = [x for x in range(10)]  # 列表解析
l = ["苹果%s" % i for i in range(10)]  # 列表解析
print(l)  # 结果：[‘苹果0‘, ‘苹果1‘, ‘苹果2‘, ‘苹果3‘, ‘苹果4‘, ‘苹果5‘, ‘苹果6‘, ‘苹果7‘, ‘苹果8‘, ‘苹果9‘]
l1 = ["苹果%s" % i for i in range(10) if i > 5]
print(l1)  # 结果：[‘苹果6‘, ‘苹果7‘, ‘苹果8‘, ‘苹果9‘]

# 3）生成器表达式---[] 变成 （）
# 列表解析
sum([i for i in range(1000000)])  # 内存占用大，机器容易卡死
# 生成器表达式
sum(i for i in range(1000000))    # 几乎不占内存
# sum函数是Python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，不用多此一举先生成列表

l2 = ("苹果%s" % i for i in range(10))  # [] 变成 （） 生成器表达式！！！！！！
print(l2)  # 结果：<generator object <genexpr> at 0x00000000037F9930> 内存地址
print(l2.__next__())  # 结果:苹果0
print(l2.__next__())  # 结果:苹果1
print(next(l2))  # 结果:苹果2

def test():
    yield 1         # 相当于return，不同于return,yield可以返回多个值
    yield 2
    yield 3

res = test()
print(res)             # 结果:<generator object test at 0x00000000037F9930> 内存地址
print(res.__next__())  # 结果:1   保留当前执行状态，下次执行从上次状态处继续往下执行
print(res.__next__())  # 结果:2
print(res.__next__())  # 结果:3   执行只能一直往前走，不能往后，只能执行一次，执行完继续执行会触发StopIteration

# 例1：母鸡下蛋
def xiadan():
    for i in range(10):
        yield "鸡蛋%s"%i
f = xiadan()
# for j in f:
#     print(j)
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())

# 例2：人口普查
def get_population():
    with open("人口普查", "r", encoding="utf-8") as f:
        for i in f:
            yield i


g = get_population()
all_g = sum(eval(i)[‘population‘] for i in g)
print(all_g)

# 例3：吃包子

# 生产包子函数：
import time
def producer():
    ret=[]
    for i in range(100):
        time.sleep(0.1)
        ret.append("包子%s" %i)
    return ret
# 吃包子函数：
def consumer(res):
    for index,baozi in enumerate(res):
        time.sleep(0.1)
        print("第%s个人，吃了%s" %(index,baozi))
res = producer()
consumer(res)
# 这样的生产与消费是：先生产完包子，再去卖，效率太低，不符合实际需求。

# 伪并发
# send()：可对yield函数传参数，参数会赋值给yield函数前的变量，通过send()可实现伪并发功能!!!!!!

import time #导入时间模块
def consumer(name):
    print("我是%s,我准备吃包子了"%name)
    while True:
        baozi = yield
        time.sleep(1)
        print("我是%s,我把包子%s吃掉了"%(name,baozi))
def producer(x):
    user_name = consumer(x)
    user_name.__next__()
    for i in range(100):
        time.sleep(1)
        user_name.send(i)#将i赋值给consumer()函数中yield前面的包子，下次执行时从此往后执行
use_name = input("欢迎您！请问怎么称呼您:")
print("好的，麻烦请稍等！包子马上就给您端上来")
producer(use_name)

import time
# 消费者--程序
def consumer(name):
    print("我是[%s],我准备吃包子了;" %name)
    while True:
        baozi = yield
        time.sleep(1)
        print("%s 很开心的把[%s]吃掉了。" %(name,baozi))
# 生产者--程序
def producer():
    v1=consumer("newmet1")
    v2=consumer("newmet2")
    v1.__next__()
    v2.__next__()
    for i in range(10):
        time.sleep(1)
        v1.send("包子%s" %i)          # 将i赋值给producer()函数中yield前面的包子，下次执行时从此往后执行
        v2.send("包子%s" %i)
producer()