python高级编程：缓存

# -*- coding: utf-8 -*-
__author__ = 'Administrator'
#缓存
"""
对于运行代价很高的函数和方法结果，可以进行缓存，只要:
1:该函数是确定性的，输入相同值，生成结果每次都相同;
2:函数返回值在一定时期内(不确定)持续有用和有效

--------
确定性函数是相同参数将始终返回相同的结果，而不确定性的函数返回结果则可能有变化
"""
#较好的缓存候选者通常是:
"""
来自查询数据库的可调用对象结果
来自呈现静态值（像文件内容，WEB请求或者PDF显示）的可调用对象结果
来自确定性的，执行复杂计算的可调用对象结果
记录具有过期时间的数值全局映射，如WEB对话对象
一些需要经常和快速访问的数据.
"""
#1确定性缓存
#计算平方数函数的例子
import random,timeit
import profile,print_stats
cache={}
def s(n):
    return n*n
@profile('not cache')
def f():
    for i in xrange(100):
        s(random.randint(1,10))
def cache_f(n):
    if n not in cache:
        cache[n]=s(n)
    return cache[n]
@profile('cache')
def c_f():
    n=[random.randint(1,10)for i in range(10)]
    ns=[cache_f(i)for i in n]

print f(),c_f()
print print_stats()
"""
当然，只要与缓存交互的时间比函数花费时间少，缓存就是有效的，如果重新计算该值更快一些，姥就一定要这么做，如果使用不正确，缓存也可能危险的
"""
#例子2
"""
在上一个例子中，使用一个函数的参数做为缓存的键值，就只有当参数可以hash时才有效，当参数就的复杂时，并且不一定可以hash时。必须手工处理它们并且将其转换为用于缓存的唯一键值
"""
def me(a,b,c,d):
    key='cache me :::%s %s %s'%(a,b,c)
    if key not in key:
        print 'caching'
        cache[key]=complex_calculation(a,b,c,d)
    print d
    return  cache[key]
"""
当然，有可能通过这个遍历每个参数以自动创建键值，但是有许多特殊情况，将需要手工计算该键值，这样的行为叫备注，可以使用装饰器来处理
"""
#如下:
cache={}
def get_key(function ,*a,**b):
    key='%s.%s'%(function.__module__,function.__name__)
    hash_args=[str(a1)for a1 in a]
    #当然，只有当V可以hash时才能正常使用
    kv=['%s:%s'%(k,hash(v))for k,v in b.items()]
    return '%s:%s:%s'%(key,hash_args,kv)
def memioze(get_key=get_key,caheck=cache):
    def _m(func):
        def _me(*a,**b):
            key=get_key(func,*a,**b)
        try:
            return caheck[key]
        except KeyError as s:
            caheck[key]=func(*a,**b)
            return value
        return _me
    return _m
@memioze()
def faction1(n):
    return n*n

faction1(4)
print cache
"""
这个装饰器使用了一个可调用 的对象来计算键值，默认的get_key将进行参数的内省，如果关键字不能hash,则出现异常
但是这个函数只用于特殊情况，保存值的映射也可以配置的

觉的方法是计算参数的md5 hash或(sha)，但是要知道，这样一个hash是有实际代价的，函数本身比键值计算更快的，缓存才意义
"""
#例子3
import md5
def key1(fuction1,n):
    return  md5.md5(str(n)).hexdigest()
@memioze(key1)
def n(n1):
    return n1**2

------------------

# -*- coding: utf-8 -*-
__author__ = 'Administrator'
#非确定性缓存
"""
对于非确定性函数而言，即使在指定相同输入时，也可能产生不同的输入
缓存持续时间按照数据平均更新时间来设置
"""
#例子
c={}
def m(get_kye=get_key,s=c,arg=0):
    def _m(f):
        def __(*a,**b):
            key=get_kye(f,*a,**b)
            try:
                v1,v2=s[key]
                exp=(arg!=0 and (v1)<time.time())
            except KeyError as s:
                exp=True
            if not exp:
                return v2
            s[key]=time.time(),f(*a,**b)
            return s[key][1]
        return __m
    return _m
#假设有一个显示当前时间的函数，如果不显示秒数，那么可以在30秒的老化其来缓存它，来获得合理精确度缓存值
from datetime import datetime
@m(age=30)
def w_t():
    return datetime.now().strftime('%H:%M')
w_t()
c
"""
当然，缓存作废必须由删除过期键的另一个函数异步实现，以加速m函数，在WEB里面经常出现
-----------
主动式缓冲
有很多缓存策略可以用来加速应用程序
MEMCACHED，如果对缓存要求很高可以使用它（http://www.danga.com/memcached）
，它是unix的，也可以在其他平台和其他语言来驱动它
更多可以请看:(http://pypi.python.org/pypi/Beakey)"""