python 装饰器

最新推荐文章于 2024-06-10 22:18:41 发布
最新推荐文章于 2024-06-10 22:18:41 发布
阅读量87 收藏 1
点赞数
分类专栏： python基础学习 文章标签： python
原文链接：https://www.bilibili.com/video/BV1SZ4y1s7cv
版权

@根据一些python装饰器例子，了解装饰器的原理和工作机制

装饰器：所谓函数装饰器，就是通过装饰器函数，在不修改原函数的前提下，来对函数的功能进行合理的扩充。本质是函数闭包的语法糖
函数闭包：一个函数,其参数和返回值都是函数
语法糖：指计算机语言中添加的某种语法，这种语法对语言的功能没有影响

  1. 语法糖没有增加新功能,只是一种更方便的写法
  2. 语法糖可以完全等价地转换为原本非语法糖的代码

装饰器的装饰函数时候的特点

  1. 在第一次调用之前增强
  2. 只增强一次

实例代码如下：

  1. 装饰器问题引入y
import time
"""
函数逻辑(查找奇数)和辅助功能(记录时间)耦合在一起了.
- 缺点: 不方便修改,容易引起bug
> 能不能将辅助功能从主要功能函数中抽离出来?
"""

def print_odds():
    """
    输出0~100之间所有奇数,并统计函数执行时间
    """
    start_time = time.clock()   # 起始时间
    # 查找并输出所有奇数
    for i in range(100):
        if i % 2 == 1:
            print(i)
    end_time = time.clock()     # 结束时间
    print("it takes {} s to find all the olds".format(end_time - start_time))

if __name__ == '__main__':
    print_odds()
  1. 直接分离两个函数
import time

"""
将辅助功能(记录时间)抽离成一个辅助函数count_time,在辅助函数count_time中调用主要功能函数print_odds.
- 优点: 解耦,函数职责分离.
- 缺点: 要通过辅助函数来调用主要功能函数,不方便.
> 我们的目标: 能不能在调用主要功能函数时自动完成对时间的统计?
"""
def count_time(func):
    """
    统计某个函数的运行时间
    """
    start_time = time.clock()  # 起始时间
    func()  # 执行函数
    end_time = time.clock()  # 结束时间
    print("it takes {} s to find all the olds".format(end_time - start_time))

def print_odds():
    """
    输出0~100之间所有奇数,并统计函数执行时间
    """
    for i in range(100):
        if i % 2 == 1:
            print(i)
            
if __name__ == '__main__':
    # print_odds()
    count_time(print_odds)
  1. 通过闭包增强主要功能函数
import time
"""
通过闭包增强主要功能函数print_odds,给它增加一个统计时间功能
缺点: 需要显式进行闭包增强
"""


def print_odds():
    """
    输出0~100之间所有奇数,并统计函数执行时间
    """
    for i in range(100):
        if i % 2 == 1:
            print(i)


# 闭包本质上是一个函数
# 闭包函数的传入参数和返回值也都是函数
# 闭包函数的返回值函数是对传入函数进行增强后的结果
def count_time_wrapper(func):
    """
    闭包,用于增强函数func: 给函数func增加统计时间的功能
    """

    def improved_func():
        start_time = time.clock()   # 起始时间
        func()                      # 执行函数
        end_time = time.clock()     # 结束时间
        print("it takes {} s to find all the olds".format(end_time - start_time))

    return improved_func


if __name__ == '__main__':
    # 调用count_time_wrapper增强函数
    print_odds = count_time_wrapper(print_odds)
    print_odds()# improved
  1. 通过装饰器去增强函数
import time

"""
通过装饰器进行函数增强,只是一种语法糖,本质上跟上个程序完全一致.
"""

def count_time_wrapper(func):
    """
    闭包,用于增强函数func: 给函数func增加统计时间的功能
    """

    def improved_func():
        start_time = time.clock()  # 起始时间
        func()  # 执行函数
        end_time = time.clock()  # 结束时间
        print(
            "it takes {} s to find all the olds".format(end_time - start_time))

    return improved_func

@count_time_wrapper
def print_odds():
    """
    输出0~100之间所有奇数,并统计函数执行时间
    """
    for i in range(100):
        if i % 2 == 1:
            print(i)

if __name__ == '__main__':
    # 装饰器等价于在第一次调用函数时执行以下语句:
    # print_odds = count_time_wrapper(print_odds)
    print_odds()
  1. 增强含有返回值的函数
import time


def count_time_wrapper(func):
    """
    闭包,用于增强函数func: 给函数func增加统计时间的功能
    """

    def improved_func():
        start_time = time.clock()   # 起始时间
        func()                      # 执行函数
        end_time = time.clock()     # 结束时间
        print("it takes {} s to find all the olds".format(end_time - start_time))


    return improved_func


def count_odds(lim=100):
    """
    输出0~lim之间所有奇数,并统计函数执行时间
    """
    cnt = 0
    for i in range(lim):
        if i % 2 == 1:
            cnt+=1
    return cnt


# 对于含有返回值的函数,调用闭包增强后,不能成功返回,但是成功增强了辅助功能
# 对于含有参数的函数,调用闭包增强后,不能成功接收参数
# if __name__ == '__main__':
#     print('增强前')
#     print(count_odds())         # 装饰前函数能正常返回,能接收参数
#     print('----------------------')
#     print('增强后')
#     count_odds = count_time_wrapper(count_odds)
#     print(count_odds())         # 装饰后函数不能正常返回,不能接收参数

if __name__ == '__main__':
    print('增强前')
    print(count_odds(lim=10000))         # 装饰前函数能正常返回,能接收参数
    print('----------------------')
    print('增强后')
    count_odds = count_time_wrapper(count_odds)
    print(count_odds(lim=10000))         # 装饰后函数不能正常返回,不能接收参数
  1. 增强含有返回值的函数2
import time


def count_time_wrapper(func):
    """
    闭包,用于增强函数func: 给函数func增加统计时间的功能
    """

    def improved_func(*args, **kwargs):     # 增强函数应该把就饿收到的所有参数传给原函数
        start_time = time.clock()   # 起始时间
        ret = func(*args, **kwargs)                     # 执行函数
        end_time = time.clock()     # 结束时间
        print("it takes {} s to find all the olds".format(end_time - start_time))
        return ret      # 增强函数的返回值应该是原函数的返回值

    return improved_func


def count_odds(lim=100):
    """
    输出0~100之间所有奇数,并统计函数执行时间
    """
    cnt = 0
    for i in range(lim):
        if i % 2 == 1:
            cnt += 1
    return cnt


if __name__ == '__main__':
    print(count_odds(lim=100000))  # 装饰前函数能正常返回,能接收参数
    print('-----------')
    count_odds = count_time_wrapper(count_odds)
    print(count_odds(lim=100000))  # 装饰后函数能正常返回,能接收参数
  1. 增强带有返回值函数的模板写法
def general_wrapper(func):

    def improved_func(*args, **kwargs):    # 接收函数参数
        # 增强功能
        ret = func(*args, **kwargs)        # 传入参数并记录返回值
        # 增强功能
        return ret                         # 返回未增强函数的返回值

    return improved_func
  1. 多个装饰器
import time


def count_time_wrapper(func):
    """
    闭包,用于增强函数func: 给函数func增加统计时间的功能
    """

    def improved_func():
        start_time = time.clock()  # 起始时间
        func()  # 执行函数
        end_time = time.clock()  # 结束时间
        print("it takes {} s to find all the olds".format(end_time - start_time))

    return improved_func


def log_wrapper(func):
    """
    闭包,用于增强函数func: 给func增加日志功能
    """

    def improved_func():
        start_time = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))  # 起始时间
        func()  # 执行函数
        end_time = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))  # 结束时间
        print("Logging: func:{} runs from {} to {}".format(func.__name__, start_time, end_time))

    return improved_func


@count_time_wrapper
@log_wrapper
def count_odds():
    """
    输出0~100之间所有奇数,并统计函数执行时间
    """
    cnt = 0
    for i in range(100):
        if i % 2 == 1:
            cnt += 1
    return cnt


if __name__ == '__main__':
    count_odds()
  1. 多个装饰器执行顺序 按装饰的顺序执行
def wrapper1(func1):
    print('set func1')  # 在wrapper1装饰函数时输出

    def improved_func1():
        print('call func1')  # 在wrapper1装饰过的函数被调用时输出
        func1()

    return improved_func1


def wrapper2(func2):
    print('set func2')  # 在wrapper2装饰函数时被输出

    def improved_func2():
        print('call func2')  # 在wrapper2装饰过的函数被调用时输出
        func2()

    return improved_func2


# @wrapper1
# @wrapper2
def original_func():
    pass


if __name__ == '__main__':
    # original_func = wrapper1(wrapper2(original_func))

    # print(original_func.__name__)               # original_func = original_func()
    original_func = wrapper2(original_func)
    # print(original_func.__name__)               # original_func = improved_func2(封装original_func)()
    original_func = wrapper1(original_func)
    # print(original_func.__name__)               # original_func = improved_func1(封装improved_func2(封装original_func)())()

    original_func()
    print('-----')
    original_func()
  1. 多个装饰器执行的逻辑
def wrapper1(func1):
    print('set func1')

    def improved_func1():
        print('call func1')
        func1()     # 封装了improve_func2(original_func)

    return improved_func1


def wrapper2(func2):
    print('set func2')

    def improved_func2():
        print('call func2')
        func2()     # 封装了original_func

    return improved_func2


# @wrapper1
# @wrapper2
def original_func():
    pass


if __name__ == '__main__':
    # original_func = wrapper1(wrapper2(original_func))

    original_func = wrapper2(original_func)
    print(original_func.__name__)
    original_func = wrapper1(original_func)
    print(original_func.__name__)
    # original_func封装了improved_func1(improve_func2(original_func))


    original_func()
    print('-----')
    original_func()

11.增强函数也带有参数值

import time

def log_wrapper(info='Everything works'):
    def internal_log_wrapper(func):
        def improved_func():
            start_time = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))  # 起始时间
            func()  # 执行函数
            end_time = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))  # 结束时间
            print("Logging: func:{} runs from {} to {}, info:[{}]".format(func.__name__, start_time, end_time, info))

        return improved_func
    return internal_log_wrapper


@log_wrapper(info='informmmmmmmm')
def count_odds():
    """
    输出0~100之间所有奇数,并统计函数执行时间
    """
    cnt = 0
    for i in range(100):
        if i % 2 == 1:
            cnt += 1
    return cnt

if __name__ == '__main__':
    count_odds()

备注：本文中实例代码来源于B站公开资源，源视频链接为：[传送门](https://www.bilibili.com/video/BV1SZ4y1s7cv)
如需删除，请联系本人qq:975485055

学习，我一直在路上
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【笔记】python装饰器超全详解
BUG从入门到精通
11-06 283
由于函数也是一个对象，而且函数对象可以被赋值给变量，所以，通过变量也能调用该函数。 函数可以被赋值给其他变量 函数可以被删除 可以在函数里面再定义函数，函数嵌套。 函数可以作为参数传递给另外一个函数 函数可以作为另一个函数的返回值 所谓装饰，就是接收一个东西，然后加上一些东西后还回去。装饰器就是干这种事的。 目录 1.最简单的装饰器 2.使用@符号代替装饰语句 3.使用多个装饰器 4.带参数的装饰器 5.类装饰器 6.带参数的类装饰器 1.最简单的装饰器 def decorat
Python 装饰器
01-20
文章目录Python 装饰器一、装饰器定义二、装饰器知识储备三、高阶函数1.高阶函数定义：2.高阶函数的示范3.高阶函数的总结四、函数嵌套五、闭包 Python 装饰器 一、装饰器定义 装饰器本质就是函数，功能是为其他函数...
Python装饰器
qq_38380338的博客
03-12 692
Python装饰器：函数闭包的语法糖 预备知识 闭包：又称为闭包函数或者闭合函数。闭包是一种特殊的函数，这种函数由两个函数的嵌套组成，且称之为外函数和内函数，外函数返回值是内函数的引用，此时就构成了闭包。格式如下： def 外层函数(参数): def 内层函数(): print("内层函数执行", 参数) return 内层函数 内层函数的引用 = 外层函数("传入参数") 内层函数的引用() 1.什么是装饰器   装饰器就是一个闭包，装饰器是闭包的一种应用。用于拓展
python 装饰器@
weixin_49346755的博客
07-19 203
装饰器就是在特定条件下为某些函数在不改动函数体的时候为函数新添加一些功能，可以对原函数进行功能扩展，而且还不需要修改原函数的内容，也不需要修改原函数的调用，装饰器的使用符合了面向对象编程的开放封闭原则，即对扩展开放、对修改封闭。装饰器基于@语法和函数闭包，将原函数封装在闭包中，然后将函数赋值为一个新的函数（内置函数），执行函数时再在内层函数中执行闭包中的原函数。定义一个函数add，实现了两个数的相加。 如果需要计算这些代码的执行时间，应该怎么办呢？一个可行的方法就是在函数体内部加上计算执行时间的代码。 输出
python删除txt指定列_python从zip中删除指定后缀文件(推荐)
weixin_39915668的博客
11-26 325
一，说明环境：python2用到的模块 os zipfile shutil程序功能：从zip中删除指定后缀的文件，然后再自动压缩函数说明：DelFileInZip(path,suffix)path: zip文件的全路径suffix： 指定的文件后缀二，源码import shutilimport zipfileimport osfrom shutil import *def UnZipFile(zi...
COUNT()函数详解
热门推荐
Java修炼记
11-24 13万+
COUNT 顾名思义，就是计数的意思，此函数用处就是对表中记录数进行计数。 MySQL COUNT()函数介绍 COUNT()函数返回表中的行数。COUNT()函数允许您对表中符合特定条件的所有行进行计数。 COUNT()函数的语法如下 - COUNT(expression) SQL COUNT()函数的返回类型为BIGINT。 如果没有找到匹配的行，则COUNT()函数返
python装饰器实例大详解
09-21
主要介绍了python装饰器实例大详解,非常不错，具有参考借鉴价值，需要的朋友可以参考下
python 装饰器功能与用法案例详解
12-20
本文实例讲述了python 装饰器功能与用法。分享给大家供大家参考，具体如下： 1、必备 #### 第一波 #### def foo(): print 'foo' foo #表示是函数 foo() #表示执行foo函数 #### 第二波 #### def foo(): print 'foo...
python装饰器练习题及答案
09-18
主要介绍了python装饰器练习题及答案,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Python装饰器基础详解
12-24
装饰器(decorator)是一种高级Python语法。装饰器可以对一个函数、方法或者类进行加工。在Python中，我们有多种方法对函数...Python装饰器以两种形式呈现： 【1】函数装饰器在函数定义的时候进行名称重绑定，提供一个逻
SELECT COUNT用法
香小鱼
03-21 3353
<br />SELECT COUNT用法<br />COUNT 是函数之一。由于它的使用广泛，我们在这里特别提出来讨论。基本上，COUNT 让我们能够数出在表格中有多少笔资料被选出来。它的语法是：<br />SELECT COUNT("栏位名") <br />       FROM "表格名"<br />举例来说，若我们要找出我们的示范表格中有几笔 store_name 栏不是空白的资料时，<br />Store_Information 表格<br />store_name<br />Sales<br />
python中count()函数的用法
九天小牛
10-12 4万+
python字符串函数用法大全链接 count()函数 描述：统计字符串里某个字符出现的次数。可以选择字符串索引的起始位置和结束位置。            语法：str.count("char", start,end)  或 str.count("char")    -&gt; int    返回整数 str —— 为要统计的字符(可以是单字符，也可以是多字符)。 star —— 为索...
hive：函数：聚合函数：count() 及多用法之count中使用函数
不花的花和尚的博客
06-25 6125
业务情景一： select count(first_interview) first_interviews, count(submit_time) submit_time, count(length(concat(submit_time,bg_time))>26) submit_time, count(followupdate) followupdate, count(arr...
Sql Count函数简单用法
小事一桩_M
02-05 1万+
很多时候我们使用Sql中的count函数用来计数，之前遇到的一种情况进行简单的记录方便以后用到时进行查询 1.count(*) 不能过滤null的值，返回的是表的所有行的值 如下图所示，这里查询返回的数据行数是1049行 2.count(列名) 会过滤掉该列中存在的空值 如下所示，这里显示的是1024行，和上图中的比较可以看出少了25行，这里count（列名）进行了统计，有
python中count()、values_counts()、size()函数
不曾走远的博客
04-12 11万+
python中count()、values_counts()、size()函数
count函数
weixin_44202871的博客
02-19 9832
count(*)包括了所有的列，相当于行数，在统计结果的时候，不会忽略列值为NULL。 count(1)包括了忽略所有列，用1代表代码行，在统计结果的时候，不会忽略列值为NULL。 count(列名)只包括列名那一列，在统计结果的时候，会忽略列值为空。 ...
廖雪峰python教程笔记：装饰器
放学遛大街
07-31 4220
这是看廖老师python教程的第一个的笔记，因为这是这份教程最难的章节之一，我来来回回看了三遍，终于有所突破，写在这里是为了巩固自己的理解，同时也是希望有错的地方能够得到指正。具体内容见廖雪峰老师的课程原址。 装饰器，起到增强函数的作用，同时我们不需要改动这个函数。这个部分之所以难，我觉得主要是难在对于返回函数的多次调用，容易打乱初学者的思路。接下来将分为以下三部分进行介绍： 初识装饰器 首...
python类里面装饰器_Python中的装饰器、类装饰器（用类的方式写）及用于类的装饰器（装饰在类上）...
weixin_39629679的博客
11-23 297
装饰器是非常Pythonic的工具之一，由于骑在函数定义语句的身上，看起来非常像Java的标注，其实是一种函数（或者类）的使用方法或称语法糖。之所以想要总结以下的内容，是因为浏览了很多与类装饰器相关的教程并未说清其含义是用类的方式写的装饰器，还是其装饰器创建的目的是使用在类上。那我们开始吧。我们先来看一个最简单的例子：def fake_decorator(obj):print(obj)class ...
基于JavaScript 如何实现爬山算法以及优化方案
最新发布
乐闻世界
06-10 1342
爬山算法（Hill Climbing Algorithm）是一种常见的启发式搜索算法，常用于解决优化问题。其核心思想是从一个初始状态出发，通过逐步选择使目标函数值增大的邻近状态来寻找最优解。接下来，我们将通过 JavaScript 实现一个简单的爬山算法，帮助大家理解其原理和应用。从一个初始状态开始。评估当前状态的目标函数值。在当前状态的邻居中选择一个目标函数值更大的状态。如果找到了更优的邻居，则移动到该邻居并重复步骤2和步骤3。如果没有更优的邻居，则算法结束，当前状态即为局部最优解。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值