python提高1 递归和迭代，迭代器协议，生成器，生产者和消费者

一，递归和迭代的感念

# def test():
#     #####################一，递归和迭代的感念#####################
#      print('递归就是：一层一层下去，找到了在一层一层返回')
#      print('迭代就是：找到一层，没找到，在找下一下层，直到找到')
# test()

二，迭代器协议

1，迭代器协议定义

# #     def test1():
# #         ###########1，迭代器协议定义#######
# #         print('就是对象必须提供一个next方法，执行该方法要么返回迭代器的下一项，要么就引起一个\
# # StopAsyncIteration异常，以终止迭代（只能往后走不能往前退）')
# #     test1()

2，迭代器对象

   # def test2():
#     #     ###########2，迭代器对象#######
#     #     print('实现了迭代器协议的对象（如何实现：对象内部定义一个__iter__()方法）')
#     # test2()

3，协议

# #         ###########3，协议#######
# #         print('协议是一种约定，可迭代对象实现了迭代器协议\
# # ,python(如for循环sum,min,max函数等)使用迭代器协议访问对象')
# #     test3()

4,要用for循环的好处

def test4():
#         ###########4,字符串，列表，字典都不是可迭代对象?#######
#         print('因为字符串，列表，字典。。都没有__next__方法 ，\
# 那怎么循环的,用了一个_iter__变成了可迭代对象,__next__')
#         v={'name':'qyl','age':19,'xb':'男'}.values().__iter__()
#         print(v)#<list_iterator object at 0x0000000001E91160>变成了可迭代对象了
#         print(v.__next__())
#         print(v.__next__())
#         print(v.__next__())
#         k = {'name': 'qyl', 'age': 19, 'xb': '男'}.keys().__iter__()
#         print(k)  # <list_iterator object at 0x0000000001E91160>变成了可迭代对象了
#         print(k.__next__())
#         print(k.__next__())
#         print(k.__next__())
#         # print(k.__next__())#遍历光了就报错
#         with open('只读模式.txt','r+',encoding='utf8',newline='') as f:
#             print(f.__iter__())#只是拿到一个内存地址
#             print(f.__next__(),end="")#这样就不损耗内存了(f.__next__()==next(f))
#             print(f.__next__(),end="")#这样就不损耗内存了
#         with open('只读模式.txt', 'r+', encoding='utf8', newline='') as f:
#             print(f.__iter__())  # 只是拿到一个内存地址
#             while 1:
#                 try:
#                     print(f.__next__(), end="")  # 这样就不损耗内存了
#                 except StopIteration:
#                     # print(" \n文件已读光")#捕捉StopIteration提示for就是没提示直接break
#                     break
#     test4()

三，生成器

生成器也是一个数据类型，自动实现了_iter_方法，说以生成器就是一个迭代器

# # def test1():
    # #     ##########1，生成器函数##########
    # #     # 就是函数里面有yield的就是生成器函数
    # #     def den():
    # #         print('sadasfasf')
    # #         print('sadasfasf1')
    # #         yield 1#有yield就是生成器函数，可以遍历
    # #         print('sadasfasf2')
    # #         print('sadasfasf3')
    # #         yield 12
    # #         yield 13
    # #     scq=den()#必须要赋值才能变成生成器，才能变成迭代器
    # #     while 1:
    # #         try:
    # #             print(scq.__next__())#地2次next就是从第一次那个yield开始运行了
    # #         except StopIteration:
    # #             break
    # #     # for i in scq:
    # #     #     print(i)
    # # test1()

2，生成器表达式

# # def test2():
    # #     ##########2，生成器表达式##########
    # #     print('(1)，三元表达式')
    # #     def sy():
    # #     ##########(1)，三元表达式##########
    # #     # 就是中间有个判断语句，为True 结果放在前面 ，为fales 结果放在后面面
    # #         name="qyl"
    # #         res='qyl' if name=="qyl" else 'qjq'
    # #         print(res)
    # #     sy()
    # #     print('(2)，列表解析')
    # #     def lbjx():
    # #     ##########(2)，列表解析##########
    # #     # 就是把列表的for循环简化,缺点就是占内存
    # #     #     li=[]
    # #     #     for i in range(10):
    # #     #         if i>=5:
    # #     #             li.append('鸡蛋%s'%i)
    # #     #     print(li)
    # #         # 简化成列表解析
    # #         li=['鸡蛋%s'%i for i in range(10) if i>=5]
    # #         print(li)
    # #     lbjx()
    # #     print('(3)，生成器表达式')
    # #     def lbjx():
    # #     ##########(3)，生成器表达式##########
    # #     # 就是把列表解析[]变成（）好处就是变量变成迭代器不占内存
    # #         li = ('鸡蛋%s' % i for i in range(10) if i >= 5)
    # #         for i in li:
    # #             print(i)
    # #     lbjx()
    # # test2()

3，计算总人口

# def pople_rk():
    #     with open("人口.txt",'r',encoding="utf8",newline='') as f:
    #         for p in f:
    #             yield p
    # pp=pople_rk()
    # all1=sum(eval(i)["人口"] for i in pp)
    # print(all1)

四，生产者和消费者

1， send用法

# def  test1():
#     # #1， send(1)用法:1给yield 赋值给res
#     # #######1， send用法#########
#     #     def scz():
#     #         print('开始生产包子.....')
#     #         res=yield 'jg1的值'
#     #         print("send的传过来的值"%res)
#     #         print('又开始生产包子.....')
#     #         res1 = yield '又做了一笼包子'
#     #         print(res1)
#     #     scz()
#     #     jg=scz()#jg是一个生成器
#     #     jg1=jg.__next__()#jg1是一个返回值
#     #     print(jg1)
#     #     jg2=jg.send("吃了一笼包子")
#     #     print(jg2)
#     # test1()

2， 生产者和消费者

# def  test2():
#     # #######2， 生产者和消费者#########
#     # #2， 生产者和消费者就是实现并发效果
#     #     import time
#     #     # 消费者
#     #     def a(name):
#     #         print("开始执行A")
#     #         while 1:
#     #             time.sleep(1)
#     #             res=yield "执行%s"%name
#     #             print(res)
#     #     #生产者
#     #     def b():
#     #         a1=a(a)
#     #         a1.__next__()
#     #         for i in range(10):
#     #             time.sleep(1)
#     #             a1.send("执行a1[第%s次]"%i)
#     #     b()
#     # test2()