详解python中的生成器、迭代器、闭包、装饰器

2023-08-16 18:30:04 64

迭代是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

1|1可迭代对象

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

一类是集合数据类型，如list、tuple、dict、set、str等；
一类是generator，包括生成器和带yield的generatorfunction。

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

1|2判断是否可以迭代

可以使用isinstance()判断一个对象是否是Iterable对象：

fromcollectionsimportIterable
isinstance([],Iterable)
#True
isinstance({},Iterable)
#True
isinstance(123,Iterable)
#False
isinstance((xforxinrange(10)),Iterable)
#True

1|3什么是迭代器

可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

可以使用isinstance()判断一个对象是否是Iterator对象：

fromcollectionsimportIterator
isinstance([],Iterator)
False
isinstance({},Iterator)
False
isinstance((xforxinrange(10)),Iterator)#
True

生成器都是迭代器。

1|4iter()函数

虽然list、tuple、dict、set、str等是可迭代对象，但他们不是迭代器。可以通过iter()函数把可迭代对象编程迭代器。

isinstance(iter([]),Iterator)
#True
isinstance(iter({}),Iterator)
#True
isinstance(iter("asdf"),Iterator)
#True

1|5总结：

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

2|0生成器

2|1什么是生成器

我们可以通过列表生成式来创建一个列表，但是收到内存的限制，列表的容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

1|1修改列表推导式创建生成器的方法

最简单的方法是把列表生成式中的[]改成()就好了。

a=[xforxinrange(10)]
print(a)#[0,1,2,3,4,5,6,7,8,9]
b=(xforxinrange(10))
print(b)#at0x03387DB0>

如何遍历生成器

我们发现生成器不是能直接打印出来的，我们可以通过next()函数来获得生成器的下一个返回值。

生成器保存的是算法，每次调用next(G)，就计算出G的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的异常。

**使用next()或者__next__():**
print(next(b))
#0
print(next(b))
#1
print(next(b))
#2
print(next(b))
#3
print(next(b))
#4
print(next(b))
#5
print(b.__next__())
#6
print(b.__next__())
#7
print(b.__next__())
#8
print(b.__next__())
#9
print(b.__next__())
#Traceback(mostrecentcalllast):
#File"",line2,in
#StopIteration

那么有什么简单的方法呢？因为生成器是可迭代对象，也可以使用for循环来遍历它，并且不需要关心StopIteration异常。

b=(xforxinrange(10))
forxinb:
print(x)
#0
#1
#2
#3
#...

1|2函数中使用yield创建生成器的方法

如果如果生成器推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。把你要返回的值前面加yield即可。

使用函数实现上面代码：

deffn():
forxinrange(3):
yieldx
#遍历函数实现的生成器
f=fn()
print(next(f))
#0
print(next(f))
#1
print(next(f))
#2
print(next(f))
#Traceback(mostrecentcalllast):
#File"",line1,in
#StopIteration

使用生成器实现斐波拉契数列：

deffib(count):
n=0
a,b=0,1
whilen",line1,in
#StopIteration:done

yield执行流程

当执行next(f)时，函数开始执行到yield，yield右边的变量x作为next()的返回值被返回，此时函数保存当前的运行状态，并暂停执行。
再次调用next(f)时，函数从上次暂停的位置开始继续执行，再次遇到yield时重复上面的操作
直到生成器遍历结束

我们在循环过程中不断调用yield，就会不断中断。当然要给循环设置一个条件来退出循环，不然就会产生一个无限数列出来。同样的，把函数改成generator后，我们基本上从来不会用next()来获取下一个返回值，而是直接使用for循环来迭代：

forxinfib(5):
print(x)
#1
#1
#2
#3
#5

但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

f=fib(5)
whileTrue:
try:
print(next(f))
exceptStopIterationase:
print("生成器返回值:%s"%e.value)
break
#1
#1
#2
#3
#5
#生成器返回值:done

1|3send方法

defgen():
i=0
whilei<3:
temp=yieldi
print(temp)
i+=1
g=gen()
print(g.__next__())
#0
print(g.send(None))
#None
#1
print(next(g))
#None
#2
print(g.send("哈哈")
#哈哈
#Traceback(mostrecentcalllast):
#File"",line1,in
#StopIteration

上面代码可以看出next()、next()、send(None)是等价的并没有什么区别。

send()其实是比他们更高级的，在之前的代码中yieldi是没有返回值的即输出为None。
如果修改send()的形参，那么yieldi的返回值就是括号中的形参，在上面的代码中g.send("哈哈")相当于temp="哈哈"，并且g.send("哈哈")的返回值就是变量i。
使用send时要注意，第一次调用生成器对象时，send()不能传参数否则会报错，第一次必须是send(None)，或者第一次调
用next()、next()也可以。

3|0闭包

3|1什么是闭包

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

deftest(number):
deftest_in(number_in):
print("test_in函数的number_in=%s"%number_in)
returnnumber_in+number
#返回test_in函数的引用
returntest_in
ret=test(20)
print(ret(100))#相当于直接调用test_in函数，并给它传值100
#test_in函数的number_in=100
#120
print(ret(200))
#test_in函数的number_in=200
#220

3|2闭包的一个例子

在数学中，一次函数：y=kx+b，在一条确定的直线中，它的k、b是不变的。求y时，根据确定的k、b、x来求出。

defline_conf(k,b):
defline(x):
returnk*x+b
returnline

line1=line_conf(1,1)
line2=line_conf(4,5)
print(line1(5))
print(line2(5))
#6
#25

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

4|0装饰器
4|1什么是装饰器

装饰器就是对一个函数进行装饰，给这个函数增加额外的功能。

deflogging(func):
defwrap():
print("正在打印日志！")
func()
returnwrap

@logging#该装饰器为函数增加了打印日志的额外功能，并且之前函数内部代码不会改变。

deflogin():
print("张三正在登陆。")
login()
#正在打印日志！
#张三正在登陆。
4|2两个装饰器
defmakeBold(fn1):
defwrapped():
print("----1----")
return""+fn1()+""
returnwrapped

defmakeItalic(fn2):
defwrapped():
print("----2----")
return""+fn2()+""
returnwrapped

@makeBold
@makeItalic
deff1():
print("----3----")
return"helloworld"

ret=f1()#此时f1并不是f1函数，它是makeBold装饰器返回的wrapped函数的引用。
print(ret)
"""
输出结果：
----1----
----2----
----3----
helloworld
"""

调用流程：

把函数f1的引用传入装饰器makeItalic中的变量fn2，此时fn2指向f1函数。
把装饰器makeItalic中wrapped函数的引用传入装饰器makeBold的变量fn1，此时fn1指向装饰器makeItalic中的wrapped函数。
ret=f1()表是执行f1所指向的函数，并返回给ret。

4|3装饰器带参数

一般情况下装饰器内部函数的参数都是不定长参数，保证通用性，确保装饰任何函数时都不会出错。

deflogging(func):
defwrap(*args,**kwargs):
print("正在打印日志！")
func(*args,**kwargs)
returnwrap