Có thư viện bộ nhớ đệm Python không?

Tôi đang tìm thư viện bộ nhớ đệm Python nhưng không tìm thấy gì cho đến nay. Tôi cần một dictgiao diện giống như đơn giản , nơi tôi có thể đặt các khóa và thời hạn của chúng và khôi phục chúng vào bộ nhớ đệm. Đại loại như:

cache.get(myfunction, duration=300)

sẽ cung cấp cho tôi mục từ bộ nhớ cache nếu nó tồn tại hoặc gọi hàm và lưu trữ nó nếu nó không có hoặc đã hết hạn. Có ai biết một cái gì đó như thế này?

Hãy xem Beaker:

• Trang chủ
• Tài liệu bộ nhớ đệm
• Bài viết bắt đầu nhanh về cách sử dụng Beaker với Django (nhưng cũng hữu ích trong bất kỳ ứng dụng nào khác)

Từ Python 3.2, bạn có thể sử dụng decorator @lru_cache từ thư viện functools. Đây là bộ đệm được sử dụng gần đây nhất, vì vậy không có thời gian hết hạn cho các mục trong đó, nhưng là một bản hack nhanh, nó rất hữu ích.

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)

Bạn cũng có thể xem qua trình trang trí Memoize . Bạn có thể có được nó để làm những gì bạn muốn mà không cần sửa đổi quá nhiều.

Joblib https://joblib.readthedocs.io hỗ trợ các chức năng bộ nhớ đệm trong mẫu Memoize. Phần lớn, ý tưởng là lưu trữ các hàm tốn kém về mặt tính toán.

>>> 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)

Bạn cũng có thể làm những việc ưa thích như sử dụng trình trang trí @ memory.cache trên các hàm. Tài liệu ở đây: https://joblib.readthedocs.io/en/latest/generated/joblib.Memory.html

Chưa có ai đề cập đến giá đỡ. https://docs.python.org/2/library/shelve.html

Nó không phải là bộ nhớ đệm, nhưng trông đơn giản hơn nhiều và có thể phù hợp với nhu cầu của bạn.

Tôi nghĩ rằng API python memcached là công cụ phổ biến, nhưng bản thân tôi chưa sử dụng nó và không chắc liệu nó có hỗ trợ các tính năng bạn cần hay không.

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 __name__ == '__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)

Bạn có thể sử dụng giải pháp đơn giản của tôi cho vấn đề. Nó thực sự đơn giản, không có gì hoa mỹ:

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]

Nó thực sự thiếu tính vui nhộn khi hết hạn, nhưng bạn có thể dễ dàng mở rộng nó bằng cách chỉ định một quy tắc cụ thể trong MemCache c-tor.

Mã hy vọng là đủ để tự giải thích, nhưng nếu không, chỉ cần đề cập, bộ nhớ cache đó đang được chuyển một chức năng dịch như một trong các tham số c-tor của nó. Nó được sử dụng lần lượt để tạo ra đầu ra được lưu trong bộ nhớ cache liên quan đến đầu vào.

Hy vọng nó giúp

Hãy thử redis, đây là một trong những giải pháp sạch nhất và dễ dàng nhất cho các ứng dụng chia sẻ dữ liệu theo cách nguyên tử hoặc nếu bạn có một số nền tảng máy chủ web. Nó rất dễ cài đặt, bạn sẽ cần một ứng dụng khách python redis http://pypi.python.org/pypi/redis

Nhìn vào gocept.cache trên pypi, quản lý thời gian chờ.

Dự án này nhằm mục đích cung cấp "Bộ nhớ đệm cho con người" (có vẻ như nó khá chưa được biết đến)

Một số thông tin từ trang dự án:

Cài đặt

pip cài đặt bộ nhớ cache

Sử dụng:

import pylibmc
from cache import Cache

backend = pylibmc.Client(["127.0.0.1"])

cache = Cache(backend)

@cache("mykey")
def some_expensive_method():
    sleep(10)
    return 42

# writes 42 to the cache
some_expensive_method()

# reads 42 from the cache
some_expensive_method()

# re-calculates and writes 42 to the cache
some_expensive_method.refresh()

# get the cached value or throw an error
# (unless default= was passed to @cache(...))
some_expensive_method.cached()

Hãy xem bda.cache http://pypi.python.org/pypi/bda.cache - sử dụng ZCA và được thử nghiệm với zope và bfg.

keyring là thư viện bộ nhớ đệm python tốt nhất. Bạn có thể dùng

keyring.set_password("service","jsonkey",json_res)

json_res= keyring.get_password("service","jsonkey")

json_res= keyring.core.delete_password("service","jsonkey")