1、使用python内存进行缓存
autocache.py 

#!/usr/bin/env python
#coding=utf-8
 
'''装饰器版的python自动缓存系统'''
 
import time
import hashlib
import pickle
from functools import wraps
 
_cache = {}
 
def _is_obsolete(entry, duration):
    '''是否过期'''
    if duration == -1: #永不过期
        return False
    return time.time() - entry['time'] > duration
 
def _compute_key(function, args,kw):
    '''序列化并求其哈希值'''
    key = pickle.dumps((function.func_name,args,kw))
    return hashlib.sha1(key).hexdigest() 
 
def memorize(duration = -1):
    '''自动缓存'''
    def _memoize(function):
        @wraps(function) # 自动复制函数信息
        def __memoize(*args, **kw):
            key = _compute_key(function, args, kw)
            #是否已缓存？
            if key in _cache:
                #是否过期？
                if _is_obsolete(_cache[key], duration) is False:
                    return _cache[key]['value']
            # 运行函数
            result = function(*args, **kw)
            #保存结果
            _cache[key] = {
                'value' : result,
                'time'  : time.time()
            }
            return result
        return __memoize
    return _memoize

2.使用redis缓存

 autocache_redis.py

#!/usr/bin/env python
#coding=utf-8
 
'''装饰器版的python自动缓存系统，使用redis持久化数据库'''
 
import hashlib
import pickle
import redis
from functools import wraps
 
r = redis.Redis(host="localhost",port=6379,db=0)
 
def _compute_key(function, args,kw):
    '''序列化并求其哈希值'''
    key = pickle.dumps((function.func_name,args,kw))
    return hashlib.sha1(key).hexdigest() 
 
def memorize(duration = -1):
    '''自动缓存'''
    def _memoize(function):
        @wraps(function) # 自动复制函数信息
        def __memoize(*args, **kw):
            key = _compute_key(function, args, kw)
            #是否已缓存？
            if r.exists(key):
                try: # 判断存在和返回之间还有一段时间，可能造成key不存在
                    return r[key]
                except:
                    pass
            # 运行函数
            result = function(*args, **kw)
            #保存结果
            r[key] = result
            r.expire(key,duration)
            return result
        return __memoize
    return _memoize

3.测试

 test_autocache_redis.py

#!/usr/bin/env python
#coding=utf-8
from autocache_redis import memorize
 
@memorize(3)
def a_hard_function(a):
    '''一个需要缓存的函数'''
    print "getting result"
    from time import sleep
    import random
    sleep(2)
    return a,random.randint(1,100)
 
if __name__=='__main__':
    while True:
        print a_hard_function(1)
        print a_hard_function(2)
        print a_hard_function.__doc__ #函数文档保持不变