精华内容
下载资源
问答
  • python 类修饰器

    2016-05-04 11:13:00
    1. 修改函数。 场景: 如果要给一个的所有方法加上计时,并打印出来。demo如下: # -*- coding:utf-8 -*- import time def time_it(fn): "Example of a method decorator" def decorator(*args, **...

    1. 修改类函数。

    场景: 如果要给一个类的所有方法加上计时,并打印出来。demo如下:

    # -*- coding:utf-8 -*-
    import time
    def time_it(fn):
        "Example of a method decorator"
        def decorator(*args, **kwargs):
        t1=time.time()
            ret = fn(*args, **kwargs)
        print '\t\t%d seconds taken for %s'%(time.time()-t1, fn.__name__)
        return ret
    
        return decorator
    
    def class_decorator(*method_names):
        def class_rebuilder(cls):
            "The class decorator example"
            class NewClass(cls):
                "This is the overwritten class"
                def __getattribute__(self, attr_name):
                    attr_val = super(NewClass, self).__getattribute__(attr_name)
                    if callable(attr_val) and attr_name in method_names:
                        return time_it(attr_val)
                    return attr_val
    
            return NewClass
        return class_rebuilder
    
    @class_decorator('first_method', 'second_method')
    class MySecondClass(object):
        """
        This class is decorated
        """
        def first_method(self, *args, **kwargs):
            print "\tthis is a the MySecondClass.first_method"
        time.sleep(2)
    
        def second_method(self, *args, **kwargs):
            print "\tthis is the MySecondClass.second_method"
        time.sleep(1)
    
    if __name__ == "__main__":
        print "::: With a decorated class :::"
        z = MySecondClass()
        z.first_method()
        z.second_method()

     

    好处相比函数修饰器要稍微简洁一点(在类有很多方法时)

     

    2. 增加类成员

    场景:比如统一给所有的模型增加id, created_time属性

    # -*- coding:utf-8 -*-
    def addAttrs(*attrs):
        def re_build(cls):
            class newClass(cls):
                def __init__(self,*args, **kws):
                    for attr in attrs:
                setattr(self, attr, None)
                    self.__id = id
                    super(newClass, self).__init__(*args, **kws)
            return newClass
        return re_build
    
    @addAttrs('id', 'created_time')
    class DBModelOne(object):
        def __init__(self, *args, **kwargs):
            pass
    
    if __name__=='__main__':
        m = DBModelOne(5)
        print m.id, m.created_time

     

    or

    # -*- coding:utf-8 -*-
    import time
    def cd(cls):
        def init(*args, **kwargs):
            cls_obj = cls(*args, **kwargs)
            setattr(cls_obj, 'id', time.time())
            return cls_obj
        return init
    @cd
    class A(object):
        def __init__(self, name, age, sex='f'):
            self.name=name
            self.age=age
            self.sex=sex
        def s(self):
            print self.id
    
    if __name__=='__main__':
        print type(A)#<type 'function'>
        a=A('Alice', 22)
        print type(a)#<class '__main__.A'>
        print a#<__main__.A object at 0x7fe617baa690>
        print a.name, a.age, a.sex#Alice 22 f
        a.s()

     

     

    转载请注明来自:http://www.cnblogs.com/Tommy-Yu/p/5457751.html

     

    转载于:https://www.cnblogs.com/Tommy-Yu/p/5457751.html

    展开全文
  • 修饰器(decorator)是函数嵌套定义的另一个重要应用。...后面第6章中的静态方法、方法、属性等也都是通过修饰器实现的,Python中还有很多这样的用法。下面的代码演示了修饰器的定义与使用方法。def b...

    修饰器(decorator)是函数嵌套定义的另一个重要应用。修饰器本质上也是一个函数,只不过这个函数接收其他函数作为参数并对其进行一定的改造之后使用新函数替换原来的函数。修饰器的主要应用场合是定义多个函数调用之前或之后需要执行的通用代码,提高代码复用度。后面第6章中的静态方法、类方法、属性等也都是通过修饰器实现的,Python中还有很多这样的用法。下面的代码演示了修饰器的定义与使用方法。

    def before(func): #定义修饰器

    def wrapper(*args, **kwargs):

    print('Before function called.')

    return func(*args, **kwargs)

    return wrapper

    def after(func): #定义修饰器

    def wrapper(*args, **kwargs):

    result = func(*args, **kwargs)

    print('After function called.')

    return result

    return wrapper

    @before

    @after

    def test(): #同时使用两个修饰器改造函数

    print(3)

    #调用被修饰的函数

    test()

    上面代码的运行结果为:

    Before function called.

    3

    After function called.

    附:”第6届高等学校计算机程序设计课程研讨会”通知

    完整版通知和回执单可以联系会务组索要。

    0

    0

    0

    展开全文
  • python函数修饰器

    2019-08-02 22:12:24
    python函数修饰器 什么是修饰器? 修饰器是一个函数,接受一个函数或方法作为其唯一的参数,并返回一个新函数或方法,其中整合了修饰后的函数或方法,并附带了一些额外的功能.1 上面的定义不免有点难以理解,我们来看下面...

    python函数修饰器

    什么是修饰器?

    修饰器是一个函数,接受一个函数或方法作为其唯一的参数,并返回一个新函数或方法,其中整合了修饰后的函数或方法,并附带了一些额外的功能.1

    上面的定义不免有点难以理解,我们来看下面的图
    修饰器的形象图

    我们之前所理解的python执行函数过程是如图1.1的流程.

    如果我们给函数添加了修饰器,那么当程序执行到函数A的时候,系统会检测到函数A上有一个修饰器,那么系统就会先执行修饰器里的过程然后再回到函数执行函数的内容.

    但是从修饰器回来的那一条线路其实并不是必须的, 需要在修饰器里面编写回来的语句回到函数,接下来会讲到

    修饰器的简单作用

    在其定义中就已经介绍修饰器的作用是给函数增加额外的功能.

    : 在修饰器的简单作用这一部分,接下来的内容我无法自己组织语言将其讲清楚,故参考了简书作者MrYun 谈谈python修饰器 的内容,个人觉得这一篇在引入修饰器作用方面的描写很棒!

    从简单的一个例子讲起,现在我们有一个函数

    def foo():
        print("this is a test")
    
    foo()
    

    现在我们需要给它进行性能测试,那么需要改成以下内容

    import time
    
    
    def foo():
        start = time.clock()
        print("this is a test")
        end = time.clock()
        print("start:", start, " end:", end)
    
    
    foo()
    

    如果我们希望给几十上百个函数都添加这样的性能测试,那么需要在每个函数内部开头与结尾都这样编辑吗?显然不是.

    这个时候我们编写一个新的函数test(),在test的函数开头与结尾编写时间定义,将要测试的函数传入test的函数(函数也是一个变量,是可以作为参数的),在中间执行,比如以下内容

    import time
    
    
    def foo():
        print("this is a test")
    
    
    def test(func):
        start = time.clock()
        foo()
        end = time.clock()
        print("start:", start, " end:", end)
    
    
    test(foo)
    

    现在我们就可以给每个函数进行测试了

    for 函数 in 项目:
        test(函数)
    

    如果我们将test中的输出加入到文件中,我们就可以得到每个函数的性能记录

    但是, 现在我们需要给大量函数实现另一个功能: 日志功能, 也就是在项目执行过程中, 函数的每一个操作都被记录下来, 意味着每使用一次函数都要手动编写test(foo), 尤其是如果需要使用函数的返回值的时候, 这种方式就有点捉襟见肘了

    这个时候修饰器的作用就显示出来了. 它可以在每个使用它的函数上进行功能的添加, 而且使用者完全感受不到他的存在, 也就是说我们使用的时候依然是foo(), 但是在内部项目却另外实现了test()的功能

    这个修饰器的使用格式如下,具体内容之后会讲解

    import time
    
    
    def test(func):
        def wrapper():
            start = time.clock()
            func()
            end = time.clock()
            print("start:", start, " end:", end)
        return wrapper
    
    
    @test
    def foo():
        print("this is a test")
    
    
    foo()
    

    修饰器的使用

    上面已经了解到了修饰器的作用,那么我们可以了解修饰器的格式了.

    上面插入的修饰器太过突兀,我们来段过渡代码(这一段代码也是来自那篇简书)

    import time
    
    def test(func):
        def wrapper():
            start = time.clock()
            func()
            end = time.clock()
            print("start:", start, " end:", end)
        return wrapper
    
    def foo():
        print("this is a test")
    
    
    foo = test(foo)
    foo()
    

    执行过程可以这样理解:

    foo = test(foo)

    foo() = test(foo)() = wrapper()
    装饰器执行过程
    在python中, 我们把foo = test(foo)用一种更简单的形式来表达, 就是在使用装饰器的函数foo上面加上 @修饰器名称, python的修饰器是一种语法糖.

    @test
    def foo():
        print("this is a test")
    

    如果需要使用到foo函数的返回值,那么test函数可以这样写

    import time
    def test(func):
        def wrapper():
            start = time.clock()
            print("this is a order test, if you need not it, delete it") # 用于测试执行顺序,可以跟着走一遍
            a = func()
            end = time.clock()
            print("start:", start, " end:", end)
            return a # 这种获得返回值的方法可能在多层修饰器的时候有矛盾,我先用!!!标记, 等理顺后再回来修改,如果我发布之后这里依然存在...说明我忘记了...
        return wrapper
    
    @test
    def foo():
        print("this is a test")
        return "this is a return value"
    
    print(foo())
    # 输出
    # this is a test wrapper, if you need not it, delete it
    # this is a test
    # start: 4.44444839506524e-07  end: 1.8222238419767486e-05
    # this is a return value
    

    在《Python3程序开发指南第二版》(以下简称《指南》)中给的例子是一个对python初学者(没涉及项目)来说比较有趣的小修饰器, 有兴趣可以看看,我给它做了一点注释

    def positive_result(function):
        def wrapper(*args, **kwargs):
            # result获得函数的返回值, 进行结果判断
            result = function(*args, **kwargs)
            # assert断言, 如果function函数的返回值大于等于0, 的产生一个AssertionError异常
            assert result >= 0, function.__name__ + "() result isn't >= 0"
            # 返回
            return result
        
        # 将wrapper的docstring和名称设置成和原始函数一样,有利于内省(获得自身的信息)
        wrapper.__name__ = function.__name__ 
        wrapper.__doc__ = function.__doc__
        return wrapper
    
    # 使用positive_result修饰器
    @positive_result
    def discriminant(a,b,c):
        return (b**2) - (4*a*c)
    
    
    print(discriminant(0,6,5))
    print(discriminant(2,6,5))
    

    执行过程可以这样理解:

        discriminant = positive_result(discriminant)
    
        discriminant(a,b,c) = positive_result(discriminant)(a,b,c) = wrapper(a, b, c)
    

    《指南》中给出了这个例子的简化版, 使用到了functools.wraps(function)

    def positive_result(function):
        # wrapper本身使用functools模块的@functools.wraps进行包裹, 这可以确保wrapper的名称与docstring与function相同
        @functools.wraps(function)
        def wrapper(*args, **kwargs):
            result = function(*args, **kwargs)
            assert result >= 0, function.__name__ + "() result isn't >= 0"
    
            return result
        return wrapper
    
    

    修饰器参数化

    现在我们已经了解到了什么是修饰器以及修饰器的基本使用, 那么在上面的日志修饰器上, 我们的日志信息往往是要写入文件内,但是不同的函数需要写进的文件名不一样, 那么简单的 @修饰器名称已经没法满足需要了, 这个时候就需要修饰器参数化, 即将要操作的文件名传递给test()函数

    现在放一个《指南》中给出的例子

    import functools
    def bounded(mininum, maxinum):
        def decorator(function):
            @functools.wraps(function)
            def wrapper(*args, **kwargs):
                result = function(*args, **kwargs)
                if result < mininum:
                    return mininum
                elif result > maxinum:
                    return maxinum
                return result
            return wrapper
        return decorator
    
    @bounded(0,100)
    def percent(amount, total):
        return (amount / total) * 100
    
    percent(15,100)
    
    • 执行过程如下
      带参数装饰器执行过程
      执行过程可以这样理解

        percent = bounded(mininum, maxinum)(percent)
      
        percent(amount, total) = bounded(mininum, maxinum)(percent)(amount, total) = wrapper(amount, total)
      

    与普通装饰器的对比:
    带参数装饰器与普通装饰器对比


    1. 《Python3程序开发指南第二版》第八章P311 ↩︎

    展开全文
  • 因困扰自己多时,打算整理一下修饰器到底是什么? 修饰器1. 定义2个函数2. 基本实现3. 问题:实现后,要修改原来代码中的变量名,funcb()改为funca(funcb)4. 解决方法:让funcb赋值等于funca(funcb),用时就是funcb(),...

    o55g08d9dv.jpg广告关闭

    腾讯云11.11云上盛惠 ,精选热门产品助力上云,云服务器首年88元起,买的越多返的越多,最高返5000元!

    因困扰自己多时,打算整理一下修饰器到底是什么? 修饰器1. 定义2个函数2. 基本实现3. 问题:实现后,要修改原来代码中的变量名,funcb()改为funca(funcb)4. 解决方法:让funcb赋值等于funca(funcb),用时就是funcb(),不用修改原来代码,这个要求需funca(funcb)返回的是一个函数a)所以要返回一个函数,则加一个函数wrapp...

    用好了装饰器,开发效率如虎添翼,所以这也是python面试中必问的问题,但对于好多初次接触这个知识的人来讲,这个功能有点绕,自学时直接绕过去了,然后面试问到了就挂了,因为装饰器是程序开发的基础知识,这个都不会,别跟人家说你会python, 看了下面的文章,保证你学会装饰器。 在学习装饰器之前,首先要懂得闭包...

    大佬太多,这里不赘述,只记录一下今天自己写对类里面的方法如何修饰。 二、修饰器如何对类里面的方法进行修饰? 1、我这里是在不同的文件夹下不同的py文件中,先定义一个修饰器,如下:def logs_decorator(func): def logs_d():print(成功获取了列表.....) func() return logs_d 2、另一个py文件中,定义一个类,类...

    今天被问到python函数修饰符,顺手写写。 python函数修饰符,“@”,与其说是修饰函数倒不如说是引用、调用它修饰的函数。 举个栗子,下面的一段代码,里面两个函数,没有被调用,也会有输出结果:def test(f): print before ... f() print after ... @testdef func(): print func was called直接运行,输出结果...

    修饰器用来包装函数,增加额外的功能,而且应能够修饰一批函数,减少代码重用。 简单的修饰器 一个函数接收函数对象作为参数,并且返回函数对象,这样的函数可以成为一个修饰器,形如下面的定义:defdeco(func):def_deco(*args):printdosomethingfunc(*args)return_deco上面的修饰器中,func称为被修饰的函数...

    装饰器在python中是一个强大的高级用法,并且在流行python框架中变得越来越常见。 经常会用到装饰器来增强函数的行为(动态的给一个对象添加一些额外的职责),包括记录日志,权限校验,性能测试,数据封装等。 有了装饰器,我们可以抽离出大量和函数功能本身无关的雷同代码并继续重用。 python装饰器有两种:函数...

    self.name = name self.age =age可以看到typeassert类装饰器的参数是传入的属性名称和类型的键值对。 如果我们想让typeassert类装饰器自动的识别类的初始...官方文档-descriptorunderstanding-get-and-set-and-python-descriptorsanyisalin -python - 描述器python描述器引导(翻译)properties and descriptors...

    python装饰器引入装饰器如果想在一个函数执行前后执行一些别的代码,比如打印一点日志用来输出这个函数的调用情况那应该怎么做呢? #!usrbinenv python# coding=utf-8 def logger(fn): # 函数作为参数即fn可以为任何参数 def wrap(*args, **kwargs):# 可变参数args和kwargs print(call {}.format(fn.__name__)) ret =...

    python 装饰器描述python 中一切皆对象,函数也可以当作参数传递装饰器就是接受一个函数作为参数,添加功能后返回一个新函数的函数或类。 python 中使用 @ 来使用装饰器。 (@ 只是装饰器的语法糖,可以等价替代为其他)装饰器经常用到的功能就是在代码中添加log 日志。 实例下面简单编写一个记录函数耗时的装饰器...

    本篇将介绍python的装饰器用法装饰器由于函数也是一个对象,而且函数对象可以被赋值给变量,所以,通过变量也能调用该函数。 def now(): print(2018年1月18日17:38:59) f = nowf()函数对象有一个__name__属性,可以拿到函数的名字:>>>now.__name__now>>>f.__name__now现在,假设我们要增强now()函数的功能,比如,在...

    什么是装饰器: 装饰器就是python中的一个语法糖。 作用就是在不改动之前代码的情况下给某个函数增加相应想要增加的功能。 假设需求: 我在几个函数内分别放了一部电影,代码如下:1 def mv1():2 print(高清无码01)3 def mv2():4 print(高清无码02) 我现在想增加一个功能就是在访问这些电影的时候需要密码,不是谁都...

    1t5qy5z5s1.jpg

    整理一下关于装饰器(decorator)的一些知识。 在解释装饰器前,先花一点时间总结一些关于函数的知识点。 这篇文章主要参考这个教程:python 进阶,是《intermediate python》的中译本。 一切皆对象在 python 中,所有的函数都是对象。 如下面的例子中,函数可以直接赋值给变量。 即使删除了原来的函数,但是变量还是...

    作者 | saurabh kukade译者 | 刘畅出品 | ai科技大本营(id:rgznai100) 最近,作者遇到一个非常有趣的概念,它就是用 python 进行元编程。 我想在本文中...修饰器 修饰器是一种在现有函数中添加新的功能而不修改其原始结构的方法。 例如,我们有以下三个函数:? 现在我们需要在函数被调用时输出函数名和参数值...

    多个装饰器的执行顺序:从最靠近原始函数的装饰器开始执行,最后执行原始函数; 直接上个简单的例子就懂了:一 最简单的装饰器:#! usrbinpythondef deco(func1): print(111) def one():print(222) func1() return one@decodef myinit():print(init)myinit()原始函数myinit,作用输出init; 装饰器函数deco,用一个函数...

    以上列表是比较简单的生成器,可以直接使用列表生成式修改得到,如果是比较复杂的生成器则需要使用包含 yield 的函数来实现。 下面我们通过 yield 函数来实现上面的列表(包含 1 至 20 中所有偶数的平方)。 #! usrbinenv python3# -*- coding:utf-8 -*- def even_squares(start, end):for n in range(start, end): ...

    很多时候我们可能需要对某个实例的属性加上除了修改、访问之外的其他处理逻辑,例如 类型检查、数值校验等,就需要用到描述器 ---《python cookbook》我们可以使用 python 自带的 property装饰器 来控制属性的访问,下面这个例子通过 property 控制了 person 的 age 属性的访问和修改class person:def __init__(self...

    预备知识在了解wraps修饰器之前,我们首先要了解partial和update_wrapper这两个函数,因为在wraps的代码中,用到了这两个函数。 partial首先说partial函数,在官方文档的描述中,这个函数的声明如下:functools.partial(func, *args, **keywords)。 它的作用就是返回一个partial对象,当这个partial对象被调用的时候...

    print(call %s():% func.__name__) return func(*args, **kw) return wrapper returndecorator@log2() # 这种情况是先调用 log2(),其返回的 函数作为实际装饰器。 所以decorator也会被调用def now2():print(2015-3-25)decorator 是一个 形参为函数 且 返回 函数的 高阶函数。 重点:形参为函数 且 返回函数装饰的...

    oxc0wszesy.png

    那么将这个函数及用到的一些变量称之为闭包在其他语言里面不允许函数内部在定义函数但是python中的闭包可以二、什么是装饰器装饰器是程序开发中经常会到的个功能,所以这也是python试中必问的问题。 定义:装饰器本身就是一个函数为其他函数提供附加功能不改变被修饰函数的源代码不改变原调用方式装饰器=高阶函数+...

    就是将组成函数的语句和这些语句的执行环境打包在一起时得到的对象,它的主要作用是封存上下文。 这一特性可以巧妙的被用于现有函数的包装,从而为现有函数添加功能,这就是装饰器。 装饰器的本质与作用装饰器(decorator)的本质是一个python函数,它可以让其他函数在不需要做任何代码变动的前提下增加额外的功能...

    展开全文
  • 主要介绍了Python使用修饰器进行异常日志记录操作,结合实例形式分析了Python基于修饰器的log日志文件操作的相关实现技巧,需要的朋友可以参考下
  • Python修饰器

    2015-07-21 10:01:57
    Python修饰器
  • 主要介绍了Python使用修饰器执行函数的参数检查功能,结合具体实例形式分析了Python实现修饰器针对函数参数检查的原理、步骤与相关操作技巧,需要的朋友可以参考下
  • python使用装饰有很多方法,下面是其中一个简单点的:# -*- coding:utf-8 -*-import inspectimport timedef service_wrap(func):"""对service func进行包装"""def wrapped(*args, **kwargs):print(u' 时间: %s...
  • [python] 修饰器

    2018-03-05 21:06:45
    修饰器本质上是一种python函数的代称,它可以让其他函数在不需要做任何代码变动的情况下增加额外的功能。 既然修饰器的本质是一种python函数,那么它就有对应的输入和输出,他的输入有两种可能,一种是参数,一种是...
  • 本文实例讲述了Python使用修饰器执行函数的参数检查功能。分享给大家供大家参考,具体如下:参数检查:1. 参数的个数;2. 参数的类型;3. 返回值的类型。考虑如下的函数:import htmldef make_tagged(text, tag):...
  • @singleton class Singletoxxx(Config): 比如这个,别singleton修饰了 如果在继承Singletonxxx就会报错:function() argument 1 must be code, not str
  • 从实现的角度来说,Python修饰器是一个可调用对象(函数、方法、),接受一个函数对象fin作为输入,并返回另一个函数对象fout。这意味着可以将任何具有这些属性的可调用对象当做一个修饰器。 修饰器模式和Python...
  • Python修饰器

    2018-05-29 16:29:35
    # 定义一个计时,传入一个,并返回另一个附加了计时功能的方法 def timeit (func) : # 定义一个内嵌的包装函数,给传入的函数加上计时功能的包装 def wrapper () : start = time.clock() ...
  • 前贴 /t/513929 中提到了 python 修饰器的一个疑问,经过一番研究终于明白了,总结了一下,然后就发出来了分享一下。与君共勉"""带参数修饰器会在初始化时就执行修饰器的代码并将方法体重新赋值给方法名。"""def ...
  • python 修饰器

    千次阅读 2018-08-29 16:06:46
    Python修饰器 python 修饰器是python 语法中一个很神奇的存在,我们可以这样理解它: 在python中,一切皆为对象,函数也是对象,我们定义的名称只是绑定到这些对象的标识符。 函数也不例外,它们也是对象(带有...
  • python @修饰器作用

    2019-11-15 16:11:01
    Python的函数中,函数定义的上一行有@functionName的修饰,当解释读到@这样的修饰符之后,会先解析@后的内容,把@下一行的函数或者作为@后边的函数的参数,然后将返回值赋值给下一行修饰的函数对象。...
  • Python 函数修饰器

    2018-09-04 20:17:15
    对于修饰器的传入参数prefix,修饰器不会立即将带待修饰的函数作为参数传入完成修饰,而是先做了一个预处理,返回了一个_deco函数,而这个_deco函数才是真正被f函数调用的修饰器。           ...
  • Python修饰器@

    2016-11-20 16:12:42
    修饰器是一个很著名的时机模式,经常用于有切面需求的场景,如插入日志、性能测试、事务处理等。修饰器能够很好地解决这些问题,有了修饰器我们能抽离出大量函数中与函数功能本身无关的雷同代码并继续使用。也就是说...
  • 属性、方法 ...修饰器是一个函数,接受一个函数或方法作为其唯一的参数,并返回一个新函数或方法,其中整合了修饰后的函数或方法,并附带了一些额外的功能.[1] 还记得装饰器(decorator)可以给函数动态加上功能
  • import time def timer(func): def wrapper(*arg, **kwds): print("%s start"%func) t0 = time.time() func(*arg, **kwds) t1 = time.time() print("%s end. total t...
  • 修饰器的用途在于提供一种统一的对象修改...其实Python语言本身很多都是采用修饰器完成其功能的。比如的方法除了常规的由对象拥有和调用的方法外,静态方法和方法是另外两种不同特性的方法,而Python正是通过内...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,667
精华内容 13,066
关键字:

python类修饰器

python 订阅