django缓存

1. 如何清理django产生的缓存

你是使用多进程的方式启动的吧，应该是部分进程更新了，刷新后会随机使用某个进程执行代码，所以会有旧的和新的同时出现，你重启下django吧。

不过也有另一种可能你做了页面换成，在view上使用了django的cache修饰器，这样的话需要先删除所有服务器上的缓存。

如果解决了您的问题请采纳！
如果未解决请继续追问

2. django redis-cache服务重启后，缓存还在吗

还在，这个存储在redis里面，redis本身带持久化机制，正常的服务器重启对这个没有影响，除非你的redis 碰到突然crash这类的问题，可能会影响短时间内的数据正常。

3. django 怎么先走缓存没有数据在走views

用@cache_page装饰器定义view级缓存，前提是定义好Cache的相关配置。

4. Django中app文件夹中的文件都是干什么用的

C:\Users\用户名\AppData里面一般有三个文件夹，分别是Local，LocalLow，Roaming，简单地来说，都是用来存放软件的配置文件和临时文件的，里面有很多以软件名称或软件公司命名的文件夹，理论上都可以删除。例如，如果安装了PhotoshopCS5，在AppData搜索Adobe，将搜到的文件和文件夹全部删除，然后启动Photoshop，已删除的文件又会重新生成，但体积变小。删除文件的时候千万要小心，因为AppData同时存放了用户帐户的配置文件。随着系统使用时间的增加和安装软件的增多，AppData占用的空间会越来越大。有一个非常简单的方法可以安全删除AppData整个文件夹，就是删除帐户！更换用户帐户有一个好处是可以“重置”系统，减少垃圾文件，但也会带来不少麻烦，系统好像回到了新安装的状态，某些软件需要重新激活，极个别软件需要重新安装。附：其中三个文件夹的作用，里面的文件可以随心所欲地删除。C:\Users\用户名\AppData\Local\Temp里面是临时文件。C:\Users\用户名\AppData\Local\Microsoft\Windows\TemporaryInternetFiles里面是IE缓存文件（默认是隐藏的）。C:\Users\用户名\AppData\Local\Microsoft\Windows\History里面是浏览器历史记录（默认是隐藏的）。

5. Django什么情况

在朋友和同事的极力推荐下最近开始看上了python,其实主要是还是因为python是2007年度语言,怎么的也要与时俱进呀.最近一路看来有些心得,希望能与大家分享,小弟其实也只接触不到一周的python,有说错的地方还望大家指出改正.

不打算从py的语法基础说起了,直接说说对django的心得:

接触django首先需要了解可能就是他那个model，建立一个model就什么都有了，这对于搞java得人员来说还是挺有吸引力的（当然貌似对于动态语言这都是小儿科），那么让我们先看一个model的例子：

偷懒了，直接拿django-admin里面的User出来了

class User(models.Model):
username = models.CharField(_('username'), maxlength=30, unique=True, validator_list=[validators.isAlphaNumeric]))
first_name = models.CharField(_('first name'), maxlength=30, blank=True)
last_name = models.CharField(_('last name'), maxlength=30, blank=True)
email = models.EmailField(_('e-mail address'), blank=True)
password = models.CharField(_('password'), maxlength=128))
class Meta:
ordering = ('username',)
每个属性就是一个库表的字段，定义起来非常简单明了，models里面提供了很多种类的Field类似上面的EmailField。不同的Field有不同的设置，可以看相应的原来来了解相关的设置．

在model class内部还有一个class Meta，这个Class的属性制定了这个表的一些存取策略，例如这里的ordering。MetaClass里面的属性可以用model的_meta属性取得。OK，那么这样一个model怎么就能实现对数据库表的灵活操作了呢。让我们来看看吧。

首先先分析一下/django/django/db/models/base.py这个文件，其中包含了models.Model这类的定义：

看看class定义的第一行吧，第一行就够我琢磨一阵子的了：

class Model(object):
__metaclass__ = ModelBase
Model采用了new style class定义，关于这个内容大家可以放狗看一下，第一行是一个__metaclass__属性的定义，该属性的值是ModelBase，这是一个类。__metaclass__的意思是，指定一个class，这个class的实例就是本class，相信您已经晕了。那么就拿这个Model的例子来说明一下，如果没有__metaclass__这个属性，产生一个实例就是正常的流程，有了这个属性流程会有改变：

首先调用BaseModel.__new__(cls, name, bases, attrs)这个方法，回返回的值是一个class类型，然后用这个class来创建实例。其实BaseModel就是Model的元类，来制定Model这个类的最终样子。关于元类的更多信息请看这里

那么我们的目光一下转移到BaseModel这个类上，我有种直觉，Meta这个class最后可以用_meta来取就是在这里做的手脚，看一下BaseModel的定义吧，有点长：

class ModelBase(type):
"Metaclass for all models"
def __new__(cls, name, bases, attrs):
# If this isn't a subclass of Model, don't do anything special.
if name == 'Model' or not filter(lambda b: issubclass(b, Model), bases): #1
return super(ModelBase, cls).__new__(cls, name, bases, attrs)

# Create the class.
new_class = type.__new__(cls, name, bases, {'__mole__': attrs.pop('__mole__')}) #2
new_class.add_to_class('_meta', Options(attrs.pop('Meta', None))) #3
new_class.add_to_class('DoesNotExist', types.ClassType('DoesNotExist', (ObjectDoesNotExist,), {}))

# Build complete list of parents #4
for base in bases:
# TODO: Checking for the presence of '_meta' is hackish.
if '_meta' in dir(base):
new_class._meta.parents.append(base)
new_class._meta.parents.extend(base._meta.parents)

model_mole = sys.moles[new_class.__mole__]

if getattr(new_class._meta, 'app_label', None) is None:
# Figure out the app_label by looking one level up.
# For 'django.contrib.sites.models', this would be 'sites'.
new_class._meta.app_label = model_mole.__name__.split('.')[-2] #5

# Bail out early if we have already created this class.
m = get_model(new_class._meta.app_label, name, False) #6
if m is not None:
return m

# Add all attributes to the class.
for obj_name, obj in attrs.items():
new_class.add_to_class(obj_name, obj) #7

# Add Fields inherited from parents
for parent in new_class._meta.parents:
for field in parent._meta.fields:
# Only add parent fields if they aren't defined for this class.
try:
new_class._meta.get_field(field.name)
except FieldDoesNotExist:
field.contribute_to_class(new_class, field.name) #8

new_class._prepare()

register_models(new_class._meta.app_label, new_class) #9
# Because of the way imports happen (recursively), we may or may not be
# the first class for this model to register with the framework. There
# should only be one class for each model, so we must always return the
# registered version.
return get_model(new_class._meta.app_label, name, False) #10
简单分析一下这个代码：

1. 检查class是否为Model的子类，不是的话，不做任何处理，直接传给父类处理，也就相当于正常的处理了class，注意super在多重继承的时候应该严格使用

2. 用type来创建类，创建的就是正常的ModelClass

3. 这句很重要，add_to_class是Model里面的class方法，这个方法其实就是传入name和value，给Model添加class属性.看到了，原来神奇的_meta就是这么来的. 提到add_to_class方法，简单看一下它的代码：

def add_to_class(cls, name, value):
if name == 'Admin':
assert type(value) == types.ClassType, "%r attribute of %s model must be a class, not a %s object" % (name, cls.__name__, type(value))
value = AdminOptions(**dict([(k, v) for k, v in value.__dict__.items() if not k.startswith('_')]))
if hasattr(value, 'contribute_to_class'):
value.contribute_to_class(cls, name)
else:
setattr(cls, name, value)
add_to_class = classmethod(add_to_class)
最后一句是制定这个方法是class方法，特点就是方法的第一个参数是本class，其实classmethod就是一个装饰器，在2。4之后可以使用@来简写。这里不得不提的是他对Admin的特殊处理，虽然AdminOption不是在admin模块里面的，但是这么做还是跟一个Admin的东东绑定起来了，在java的世界解耦是一件大事，看到下面还有对'contribute_to_class'这个方法的特殊处理，django为啥不弄的解耦点呢。而且同样是包装成Option，一个是在BaseModel里面弄（那个Meta的包装），一个在add_to_class方法里面弄，实在有点不优雅，可能还没了解太多，不知道他的深度用意吧。
4. Meta的集成，Option的这个类提供继承方法

5. 取得applabel，就是把model的名字分割取到数第二个，我很喜欢-2这样的设定

6. get_model方法取得缓存里面的东西。

7. 把所有的class attr拿出来搞一遍，一般的属性就setattr弄回去了，要是这个属性有contribute_to_class这个callable属性，那就执行之（Admin的处理完全也可以这样，其实我们常用的objects就是用这个方法弄的）

8. 每个Field调用自己的contribute_to_class方法来进行特殊的处理

9. 进入缓存，，暂且叫缓存吧，里面的东西大家看看很简单 文件在 /django/django/db/models/loading.py 里面还是有很多内容的

10.看注释说的很清楚了，我们一定要在缓存里面拿model。

6. 如何django中用redis缓存服务器，求详细教程。

django-redis 中文文档
Andrey Antukh, [email protected] 4.7.0

翻译: RaPoSpectre

1. 介绍

django-redis 基于 BSD 许可, 是一个使 Django 支持 Redis cache/session 后端的全功能组件.

1.1 为何要用 django-redis ?
因为:

持续更新
本地化的 redis-py URL 符号连接字符串
可扩展客户端
可扩展解析器
可扩展序列器
默认客户端主/从支持
完善的测试
已在一些项目的生产环境中作为 cache 和 session 使用
支持永不超时设置
原生进入 redis 客户端/连接池支持
高可配置 ( 例如仿真缓存的异常行为 )
默认支持 unix 套接字
支持 Python 2.7, 3.4, 3.5 以及 3.6
1.2 可用的 django-redis 版本
稳定版本: 4.7.0
稳定版本: 3.8.4
1.3 我该使用哪个版本
版本号像 3.6, 3.7 … 等的是主要发行版本, 会包含向后不兼容的内容. 跟多信息请在升级前阅读升级日志.

版本号像 3.7.0, 3.7.1… 等的是小更新或者 bug 修复版本, 一般只会包含 bug 修复, 没有功能更新.

1.4 依赖
1.4.1 Django 版本支持
django-redis 3.8.x 支持 django 1.4, 1.5, 1.6, 1.7 (或许会有 1.8)
django-redis 4.4.x 支持 django 1.6, 1.7, 1.8, 1.9 和 1.10
1.4.2 Redis Server 支持
django-redis 3.x.y 支持 redis-server 2.6.x 或更高
django-redis 4.x.y 支持 redis-server 2.8

7. 如何对django的model对象缓存

直接利用python提供的json包，在django model的定义中增加一个方法toJSON，利用django model 能访问 _meta.fields 得到相关属性而得到，例子如下： class Category(models.Model): autoid = models.AutoField(primary_key=True) email=models.Ch

8. 震惊，Django缓存中的数据频频丢失，究竟谁是幕后黑手

1.起因

昨天晚上尝试使用celery对Django缓存进行定时任务的更新，
但是发现定时任务并不能刷新到Django中，
由此开始了一阵debug

2.经过

2.1问题出现的场景

想使用一个后台任务在缓存中存放一些信息，然后在Django中有request的时候可以快速获取到页面信息，
但是失败了，用户在进入主页的时候并没有获取到后台任务在缓存中存放的信息

2.2尝试解决问题经过

首先使用celery打出cache对象的内存地址以及一些简单信息

原因: 不同py进程在from django.core.cache import cache中获取的 cache 只是原型的复制品，并不是同一块内存

2.3 解决问题的过程

当然，我们的问题并没有解决，真正的原因是因为我一开始使用的是

CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', 'LOCATION': 'unique-snowflake',
}
}

我所使用的LocMemCache它的机制是不能做同步缓存的 (*见第三小节)

在更改为DatabaseCache之后，问题解决

CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.db.DatabaseCache', 'LOCATION': 'django_cache',
}
}

3.结论与文档

废话不多说，直接上官方文档吧:

Local-memory caching

This is the default cache if another is not specified in your settings file. If you want the speed advantages of in-memory caching but don’t have the capability of running Memcached, consider the local-memory cache backend. This cache is per-process (see below) and thread-safe. To use it, set BACKEND to “django.core.cache.backends.locmem.LocMemCache”. For example:

CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', 'LOCATION': 'unique-snowflake',
}
}

The cache LOCATION is used to identify indivial memory stores. If you only have one locmem cache, you can omit the LOCATION; however, if you have more than one local memory cache, you will need to assign a name to at least one of them in order to keep them separate.

Note that each process will have its own private cache instance, which means no cross-process caching is possible. This obviously also means the local memory cache isn’t particularly memory-efficient, so it’s probably not a good choice for proction environments. It’s nice for development.

着重标记最后一段文档:

Note that each process will have its own private cache instance, which means no cross-process caching is possible.
注意每个进程都有自己的私有缓存实例，这意味着不可能有跨进程缓存

所以说，LocMemCache是不能用来做同步缓存的! 请使用别的任意Cache!

9. django 制作web网站，动态页面数据已更新，但是无法刷新，这是怎么回事是页面缓存吗

“再次刷新页面时应该显示该用户已注册过的提示”，我觉着似乎有些别扭：

通常注册时应该包括这几个逻辑：
1.需要认证登陆的页面，自动跳转到登陆页
2.用户登陆不成功，则重复登陆，提示注册，
3.如果注册时用户名重复，提示继续注册，注册成功后，
4.注册成功后有两种处理，一种与登陆成功一样跳转，或者是提示注册成功
5.用户登陆成功后自动跳转到前面的那个需要认证的history url的页
或者是登陆到系统主页，并在上面提示栏里显示用户名，以及登陆状态

你这种情况应该是注册成功后如果是通常客户端跳转到了主页面，你再刷新，刷新的是主页面的URL，而不是post请求。所以仍然会显示主页信息。

如果你服务端用的是302 location的办法，则浏览器仍然保留注册的那个URL，再刷新应该是提示了post请求则既然是是刷新的post请求，这个时候应该提示已注册过的信息。

如果你现在仍然显示注册成功信息，说明服务端可以重复注册相同的用户名。需要改一下业务逻辑。

10. 如何在django中使用redis做缓存服务器

实现缓存的方式，有多种，本地内存缓存，数据库缓存，文件系统缓存。这里介绍使用Redis数据库进行缓存。

环境

• redis

• django-redis

配置

• settings.py

• CACHES = { "default": { "BACKEND": "django_redis.cache.RedisCache", "LOCATION": "redis://127.0.0.1:6379/1", "OPTIONS": { "CLIENT_CLASS": "django_redis.client.DefaultClient", "PASSWORD": "mysecret"


• }


• }


• }


• python manage.py createcachetable1



缓存有站点缓存，和单个view缓存

• 站点缓存：
  

• settings.py

• MIDDLEWARE = [ # 站点缓存 ， 注意必须在第一个位置


• 'django.middleware.cache.UpdateCacheMiddleware',


• ... # 站点缓存, 注意必须在最后一个位置


• 'django.middleware.cache.FetchFromCacheMiddleware',


• ]



• 视图缓存：
  

• views.py

• from django.shortcuts import renderfrom django.views.decorators.cache import cache_pagefrom cache.models import Foo# 在需要缓存的视图上添加装饰器, 参数是设置timeout 超时时间， 单位是秒， @cache_page(60)def index(request):


• bar = Foo.objects.all() return render(request, 'cache/index.html', {'bar': bar})