Python迭代器、生成器和装饰器

迭代器

可迭代对象：

list, str, tuple etc. ----> for … in … 遍历 ----> 遍历（迭代）

迭代器协议：

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

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

如何实现？

• 通过在对象内部定义一个__iter__方法。

sr = 'abcd'
li = [1,2,3]
sr_iter = sr.__iter__()
li_iter = li.__iter__()
print(next(li_iter))
print(li_iter.__next__())#----> next(li_iter)
print(li_iter.__next__())
print(sr_iter.__next__())

for i in 100:
    print(i) #报错,不是可迭代对象

可迭代对象测试

使用instance() 来判断一个对象是否可迭代

from _collections_abc import Iterable

print(isinstance([],Iterable))    #T
print(isinstance(str(),Iterable)) #T
print(isinstance({},Iterable))    #T
print(isinstance(set(),Iterable)) #T
print(isinstance(True,Iterable))  #T

自定义一个类，其可以容纳数据，测试该类的可迭代性

from _collections_abc import Iterable
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('Jack')
my_class.add('Lucy')
print('是否为可迭代对象:',isinstance(my_class,Iterable))
#判断是否为可迭代对象，若是则输出该可迭代对象的名字
for tmp in my_class:
    print(tmp,end=' ')

是否为可迭代对象: True
Tom Jack Lucy

回顾之前说的__iter__方法，其可以为我们提供一个迭代器。

在迭代一个可迭代对象的时候，实际上就是获取该对象提供的一个迭代器。然后通过该迭代器获取对象的每一个数据。

from _collections_abc import Iterable
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('Jack')
my_class.add('Lucy')
print('是否为可迭代对象:',isinstance(my_class,Iterable))
#通过迭代器迭代
print(my_class)

my_class_iter = iter(my_class)
print(my_class_iter)

print(next(my_class_iter))
print(next(my_class_iter))
print(next(my_class_iter))

是否为可迭代对象: True
<main.Myclass object at 0x00AF9050>
<list_iterator object at 0x00AFEB10>
Tom
Jack
Lucy

for item in 可迭代对象 循环的本质

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

class test:
    def __init__(self,data= 1):
        self.data =data

    def __iter__(self):
        return self
    def __next__(self):
        if self.data>5:
            raise StopIteration
        else:
            self.data += 1
            return self.data
for i in test(2):
    print(i,end= ' ')

应用场景

迭代器的核心就是通过next()函数调用返回下一个数据值。如果每次返回的数值不是在一个已有的数据集合中读取的，而是通过程序按照一定规律计算生成。那么也就意味着可以不用依赖一个已有的数据集合，namely，无需将所有的迭代对象数据一次性缓存下来供后续使用。这样，可以节省大量的储存（内存）空间。

demo:

斐波那契数列

class FibIterator(object):
    """斐波那契数列"""
    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 = FibIterator(10)
for num in fib:
    print(num,end = ' ')

现在我们希望通过 for… in …的方式来遍历斐波那契数列中的前n个数。

通过迭代来实现，每次迭代都可以通过数学计算生成下一个数。

生成器

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

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

创建一个生成器

列表[] ----> ()

li = [x**2 for x in range(6)]
print(li)
gen = (x**2 for x in range(6))
print(gen)
print('通过next()函数取得下一个值')
print(next(gen))
print(next(gen))
print(next(gen))
print(next(gen))
print(next(gen))
print(next(gen))

print('通过for遍历')
gen = (x**2 for x in range(6))
for i in gen:
    print(i,end=' ')

[0, 1, 4, 9, 16, 25]
<generator object at 0x00F45F70>
通过next()函数取得下一个值
0
1
4
9
16
25
通过for遍历
0 1 4 9 16 25

生成器函数

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

def foo():
    yield 1
    yield 2
    # return
    yield 3
f = foo()
print(next(f))#程序会停留在对应yield后的语句
print(next(f))
print(next(f))#当程序遇到return,return后的语句不会再执行。因此报错

next和yield进行匹配，如果遇到return，return后的语句不会再执行，直接抛出StopIteration，终止迭代。

如果return后有返回值，那么这个值就是异常的说明，而不是函数的返回值。

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

def odd():
    n = 1
    while True:
        yield n
        n+=2
o = odd()
count = 0
print(o)
for i in o:
    if count>5:
        break
    print(i)
    count += 1
    #13在这里
print(next(o))

<generator object odd at 0x01D65F70>
1
3
5
7
9
11
15

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

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()
  • 手动关闭生成器函数，后面调用会直接引起StopIteration异常。

def gen():
    yield 1
    yield 2
    yield 3
    yield 4
g = gen()
print(next(g))
print(next(g))
g.close()
print(next(g)) #回溯

• send()

  • x = yield y

• 如果生成器未启动，则必须在使用send()前启动生成器，而启动的方法可以是gen.next()，也可以是gen.send(None)执行到第一个yield处。之后就可以使用send(para)

  • 如果是已启动，则send(para)的作用就是给x赋值为发送的值（send的参数），然后让生成器执行到下一个yield。

def gen():
    value = 0
    while True:
        receive = yield value
        if receive == 'e':
            break
        value = 'get: %s'%receive

g = gen()
print(g.send(None))
print(g.send('aa'))
print(g.send(123))
print(g.send('e'))

Traceback (most recent call last):
File “C:/Python_study/day11/day11.py”, line 176, in
print(g.send(‘e’))
StopIteration

0
get: aa
get: 123

• throw()
  • 手动抛出异常。

def gen():
    i = 0
    while i <5:
        yield i
        i += 1
obj = gen()
print(next(obj))
print(next(obj))
print(obj.throw(Exception,'Method throw called'))

闭包

什么是闭包？

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

闭包：

• 内部函数对外部函数作用域的变量的引用。、
• 函数内的属性，都是有生命周期，都是在函数执行期间
• 闭包类的闭包函数私有化的变量，完成了数据的封装，类似面向对象

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

由于作用域的问题，函数内的属性都是有生命周期的，只有在函数执行短的期间再考虑这段代码，只是调用foo()是，内部的print()及bar()才能存活。

现在我们为了让foo()内的bar()存活，就是调用bar()，我们该怎么做？

把bar()函数返回给函数

def foo():
    print('in foo')
    def bar():
        print('in bar')
    return bar
var = foo()
var()

前面说，内部函数对外部函数作用域变量的引用，---->如果是变量呢？

def foo():
    a = 666
    print('in foo')
    def bar(num):
        print('in bar')
        print(a + num)
    return bar
var = foo()
var(22)

in foo
in bar
688

li = [1,2,3,4,5]
def foo(obj):
    print('foo:', obj)
    
    def bar():
        obj[0] += 1
        print('bar:', obj)
    return bar

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

#程序再执行时，foo()函数返回给了内部定义的bar()
foo(li)
foo(li)
var = foo(li) #将返回值赋值给var

foo: [1, 2, 3, 4, 5]
bar: [2, 2, 3, 4, 5]
bar: [3, 2, 3, 4, 5]

foo: [1, 2, 3, 4, 5]
foo: [1, 2, 3, 4, 5]
foo: [1, 2, 3, 4, 5]

装饰器

首先，看一个demo：

@func1
def func():
    print('aaa')

装饰器存在的意义

• 不影响原有函数的功能
• 添加新功能

一般常见的，比如拿到第三方的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()

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(s):
        print('Start')
        func(s)
        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))
#Start
#6

万能装饰器

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

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

通过可变参数（*args,**kwargs）来接收不同参数

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,'aa')

@setFunc
def demo(a,b,*c,**d):
    print((a,b))
    print(c)
    print(d)
demo('city','college',1998,1 ,1,school = 'zhejiang')

Wrapper context.
Tom 18 aa

Wrapper context.
(‘city’, ‘college’)
(1998, 1, 1)
{‘school’: ‘zhejiang’}

函数被多个装饰器所装饰

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

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

#装饰器1
def setFunc1(func):
    def wrapper1(*args,**kwargs):
        print('wrapper context 1 start.'.center(40,'-'))
        func(*args,**kwargs)
        print('Wrapper Context 1 end.'.center(40,'-'))
    return wrapper1
#装饰器2
def setFunc2(func):
    def wrapper2(*args,**kwargs):
        print('wrapper context 2 start.'.center(40,'-'))
        func(*args,**kwargs)
        print('Wrapper Context 2 end.'.center(40,'-'))
    return wrapper2
@setFunc1                #---->F
@setFunc2                #---->g
def show(*args,**kwargs):#---->f
    print('Show Run.'.center(40,'-'))

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

总结：

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

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

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

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

5.Python中，装饰器就是用闭包来实现的。

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

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

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

9.万能装饰器，通过可变参数(*args,**kwargs)来实现。

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

11.一个函数也可以被多个装饰器所装饰。

12.通过类实现装饰器，重写__init__和__call__函数。

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