python-生成器、装饰器

动态语言和静态语言：
__slots__
生成器
迭代器
闭包
装饰器

动态语言和静态语言：

动态语言可以在运行的过程中修改代码，例如python在运行的过程中给已创建好的类添加属性和方法。

静态语言在编译时已经确定好代码，在运行过程中不能修改代码

那么问题来了，如果我们不想在python的运行中，或者让别人在调用我们的模块时添加新的属性，我们就需要使用python定义的一个特殊变量：__slots__

slots

在定义一个类的时候使用这个变量，可以限制类的实例添加属性

class Person(object):
    __slots__ = ('name','age')
    
p = person()
p.name = 'laowang'
p.age = 20
p.heigt = 180
>> AttributeError: Person instance has no attribute 'score'

注意：

使用__slots__定义的属性仅针对当前类的实例起作用，对继承自该类的子类不起作用

生成器

首先思考一个问题，当某个函数隔一段时间需要去从一个列表中获取一个数据，那假设这个函数要不断获取1百万个数据时，需要先把这一百万个数据全都放在列表里吗？答案是否定的，这会非常浪费内存空间。所以生成器产生了，在python中，一边循环一边计算的机制成为生成器：generator，我是这样理解的：先定义一个按需求循环生产数据的对象，不需要一次全部生产出来，当每次另一边需要时，从这个对象里面取出一个值使用就好了，这样可以节省内存空间，同时也方便多个对象来使用它。

创建生成器的方法1

G = ( x*2 for x in range(5))
>>G
>><generator object <genexpr> at 0x7f626c132db0>
>>next(G)
>>0
>>next(G)
>>2

创建生成器的方法2

除了用简单的for方法，我们还可以用函数来实现生成器

def fib(times):
    n = 0
    a,b = 0,1
    while n<times:
        yield b
        a,b = b,a+b
        n+1
    retrue 'done'

F = fib(5)
next(F)
>>1
next(F)
>>1
next(F)
>>2

注意，这里使用了yield，相当于执行到yield之后，这个函数会进入阻塞状态。再次调用时，从yield下方开始，再到yield停止。当这个生成器的值被取完后，再次取值程序会报错，返回done。所以一定要注意生成器的剩余值情况。

生成器的send和next方法

def gen():
    i = 0
    while i<5:
        temp = yield i
        print(temp)
        i += 1

>> f = gen()
>> f.__next__()
>> 0
>> f.__next__()
>> None
>> 1
>> f.send('laowang')
>> laowang
>> 2

从上两块代码可见，__next__()方法跟next(f)实现了相同的效果。

前面提到过，yield后，程序会进入阻塞状态，另外赋值语句是先执行等号的右边，再执行等号的左边，所以send方法发送的参数会传递给temp，这就意味着处理数据的函数和生成器可以“沟通”下一步该怎么生产数据

迭代器

迭代是访问集合的一种方式，迭代器是一个可以记住遍历的位置的对象，迭代器对象从集合的第一个元素开始访问，知道所有元素都被访问完结束。

可迭代对象

以直接作用于 for 循环的数据类型有以下几种：

一类是集合数据类型，如 list 、 tuple 、 dict 、 set 、 str 等；

一类是 generator ，包括生成器和带 yield 的generator function。

这些可以直接作用于 for 循环的对象统称为可迭代对象： Iterable 。

生成器都是 Iterator 对象，但 list 、 dict 、 str 虽然是 Iterable ，却不是 Iterator 。

总结

凡是可作用于 for 循环的对象都是 Iterable 类型；
凡是可作用于 next() 函数的对象都是 Iterator 类型
集合数据类型如 list 、 dict 、 str 等是 Iterable 但不是 Iterator ，不过可以通过 iter() 函数获得一个 Iterator 对象。

闭包

首先举个例子

def test():
    print('233')

x = test
print(id(x))
print(id(test))
x()
>> 140212571149040
>> 140212571149040
>> 233

x实际上是引用了test函数的地址，并不是直接创建了一个新的函数或者使用了一个新的地址。

什么是闭包

在函数内部再定义一个函数，并且这个函数用到了外边函数的变量，那么将这个函数及用到的一些变量称之为闭包

def test(num_out):
    def test_in(num_in):
        print(num_in)
        return num_out + num_in
    return test_in  # 注意返回的是内部函数地址

ret = test(20)  # 20给num_out，因为都在一个函数内部，所以变量是可以使用的
print(ret(100)) # 100给num_in
>> 100
>> 120

这里需要注意ret = test(100)直接执行到return test_in 将内部函数的地址返回给ret，所以才能打印。

闭包再理解

def line_conf(a, b):
    def line(x):
        return a*x + b
    return line

line1 = line_conf(1, 1)
line2 = line_conf(4, 5)
print(line1(5))
print(line2(5))

在创建闭包的时候，我们通过line_conf的参数a,b说明了这两个变量的取值，这样，我们就确定了函数的最终形式(y = x + 1和y = 4x + 5)。我们只需要变换参数a,b，就可以获得不同的直线表达函数。由此，我们可以看到，闭包也具有提高代码可复用性的作用。

如果没有闭包，我们需要每次创建直线函数的时候同时说明a,b,x。这样，我们就需要更多的参数传递，也减少了代码的可移植性。

闭包可以帮我们把相同规律的事情总结一下，初始化部分交给一个函数，后续操作交给另一个函数，让事情变得层次分明，同时也更方便操作。

闭包思考

1.闭包似优化了变量，原来需要类对象完成的工作，闭包也可以完成
2.由于闭包引用了外部函数的局部变量，则外部函数的局部变量没有及时释放，消耗内存

装饰器

作为python3的新特性，装饰器可以提高开发效率，也是python面试中经常会问的问题。

首先对函数名要有这样的理解，名字只是代表了对一个空间的引用，它是可以改变的

def foo():
    print('ffffooo')
foo = lambda x:x+1
foo()
>>TypeError: <lambda>() missing 1 required positional argument: 'x'
肯定会报错，因为foo指向的引用地址改变了。

装饰器(decorator)功能

引入日志
函数执行时间统计
执行函数前预备处理
执行函数后清理功能
权限校验等场景
缓存

引入

假设某公司让一个开发部门开发了一些功能，让四个部门分别使用自己的功能，所以要在四个部门使用前验证一次身份，以保证安全性。

已实现的完整功能：
def f1():
    print('f1')
def f2():
    print('f2')
调用：
# A部门使用f1
# B部门使用f2
# 因为要验证，所以某开发人员又将函数写成了如下形式，
def check()
    验证身份
def f1():
    check() 
    print('f1')
def f2():
    check()
    print('f2')
# 然后再让A部门调用f1，B部门调用f2

虽然也完成了想要的功能，但违反了开放封闭原则，即已实现的功能代码块不允许被修改，但可以扩展（修改复杂业务逻辑的代码容易出现bug，但可以在参数传入前加工一下或数据处理后再进行修正）

开放：对扩展开发
封闭：已实现的功能代码块

所以需要结合闭包将代码改成如下形式

def w1(func):
    def inner():
        print('check')
        func()
    print("i am inner", id(inner))
    return inner

@w1
def f1():
    print('i am f1', id(f1))
    print('f1')
f1()

>>
i am inner 2814185593032
check
i am f1 2814185593032
f1

此时，我们再不修改f1的情况下完成了验证，那代码的执行逻辑是怎么的呢？

最关键的一点是@w1 > f1 = w1(f1)

w1执行后会将f1的引用传递给func（以供inner调用它），然后打印inner函数的id，再将inner的引用返回给f1
f1():执行f1，则f1实际上的引用指向的是inner，所以会执行整个inner函数，而inner中又包含了f1的引用，这样就可以再f1功能执行前加入一些需要的操作，例如之前提到的验证身份

所以@w1就是所谓的装饰器，@函数名 是python中的一种语法糖

再谈装饰器

# 定义函数：完成包裹数据
def makeBold(fn2):
    def wrapped2():
        return "<b>" + fn2() + "</b>"
    return wrapped2

# 定义函数：完成包裹数据
def makeItalic(fn1):
    def wrapped1():
        return "<i>" + fn1() + "</i>"
    return wrapped1

@makeBold   
@makeItalic 
def test():
    return "hello world"

print(test())
>> <b><i>hello world</i></b>

@makeBold

@makeItalic

这里会先执行makeItalic，再执行makeBold，因为这个语法糖需要对函数操作，没有函数就让下面的先执行。

@makeItalic  # test = makeItalic(test) -> makeItalic-wrapped1, fn1 -> test(原始内存空间的引用)
@makeBold   # test(引用已改变) = makeBold(test) -> makeBold-wrapped2, fn2 -> makeItalic-wrapped1

装饰器举例

被装饰的函数有不定长参数
from time import ctime, sleep
def timefun(func):
    def wrappedfunc(*args, **kwargs):
        print("%s called at %s"%(func.__name__, ctime()))
        func(*args, **kwargs)
    return wrappedfunc

@timefun
def foo(a, b, c):
    print(a+b+c)

foo(3, 5, 7)
sleep(2)
foo(1, 4, 6)

被装饰的函数有return的处理
from time import ctime, sleep

def timefun(func):
    def wrappedfunc():
        print("%s called at %s"%(func.__name__, ctime()))
        func()
    return wrappedfunc

@timefun
def getInfo():
    return 'haha'
print(getInfo())
>> None
# getInfo被装饰后，因为return的'haha'是给的func()，而不是getInfo，因此getInfo是没有返回值的，所以打印的是None。
# 需要将func()修改成 return func()，才返回给getInfo，然后打印出'haha'

总结：为了装饰器更通用，一般可以有return

装饰器带参数,在原有装饰器的基础上，设置变量
from time import ctime, sleep

def timefun_arg(pre="hello"):
    print('tag1, '， pre)
    def timefun(func):
        def wrappedfunc():
            print("%s called at %s %s"%(func.__name__, ctime(), pre))
            return func()
        return wrappedfunc
    return timefun

@timefun_arg("itcast")
def foo():
    print("I am foo")

print('tag2')
sleep(2)
foo()
>>输出：
tag1, itcast
tag2
foo called at Sun Dec  9 21:43:36 2018 itcast
I am foo

可见，当装饰器带有参数后，它会先去执行装饰器函数，而以前没有带入参数时它会直接装饰下方定义的函数。这样的话我们就可以给装饰器添加一些变量或者常用量