个人中心
gpt4 book ai didi

python实现装饰器、描述符

转载 作者：qq735679552 更新时间：2022-09-28 22:32:09 30 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章python实现装饰器、描述符由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

概要 。

本人python理论知识远达不到传授级别，写文章主要目的是自我总结，并不能照顾所有人，请见谅，文章结尾贴有相关链接可以作为补充 。

全文分为三个部分装饰器理论知识、装饰器应用、装饰器延申 。

  • 装饰理基础：无参装饰器、有参装饰器、functiontools、装饰器链
  • 装饰器进阶：property、staticmethod、classmethod源码分析（python代码实现）

装饰器基础 。

无参装饰器 。

?
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
'''
假定有一个需求是：打印程序函数运行顺序
此案例打印的结果为：
   foo1 function is starting
   foo2 function is starting
'''
from functools import wraps
 
def NoParamDec(func):
   #函数在被装饰器装时后，其函数属性也会改变，wraps作用就是保证被装饰函数属性不变
   @wraps (func)
   def warpper( * args, * * kwargs):
     print ( '{} function is starting' . format (func.__name__))
     return func( * args, * * kwargs)
  
   return warpper
 
#python黑魔法省略了NoParamDec=NoParamDec(foo1)
@NoParamDec
def foo1():
   foo2()
 
@NoParamDec
def foo2():
   pass
 
if __name__ = = "__main__" :
 
   foo1()

有参装饰器 。

?
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
'''
假定有一个需求是：检查函数参数的类型，只允许匹配正确的函数通过程序
此案例打印结果为：
('a', 'b', 'c')
-----------------------分割线------------------------
ERROS!!!!b must be <class 'str'>
ERROS!!!!c must be <class 'str'>
('a', 2, ['b', 'd'])
 
  
'''
from functools import wraps
from inspect import signature
 
 
def typeAssert( * args, * * kwargs):
   deco_args = args
   deco_kwargs = kwargs
  
   def factor(func):
     #python标准模块类，可以用来检查函数参数类型，只允许特定类型通过
     sig = signature(func)
     #将函数形式参数和规定类型进行绑定
     check_bind_args = sig.bind_partial( * deco_args, * * deco_kwargs).arguments
    
     @wraps (func)
     def wrapper( * args, * * kwargs):
       #将实际参数值和形式参数进行绑定
       wrapper_bind_args = sig.bind( * args, * * kwargs).arguments.items()
       for name, obj in wrapper_bind_args:
         #遍历判断是否实际参数值是规定参数的实例
         if not isinstance (obj, check_bind_args[name]):
           try :
             raise TypeError( 'ERROS!!!!{arg} must be {obj} ' . format ( * * { 'arg' : name, 'obj' : check_bind_args[name]}))
           except Exception as e:
             print (e)
       return func( * args, * * kwargs)
    
     return wrapper
  
   return factor
 
@typeAssert ( str , str , str )
def inspect_type(a, b, c):
   return (a, b, c)
 
if __name__ = = "__main__" :
   print (inspect_type( 'a' , 'b' , 'c' ))
   print ( '{:-^50}' . format ( '分割线' ))
   print (inspect_type( 'a' , 2 , [ 'b' , 'd' ]))

装饰器链 。

?
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
'''
假定有一个需求是：
输入类似代码：
@makebold
@makeitalic
def say():
   return "Hello"
 
输出：
<b><i>Hello</i></b>
'''
from functools import wraps
 
def html_deco(tag):
   def decorator(fn):
     @wraps (fn)
     def wrapped( * args, * * kwargs):
       return '<{tag}>{fn_result}<{tag}>' . format ( * * { 'tag' : tag, 'fn_result' : fn( * args, * * kwargs)})
    
     return wrapped
  
   return decorator
 
@html_deco ( 'b' )
@html_deco ( 'i' )
def greet(whom = ''):
   # 等价于 geet=html_deco('b')(html_deco('i)(geet))
   return 'Hello' + ( ' ' + whom) if whom else ''
 
if __name__ = = "__main__" :
   print (greet( 'world' )) # -> <b><i>Hello world</i></b>

装饰器进阶 。

property 原理 。

通常，描述符是具有“绑定行为”的对象属性，其属性访问已经被描述符协议中的方法覆盖。这些方法是__get__()、__set__()和__delete__()。如果一个对象定义这些方法中的任何一个，它被称为一个描述符。如果对象定义__get__()和__set__()，则它被认为是数据描述符。仅定义__get__()的描述器称为非数据描述符（它们通常用于方法，但是其他用途也是可能的）.

属性查找优先级为:

  • 类属性
  • 数据描述符
  • 实例属性
  • 非数据描述符
  • 默认为__getattr__()
?
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
class Property ( object ):
   '''
   内部property是用c实现的，这里用python模拟实现property功能
   代码参考官方doc文档
   '''
 
   def __init__( self , fget = None , fset = None , fdel = None , doc = None ):
     self .fget = fget
     self .fset = fset
     self .fdel = fdel
     self .__doc__ = doc
 
   def __get__( self , obj, objtype = None ):
     if obj is None :
       return self
     if self .fget is None :
       raise (AttributeError, "unreadable attribute" )
     print ( 'self={},obj={},objtype={}' . format ( self ,obj,objtype))
     return self .fget(obj)
 
   def __set__( self , obj, value):
     if self .fset is None :
       raise (AttributeError, "can't set attribute" )
     self .fset(obj, value)
 
   def __delete__( self , obj):
     if self .fdel is None :
       raise (AttributeError, "can't delete attribute" )
     self .fdel(obj)
 
   def getter( self , fget):
     return type ( self )(fget, self .fset, self .fdel, self .__doc__)
 
   def setter( self , fset):
     return type ( self )( self .fget, fset, self .fdel, self .__doc__)
 
   def deleter( self , fdel):
     return type ( self )( self .fget, self .fset, fdel, self .__doc__)
 
 
class Student( object ):
   @Property
   def score( self ):
     return self ._score
   @score .setter
   def score( self , val ):
     if not isinstance ( val, int ):
       raise ValueError( 'score must be an integer!' )
     if val > 100 or val < 0 :
       raise ValueError( 'score must between 0 ~ 100!' )
     self ._score = val
 
 
if __name__ = = "__main__" :
   s = Student()
   s.score = 60
   s.score

staticmethod 原理 。

@staticmethod means: when this method is called, we don't pass an instance of the class to it (as we normally do with methods). This means you can put a function inside a class but you can't access the instance of that class (this is useful when your method does not use the instance). 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class StaticMethod ( object ):
   "python代码实现staticmethod原理"
  
   def __init__( self , f):
     self .f = f
  
   def __get__( self , obj, objtype = None ):
     return self .f
 
 
class E( object ):
   #StaticMethod=StaticMethod(f)
   @StaticMethod
   def f( x):
     return x
 
if __name__ = = "__main__" :
   print (E.f( 'staticMethod Test' ))

classmethod 。

@staticmethod means: when this method is called, we don't pass an instance of the class to it (as we normally do with methods). This means you can put a function inside a class but you can't access the instance of that class (this is useful when your method does not use the instance). 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class ClassMethod ( object ):
   "python代码实现classmethod原理"
  
   def __init__( self , f):
     self .f = f
  
   def __get__( self , obj, klass = None ):
     if klass is None :
       klass = type (obj)
    
     def newfunc( * args):
       return self .f(klass, * args)
    
     return newfunc
  
class E( object ):
   #ClassMethod=ClassMethod(f)
   @ClassMethod
   def f( cls ,x):
     return x
  
if __name__ = = "__main__" :
   print (E().f( 'classMethod Test' ))

原文链接：https://segmentfault.com/a/1190000013425128 。

最后此篇关于python实现装饰器、描述符的文章就讲到这里了,如果你想了解更多关于python实现装饰器、描述符的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

30 4 0
文章推荐： Python语言实现机器学习的K-近邻算法
文章推荐： 冷艳霸气古风网名女生 简约酷酷的女生古风网名2021
文章推荐： 皮一点又蛮可爱的网名二字网名 萌萌哒简短的超甜昵称两个字
文章推荐： 王者荣耀本命英雄测试地址 看看谁是你的本命英雄
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com