迭代器；生成器；装饰器；闭包

迭代器

可迭代对象：list、str、tuple、—>for…in…遍历

迭代器协议

对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么引起StopIteration异常，以终止迭代（只能往下走，不可以回退）

现在我们就可以说，实现了迭代器协议的对象就是可迭代对象

如何实现：

​ -通过在对象内部定义一个__iter__方法

li=[1,2,3]
li_iter=li.__iter__()     #创建一个迭代器
print(li_iter.__next__())  #一个一个将元素取出，这样可以节省内存,但li_iter中的元素将会减少
print(li_iter.__next__())
print(li_iter.__next__())
print(li_iter.__next__())

输出：
1
2
3
StopIteration

可迭代对象测试

from collections import Iterable  #使用instance()来判断一个对象是否可迭代
print(isinstance([],Iterable))

输出：True

from collections import Iterable

class MyClass:
    def __init__(self):
        self.names=[]

    def add(self,name):
        self.names.append(name)
 
my_class=MyClass()
my_class.add('tom')
my_class.add('jim')
print('是否为可迭代对象:',isinstance(my_class,Iterable))

输出：是否为可迭代对象: False


使用__iter__方法，可以为我们提供一个迭代器。然后通过该迭代器依次获取对象的每一个数据
class MyClass:
    def __init__(self):
        self.names=[]
    
    def add(self,name):
        self.names.append(name)
        
    def __iter__(self):
        return self.names.__iter__()


my_class=MyClass()
my_class.add('tom')
my_class.add('jim')
print('是否为可迭代对象:',isinstance(my_class,Iterable))

输出：是否为可迭代对象:True

应用场景

迭代器的核心就是通过调用next（）函数返回下一个数据值。如果每次返回的数据值不是在一个已有的数据集合中读取的，而是通过程序按照一定规律计算生成的。那么就意味着可以不用依赖一个已有的数据集合，namely。

无需将所有的迭代对象数据一次性缓存下来供后续使用。这样，可以节省大量的存储（内存）空间。

demo：

斐波那契数列

通过for …in…的方式来遍历斐波那契数列中的前n个数，通过迭代来实现

class Fib:
    '斐波那契数列迭代器'

    def __init__(self,n):
        '记录生成的斐波那契数列的个数'
        self.n=n
        '记录当前记录的索引'
        self.current_index=0
        '记录两个初始值'
        self.num1=0
        self.num2=1

    def __next__(self):
        '调用next函数获取下一个数'
        if self.current_index<self.n:
            num=self.num1
            self.num1,self.num2=self.num2,self.num1+self.num2
            self.current_index+=1
            return num
        else:
            raise StopIteration

    def __iter__(self):
        return self

fib=Fib(10)
for i in fib:
    print(i，end=' ')
    
  输出： 0 1 1 2 3 5 8 13 21 34

for…in…循环本质

就是通过iter（）函数获取可迭代对象的iterable的迭代器，然后对获取到的迭代器不断调用next（）方法来获取下一个值并将其赋值item，当遇到StopIteration的异常后，退出。

iter() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 next() 方法并通过 StopIteration 异常标识迭代的完成。

next() 方法会返回下一个迭代器对象。

生成器

利用迭代器，我们可以在每次迭代获取数据时（通过next（）方法）按照特定的规律进行生成。但我们在实现一个迭代器时，关于当前迭代的状态需要我们自己记录，进而才能根据当前的状态生成下一次数据。为了达到记录当前状态，并配合next()函数进行迭代使用，可以采用更简便的语法。

即生成器（generator） ，生成器是一种特殊的迭代器，它比迭代器更优雅。

创建一个生成器

列表[]—>()

li=[x**2 for x in range(6)]
print(li)
gen=(x**2 for x in range(6))
for i in gen:
    print(i)

生成器函数

在函数中如果出现了yield关键字，那么该函数就不再是一个普通函数而是一个生成器函数

def foo():
    yield 'a'
    yield 'b'
    return Error
    yield 'c'
f=foo()
print(next(f))
print(next(f))
print(next(f))   #next和yield进行匹配。如果遇到return，return后的语句不再执行

输出：
a
b
StopIteration: Error

构造一个产生无穷奇数的生成器

通过类手动编写迭代器，实现类似效果

class OddIter:
    def __init__(self):
        self.start=1

    def __iter__(self):
        return self

    def __next__(self):
        self.start+=2
        return self.start

odd=OddIter()
for i in range(6):
    print(next(odd))

close()关闭生成器，若后面再调用，会报错

def gen():
    yield 1
    yield 2
    yield 3

g=gen()
print(next(g))
g.close()
print(next(g))  #回溯

def gen():
i=0
    while i<5:
        temp = yield i
        print(temp)
        i+=1
g=gen()
print(next(g))     #next与yield的值匹配
print(next(g))
print(g.send('bb'))  #'bb'直接赋值给temp

输出：
0
None
1
bb
2

https://blog.csdn.net/mieleizhi0522/article/details/82142856  #解释

**throw（）**手动抛出异常

闭包

闭是封闭（函数中的函数），包是包含（该内部函数对外部函数作用域而非全局作用域变量引起）

闭包：

​ -内部函数对外部函数作用域里的变量的引用

​ -函数内的属性，都是有生命周期，都是在函数执行期间

​ -闭包内的闭包函数私有化了变量，完成了数据的封装，类似面向对象

def foo():
    print('in foo()')

    def bar():
        print('in bar()')

由于作用域的问题，函数内的属性，都是有生命周期，只有在函数执行期间才能存活

若想在外部调用bar()

li = [1,2,3]

def foo(obj):
    print('foo:',obj)

    def bar():
        obj[0]+=1
        print('bar:',obj)
    return bar

foo(li)
var=foo(li)
var()

输出：
foo: [1, 2, 3]
foo: [1, 2, 3]
bar: [2, 2, 3]

装饰器

装饰器的意义：

​ -不影响原函数的功能

​ -可以添加新功能

-一般常见的，比如拿到第三方API接口，第三方不允许修改这个接口。这时候就用到装饰器

-装饰器也是一个函数，作用是为现有存在的函数，在不改变函数的基础上，增加一些功能进行装饰

-它是以闭包的形式是实现的

-在使用装饰器函数时，在被装饰的函数的前一行，使用 @装饰器函数名 形式进行装饰

Demo:

现在在一个项目中，有很多函数，由于我们的项目越来越多，功能也越来越多，就导致程序越来越慢。

其中有一个功能函数是实现一百万次的累加

import time
def my_count():
    s = 0
    for i in range(1000001):
        s += i
    print('sum:',s)
start = time.time()
my_count()
end = time.time()
print('执行时间：',(end - start))

成功的实现时间的计算。But，加入有成千上万个函数，每个函数这么写一遍非常麻烦。

import time
def my_count():
    s = 0
    for i in range(1000001):
        s += i
    print('sum:',s)
# start = time.time()
# my_count()
# end = time.time()
#将上述代码改写成一个函数
def count_time(func1):
    start = time.time()
    func1()
    end = time.time()
    print('执行时间：',(end - start))

count_time(my_count)

经过修改后，定义一个函数来实现时间计算功能。

初看上去，比之前好很多。只是我们在使用的时候，需要将我们对应的函数传入到时间计算函数中。

但任然影响了原来的使用。

接下来思考，能不能在不影响函数的原来的使用方式下实现时间计算？

import time


def count_time(func):
    def wrapper():
        start = time.time()
        func()
        end = time.time()
        print('执行时间：', (end - start))

    return wrapper



def my_count():
    s = 0
    for i in range(1000001):
        s += i
    print('sum:', s)


my_count = count_time(my_count)
my_count()

在使用时，让my_count函数重新指向count_time函数返回的函数引用。这样我们在使用my_count时，就和原来的使用方式一样了。

实现就是采用装饰器。

import time


def count_time(func):
    def wrapper():
        start = time.time()
        func()
        end = time.time()
        print('执行时间：', (end - start))

    return wrapper


@count_time
def my_count():
    s = 0
    for i in range(1000001):
        s += i
    print('sum:', s)

my_count()

这样实现的好处，定义闭包函数后，只需要通过@装饰器函数名形式的装饰器语法，就可以将@装饰器函数名加到要装饰的函数前即可。

这种不改变原有函数功能，对函数进行拓展的形式，就成为装饰器

在执行@装饰器函数名时，就是将原函数传递到闭包中。然后，原函数的引用指向闭包返回的装饰过的内部函数的引用。
装饰器的几种形式

1.无参数无返回值(被装饰的函数)

def setfunc(func):
    def wrapper():
        print('Start')
        func()
        print('end')

    return wrapper

@setfunc
def show():
    print('show')

show()

输出：
start
show
end

2.无参数有返回值

def setfunc(func):
    def wrapper():
        print('Start')
        return func()
        print('end')#遇到return，此句不再执行

    return wrapper

@setfunc
def show():
    return 'show'

print(show())
#Start
#show

3.有参数无返回值

def setfunc(func):
    def wrapper(a):
        print('Start')
        func(a)
        print('end')#遇到return，此句不再执行

    return wrapper

@setfunc #setfunc(show())
def show(s):
    print('Hello %s'%s)
show('city college')

4.有参数有返回值

def setfunc(func):
    def wrapper(x,y):
        print('Start')
        return func(x,y)
        # print('end')  # 遇到return，此句不再执行

    return wrapper


@setfunc  
def myAdd(x, y):
    return x + y
print(myAdd(3,3))

万能装饰器

根据被装饰函数的定义不同，分出了四种形式。

能不能实现一种适用于任何形式函数定义的装饰器

def setFunc(func):
    def wrapper(*args,**kwargs):
        print('wrapper context')
        return func(*args,**kwargs)

    return wrapper

@setFunc
def func(name,age,job='IT'):
    print(name,age,job)

func('tom',18)

@setFunc
def demo(a,b,*c,**d):
    print((a,b))
    print(c)
    print(d)

demo('city','college',1,2,3,school='zucc')
    
输出：
wrapper context
tom 18 IT
wrapper context
('city', 'college')
(1, 2, 3)
{'school': 'zucc'

函数被多个装饰器装饰

一个函数在使用时，通过一个装饰器来拓展，可能并不能达到预期

一个函数被多个装饰器装饰

def setFunc1(func):
    def wrapper1(*args,**kwargs):
        print('wrapper context 1 start')
        func(*args,**kwargs)
        print('wrapper context 1 end')

    return wrapper1


def setFunc2(func):
    def wrapper2(*args, **kwargs):
        print('wrapper context 2 start')
        func(*args, **kwargs)
        print('wrapper context 2 end')

    return wrapper2

@setFunc1                   #--->F
@setFunc2                   #--->g
def show(*args,**kwargs):   #--->f
    print('show run')

show()

输出：
wrapper context 1 start
wrapper context 2 start
show run
wrapper context 2 end
wrapper context 1 end

#从下往上装饰（从程序运行顺序来看）
#从内往外去装饰（函数的调用来看） F(g(f))

总结：

1.函数可以像普通变量一样，作为函数的参数或者返回值进行传递

2.函数的内部可以定义另外一个函数。目的：隐藏函数功能的实现

3.闭包实际上也是函数定义的一种形式

4.闭包定义的规则，在外部函数内定义一个内部函数，内部函数使用外部函数的变量，并返回内部函数的引用

5.python中装饰器就是用闭包实现的

6.装饰器的作用，在不改变现有函数的基础上，为函数增加功能

7.装饰器的使用，通过’@装饰器函数名’的形式给已有函数进行装饰，添加功能

8.装饰器的四种形式，根据参数的不同以及返回值的不同

9.万能装饰器，通过可变参数（*args和**kwargs）实现

10.一个装饰器可以为多个函数提供装饰功能

11.一个函数也可以被多个装饰器所装饰（作为了解）

12.通过类实现装饰器，重写_init_和_call_

13.类装饰器在装饰函数后，原来的引用不再是函数，而是装饰类的对象