pip install lazyprop例子1

from lazyprop import lazypropclass Foo(object): def __init__(self):self.load_count = 0 @lazyprop def lazy(self):self.load_count += 1f = Foo()f.lazyf.lazyf.lazyprint(f.load_count)

輸出：

1

from lazyprop import lazypropclass Foo(object): def __init__(self):self.load_count = 0 # @lazyprop def lazy(self):self.load_count += 1f = Foo()f.lazyf.lazyf.lazyprint(f.load_count)

輸出：

0

補充：python語言中的AOP利器：裝飾器

面向切面編程（AOP）是一種編程思想，與OOP并不矛盾，只是它們的關注點相同。面向對象的目的在于抽象和管理，而面向切面的目的在于解耦和復用。

1）java中mybatis的@Transactional注解，大家知道被這個注解注釋的函數立即就能獲得DB的事務能力。

2）python中的with threading.Lock()，大家知道，被這個with代碼塊包裹的部分立即獲得同步的鎖機制。

這樣我們把事務和加鎖這兩種與業務無關的邏輯抽象出來，在邏輯上解耦，并且可以輕松的做到代碼復用。

當然你可以使用with上下文管理器實現一些AOP的思想，這里有個模塊叫contextlib可以幫助你簡易的實現上下文管理器。

上下文管理最常見的例子是with open(’file’) as fh，回收打開句柄的例子。

這種方式還是比較麻煩的，下面我們看一下python中的裝飾器怎么樣實現AOP編程。

python中的裝飾器就是設計來實現切面注入功能的。下面給出幾個例子，這幾個例子都是在生產環境驗證過的。

其中的任務管理機是偽代碼，需要自己實現寫數據庫的邏輯。

只要do函數被@retry_exp裝飾，便可以獲得指數退避的重試能力。

@retry_exp(max_retries=10)def do(): # do whatever pass

那retry_exp是如何實現的呢？

def retry_exp(max_retries=3, max_wait_interval=10, period=1, rand=False): def _retry(func):def __retry(*args, **kwargs): MAX_RETRIES = max_retries MAX_WAIT_INTERVAL = max_wait_interval PERIOD = period RAND = rand retries = 0 error = None ok = False while retries < MAX_RETRIES:try: ret = func(*args, **kwargs) ok = True return retexcept Exception, ex: error = exfinally: if not ok:sleep_time = min(2 ** retries * PERIOD if not RAND else randint(0, 2 ** retries) * PERIOD, MAX_WAIT_INTERVAL)time.sleep(sleep_time)retries += 1 if retries == MAX_RETRIES:if error: raise errorelse: raise Exception('unknown')return __retry return _retry2、降級開關

只要do函數被@degrade裝飾，就會安裝app名稱校驗redis里的開關，一旦發現開關關閉，則do函數不被執行，也就是降級。

@degradedef do(app): # do whatever pass

那么degrade是怎樣實現的呢？

def degrade(app): def _wrapper(function):def __wrapper(*args, **kwargs): value = None try:redis = codis_pool.get_connection()value = redis.get('dmonitor:degrade:%s' % app) except Exception, _:logger.info(traceback.format_exc()) if not value or int(value) != 1:function()logger.info('[degrade] is_on: %s' % app) else:logger.info('[degrade] is_off: %s' % app)return __wrapper return _wrapper3、任務狀態機

這個是最常用的，我們需要跟蹤落盤DB一個任務的執行狀態(等待調度，執行中，執行成功，執行失敗)

一旦do方法被@tasks_decorator裝飾，就獲得了這樣的能力。對item_param(是個json)中task_id指明的任務進行狀態管理。

@tasks_decoratordef do(item_param): # do whatever pass

tasks_decorator是怎樣實現的呢？

def tasks_decorator(function): def _wrap(*args, **kwargs):param_dict = kwargs.get(’item_param’)task_id = param_dict.get(’task_id’)try: param_dict.update({’status’: TaskStatus.Waiting, ’start_time’: datetime.now().strftime(’%Y-%m-%d %H:%M:%S’)}) try:manager_dao.save_task(param_dict) except Exception, ex:pass _update_task_status(task_id, TaskStatus.Doing) function(*args, **kwargs) _update_task_status(task_id, TaskStatus.Done)except Exception as e: time.sleep(0.5) _update_task_status(task_id, TaskStatus.Fail, unicode(e.message)) raise return _wrap4、全局唯一性

在分布式+異步環境中，如果想保證exactly once是需要額外的邏輯的，其實主要是實現唯一鍵，一旦唯一鍵實現了，就可以使用公共緩存redis進行唯一鍵判定了。

do函數被unique裝飾，那么對于task_id對應的任務，全局只會執行一次。

@uniquedef do(task_id): # do whatever pass

unique是怎樣實現的呢？

def unique(function): def _wrap(*args, **kwargs):task_id = kwargs.get(’task_id’)try: redis = codis_pool.get_connection() key = 'unique:%s' % task_id if not redis.setnx(key):redis.expire(key, 24*60*60)function(*args, **kwargs)except Exception as e: logger.error(traceback.format_exc()) raise return _wrap四、總結

AOP在少量增加代碼復雜度的前提下，顯著的獲得以下優點：

1、使得功能邏輯和業務邏輯解耦，功能和業務的修改完全獨立，代碼結構清晰，開發方便

2、一鍵注入，代碼復用程度高，擴展方便

以上為個人經驗，希望能給大家一個參考，也希望大家多多支持好吧啦網。