python3大器--迭代器、生成器、装饰器

最新推荐文章于 2021-06-07 20:50:51 发布

林殊途

最新推荐文章于 2021-06-07 20:50:51 发布

阅读量286

点赞数 1

分类专栏： python 文章标签： python

本文链接：https://blog.csdn.net/qq_40890660/article/details/97618316

版权

python 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

python3大器–迭代器、生成器、装饰器

文章导读：写这篇博客的初衷就是想把知识内化的同时把自己浅薄的见解分享给初学者或者是对于这块知识模糊的朋友们。文章的不足自处，请望谅解！

迭代器

什么是迭代器：迭代器就是一个可以记住遍历的位置的对象。

这句话中就体现了两个重要的知识点：一个是对象，一个是可以记住遍历的位置。后续我们就围绕着这两点开始讲解什么是迭代器。

我们学习迭代器肯定要和可迭代对象进行类比学习：

可迭代对象我们应该都使用过：像range(20)，list，dict，tuple，str，set他们都是可迭代对象。

s = [1,2,3,4,5]
print (s.__repr__)
>>><method-wrapper '__repr__' of list object at 0x000001C6A6E66288>
for i in s:
	print (i)
输出结果：1 2 3 4 5
#这就是一个列表的可迭代对象的实例。在这里我们会发现一点，我们遍历列表s的时候，可以把它里面的内容全部输出打印出来（这也是可迭代对象和迭代器的区别）。

现在我们就创建一个迭代器：

lst = [1,2,3,4]
lst1 = iter(lst)  #创建迭代器
print(lst1.__repr__)
>>><method-wrapper '__repr__' of list_iterator object at 0x000001C6A71D7320>
print (next(lst1)) #输出迭代器的第一个元素
>>>1
print (next(lst1)) #输出迭代器的第二个元素
>>>2
print (lst1)
>>><list_iterator object at 0x000001C6A71D7320>
#在这个例子中我们发现打印s和lst1类型的时候s是一个list对象类型，lst1是一个list_iterator（列表_迭代器）对象。同时打印lst1的时候打印的是一个内存地址，这也是迭代器的一个形式。

在这个例子中，我门发现了两个方法：iter()和next()。其中iter()是用于创建一个迭代器，next()用于从迭代器中取出值。

我们发现next()取迭代器的值得时候每次只能取一个，那么我们怎么把迭代器中的值全部取出来呢？和取可迭代对像一样，使用for循环就可以：

lst=[1,2,3,4]
lst1 = iter(lst)    # 创建迭代器对象
for x in lst1:
    print (x)
>>>1 2 3 4

下面我们来分析一下迭代器的特点：

第一点也是很重要的一点就是迭代器具有惰性机制。
- 那么什么是惰性机制呢，我们结合上面的实例知道创建完迭代器之后，我们去取值可以使用next()方法，我们取第一次的时候返回的是1，取值第二次的时候返回的是2…于是我们是不是可以这样认为：迭代器就是一个容器，里面放的是我们想取得的数据，当我们去拿的时候，它不是一次全给我们，我们要一次它就可我们一个，要一次给一个。这就是迭代器的惰性机制。
迭代器是一次性的
- 我们知道一次性筷子、一次性所料袋。对，迭代器就是这样的，我们创建完迭代器之后，我们去取值，当我们把里面的东西全部拿完之后它就不可以使用了。
- ```
next(lst1)  #lst1里面的数据我们已经取完了
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration  #取完之后的迭代器再去取它的时候报的错误。
```

分析完迭器之后我们去对比一下迭代器和可迭代对象

迭代器的优缺点
1. 优点：节省内存、惰性机制
2. 缺点：使用不灵活、操作比较繁琐、不能查看元素
可迭代对象的优缺点
1. 优点：使用灵活、可以直接查看值
2. 缺点：消耗内存

我们知道知道了迭代器之后怎么是运用呢？

需求：像操作文件的时候，文件较大的时候，我们就去操作文件的句柄，否则还是使用可迭代对象。

注：迭代器就是一个可迭代对象，但是可迭代对象不一定是一个迭代器（具有iter()方法的就是可迭代对象，具有iter()和next()方法的就是迭代器）。

拓展：

for的本质就是一个迭代器。

a = "这是一个可迭代对象"
new_a = iter(a) #将可迭代对象转换成一个迭代器
while True: 
   try:  #监视程序 
      print (next(new_a))  #将迭代器的内容一个个的输出出来。
   except StopIteration:  #这句就是当迭代器取值完之后报的错误
      break

生成器

首先我们回顾一下什么是迭代器：

迭代器的本质就是python内置的节省空间的一种工具。

那么，什么是生成器？

生成器的本质就是一个迭代器，在python社区中，大多数人似乎都把迭代器和生成器当做同一个概念。

迭代器和生成器的异同

迭代器是python为我们提供的，而生成器是我们程序员自己写的。

写一个生成器函数

def foo():
	if 3 > 1:
		yield "我是第一次返回"
	if 3 > 2:
		yield "我是第二次返回"

s = foo()   #生成一个迭代器
# print (s.__next__())
# print (s.__next__())

for i in s:  #把生成器的元素全部打印出来
	print (i)
#yield是生成器的关键字，一个函数把return替换成yield就写了一个生成器。

yield和return的区别

return一般在函数中只设置一个，它的作用是终止函数，并且给函数的执行者返回值。

yield在生成器函数中可以设置多个，它并不会终止函数，next()会获取对应yield生成的元素。

实例展示

需求：A学校向楼下卖包子的老板订购了10000个包子.包子铺老板非常实在，一下就全部都做出来了

def eat():
    lst = []
    for i in range(1,10000):
        lst.append('包子'+str(i))
    return lst
e = eat()
print(e)

这样做没有问题，但是我们由于学生没有那么多，只吃了2000个左右，剩下的8000个，就只能占着一定的空间，放在一边了。如果包子铺老板效率够高，我吃一个包子，你做一个包子，那么这就不会占用太多空间存储了，完美。

def eat():
    for i in range(1,10000):
        yield '包子'+str(i)
e = eat()
for i in range(200):
    next(e)

这两者的区别:

第一种是直接把包子全部做出来，占用内存。

第二种是吃一个生产一个，非常的节省内存，而且还可以保留上次的位置。
def eat():
    for i in range(1,10000):
        yield '包子'+str(i)
e = eat()
for i in range(200):
    next(e)
for i in range(300):
    next(e)
# 多次next包子的号码是按照顺序记录的。

坑

例子1：
def foo1():
	for i in range(10):
		pass
	yield i
	count = 0
	while True:
		yield  count
		count += 1
		yield count
#这是一个坑，为什么会一直打印9，因为每次的foo1（）都是生一个迭代器。所以需要把迭代器赋值
print (foo1().__next__())  #打印9
print (foo1().__next__())  #打印9
print (foo1().__next__())  #打印9
#正确的取值
s = foo1()
for i in foo1():
 	print (i)
例子2：
def func():
    lst1 = ['卫龙', '老冰棍', '北冰洋', '牛羊配']
    lst2 = ['馒头', '花卷', '豆包', '大饼']
    yield from lst1
    yield from lst2
#第一眼看的时候，我们以为会先返回第一个列表的第一个元素，再但会第二个列表的第一个元素。但是这是错误的思想。
g = func()
for i in g:
    print(i)
#正确的答案应该是：先把第一个列表的元素全部打印出来，然后再把第二个列表的元素打印出来。

注：在函数的内部yield能将for循环和while循环进行临时暂停。

装饰器

什么是装饰器？

打一个比方，我写了一个python插件，提供给用户使用，但是在使用的时候，我不希望用户改变调用的方式，该怎么办，这个时候就使用装饰器解决。

下面我用几个实例带入装饰器的讲解

import time
#装饰器
#装饰器带入一
def times(f):
	def inner():
		start_time = time.time()
		f()
		print (time.time() - start_time)
	return inner
def foo():
	time.sleep(1)
	print ("我是装饰器。")
foo = times(foo)
#执行流程：把foo函数的名称当作参数传给times函数中，现在times函数初始化inner函数，并
#返回inner函数的地址，并把它当作变量赋值给foo。
foo()
#现在的foo就是inner，foo()就是执行inner里面的代码，现在执行到f()就是foo()函数。

#装饰器带入二
def wrapper(f):
	def inner():
		print (f())
	return inner
def func():
	print("这是一个func函数。")
func = wrapper(func)
#简述：wrapper函数执行并接收func函数名作为参数，并返回inner函数名给func变量。
func()
#func()实际执行的是inner()，但是inner()函数里面调用了func()函数。
#总结：首先调用增加功能的函数，并给他传入需要增加功能的函数，返回的是一个嵌套的函数名，
# 进一步调用返回的函数，就是触发调用需要增加功能的函数。

真正的装饰器

def wrapper(f):
	def inner(*args,**kwargs):
		#被装饰前
		start_time  = time.time()
		f(*args,**kwargs)
		print (time.time() - start_time)
		#被装饰后
	return inner
@wrapper  #这行代码就等价于func = wrapper(func)
def func(*args,**kwargs):
	print (f"这是{args}函数。")
	time.sleep(2)
@wrapper  #这行代码就等价于foo = wrapper(foo)
def foo(*args,**kwargs):
	print (f"这是{args}函数。")
	time.sleep(3)
func("func","func")
foo("foo","foo")
#分析：@wrapper()就叫做语法糖。语法糖必须凡在被装饰函数的正上方。

实例应用装饰器

#需求分析：现在我们模拟博客园，当我们没有登陆想去评论或者点击收藏等操作时，都自动的
#跳转到登陆的界面，当登陆成功之后就自动的跳转到刚才来登陆之前的界面。 ）
login_dic = {
	"username":None,
	"flag":False
}
#这个就是我们增加功能的函数，就相当于一个桥梁函数，就是以它为媒介做的跳转
def auth(f):
	def inner(*args,**kwargs):
		if login_dic["flag"]:
			return f()
		else:
			return login()
	return inner

def login():
	print("这是一个登录页面")
	user = input("username:")
	pwd = input("password:")
	if user == "pl" and pwd == "123":
		login_dic["flag"] = True
		login_dic["username"] = user
		return "登录成功!"
@auth
def comment():
	print(f"这是{login_dic['username']}评论")
@auth
def index():
	print(f"这是{login_dic['username']}主页")
	return "主页没有内容。"
#我们首先看看有没有登陆，没有登陆就跳转登陆
while not login_dic["flag"]:
	if comment() == "登录成功!":
		comment()

带参数的装饰器

实质：实现就是在装饰器的基础上再套一层函数
@auth(参数) 这个语法糖拆开等价于。

wrapper = auth(choose) #今天加入的外层函数。

func = wrapper(func) #回到了昨天的装饰器。

带参数的装饰器实例带入

#需求：现在我们需要做登录验证，但是我们有几种登录的方式：分别是qq、微信、抖音。默认不输入选择自动进入邮箱输入验证。现在我们就去实现。
dic_login = {          #1
	"flag":False,
	"username":""
}
def auth(argv):  #2
	def wrapper(f): #5
		def inner(*args,**kwargs): #7
			if dic_login["flag"]: #11
				f(*args,**kwargs) #12
			else: #11
				if argv == "QQ": #12
					print ("欢迎进入qq登录界面：")
					while True:
						username = input("username:")
						password = input("password:")
						if username == "pl" and password
                        == "123":
							f(*args,**kwargs)
							break
						else:
							print ("输入的用户名或密码错误。")
				elif argv == "微信":
					pass
				elif argv == "抖音":
					pass
				else:
					pass
		return inner #8
	return wrapper #6
print("--------登录方式列表---------")
print(format("QQ","^20"))
print(format("微信","^20"))
print(format("抖音","^20"))
print("----------------------------")
login_way = input("请输入你的登录方式：").upper() #3
@auth(login_way)#4
def func(*args,**kwargs): #9
	print ("我只是一个被调用的函数。")
#语法糖拆开
# wrapper = auth(login_way)  #添加的最外层的函数和参数
# func = wrapper(func)   #内层函数，就是昨天学的语法糖的拆开
func() #10

多个装饰器装饰一个函数

先执行离被装饰的函数最近的语法糖
进入装饰器从上网下走，走到最后一个装饰器执行被装饰函数；然后返回执行语法并从下往上执行语法糖。

多个装饰器装饰一个函数谁带入

def wrapper1(func):
	def inner1(*args,**kwargs):
		print ("这是第一个装饰器开始。")
		func(*args,**kwargs)
		print ("这是第一个装饰器结束")
	return inner1

def wrapper2(func):
	def inner2(*args,**kwargs):
		print ("这是第二个装饰器开始。")
		func(*args,**kwargs)
		print ("这是第二个装饰器结束")
	return inner2

@wrapper1
@wrapper2
def func(*args,**kwargs):
	print ("我只是一个函数啊。")
#两个装饰器的拆开
# func = wrapper2(func) #func=inner2
# func = wrapper1(func) #func=wrapper1(inner2)
func()
#>>>这是第一个装饰器开始。
#>>>这是第二个装饰器开始。
#>>>我只是一个函数啊。
#>>>这是第二个装饰器结束
#>>>这是第一个装饰器结束

作者寄语：希望本博文对您有用！欢迎大家指正错误！

林殊途

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
python3大器--迭代器、生成器、装饰器

python3大器–迭代器、生成器、装饰器文章导读：写这篇博客的初衷就是想把知识内化的同时把自己浅薄的见解分享给初学者或者是对于这块知识模糊的朋友们。文章的不足自处，请望谅解！迭代器什么是迭代器：迭代器就是一个可以记住遍历的位置的对象。这句话中就体现了两个重要的知识点：一个是对象，一个是可以记住遍历的位置。后续我们就围绕着这两点开始讲解什么是迭代器。我们学习迭代器肯定要和可迭代对象进行...
复制链接

扫一扫