Python入门【装饰器编辑、多个装饰器、带参数的装饰器、生成器、生成器定义、迭代器】(二十八)

艾派徳

已于 2023-08-19 21:37:13 修改

阅读量270

点赞数 3

分类专栏： python入门到实战文章标签： python 迭代器

于 2023-08-17 17:38:06 首次发布

本文链接：https://blog.csdn.net/abc19991119/article/details/132328072

版权

python入门到实战专栏收录该内容

35 篇文章 19 订阅

订阅专栏

👏作者简介：大家好，我是爱敲代码的小王，CSDN博客博主,Python小白
📕系列专栏：python入门到实战、Python爬虫开发、Python办公自动化、Python数据分析、Python前后端开发
📧如果文章知识点有错误的地方，请指正！和大家一起学习，一起进步👀
🔥如果感觉博主的文章还不错的话，请👍三连支持👍一下博主哦
🍂博主正在努力完成2023计划中：以梦为马，扬帆起航，2023追梦人

🔥🔥🔥 python入门到实战专栏：从入门到实战

🔥🔥🔥 Python爬虫开发专栏：从入门到实战

🔥🔥🔥 Python办公自动化专栏：从入门到实战

🔥🔥🔥 Python数据分析专栏：从入门到实战

🔥🔥🔥 Python前后端开发专栏：从入门到实战

装饰器

概念

装饰器来自 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)

装饰器用于有以下场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。

多个装饰器

有时候，我们需要多个装饰器修饰一个函数。比如：需要增加日志功能、增加执行效率测试功能。装饰器函数的执行顺序是分为（被装饰函数）定义阶段和（被装饰函数）执行阶段的，装饰器函数在被装饰函数定义好后立即执行

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是永远不可能存储全体自然数的。