迭代器
可迭代对象:
list,str,tuple…—>for … in …遍历—> 遍历(迭代)
迭代器协议:对象必须提供一个next方法,执行该方法要么返回迭代中的下一项,要么引起StopIteration异常,以终止迭代(只能往下走,不可以回退)
现在,我们就可以说,实现了迭代器协议的对象就是可迭代对象。
实现:
- 通过在对象内部定义一个
__iter__
方法
li=[1,2,3]
sr='abcd'
li_iter=iter(li)
sr_iter=sr.__iter__()
print(li_iter.__next__())
print(li_iter.__next__())
print(next(li_iter))
print(sr_iter.__next__())
print(sr_iter.__next__())
print(next(sr_iter))
print(next(sr_iter))
测试是否可迭代
for i in 10:
print(i)
#报错
from collections import Iterable
print(isinstance([],Iterable))
print(isinstance('',Iterable))
print(isinstance({},Iterable))
print(isinstance(set(),Iterable))
print(isinstance(1,Iterable))
print(isinstance(True,Iterable))
----------
True
True
True
True
False
False
自定义一个类,其可以容纳数据,测试该类的可迭代性
from collections import Iterable
class Myclass:
def __init__(self):
self.names=[]
def add(self,name):
self.names.append(name)
myclass=Myclass()
myclass.add(2)
myclass.add('sleep')
myclass.add({'nemu1':'fish'})
print(isinstance(myclass,Iterable))
print(isinstance(myclass.names,Iterable))
for i in myclass:
print(i,end=' ')
----------
False
True
TypeError: 'Myclass' object is not iterable
对Myclass类内最后增加一个
def __iter__(self):
return self.names.__iter__()
#接着再运行
print(isinstance(myclass,Iterable))
print(isinstance(myclass.names,Iterable))
for i in myclass:
print(i,end=' ')
--------
True
True
2 sleep {'nemu1': 'fish'}
回顾之前说的__iter__
方法,其可以为我们提供一个迭代器
在迭代一个可迭代对象的时候,实际上就是获取该对象提供的一个迭代器。然后通过该迭代器依次获取对象的每一个数据
for…in…循环的本质
就是通过iter()函数获取可迭代对象地Iterable的迭代器,然后对获取到的迭代器不断调用next()方法来获取下一个值并将其赋值,当遇到StopIteration的异常后,退出。
应用场景
迭代器的核心就是通过next()函数调用返回下一个数据值。如果每次返回的数据值不是在一个已有的数据集合中读取的,而是通过程序按照一定规律计算生成。那么也就意味着可以不用依赖一个已有的数据集合,namely,无需将所有的迭代对象数据一次性全部缓存下来。这样就可以节省大量的存储空间。
demo:
斐波那契数列
现在我们希望通过for…in…的方式来遍历斐波那契数列的前n个数。
通过迭代来实现,每次迭代都可以通过数学计算来生成下一个数
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:
self.num1, self.num2 = self.num2, self.num1 + self.num2
num = self.num1
self.current_index+=1
return num
else:
raise StopIteration
def __iter__(self):
return self
fib=FibIterator(10)
for num in fib:
print(num,end=' ')
生成器
生成器是利用迭代器,我们可以在每次迭代获取数据时(通过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))
gen=(x**2 for x in range(6)) #如果没有这个重新赋值,没有输出
print("通过for遍历") #for...in..本质就是next()
for i in gen:
print(i,end=' ')
----------------
[0, 1, 4, 9, 16, 25]
<generator object <genexpr> at 0x0000022DE6553E08>
通过next()函数取得下一个值
0
1
4
9
16
25
0 1 4 9 16 25
生成器函数
在函数中如果出现了yield关键字,那么该函数就不再是一个普通函数而是一个生成器函数
def foo():
yield 1
yield 2
yield 3
f=foo()
print(next(f),end=' ')#程序会停留在对应yield后的语句
print(next(f),end=' ')
print(next(f),end=' ')
---
1 2 3
next和yield进行匹配,如果函数中有return,return后的yield也不会再执行,因此报错
def foo():
yield 1
return
yield 2 #在IDE中很明显看到这里就报错了.
用来输出奇数,函数:
def odd():
n=1
while 1:
yield n
n+=2
o=odd()
for i in range(5):
print(next(o))
生成器:
class Odd:
def __init__(self):
self.num=-1
def __next__(self):
self.num+=2
return self.num
def __iter__(self):
return self
o=Odd()
for i in range(5):
print(next(o))
close()
- 手动关闭生成器函数,后面调用会直接引起StopIteration异常
def gen():
yield 1
yield 2
yield 3
yield 4
g=gen()
print(next(g))
print(next(g))
g.close() #这行存在就返回StopIteration,而注释这行,下面能正常运行。
print(next(g))
send()
- 传送一个值赋给生成器里的值,让生成器继续执行到下一个yield。
- 如果生成器未启动,则必须在使用send()前启动生成器,启动方法可以是gen.next(),也可以是gen.send(None)执行到第一个yield处,之后就可以使用send(para)不断的传入值
- 如果已启动,则send(para)的作用就是给receive赋值为发送的值(para),然后让生成器执行到下一个yield.
def gen():
value=0
while 1:
receive =yield value
if receive =="e":
break
value="got:%s"%receive
g=gen()
print(g.send(None))
print(g.send("aaa"))
print(g.send("e88"))
print(g.send("e"))
闭包
什么是闭包
闭是封闭(函数中的函数),包是包含(该内部函数对外部函数作用域而非全局作用域变量的引用)
闭包:
- 内部函数对外部函数作用域里的变量的引用
- 函数内的函数,都是有生命周期,都是在函数执行期间
- 比包内的闭包函数私有化了变量,完成了数据的封装,类似面向对象
demo:
def foo():
print("in foo()")
def bar():
print("in bar")
#1.直接运行
bar() #报错
#2.考虑先运行外部函数,再运行内部函数
foo()
bar() #依然报错
由于作用域的问题,函数内的属性,都是有生命周期的,只有在函数执行期间才存活,
现在我们为了让foo()内的bar()存活,就是调用bar(),我们该则么做?
在foo函数中返回bar函数
def foo():
print("in foo()")
def bar():
print("in bar()")
return bar
vas = foo()
vas()#程序再执行时,foo()函数返回内部定义的bar()函数
----
in foo()
in bar()
已经能返回函数,那么里面的变量呢?
def foo():
a=66
print("in foo()")
def bar(num):
print("in bar()")
print(a+num)
return bar
vas = foo()
vas(22)
print(a)
---
in foo()
in bar()
88
NameError: name 'a' is not defined
同样遵循上面的原则
装饰器
装饰器存在的意义:
- 不影响原有函数的功能
- 可以添加新功能
一般常见的,比如拿到第三方的API接口,第三方不允许修改这个接口。这个时候,装饰器就派上用处
装饰器本身也是一个
函数,作用是为现有存在的函数,在不改变函数的基础上,增加一些功能进行装饰。
它是以闭包的形式去实现的。
在使用装饰器函数时,在被装饰的函数的前一行,使用@装饰器函数名
来进行装饰。
demo:
现在在一个项目中,有很多函数,由于我们的项目越来越大,功能越来越多,就会导致程序运行越来越慢。其中一个函数的功能,是实现一百万的累加。
def my_cout():
s=0
for i in range(1000001):
s+=i
print("sum:",s)
想知道他的运行时间,按原先的做法是这样:
import time
start=time.time()
my_cout()
end=time.time()
print("执行时间为:",(end-start))
虽然成功的实现了时间的计算。但是,假如有成千上万个函数,每个函数写一遍,非常麻烦,代码冗余。运用我们以前所学的函数封装这个过程来实现这个功能。
import time
def count_time(func):
start = time.time()
func()
end = time.time()
print("执行时间为:", (end - start))
count_time(测量的函数)
经过修改后,比之前好一点点,只是要在使用时,需要将对应的函数传入到时间计算函数中。但是仍然影响原来的使用,使用装饰器来装饰它
import time
def count_time(func):
start = time.time()
func()
end = time.time()
print("执行时间为:", (end - start))
@count_time
def my_count():
s = 0
for i in range(1000001):
s += i
print("sum:", s)
my_count()
这样实现的好处,定义闭包函数后,只需通过@装饰器函数名
形式的装饰器语法,就可以将@装饰器函数名
加到要装饰的函数上。
在执行@装饰器函数名
时,就是讲原函数传递到闭包中。然后,原函数的引用指向闭包返回的装饰过的内部函数的引用