装饰器、迭代器和生成器

1、python-------装饰器

一、简单的装饰器

1.为什么要使用装饰器呢？

　　装饰器的功能：在不修改原函数及其调用方式的情况下对原函数功能进行扩展

　　装饰器的本质：就是一个闭包函数

那么我们先来看一个简单的装饰器：实现计算每个函数的执行时间的功能

 1 import time 
 2 def  wrapper(func):
 3         def inner():
 4               start=time.time()
 5               func()
 6               end=time.time()
 7               print(end-start)
 8         return inner 
 9     
10 def  hahaha():
11         time.sleep(1)
12         print('aaaaa')
13 hahaha=wrapper(hahaha)
14 hahaha() 

上面的功能有点不简介，不完美，下面就引进了语法糖。

 1 import time
 2 def wrapper(func):
 3         def inner():
 4                start=time.time()
 5                func()
 6                end=time.time()
 7                print(end-start)
 8         return inner
 9 @wrapper
10 def  kkk():#相当于kkk=wrapper(kkk)
11     print('aaaaa')
12 kkk()

以上的装饰器都是不带参数的函数，现在装饰一个带参数的该怎么办呢?

 1 import time
 2 def timer(func):
 3     def inner(*args,**kwargs):
 4         start = time.time()
 5         re = func(*args,**kwargs)
 6         end=time.time()
 7         print(end- start)
 8         return re
 9     return inner
10 
11 @timer   #==> func1 = timer(func1)
12 def func1(a,b):
13     print('in func1')
14     print(a,b)
15 
16 @timer   #==> func1 = timer(func1)
17 def func2(a):
18     print('in func2 and get a:%s'%(a))
19     return 'fun2 over'
20 
21 func1(1,2)
22 print(func2('aaaaaa'))

1 import time
 2 def timer(func):
 3     def inner(*args,**kwargs):
 4         start = time.time()
 5         re = func(*args,**kwargs)
 6         end=time.time()
 7         print(end - start)
 8         return re
 9     return inner
10 
11 @timer   #==> func1 = timer(func1)
12 def jjj(a):
13     print('in jjj and get a:%s'%(a))
14     return 'fun2 over'
15 
16 jjj('aaaaaa')
17 print(jjj('aaaaaa'))

二、开放封闭原则

1.对扩展是开放的

2.对修改是封闭的

 三、装饰器的固定结构

1 import time
 2 def wrapper(func):  # 装饰器
 3     def inner(*args, **kwargs):
 4         '''函数执行之前的内容扩展'''
 5         ret = func(*args, **kwargs)
 6          '''函数执行之前的内容扩展'''
 7         return ret
 8     return inner
 9 
10 @wrapper  # =====>aaa=timmer(aaa)
11 def aaa():
12     time.sleep(1)
13     print('fdfgdg')
14 aaa()

 四、带参数的装饰器

带参数的装饰器：就是给装饰器传参

　　　　　　　　用处：就是当加了很多装饰器的时候，现在忽然又不想加装饰器了，想把装饰器给去掉了，但是那么多的代码，一个一个的去闲的麻烦，那么，我们可以利用带参数的装饰器去装饰它，这就他就像一个开关一样，要的时候就调用了，不用的时候就去掉了。给装饰器里面传个参数，那么那个语法糖也要带个括号。在语法糖的括号内传参。在这里，我们可以用三层嵌套，弄一个标识为去标识。如下面的代码示例

 1 # 带参数的装饰器：（相当于开关）为了给装饰器传参
 2 # F=True#为True时就把装饰器给加上了
 3 F=False#为False时就把装饰器给去掉了
 4 def outer(flag):
 5     def wrapper(func):
 6         def inner(*args,**kwargs):
 7             if flag:
 8                 print('before')
 9                 ret=func(*args,**kwargs)
10                 print('after')
11             else:
12                 ret = func(*args, **kwargs)
13             return ret
14         return inner
15     return wrapper
16 
17 @outer(F)#@wrapper
18 def hahaha():
19     print('hahaha')
20 
21 @outer(F)
22 def shuangwaiwai():
23     print('shuangwaiwai')
24 
25 hahaha()
26 shuangwaiwai()

 五、多个装饰器装饰一个函数

 1 def qqqxing(fun):
 2     def inner(*args,**kwargs):
 3         print('in qqxing: before')
 4         ret = fun(*args,**kwargs)
 5         print('in qqxing: after')
 6         return ret
 7     return inner
 8 
 9 def pipixia(fun):
10     def inner(*args,**kwargs):
11         print('in qqxing: before')
12         ret = fun(*args,**kwargs)
13         print('in qqxing: after')
14         return ret
15     return inner
16 @qqqxing
17 @pipixia
18 def dapangxie():
19     print('饿了吗')
20 dapangxie()
21 
22 '''
23 @qqqxing和@pipixia的执行顺序：先执行qqqxing里面的 print('in qqxing: before')，然后跳到了pipixia里面的
24         print('in qqxing: before')
25         ret = fun(*args,**kwargs)
26         print('in qqxing: after')，完了又回到了qqqxing里面的 print('in qqxing: after')。所以就如下面的运行结果截图一样
27 '''

 上例代码的运行结果截图

六、统计多少个函数被装饰了的小应用

1  统计多少个函数被我装饰了
 2 l=[]
 3 def wrapper(fun):
 4     l.append(fun)#统计当前程序中有多少个函数被装饰了
 5     def inner(*args,**kwargs):
 6         # l.append(fun)#统计本次程序执行有多少个带装饰器的函数被调用了
 7         ret = fun(*args,**kwargs)
 8         return ret
 9     return inner
10 
11 @wrapper
12 def f1():
13     print('in f1')
14 
15 @wrapper
16 def f2():
17     print('in f2')
18 
19 @wrapper
20 def f3():
21     print('in f3')
22 print(l)

2、python----------迭代器和生成器

一、可迭代协议：可以被迭代要满足要求的就叫做可迭代协议。内部实现了__iter__方法

　　iterable：可迭代的------对应的标志

　　什么叫迭代？：一个一个取值，就像for循环一样取值

       字符串，列表，元组，集合，字典都是可迭代的

二、迭代器协议：内部实现了__iter__，__next__方法

　　迭代器大部分都是在python的内部去使用的，我们直接拿来用就行了

　　迭代器的优点：如果用了迭代器，节约内存，方便操作

 　　dir([1,2].__iter__())是列表迭代器中实现的所有的方法，而dir([1,2])是列表中实现的所有方法，都是以列表的方式返回给我们，为了方便看清楚，我们把他们转换成集合，然后取差集，然而，我们看到列表迭代器中多出了三个方法，那么这三个方法都分别是干什么的呢？

1 print(dir([1,2].__iter__()))#查看列表迭代器的所有方法
2 print(dir([1,2]))#查看列表的所有方法
3 print(set(dir([1,2].__iter__()))-set(dir([1,2])))

 1 iter_l=[1,2,3,4,5,6].__iter__()
 2 
 3 print(iter_l.__length_hint__())#获取迭代器中元素的长度
 4 # print(iter_l.__setstate__(4))#根据索引指定从哪里开始迭代
 5 
 6 print(iter_l.__next__())
 7 print(iter_l.__next__())
 8 print(iter_l.__next__())#一个一个的取值
 9 print(next(iter_l))
10 #next(iter_l)这个方法和iter_l.__next__()方法一样，推荐用next(iter_l)这个

 1 l=[1,2,3,4,5]
 2 a=l.__iter__()
 3 
 4 # print(next(a))
 5 # print(next(a))
 6 # print(next(a))
 7 # print(next(a))
 8 # print(next(a))
 9 # print(next(a))   #上面的列表长度只有5个，而你多打印了，就会报错。处理的情况如下，就不会报错了
10 
11 while True:
12     try:
13         item=a.__next__()
14         print(item)
15     except StopIteration: # 异常处理
16         break

三、可迭代和迭代器的相同点：都可以用for循环

四、可迭代和迭代器的不同点：就是迭代器内部多实现了一个__next__方法

五、判断迭代器和可迭代的方法：

　　第一种：判断内部是不是实现了__next__方法

　　　　　　 1 '__iter__' in dir(str)#如果__iter__在这个方法里面，就是可迭代的。 

　　第二种：

　　　　Iterable 判断是不是可迭代对象

　　　　Iterator 判断是不是迭代器

　　　　用法：

1 from collections import Iterable  
2 from collections import Iterator
3 
4 #比如给一个字符串
5 s='abc'
6 print(isinstance(s,Iterable))#isinstance判断类型的
7 print(isinstance(s,Iterator))

判断range函数和map函数

1 map1=map(abs,[1,-2,3,-4])
2 print(isinstance(map1,Iterable))
3 print(isinstance(map1,Iterator))#map方法自带迭代器
4 
5 s=range(100)#是一个可迭代的，但是不是迭代器
6 print(isinstance(s,Iterable))
7 print(isinstance(s,Iterator))

五、生成器函数：常规定义函数，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果。生成器的好处，就是一下子不会在内存中生成太多的数据

python中提供的生成器：1.生成器函数    2.生成器表达式

生成器的本质：就是一个迭代器

1 def  func(): #这是一个简单的函数
 2         a=1
 3         return a
 4 print(func())
 5 
 6 
 7 def func():
 8     print('aaaaaaaaaaa')
 9     a = 1
10     yield a  # 返回第一个值
11     print('bbbbbb')
12     yield 12  # 返回第二个值
13 
14 
15 ret = func()  # 得拿到一个生成器
16 # print(ret)#返回的是一个地址
17 print(next(ret))#取第一个值
18 print(next(ret))# 取第二个值
19 print(next(ret))# 取第三个值，会报错，因为没有yield第三个值

假如我想让工厂给学生做校服，生产2000000件衣服，我和工厂一说，工厂应该是先答应下来，然后再去生产，我可以一件一件的要，也可以根据学生一批一批的找工厂拿。
而不能是一说要生产2000000件衣服，工厂就先去做生产2000000件衣服，等回来做好了，学生都毕业了。。。

1 def make_cloth():
2     for i in range(1,20000):
3         yield '第%s件衣服'%(i)
4 ret = make_cloth()
5 print(next(ret))
6 print(next(ret))
7 print(next(ret))
8 for i in range(100):
9     print(next(ret))

1 必须先用next再用send
 2 def average():
 3     total=0 #总数
 4     day=0 #天数
 5     average=0 #平均数
 6     while True:
 7         day_num = yield average   #average=0
 8         total += day_num
 9         day += 1
10         average = total/day
11 avg=average() #直接返回生成器
12 next(avg)#激活生成器，avg.send(),什么都不传的时候send和next的效果一样
13 print(avg.send(10))
14 print(avg.send(20))#send   1.传值 2.next
15 print(avg.send(30))

 1 让装饰器去激活
 2 def wrapper(func):
 3     def inner(*args,**kwargs):
 4        ret = func(*args,**kwargs)
 5        next(ret)
 6        return ret
 7     return inner
 8 
 9 @wrapper
10 def average():
11     total=0 #总数
12     day=0 #天数
13     average=0 #平均数
14     while True:
15         day_num = yield average   #average=0
16         total += day_num
17         day += 1
18         average = total/day
19 
20 
21 ret=average() #直接返回生成器
22 print(ret.send(10))
23 print(ret.send(20))#send   1.传一个值过去 2.让当前yield继续执行
24 print(ret.send(30))

1 import time
 2 
 3 
 4 def tail(filename):
 5     f = open(filename)
 6     f.seek(0, 2) #从文件末尾算起
 7     while True:
 8         line = f.readline()  # 读取文件中新的文本行
 9         if not line:
10             time.sleep(0.1)
11             continue
12         yield line
13 
14 tail_g = tail('tmp')
15 for line in tail_g:
16     print(line)

六、yield  from

 1 def func():
 2     # for i in 'AB':
 3     #     yield i
 4     yield from 'AB'     yield from 'AB'就相当于上面的for循环，吧循环简化了
 5     yield from [1,2,3]
 6 
 7 g=func()
 8 print(list(g))
 9 # print(next(g))
10 # print(next(g))

七、列表推导式：

1 举例一
 2 y=2
 3 #for i in range(100):
 4  #   print(i*y)
 5 
 6 
 7 #列表推导式是for循环的简写
 8 l=[i*y for i in range(100)]
 9 
10 举例二
11 l=[{'name':'v1','age':'22'},{'name':'v2'}]
12 # for dic in l:
13 #     print(dic['name'])
14 name_list=[dic['name'] for dic in l]
15 print(name_list)

# ======一层循环======
l = [i*i for i in range(1,10)]
print(l)
# 上面的列表推倒式就相当于下面的
l  = []
for i in range(1,10):
    l.append(i*i)
print(l)
l = []


# ======多层循环========
# 1.列表推倒式
l = [i*j for i in range(1,10) for j in range(1,10)]
print(l)
# 2.循环
l = []
for i in range(1,10):
    for j in range(1,10):
        s = i*j
        l.append(s)
print(l)

八、生成器表达式：类似于列表推倒式，就是把列表推导式的【】改为了（）

1 l=[{'name':'v1','age':'22'},{'name':'v2'}]
2 
3 name_list=(dic['name'] for dic in l)#吧列表生成器的[]改成()
4 print(name_list)#取出的是一个生成器，而不是要取得值，所以得加上next
5 print(next(name_list))
6 print(next(name_list))
7 # print(next(name_list))