web-dev-qa-db-fra.com

Existe-t-il une bibliothèque de cache Python?

Je cherche une bibliothèque de cache Python mais je ne trouve rien jusqu'à présent. J'ai besoin d'une simple interface de type dict- où je peux définir les clés, leur leur retour en cache.

cache.get(myfunction, duration=300)

qui me donnera l'élément du cache s'il existe ou appelle la fonction et le stocke s'il n'a pas expiré ou s'il a expiré. Est-ce que quelqu'un sait quelque chose comme ça?

pythoncaching
107
Stavros Korokithakis

Jetez un coup d'œil à Beaker:

46
Corbin March

À partir de Python 3.2, vous pouvez utiliser le décorateur @ lru_cache de la bibliothèque functools. Il s’agit d’un cache utilisé récemment, il n’existe donc aucun délai d’expiration pour les éléments qu’il contient, mais comme un hack rapide c'est très utile.

from functools import lru_cache

@lru_cache(maxsize=256)
def f(x):
  return x*x

for x in range(20):
  print f(x)
for x in range(20):
  print f(x)
58
Genma

Vous pouvez également jeter un oeil à Memoize decorator . Vous pourriez probablement le faire faire ce que vous voulez sans trop de modifications.

27
tgray

Joblib http://packages.python.org/joblib/ prend en charge les fonctions de mise en cache dans le modèle Memoize. Généralement, l’idée est de mettre en cache des fonctions coûteuses en calcul.

>>> from joblib import Memory
>>> mem = Memory(cachedir='/tmp/joblib')
>>> import numpy as np
>>> square = mem.cache(np.square)
>>> 
>>> a = np.vander(np.arange(3)).astype(np.float)
>>> b = square(a)                                   
________________________________________________________________________________
[Memory] Calling square...
square(array([[ 0.,  0.,  1.],
       [ 1.,  1.,  1.],
       [ 4.,  2.,  1.]]))
___________________________________________________________square - 0...s, 0.0min

>>> c = square(a)

Vous pouvez également faire des choses fantaisistes comme utiliser le décorateur @ memory.cache sur des fonctions. La documentation est ici: http://packages.python.org/joblib/memory.html

14
j13r

Personne n'a encore mentionné shelve. https://docs.python.org/2/library/shelve.html

Il n'est pas mémorisé, mais semble beaucoup plus simple et pourrait répondre à vos besoins.

12
NuclearPeon

Je pense que la python memcached est l'outil le plus utilisé, mais je ne l'ai pas utilisé moi-même et je ne suis pas sûr qu'il prenne en charge les fonctionnalités dont vous avez besoin.

9
David Berger
import time

class CachedItem(object):
    def __init__(self, key, value, duration=60):
        self.key = key
        self.value = value
        self.duration = duration
        self.timeStamp = time.time()

    def __repr__(self):
        return '<CachedItem {%s:%s} expires at: %s>' % (self.key, self.value, time.time() + self.duration)

class CachedDict(dict):

    def get(self, key, fn, duration):
        if key not in self \
            or self[key].timeStamp + self[key].duration < time.time():
                print 'adding new value'
                o = fn(key)
                self[key] = CachedItem(key, o, duration)
        else:
            print 'loading from cache'

        return self[key].value



if __== '__main__':

    fn = lambda key: 'value of %s  is None' % key

    ci = CachedItem('a', 12)
    print ci 
    cd = CachedDict()
    print cd.get('a', fn, 5)
    time.sleep(2)
    print cd.get('a', fn, 6)
    print cd.get('b', fn, 6)
    time.sleep(2)
    print cd.get('a', fn, 7)
    print cd.get('b', fn, 7)
7
Tzury Bar Yochay

Essayez redis, c’est l’une des solutions les plus propres et les plus simples pour les applications qui permettent de partager des données de manière atomique ou avec une plate-forme de serveur Web. Son très facile à installer, vous aurez besoin d'un python client redis http://pypi.python.org/pypi/redis

5
harry

Vous pouvez utiliser ma solution simple au problème. C'est vraiment simple, rien d'extraordinaire:

class MemCache(dict):
    def __init__(self, fn):
        dict.__init__(self)
        self.__fn = fn

    def __getitem__(self, item):
        if item not in self:
            dict.__setitem__(self, item, self.__fn(item))
        return dict.__getitem__(self, item)

mc = MemCache(lambda x: x*x)

for x in xrange(10):
    print mc[x]

for x in xrange(10):
    print mc[x]

Il manque certes une fonctionnalité d'expiration, mais vous pouvez facilement l'étendre en spécifiant une règle particulière dans MemCache c-tor.

Hope code est suffisamment explicite, mais si ce n'est pas le cas, il suffit de mentionner que la fonction de cache est en train de transmettre une fonction de traduction en tant qu'un de ses paramètres c-tor. Il est utilisé à son tour pour générer une sortie en cache concernant l'entrée.

J'espère que ça aide

4
Jakub Koszuliński

Regardez gocept.cache sur pypi, gérez le délai d'attente.

2
Andreas Jung

Regardez bda.cache http://pypi.python.org/pypi/bda.cache - utilise ZCA et est testé avec zope et bfg.

0
Jens W. Klein