python實現(xiàn)裝飾器、描述符

更新時間：2018年02月28日 14:11:15 作者：Geekrun

本篇文章通過代碼實例給大家分享了python實現(xiàn)裝飾器、描述符模擬代碼的過程，對戲需要的讀者可以參考下。

概要

本人python理論知識遠達不到傳授級別，寫文章主要目的是自我總結(jié)，并不能照顧所有人，請見諒，文章結(jié)尾貼有相關(guān)鏈接可以作為補充

全文分為三個部分裝飾器理論知識、裝飾器應用、裝飾器延申

裝飾理基礎：無參裝飾器、有參裝飾器、functiontools、裝飾器鏈
裝飾器進階：property、staticmethod、classmethod源碼分析（python代碼實現(xiàn)）

裝飾器基礎

無參裝飾器

'''
假定有一個需求是：打印程序函數(shù)運行順序
此案例打印的結(jié)果為：
  foo1 function is starting
  foo2 function is starting
'''
from functools import wraps

def NoParamDec(func):
  #函數(shù)在被裝飾器裝時后，其函數(shù)屬性也會改變，wraps作用就是保證被裝飾函數(shù)屬性不變
  @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()

有參裝飾器

'''
假定有一個需求是：檢查函數(shù)參數(shù)的類型，只允許匹配正確的函數(shù)通過程序
此案例打印結(jié)果為：
('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標準模塊類，可以用來檢查函數(shù)參數(shù)類型，只允許特定類型通過
    sig = signature(func)
    #將函數(shù)形式參數(shù)和規(guī)定類型進行綁定
    check_bind_args = sig.bind_partial(*deco_args, **deco_kwargs).arguments
    
    @wraps(func)
    def wrapper(*args, **kwargs):
      #將實際參數(shù)值和形式參數(shù)進行綁定
      wrapper_bind_args = sig.bind(*args, **kwargs).arguments.items()
      for name, obj in wrapper_bind_args:
        #遍歷判斷是否實際參數(shù)值是規(guī)定參數(shù)的實例
        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']))

裝飾器鏈

'''
假定有一個需求是：
輸入類似代碼：
@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 原理

通常，描述符是具有“綁定行為”的對象屬性，其屬性訪問已經(jīng)被描述符協(xié)議中的方法覆蓋。這些方法是__get__()、__set__()和__delete__()。如果一個對象定義這些方法中的任何一個，它被稱為一個描述符。如果對象定義__get__()和__set__()，則它被認為是數(shù)據(jù)描述符。僅定義__get__()的描述器稱為非數(shù)據(jù)描述符（它們通常用于方法，但是其他用途也是可能的）。

屬性查找優(yōu)先級為：

類屬性
數(shù)據(jù)描述符
實例屬性
非數(shù)據(jù)描述符
默認為__getattr__()

class Property(object):
  '''
  內(nèi)部property是用c實現(xiàn)的，這里用python模擬實現(xiàn)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).

class StaticMethod(object):
  "python代碼實現(xiàn)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).

class ClassMethod(object):
  "python代碼實現(xiàn)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'))

您可能感興趣的文章: