再学python3(四)：python-装饰器、迭代器、生成器

一、装饰器  详见这里

1.1 什么是装饰器？

装饰器本质上就是一个python函数，他可以让其他函数在不需要做任何代码变动的前提下，增加额外的功能，装饰器的返回值也是一个函数对象。

装饰器的应用场景：比如插入日志，性能测试，事务处理，缓存等等场景。

1.2 装饰器的形成过程。

现在我有一个需求，我想让你测试这个函数的执行时间，在不改变这个函数代码的情况下

import time

def func1():
    print('in func1')

def timer(func):
    def inner():
        start = time.time()
        func()
        print(time.time() - start)
    return inner

func1 = timer(func1)
func1()

但是如果有多个函数，我都想让你测试他们的执行时间，你每次是不是都得func1 = timer(func1)?这样还是有点麻烦，因为这些函数的函数名可能是不相同，有func1，func2,graph,等等，所以更简单的方法，python给你提供了，那就是语法糖。

import time
def timer(func):
    def inner():
        start = time.time()
        func()
        print(time.time() - start)
    return inner

@timer   #==> func1 = timer(func1)
def func1():
    print('in func1')


func1()

 刚刚我们讨论的装饰器都是装饰不带参数的函数，现在要装饰一个带参数的函数怎么办呢？

 装饰器---带参数的装饰器

import time
def timer(func):
    def inner(*args,**kwargs):
        start = time.time()
        re = func(*args,**kwargs)
        print(time.time() - start)
        return re
    return inner

@timer   #==> func1 = timer(func1)
def func1(a,b):
    print('in func1')

@timer   #==> func2 = timer(func2)
def func2(a):
    print('in func2 and get a:%s'%(a))
    return 'fun2 over'

func1('aaaaaa','bbbbbb')
print(func2('aaaaaa'))

上面的装饰器已经非常完美了，但是有我们正常情况下查看函数信息的方法在此处都会失效：

def index():
    '''这是一个主页信息'''
    print('from index')

print(index.__doc__)    #查看函数注释的方法
print(index.__name__)   #查看函数名的方法

如何解决呢？

from functools import wraps

def deco(func):
    @wraps(func) #加在最内层函数正上方
    def wrapper(*args,**kwargs):
        return func(*args,**kwargs)
    return wrapper

@deco
def index():
    '''哈哈哈哈'''
    print('from index')

print(index.__doc__)
print(index.__name__)

1.3 开放封闭原则。

1.对扩展是开放的

　　　　为什么要对扩展开放呢？

　　　　我们说，任何一个程序，不可能在设计之初就已经想好了所有的功能并且未来不做任何更新和修改。所以我们必须允许代码扩展、添加新功能。

　　2.对修改是封闭的

　　　　为什么要对修改封闭呢？

　　　　就像我们刚刚提到的，因为我们写的一个函数，很有可能已经交付给其他人使用了，如果这个时候我们对其进行了修改，很有可能影响其他已经在使用该函数的用户。

装饰器完美的遵循了这个开放封闭原则。

1.4 装饰器的主要功能和固定结构。

def timer(func):
    def inner(*args,**kwargs):
        '''执行函数之前要做的'''
        re = func(*args,**kwargs)
        '''执行函数之后要做的'''
        return re
    return inner

from functools import wraps

def deco(func):
    @wraps(func) #加在最内层函数正上方
    def wrapper(*args,**kwargs):
        return func(*args,**kwargs)
    return wrapper

1.5 带参数的装饰器。

假如你有成千上万个函数使用了一个装饰器，现在你想把这些装饰器都取消掉，你要怎么做？

一个一个的取消掉？ 没日没夜忙活3天。。。

过两天你领导想通了，再让你加上。。。

def outer(flag):
    def timer(func):
        def inner(*args,**kwargs):
            if flag:
                print('''执行函数之前要做的''')
            re = func(*args,**kwargs)
            if flag:
                print('''执行函数之后要做的''')
            return re
        return inner
    return timer

@outer(False)
def func():
    print(111)

func()

1.6 多个装饰器装饰一个函数。

def wrapper1(func):
    def inner():
        print('wrapper1 ,before func')
        func()
        print('wrapper1 ,after func')
    return inner

def wrapper2(func):
    def inner():
        print('wrapper2 ,before func')
        func()
        print('wrapper2 ,after func')
    return inner

@wrapper2
@wrapper1
def f():
    print('in f')

f()

二、迭代器

# 迭代器
'''
可被for循环的数据类型
list
dic
str
set
tuple
f = open()
range
enumerate 枚举


'''

# 可用dir()函数打印出数据类型的可用函数
print(dir({})) # ['__class__', '__contains__',  …… , 'clear', 'copy', 'fromkeys', 'update', 'values']

# 双下划线方法
print([1].__add__([2]))
print([1]+[2])


'''
迭代器：
Iterable 可迭代的  ---> __iter__ 只要含有__iter__方法都是可迭代的
[].__iter__()迭代器 --> __next__ 可从迭代器中一个一个的取值

可迭代协议：只要含有__iter__方法都是可迭代的
迭代器协议：内部含有__iter__和 __next__的方法就是迭代器
可for循环的都是可迭代的
可迭代的.__iter__()方法就可以得到一个迭代器

迭代器的好处
1. 可以一个一个取值
2.节省内存空间
'''

三、生成器

# 生成器函数

'''
1.含有yield的函数就是生成器函数
2.yield不能与return共存
3.yield只能用在函数中
'''

# def generator():
#     print('1')
#     yield 'aaaaa'
#     print('2')
#     yield 'bbbb'


# g = generator()
#g()  # 输出为错误 与return 不同，yield是返回的一个迭代器，不能直接调用


#g.__next__()   # 输出为1
#g.__next__()   # 输出为2

# print(g.__next__())   # 输出为1
# print(g.__next__())   # 输出为2

# 可用for循环
# for i in g:
#      print(i)


# 文件监听输入   如果输入的一行字符串中包含hhh  着输出此行内容
def tail(filename):
    f = open(filename, encoding='utf-8')
    while True:
        line = f.readline()
        if line.strip():  # 去回车
            yield line.strip()

g = tail('1.txt')
for i in g:
    if 'hhh' in i:
        print('11111', i)

生成器例题等

# 列表推导式和生成器表达式
'''
区别
1.有无括号
2.返回值不一样
3.生成器表达式几乎不占内存
'''
# list1 = ['hhh%s'%i for i in range(10)]  # 列表推导式  ['hhh0', 'hhh1',…, 'hhh9']
# print(list1)
#
# g = ('hhh%s' % i for i in range(10))
# for i in g:
#     print(i)  # 生成器表达式  hhh0 … hhh9


# 推导式进阶
'''
[每个元素或元素的相关操作 for 元素 in 可迭代数据类型]    遍历处理
[每个元素或元素的相关操作 for 元素 in 可迭代数据类型 if 元素相关条件 ]    遍历处理
 '''

# list2 = [i for i in range(31) if i % 3 == 0]
# print('31以内可被3整除的数%s' % list2)  # 31以内可被3整除的数[0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30]


#生成器只能取一次，再取就为空

# 例1
def fun1():
    for i in range(4):
        yield i

g = fun1()
g1 = (i for i in g)
g2 = (i for i in g1)

'''
#case1
print(list(g1))  # [0, 1, 2, 3]
print(list(g2))  #g1已经取过了，g2要再从g1取 所以为  []
'''

'''
#case2
print(list(g1))  # [0, 1, 2, 3]
print(list(g1))  #g1已经取过了所以为 []
print(list(g2))  # []
'''

'''
#case3
print(list(g))  # [0, 1, 2, 3]
print(list(g1))  #g 已经取过了，g1要再从g取 所以为 []
print(list(g2))  # []
'''

# 例2

def fun1(n,i):
    return n+i

def fun2():
    for i in range(4):
        yield i

g = fun2()
for n in [1, 10]:
    g = (fun1(n, i) for i in g)

print(list(g))  # [20, 21, 22, 23]

'''
for n in [1, 10]:
    g = (fun1(n, i) for i in g)
可替换为
n = 1
 g = (fun1(n, i) for i in g) 但是此时g不执行

n = 10
g = (fun1(n, i) for i in g)

当list(g)时，会执行
n = 10
g = (fun1(n, i) for i in g) 寻找g
从
n = 1
g = (fun1(n, i) for i in g)取g
此时g从生成器取(0 1 2 3)
则
n = 10
g = (fun1(n, i) for i in g) 可化为
g = (fun1(n, i) for i in (fun1(n, i) for i in g)) 化为
g = (fun1(n, i) for i in (fun1(n, i) for i in (0 1 2 3)))
即：
g = (fun1(10, i) for i in (fun1(10, i) for i in (0 1 2 3)))
即：[20, 21, 22, 23]

意思就是当list的时候才从下到上寻找g  执行上面的代码，不list的时候 不做操作
'''