python装饰器的使用

简介: http://www.cnblogs.com/rhcad/archive/2011/12/21/2295507.html 这是在Python学习小组上介绍的内容,现学现卖、多练习是好的学习方式。

http://www.cnblogs.com/rhcad/archive/2011/12/21/2295507.html

这是在Python学习小组上介绍的内容,现学现卖、多练习是好的学习方式。

第一步:最简单的函数,准备附加额外功能

1
2
3
4
5
6
7
8
# -*- coding:gbk -*-
'''示例1: 最简单的函数,表示调用了两次'''
 
def  myfunc():
     print ( "myfunc() called." )
 
myfunc()
myfunc()

 

第二步:使用装饰函数在函数执行前和执行后分别附加额外功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# -*- coding:gbk -*-
'''示例2: 替换函数(装饰)
装饰函数的参数是被装饰的函数对象,返回原函数对象
装饰的实质语句: myfunc = deco(myfunc)'''
 
def  deco(func):
     print ( "before myfunc() called." )
     func()
     print ( "  after myfunc() called." )
     return  func
 
def  myfunc():
     print ( " myfunc() called." )
 
myfunc  =  deco(myfunc)
 
myfunc()
myfunc()

第三步:使用语法糖@来装饰函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# -*- coding:gbk -*-
'''示例3: 使用语法糖@来装饰函数,相当于“myfunc = deco(myfunc)”
但发现新函数只在第一次被调用,且原函数多调用了一次'''
 
def  deco(func):
     print ( "before myfunc() called." )
     func()
     print ( "  after myfunc() called." )
     return  func
 
@deco
def  myfunc():
     print ( " myfunc() called." )
 
myfunc()
myfunc()

第四步:使用内嵌包装函数来确保每次新函数都被调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# -*- coding:gbk -*-
'''示例4: 使用内嵌包装函数来确保每次新函数都被调用,
内嵌包装函数的形参和返回值与原函数相同,装饰函数返回内嵌包装函数对象'''
 
def  deco(func):
     def  _deco():
         print ( "before myfunc() called." )
         func()
         print ( "  after myfunc() called." )
         # 不需要返回func,实际上应返回原函数的返回值
     return  _deco
 
@deco
def  myfunc():
     print ( " myfunc() called." )
     return  'ok'
 
myfunc()
myfunc()

第五步:对带参数的函数进行装饰

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# -*- coding:gbk -*-
'''示例5: 对带参数的函数进行装饰,
内嵌包装函数的形参和返回值与原函数相同,装饰函数返回内嵌包装函数对象'''
 
def  deco(func):
     def  _deco(a, b):
         print ( "before myfunc() called." )
         ret  =  func(a, b)
         print ( "  after myfunc() called. result: %s"  %  ret)
         return  ret
     return  _deco
 
@deco
def  myfunc(a, b):
     print ( " myfunc(%s,%s) called."  %  (a, b))
     return  +  b
 
myfunc( 1 2 )
myfunc( 3 4 )

第六步:对参数数量不确定的函数进行装饰

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# -*- coding:gbk -*-
'''示例6: 对参数数量不确定的函数进行装饰,
参数用(*args, **kwargs),自动适应变参和命名参数'''
 
def  deco(func):
     def  _deco( * args,  * * kwargs):
         print ( "before %s called."  %  func.__name__)
         ret  =  func( * args,  * * kwargs)
         print ( "  after %s called. result: %s"  %  (func.__name__, ret))
         return  ret
     return  _deco
 
@deco
def  myfunc(a, b):
     print ( " myfunc(%s,%s) called."  %  (a, b))
     return  a + b
 
@deco
def  myfunc2(a, b, c):
     print ( " myfunc2(%s,%s,%s) called."  %  (a, b, c))
     return  a + b + c
 
myfunc( 1 2 )
myfunc( 3 4 )
myfunc2( 1 2 3 )
myfunc2( 3 4 5 )

第七步:让装饰器带参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# -*- coding:gbk -*-
'''示例7: 在示例4的基础上,让装饰器带参数,
和上一示例相比在外层多了一层包装。
装饰函数名实际上应更有意义些'''
 
def  deco(arg):
     def  _deco(func):
         def  __deco():
             print ( "before %s called [%s]."  %  (func.__name__, arg))
             func()
             print ( "  after %s called [%s]."  %  (func.__name__, arg))
         return  __deco
     return  _deco
 
@deco ( "mymodule" )
def  myfunc():
     print ( " myfunc() called." )
 
@deco ( "module2" )
def  myfunc2():
     print ( " myfunc2() called." )
 
myfunc()
myfunc2()

第八步:让装饰器带 类 参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
# -*- coding:gbk -*-
'''示例8: 装饰器带类参数'''
 
class  locker:
     def  __init__( self ):
         print ( "locker.__init__() should be not called." )
         
     @staticmethod
     def  acquire():
         print ( "locker.acquire() called.(这是静态方法)" )
         
     @staticmethod
     def  release():
         print ( "  locker.release() called.(不需要对象实例)" )
 
def  deco( cls ):
     '''cls 必须实现acquire和release静态方法'''
     def  _deco(func):
         def  __deco():
             print ( "before %s called [%s]."  %  (func.__name__,  cls ))
             cls .acquire()
             try :
                 return  func()
             finally :
                 cls .release()
         return  __deco
     return  _deco
 
@deco (locker)
def  myfunc():
     print ( " myfunc() called." )
 
myfunc()
myfunc()

第九步:装饰器带类参数,并分拆公共类到其他py文件中,同时演示了对一个函数应用多个装饰器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# -*- coding:gbk -*-
'''mylocker.py: 公共类 for 示例9.py'''
 
class  mylocker:
     def  __init__( self ):
         print ( "mylocker.__init__() called." )
         
     @staticmethod
     def  acquire():
         print ( "mylocker.acquire() called." )
         
     @staticmethod
     def  unlock():
         print ( "  mylocker.unlock() called." )
 
class  lockerex(mylocker):
     @staticmethod
     def  acquire():
         print ( "lockerex.acquire() called." )
         
     @staticmethod
     def  unlock():
         print ( "  lockerex.unlock() called." )
 
def  lockhelper( cls ):
     '''cls 必须实现acquire和release静态方法'''
     def  _deco(func):
         def  __deco( * args,  * * kwargs):
             print ( "before %s called."  %  func.__name__)
             cls .acquire()
             try :
                 return  func( * args,  * * kwargs)
             finally :
                 cls .unlock()
         return  __deco
     return  _deco
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# -*- coding:gbk -*-
'''示例9: 装饰器带类参数,并分拆公共类到其他py文件中
同时演示了对一个函数应用多个装饰器'''
 
from  mylocker  import  *
 
class  example:
     @lockhelper (mylocker)
     def  myfunc( self ):
         print ( " myfunc() called." )
 
     @lockhelper (mylocker)
     @lockhelper (lockerex)
     def  myfunc2( self , a, b):
         print ( " myfunc2() called." )
         return  +  b
 
if  __name__ = = "__main__" :
     =  example()
     a.myfunc()
     print (a.myfunc())
     print (a.myfunc2( 1 2 ))
     print (a.myfunc2( 3 4 ))

下面是参考资料,当初有不少地方没看明白,真正练习后才明白些:

1. Python装饰器学习 http://blog.csdn.net/thy38/article/details/4471421

2. Python装饰器与面向切面编程 http://www.cnblogs.com/huxi/archive/2011/03/01/1967600.html

3. Python装饰器的理解 http://apps.hi.baidu.com/share/detail/17572338

目录
相关文章
|
21天前
|
Python
深入理解Python装饰器:从入门到实践####
本文旨在通过简明扼要的方式,为读者揭开Python装饰器的神秘面纱,从基本概念、工作原理到实际应用场景进行全面解析。不同于常规的摘要仅概述内容概要,本文将直接以一段精炼代码示例开篇,展示装饰器如何优雅地增强函数功能,激发读者探索兴趣,随后深入探讨其背后的机制与高级用法。 ####
47 11
|
17天前
|
设计模式 缓存 开发者
深入浅出Python装饰器
【10月更文挑战第39天】本文将通过浅显易懂的语言和生动的比喻,带你探索Python中一个神奇而又强大的特性——装饰器。我们将一起揭开装饰器的神秘面纱,了解它的工作原理,并通过实际代码示例学习如何应用它来美化我们的代码。无论你是编程新手还是有经验的开发者,这篇文章都将为你打开一扇新的大门,让你的代码更加优雅和高效。
|
17天前
|
缓存 测试技术 数据库
深入理解Python中的装饰器
在本文中,我们将探讨Python语言中一个强大而灵活的特性——装饰器。装饰器允许开发者在不修改原有函数或方法代码的情况下增加额外的功能,这大大提高了代码的复用性和可读性。通过具体示例和应用场景的讲解,本篇文章旨在为读者提供一个关于如何使用装饰器的全面指南,包括装饰器的定义、使用场景、以及如何自定义装饰器等内容。
|
22天前
|
设计模式 Python
掌握Python中的装饰器
【10月更文挑战第34天】装饰器是Python中一种强大的工具,它允许我们在不修改原函数代码的情况下增加其功能。本文通过简单易懂的语言和实例,引导你理解装饰器的概念、种类及其应用,帮助你在编程实践中灵活使用这一高级特性。
|
12天前
|
开发框架 缓存 测试技术
Python中的装饰器:魔法般的功能增强
在Python编程中,装饰器是一种强大而灵活的工具,它允许开发者修改或扩展函数和类的行为。本文将深入探讨Python装饰器的工作原理,并通过实例演示如何创建和使用自定义装饰器来增强代码的功能性和可读性。我们将从基础概念讲起,逐步深入到高级应用,揭示装饰器背后的“魔法”,并展示它们在实际开发中的多种用途。
|
18天前
|
缓存 监控 测试技术
Python中的装饰器:功能扩展与代码复用的利器###
本文深入探讨了Python中装饰器的概念、实现机制及其在实际开发中的应用价值。通过生动的实例和详尽的解释,文章展示了装饰器如何增强函数功能、提升代码可读性和维护性,并鼓励读者在项目中灵活运用这一强大的语言特性。 ###
|
21天前
|
缓存 开发者 Python
探索Python中的装饰器:简化代码,增强功能
【10月更文挑战第35天】装饰器在Python中是一种强大的工具,它允许开发者在不修改原有函数代码的情况下增加额外的功能。本文旨在通过简明的语言和实际的编码示例,带领读者理解装饰器的概念、用法及其在实际编程场景中的应用,从而提升代码的可读性和复用性。
|
17天前
|
设计模式 缓存 开发框架
Python中的装饰器:从入门到实践####
本文深入探讨了Python中装饰器的工作原理与应用,通过具体案例展示了如何利用装饰器增强函数功能、提高代码复用性和可读性。读者将学习到装饰器的基本概念、实现方法及其在实际项目开发中的实用技巧。 ####
26 3
|
17天前
|
Python
探索Python中的装饰器:简化代码,提升效率
【10月更文挑战第39天】在编程的世界中,我们总是在寻找使代码更简洁、更高效的方法。Python的装饰器提供了一种强大的工具,能够让我们做到这一点。本文将深入探讨装饰器的基本概念,展示如何通过它们来增强函数的功能,同时保持代码的整洁性。我们将从基础开始,逐步深入到装饰器的高级用法,让你了解如何利用这一特性来优化你的Python代码。准备好让你的代码变得更加优雅和强大了吗?让我们开始吧!
22 1
|
22天前
|
设计模式 缓存 监控
Python中的装饰器:代码的魔法增强剂
在Python编程中,装饰器是一种强大而灵活的工具,它允许程序员在不修改函数或方法源代码的情况下增加额外的功能。本文将探讨装饰器的定义、工作原理以及如何通过自定义和标准库中的装饰器来优化代码结构和提高开发效率。通过实例演示,我们将深入了解装饰器的应用,包括日志记录、性能测量、事务处理等常见场景。此外,我们还将讨论装饰器的高级用法,如带参数的装饰器和类装饰器,为读者提供全面的装饰器使用指南。