Day15

1.1 迭代器
　　1、什么是迭代器
　　 迭代器指的是迭代取值的工具，迭代是一个重复的过程，每次重复
　　 都是基于上一次的结果而继续的，单纯的重复并不是迭代

　　2、为何要有迭代器
　　 迭代器是用来迭代取值的工具，而涉及到把多个值循环取出来的类型
　　 有：列表、字符串、元组、字典、集合、打开文件

　　 l=['egon','liu','alex']
　　 i=0
　　 while i < len(l):
　　 print(l[i])
　　 i+=1

　　 上述迭代取值的方式只适用于有索引的数据类型：列表、字符串、元组
　　 为了解决基于索引迭代器取值的局限性
　　 python必须提供一种能够不依赖于索引的取值方式，这就是迭代器
　　3、如何用迭代器
　　# 1、可迭代的对象：但凡内置有__iter__方法的都称之为可迭代的对象
　　# s1=''
　　# # s1.__iter__()
　　#
　　# l=[]
　　# # l.__iter__()
　　#
　　# t=(1,)
　　# # t.__iter__()
　　#
　　# d={'a':1}
　　# # d.__iter__()
　　#
　　# set1={1,2,3}
　　# # set1.__iter__()
　　#
　　# with open('a.txt',mode='w') as f:
　　# # f.__iter__()
　　# pass

　　# 2、调用可迭代对象下的__iter__方法会将其转换成迭代器对象
　　d={'a':1,'b':2,'c':3}
　　d_iterator=d.__iter__()
　　# print(d_iterator)

　　# print(d_iterator.__next__())
　　# print(d_iterator.__next__())
　　# print(d_iterator.__next__())
　　# print(d_iterator.__next__()) # 抛出异常StopIteration

　　# while True:
　　# try:
　　# print(d_iterator.__next__())
　　# except StopIteration:
　　# break
　　#
　　# print('====>>>>>>') # 在一个迭代器取值取干净的情况下，再对其取值娶不到
　　# d_iterator=d.__iter__()
　　# while True:
　　# try:
　　# print(d_iterator.__next__())
　　# except StopIteration:
　　# break

　　# l=[1,2,3,4,5]
　　# l_iterator=l.__iter__()
　　#
　　# while True:
　　# try:
　　# print(l_iterator.__next__())
　　# except StopIteration:
　　# break

　　# 3、可迭代对象与迭代器对象详解
　　# 3.1 可迭代对象（"可以转换成迭代器的对象"）：内置有__iter__方法对象
　　# 可迭代对象.__iter__(): 得到迭代器对象

　　# 3.2 迭代器对象：内置有__next__方法并且内置有__iter__方法的对象
　　# 迭代器对象.__next__（）：得到迭代器的下一个值
　　# 迭代器对象.__iter__（）：得到迭代器的本身，说白了调了跟没调一个样子
　　# dic={'a':1,'b':2,'c':3}
　　#
　　# dic_iterator=dic.__iter__()
　　# print(dic_iterator is dic_iterator.__iter__().__iter__().__iter__())
　　#

　　# 4、可迭代对象：字符串、列表、元组、字典、集合、文件对象
　　# 迭代器对象：文件对象
　　# s1=''
　　# s1.__iter__()
　　#
　　# l=[]
　　# l.__iter__()
　　#
　　# t=(1,)
　　# t.__iter__()
　　#
　　#
　　# d={'a':1}
　　# d.__iter__()
　　#
　　# set1={1,2,3}
　　# set1.__iter__()
　　#
　　#
　　# with open('a.txt',mode='w') as f:
　　# f.__iter__()
　　# f.__next__()

　　# 5、for循环的工作原理：for循环可以称之为叫迭代器循环
　　d={'a':1,'b':2,'c':3}

　　# 1、d.__iter__()得到一个迭代器对象
　　# 2、迭代器对象.__next__()拿到一个返回值，然后将该返回值赋值给k
　　# 3、循环往复步骤2，直到抛出StopIteration异常for循环会捕捉异常然后结束循环
　　# for k in d:
　　# print(k)

　　# with open('a.txt',mode='rt',encoding='utf-8') as f:
　　# for line in f: # f.__iter__()
　　# print(line)

　　# list('hello') #原理同for循环

　　# 6、迭代器优缺点总结
　　# 6.1 缺点：
　　# I、为序列和非序列类型提供了一种统一的迭代取值方式。
　　# II、惰性计算：迭代器对象表示的是一个数据流，可以只在需要时才去调用next来计算出一个值，就迭代器本身来说，同一时刻在内存中只有一个值，因而可以存放无限大的数据流，而对于其他容器类型，如列表，需要把所有的元素都存放于内存中，受内存大小的限制，可以存放的值的个数是有限的。

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

　　　　若函数体包含yield关键字，再调用函数，并不会执行函数体代码，得到的返回值即生成器对象

　　　
　　　　　　# 如何得到自定义的迭代器：
　　　　　　# 在函数内一旦存在yield关键字，调用函数并不会执行函数体代码
　　　　　　# 会返回一个生成器对象，生成器
　　　　　　def func():
　　　　　　 print('第一次')
　　　　　　 yield 1
　　　　　　 print('第二次')
　　　　　　 yield 2
　　　　　　 print('第三次')

　　　　　　　　g = func()
　　　　　　print(g) # generator
　　　　　　# 生成器就是迭代器
　　　　　　g.__iter__()
　　　　　　g.__next__()

　　　　　　# 会触发函数体代码的运行，然后遇到yield停下来，将yield后的值当作本次调用的结果返回
　　　　　　res1 = g.__next__()
　　　　　　print(res1)

　　　　　　# 应用案例
　　　　　　# 需求：造一个能够产生无穷个值的数据类型
　　　　　　def my_range(start, stop, step=1):
　　　　　　 # print('start...')
　　　　　　 while start < stop:
　　　　　　 start += step
　　　　　　 yield start
　　　　　　# print('end...')

　　　　　　for n in my_range(1, 7, 2):
　　　　　　 print(n)

　　　　　　# yield与return对比总结说明：
　　　　　　'''
　　　　　　函数调用函数体代码执行到yield时会返回yield后的值并将函数运行状态暂停在yield的位置
　　　　　　而return，当函数被调用时函数体代码运行到return时返回return后的值但是函数直接被结束掉了。
　　　　　　因此，return只能返回一次值，而yield可以返回多次值
1.0 叠加多个装饰器的加载，运行分析　
　　def deco1(func1): # func1 = wrapper2的内存地址
　　 def wrapper1(*args,**kwargs):
　　 print('正在运行===>deco1.wrapper1')
　　 res1=func1(*args,**kwargs)
　　 return res1
　　 return wrapper1

　　def deco2(func2): # func2 = wrapper3的内存地址
　　 def wrapper2(*args,**kwargs):
　　 print('正在运行===>deco2.wrapper2')
　　 res2=func2(*args,**kwargs)
　　 return res2
　　 return wrapper2

　　def deco3(x):
　　 def outter3(func3): # func3=被装饰对象index函数的内存地址
　　 def wrapper3(*args,**kwargs):
　　 print('正在运行===>deco3.outter3.wrapper3')
　　 res3=func3(*args,**kwargs)
　　 return res3
　　 return wrapper3
　　 return outter3

　　# 加载顺序自下而上(了解)
　　@deco1 # index=deco1(wrapper2的内存地址) ===> index=wrapper1的内存地址
　　@deco2 # index=deco2(wrapper3的内存地址) ===> index=wrapper2的内存地址
　　@deco3(111) # ===>@outter3===> index=outter3(index) ===> index=wrapper3的内存地址
　　def index(x,y):
　　 print('from index %s:%s' %(x,y))

　　# 执行顺序自上而下的，即wraper1-》wrapper2-》wrapper3
　　index(1,2) # wrapper1(1,2)
1.1 yield表达式应用　
　　def func(name):
　　 gcd_list = []
　　 with open('db.txt', 'at', encoding='utf-8') as f:
　　 print('%s开始读条！' % name)
　　 while True:
　　 # x拿到的是yield接收到的值
　　 gcd = yield gcd_list # x = '小笼包'
　　 print('%s使用了%s' % (name, gcd))
　　 gcd_list.append(gcd)
　　 if gcd is not None:
　　 f.write('%s ' % gcd)

　　g = func('残暴正义号')
　　res = g.send(None) # 必须要给一个初始的None值否则会报错
　　print('残暴正义号时间轴:', res)
　　res = g.send('蒸汽站轮')
　　print('残暴正义号时间轴::', res)
　　res = g.send('非最终审判')
　　print('残暴正义号时间轴:', res)
　　#g.close()
　　res = g.send('终审开庭') # 关闭之后无法传值
　　print('残暴正义号时间轴:', res)
　　print('残暴正义号狂暴了！')
1.2 三元表达式
　　# 语法格式： 条件成立时要返回的值 if 条件 else 条件不成立时要返回的值
　　def func():
# if 1 > 3:
# x=1
# else:
# x=3

x = 1 if 1 > 3 else 3
1.3 生成式
　　1.3.1 列表生成式　

　　l = ['alex_dsb', 'lxx_dsb', 'wxx_dsb', "xxq_dsb", 'egon']
　　# new_l=[]
　　# for name in l:
　　# if name.endswith('dsb'):
　　# new_l.append(name)

　　# new_l=[name for name in l if name.endswith('dsb')]
　　# new_l=[name for name in l]

　　# print(new_l)

　　# 把所有小写字母全变成大写
　　# new_l=[name.upper() for name in l]
　　# print(new_l)

　　# 把所有的名字去掉后缀_dsb
　　# new_l=[name.replace('_dsb','') for name in l]
　　# print(new_l)
　　1.3.2 字典生成式

　　# keys=['name','age','gender']
　　# dic={key:None for key in keys}
　　# print(dic)

　　# items=[('name','egon'),('age',18),('gender','male')]
　　# res={k:v for k,v in items if k != 'gender'}
　　# print(res)
　　1.3.3 集合生成式

　　# keys=['name','age','gender']
　　# set1={key for key in keys}
　　# print(set1,type(set1))
　　1.3.4 生成器表达式　

　　# g=(i for i in range(10) if i > 3)
　　# ！！！！！！！！！！！强调！！！！！！！！！！！！！！！
　　# 此刻g内部一个值也没有

　　# print(g,type(g))

　　# print(g)
　　# print(next(g))
　　。。。。。
　　
　　
　　with open('笔记.txt', mode='rt', encoding='utf-8') as f:
　　 # 方式一：
　　 # res=0
　　 # for line in f:
　　 # res+=len(line)
　　 # print(res)

　　 # 方式二：
　　 # res=sum([len(line) for line in f])
　　 # print(res)

　　 # 方式三 ：效率最高
　　 # res = sum((len(line) for line in f))
　　 # 上述可以简写为如下形式
　　 res = sum(len(line) for line in f)
　　 print(res)