url(r'^index', views.red, name="index_view")

def redirect_test(request):
    page = request.GET.get('page', None)
    if page is not None:
        redirect(page)
    return HttpResponse("OK")

# url
url(r'^example', views.redirect_test, name="redirect")

from django.views.decorators.cache import cache_page

@cache_page(60 * 15)
def cache_views(requests)
    ....


或者

# urls.py
path('cache_url', cache_page(60 * 60 * 6)(cache_views))

def get(self, key, default=None, version=None):
    fname = self._key_to_file(key, version)
    try:
        with open(fname, 'rb') as f:
            if not self._is_expired(f):
                return pickle.loads(zlib.decompress(f.read()))
    except FileNotFoundError:
        pass
    return default

def _is_expired(self, f):
    """
    Take an open cache file `f` and delete it if it's expired.
    """
    try:
        exp = pickle.load(f)
    except EOFError:
        exp = 0  # An empty file is considered expired.
    if exp is not None and exp < time.time():
        f.close()  # On Windows a file has to be closed before deleting
        self._delete(f.name)
        return True
    return False

def _generate_cache_key(request, method, headerlist, key_prefix):
    """Return a cache key from the headers given in the header list."""
    ctx = hashlib.md5()
    for header in headerlist:
        value = request.META.get(header)
        if value is not None:
            ctx.update(value.encode())
    url = hashlib.md5(iri_to_uri(request.build_absolute_uri()).encode('ascii'))
    cache_key = 'views.decorators.cache.cache_page.%s.%s.%s.%s' % (
        key_prefix, method, url.hexdigest(), ctx.hexdigest())
    return _i18n_cache_key_suffix(request, cache_key)

def _key_to_file(self, key, version=None):
    """
    Convert a key into a cache file path. Basically this is the
    root cache path joined with the md5sum of the key and a suffix.
    """
    key = self.make_key(key, version=version)
    self.validate_key(key)
    return os.path.join(self._dir, ''.join(
        [hashlib.md5(key.encode()).hexdigest(), self.cache_suffix]))

import pickle
from django.http.cookie import SimpleCookie
import zlib
import sys


class HttpResponseBase:
    def __init__(self, content_type=None, status=None, reason=None, charset='utf-8'):
        self._headers = {}
        self._resource_closers = [] 
        self._handler_class = None
        self.cookies = SimpleCookie()
        self.closed = False
        self._reason_phrase = reason
        self._charset = charset
        if content_type is None:
            content_type = 'text/html; charset=%s' % self.charset
        self['Content-Type'] = content_type


    def _convert_to_charset(self, value, charset, mime_encode=False):
        if not isinstance(value, (bytes, str)):
            value = str(value)
        if ((isinstance(value, bytes) and (b'\n' in value or b'\r' in value)) or
                isinstance(value, str) and ('\n' in value or '\r' in value)):
            raise BadHeaderError("Header values can't contain newlines (got %r)" % value)
        try:
            if isinstance(value, str):
                # Ensure string is valid in given charset
                value.encode(charset)
            else:
                # Convert bytestring using given charset
                value = value.decode(charset)
        except UnicodeError as e:
            if mime_encode:
                value = Header(value, 'utf-8', maxlinelen=sys.maxsize).encode()
            else:
                e.reason += ', HTTP response headers must be in %s format' % charset
                raise
        return value

    def __setitem__(self, header, value):
        header = self._convert_to_charset(header, 'ascii')
        value = self._convert_to_charset(value, 'latin-1', mime_encode=True)
        self._headers[header.lower()] = (header, value)

    def __delitem__(self, header):
        self._headers.pop(header.lower(), False)

    def __getitem__(self, header):
        return self._headers[header.lower()][1]

    def make_bytes(self, value):

        if isinstance(value, (bytes, memoryview)):
            return bytes(value)
        if isinstance(value, str):
            return bytes(value.encode(self.charset))
        return str(value).encode(self.charset)


class HttpResponse(HttpResponseBase):
    streaming = False

    def __init__(self, content=b'', *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.content = content
    @property
    def content(self):
        return b''.join(self._container)
    @content.setter
    def content(self, value):
        # Consume iterators upon assignment to allow repeated iteration.
        if hasattr(value, '__iter__') and not isinstance(value, (bytes, str)):
            content = b''.join(self.make_bytes(chunk) for chunk in value)
            if hasattr(value, 'close'):
                try:
                    value.close()
                except Exception:
                    pass
        else:
            content = self.make_bytes(value)
        self._container = [content]

    def __iter__(self):
        return iter(self._container)

def readcachecontent(filename):

    f = open(filename, "rb")
    pickle.load(f)
    previous_value =  pickle.loads(zlib.decompress(f.read()))
    f.close()
    print("Content:")
    print(previous_value.content)


if __name__ == '__main__':
    filename = sys.argv[1]
    readcachecontent(filename)

@cache_page(60 * 60, key_prefix="obfuscating cache")