👏作者简介：大家好，我是爱敲代码的小王，CSDN博客博主,Python小白
📕系列专栏：python入门到实战、Python爬虫开发、Python办公自动化、Python数据分析、Python前后端开发
📧如果文章知识点有错误的地方，请指正！和大家一起学习，一起进步👀
🔥如果感觉博主的文章还不错的话，请👍三连支持👍一下博主哦
🍂博主正在努力完成2023计划中：以梦为马，扬帆起航，2023追梦人
🔥🔥🔥 python入门到实战专栏：从入门到实战
🔥🔥🔥 Python爬虫开发专栏：从入门到实战
🔥🔥🔥 Python办公自动化专栏：从入门到实战
🔥🔥🔥 Python数据分析专栏：从入门到实战
🔥🔥🔥 Python前后端开发专栏：从入门到实战
目录
装饰器编辑
概念
多个装饰器
带参数的装饰器
内置装饰器
property装饰器
staticmethod装饰器
classmethod装饰器
类装饰器
缓存装饰器和计时装饰器综合练习
生成器
生成器定义
创建生成器的方式二(生成器函数)
迭代器
可迭代对象和迭代器区别
装饰器
概念
装饰器来自 Decorator 的直译。什么叫装饰，就是装点、提供一些额外的功能。在 python 中的装饰器则是提供了一些额外的功能。
装饰器本质上是一个Python函数（其实就是闭包），它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。
装饰器用于有以下场景，比如：插入日志、性能测试、事务处理、 缓存、权限校验等场景。
装饰器解决日志问题（分三个版本）
1、 v1.0版本解决
def fun1():
print("使用功能1")
print("日志记录")
def fun2():
print("使用功能2")
print("日志记录")2、 v2.0版本解决
def writeLog():
print("日志纪录")
def fun1():
print("使用功能1")
writeLog()
def fun2():
print("使用功能2")
writeLog() 3 、v3.0版本解决
def outfunc(func):
def infunc():
func()
print("日志纪录")
return infunc
def fun1():
print("使用功能1")
def fun2():
print("使用功能2")
fun1 = outfunc(fun1)
# 装饰器(闭包)
fun1()4、 v4.0版本解决，装饰器
def outfunc(func):
def infunc():
func()
print("日志纪录")
return infunc
@outfunc
def fun1():
print("使用功能1")
@outfunc
def fun2():
print("使用功能2")
fun1()
fun2()5、 修改变量名，见名知意
def mylog(func):
def infunc():
func()
print("日志纪录")
return infunc
@mylog
def fun1():
print("使用功能1")
@mylog
def fun2():
print("使用功能2")
fun1()
fun2()6 、增加参数处理，可以装饰任意多个参数的函数
def mylog(func):
def infunc(*args,**kwargs):
func(*args,**kwargs)
print("日志纪录")
return infunc
@mylog
def fun1():
print("使用功能1")
@mylog
def fun2(a,b):
print(f"使用功能2:{a},{b}")
fun1()
fun2(100,200)装饰器本质上是一个Python函数（其实就是闭包），它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返 回值也是一个函数对象。
装饰器用于有以下场景，比如：插入日志、性能测试、事务处理、 缓存、权限校验等场景。
多个装饰器
有时候，我们需要多个装饰器修饰一个函数。比如：需要增加日志功能、增加执行效率测试功能。 装饰器函数的执行顺序是分为（被装饰函数）定义阶段和（被装饰函数）执行阶段的，装饰器函数在被装饰函数定义好后立即执行
1、在函数定义阶段：执行顺序是从最靠近函数的装饰器开始，自内而外的执行
2、在函数执行阶段：执行顺序由外而内，一层层执行
【示例】多个装饰器执行顺序
@mylog
@cost_time
# 函数定义阶段：
# 相当于：
# fun2 = cost_time(fun2)
# fun2 = mylog(fun2)
# 也相当于：
# fun2 = mylog(cost_time(fun2))
# 定义阶段：先执行cost_time函数，再执行mylog函数
def fun2():
pass
#调用执行阶段
#先执行mylog的内部函数，再执行cost_time的内部函数
fun2()【示例】增加日志和执行计时功能的装饰器
import time
def mylog(func):
print("mylog start")
def infunc():
print("日志纪录 start")
func()
print("日志纪录 end")
print("mylog end")
return infunc
def cost_time(func):
print("cost time start")
def infunc():
print("开始计时..")
start = time.time()
func()
end = time.time()
print(f"耗费时间:{end-start}")
return end-start
print("cost time end")
return infunc
@mylog
@cost_time
# 相当于：
# fun2 = cost_time(fun2)
# fun2 = mylog(fun2)
# 也相当于：
# fun2 = mylog(cost_time(fun2))
def fun2():
print("使用功能2")
time.sleep(2)
print("使用功能22")
fun2()带参数的装饰器
【示例】带参数的装饰器
# coding=utf-8
# 带参数的装饰器的典型写法
def mylog(type):
def decorator(func):
def infunc(*args,**kwargs):
if type=="文件":
print("文件中：日志纪录")
else:
print("控制台：日志纪录")
return func(*args,**kwargs)
return infunc
return decorator
@mylog("文件")
def fun2(a,b):
print("使用功能2",a,b)
if __name__ == '__main__':
fun2(100,200)wraps装饰器
一个函数不止有他的执行语句，还有着 __name__ （函数名）， __doc__ （说明文档）等属性，我们之前的例子会导致这些属性改变。 functool.wraps 可以将原函数对象的指定属性赋值给包装函数对象，默认有module、name、doc，或者通过参数选择。
【示例】wraps装饰器案例
# coding=utf-8
from functools import wraps
def mylog(func):
@wraps(func)
def infunc(*args,**kwargs):
print("日志纪录...")
print("函数文档:",func.__doc__)
return func(*args,**kwargs)
return infunc
@mylog # fun2 = mylog(fun2)
def fun2():
"""强大的功能2"""
print("使用功能2")
if __name__ == '__main__':
fun2()
print("函数文档--->",fun2.__doc__)
"""
运算结果：
日志纪录...
函数文档: 强大的功能2
使用功能2
函数文档---> 强大的功能2
"""内置装饰器
我们在面向对象学习时，学习过三种装饰器： property 、 staticmethod 、 classmethod 。
property装饰器
property 装饰器用于类中的函数，使得我们可以像访问属性一样来获取一个函数的返回值。
【示例】prperty装饰器的使用
class User:
def __init__(self,name,month_salary):
self.name = name
self.month_salary = month_salary
@property
def year_salary(self):
return int(self.month_salary)*12
if __name__ == '__main__':
u1 = User("gaoqi","30000")
print(u1.year_salary)
staticmethod装饰器
staticmethod 装饰器同样是用于类中的方法，这表示这个方法将会是一个静态方法，意味着该方法可以直接被调用无需实例化，但同样意味着它没有 self 参数，也无法访问实例化后的对象。
【示例】staticmethod装饰器的使用
class Person:
@staticmethod
def say_hello():
print("hello world!")
if __name__ == '__main__':
Person.say_hello()
classmethod装饰器
classmethod 这个方法是一个类方法。该方法无需实例化，没有 self 参数。相对于 staticmethod 的区别在于它会接收一个指向类本身的 cls 参数。
【示例】classmethod装饰器
class Person:
@classmethod
def say_hello(cls):
print(f"我是{cls.__name__}")
print("hello world!")
if __name__ == '__main__':
Person.say_hello()类装饰器
上面写的装饰器都是函数来完成的。我们用类也可以实现装饰器。 类能实现装饰器的功能， 是由于当我们调用一个对象时，实际上调 用的是它的 __call__ 方法。
【示例】调用对象， __call__ 方法的使用
class Demo:
def __call__(self):
print('我是 Demo')
demo = Demo()
demo() # 直接调用对象，实质是调用了他的__call__()【示例】类装饰器的使用案例
class MyLogDecorator():
def __init__(self,func):
self.func = func
def __call__(self, *args, **kwargs):
print("日志纪录...")
return self.func(*args,**kwargs)
@MyLogDecorator
def fun2():
print("使用功能2")
if __name__ == '__main__':
fun2()缓存装饰器和计时装饰器综合练习
【示例】实现函数执行结果缓存和计时的装饰器功能
# coding=utf-8
import time
class CacheDecorator():
__cache={}
def __init__(self,func):
self.func = func
def __call__(self, *args, **kwargs):
# 如果缓存中有对应的方法名，则直接返回对应的返回值
if self.func.__name__ in CacheDecorator.__cache:
return CacheDecorator.__cache[self.func.__name__]
# 如果缓存中没有对应的方法名，则进行计算，并将结果缓存
else:
result = self.func(*args,**kwargs)
CacheDecorator.__cache[self.func.__name__] = result
return result
def cost_time(func):
def infunc(*args,**kwargs):
start = time.time()
result = func(*args,**kwargs)
end = time.time()
print(f"耗时:{end-start}")
return result
return infunc
@cost_time
@CacheDecorator
def func1_long_time():
"""模拟耗时较长，每次执行返回结果都一样的情况"""
print("start func1")
time.sleep(3)
print("end func1")
return 999
if __name__ == '__main__':
r1 = func1_long_time()
r2 = func1_long_time()
print(r1)
print(r2)
"""
运行结果：
start func1
end func1
耗时:3.0079846382141113
耗时:0.0
999
999
"""生成器
生成器定义
在Python中，一边循环一边计算的机制，称为生成器：generator
为什么要有生成器
列表所有数据都在内存中，如果有海量数据的话将会非常耗内存。
如：仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。
如果列表元素按照某种算法推算出来，那我们就可以在循环的过程中不断推算出后续的元素，这样就不必创建完整的list，从而节省大量的空间。
简单说：
1、时间换空间！想要得到庞大的数据，又想让它占用空间少，那就用生成器！
2、延迟计算！需要的时候，再计算出数据！
创建生成器的方式一(生成器表达式)
生成器表达式很简单，只要把一个列表推导式的 [] 改成 () ，就创建 了一个生成器(generator)：
L = [x * x for x in range(10)]
print(L)
g = (x * x for x in range(10))
print(g)
#<generator object <genexpr> at 0x1022ef630>创建 L 和 g 的区别仅在于最外层的 [] 和 () ， L 是一个list，而 g 是一个 generator。
创建生成器的方式二(生成器函数)
生成器函数：
如果一个函数中包含 yield 关键字，那么这个函数就不再是一个普通函数，调用函数就是创 建了一个生成器（generator）对象。 生成器函数：其实就是利用关键字 yield 一次性返回一个结果，阻塞，重新开始
生成器函数的工作原理
原理是这样的：
1、生成器函数返回一个迭代器，for循环对这个迭代器不断调用 __next__() 函数，不断运行到下一个 yield 语句，一次一次取得每一个返回值，直到没有 yield 语句为止，最终引发 StopIteration 异常。
2、yield 相当于 return 返回一个值，并且记住这个返回的位置，下次迭代时，代码从 yield 的下一条语句(不是下一行)开始执行。
3、send() 和 next() 一样，都能让生成器继续往下走一步（下次遇到 yield 停），但 send() 能传一个值，这个值作为 yield 表达式整体的结果
生成器推导式底层原理也是这样的。
【示例】测试生成器工作原理(yield)
#coding=utf-8
"""
1. 函数有了yield之后，调用它，就会生成一个生成器
2. yield作用：程序挂起，返回相应的值。下次从下一个语句开始执行。
3. return在生成器中代表生成器种植，直接报错：
StopIeratation
4. next方法作用：唤醒并继续执行
"""
def test():
print("start")
i=0
while i<3:
temp = yield i #下次迭代时，代码从`yield`的下一条语句(不是下一行)开始执行
print(f"temp:{temp}")
i += 1
print("end")
return "done"
if __name__ == '__main__':
a = test()
print(type(a))
print(a.__next__())
print(a.__next__())
print(a.__next__()) # next(a) 一样
print(a.__next__()) # 抛出异常：
StopIteration
"""
运行结果：
<class 'generator'>
start
0
temp:None
1
temp:None
2
temp:None
end
Traceback (most recent call last):
File
"C:\Users\webChubby\PycharmProjects\网络编程
\test.py", line 18, in <module>
print(a.__next__()) # 抛出异常：
StopIteration
StopIteration: done
"""【示例】测试生成器工作原理(send)
# send的作用是唤醒并继续执行，发送一个信息到生成器内部
def foo():
print("start")
i = 0
while i<2:
temp = yield i
print(f"temp:{temp}")
i=i+1
print("end")
g = foo()
print(next(g))
print("*"*20)
print(g.send(100))
print(next(g))
"""
运算结果：
start
0
********************
temp:100
1
temp:None
end
Traceback (most recent call last):
File
"C:\Users\webChubby\PycharmProjects\网络编程
\test.py", line 14, in <module>
print(next(g))
StopIteration
"""
总结
1、什么是生成器？
生成器仅仅保存了一套生成数值的算法，并且没有让这个算法现在就开始执行，而是我什么时候调它，它什么时候开始 计算一个新的值，并给你返回。
2、生成器特点：
1、生成器函数生成一系列结果。通过 yield 关键字返回一个值后，还能从其退出的地方继续运行，因此可以随时间产生一系列的值。
2、生成器和迭代是密切相关的，迭代器都有一个 __next__() 成员方法，这个方法要么返回 迭代的下一项，要么引起异常结束迭代。
3、生成器是一个特殊的程序，可以被用作控制循环的迭代行为，python中生成器是迭代器 的一种，使用yield返回值函数，每次调用yield会暂停，而可以使用 next() 函数和 send() 函数恢复生成器。
4、生成器看起来像是一个函数，但是表现得却像是迭代器
迭代器
概念
1 迭代是Python最强大的功能之一，是访问集合元素的一种方式。
2 迭代器是一个可以记住遍历的位置的对象。
3 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。
4 迭代器只能往前不会后退。
5 迭代器有两个基本的方法： iter() 和 next()
可迭代对象和迭代器区别
1、一个实现了 iter 方法的对象，称为"可迭代对象Ieratable"
2、一个实现 next 方法并且是可迭代的对象，称为"迭代器Iterator"
即：实现了 iter 方法和 next 方法的对象就是迭代器。
⚠️生成器都是 Iterator 对象，但 list 、 dict 、 str 虽然是 Iterable（可迭代对象） ，却不是 Iterator（迭代器） 。
#python3.6之前不加.abc，之后的加
from collections.abc import Iterator
from collections.abc import Iterable
a = isinstance([], Iterable)
a = isinstance([], Iterator)
print(a)list 、 dict 、 str 等 Iterable 变成 Iterator , 可以使用 iter() 函数：
>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True
为什么 list 、 dict 、 str 等数据类型不是 Iterator ？
Python的 Iterator 对象表示的是一个数据流。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过 next() 函数实现按需计算下一个数据，所以 Iterator 的计算是惰性的，只有在需要返回下一个数据时它才会计算。 所以，生成器一定是迭代器。 Iterator 甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。
