Django项目知识点汇总

整个application()函数本身没有涉及到任何解析HTTP的部分，也就是说，底层代码不需要我们自己编写，
我们只负责在更高层次上考虑如何响应请求就可以了。application()函数必须由WSGI服务器来调用。有很多符合WSGI规范的服务器，我们可以挑选一个来用。Python内置了一个WSGI服务器，这个模块叫wsgiref application()函数就是符合WSGI标准的一个HTTP处理函数，它接收两个参数： //environ：一个包含所有HTTP请求信息的dict对象； //start_response：一个发送HTTP响应的函数。在application()函数中，调用：start_response('200 OK', [('Content-Type', 'text/html')])就发送了HTTP响应的Header，注意Header只能发送一次，也就是只能调用一次start_response()函数。
start_response()函数接收两个参数，一个是HTTP响应码，一个是一组list表示的HTTP Header，每
个Header用一个包含两个str的tuple表示。通常情况下，都应该把Content-Type头发送给浏览器。其他很多常用的HTTP Header也应该发送。然后，函数的返回值b'<h1>Hello, web!</h1>'将作为HTTP响应的Body发送给浏览器。有了WSGI，我们关心的就是如何从environ这个dict对象拿到HTTP请求信息，然后构造HTML，
通过start_response()发送Header，最后返回Body。

process_request- 有，直接执行当前中间件和上方中间件的process_response- 应用： 用户登录授权（排除不需要登录的url）process_viewprocess_exception- process_tempalte_response
- 必须有返回值
- 必须对象中要有render方法process_response- 必须有返回值

#AUTHOR:FAN
from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponseclass Row1(MiddlewareMixin):
def process_request(self,request):
print("中间件1请求")
def process_response(self,request,response):
print("中间件1返回")
return responseclass Row2(MiddlewareMixin):
def process_request(self,request):
print("中间件2请求")
# return HttpResponse("走")
def process_response(self,request,response):
print("中间件2返回")
return responseclass Row3(MiddlewareMixin):
def process_request(self,request):
print("中间件3请求")
def process_response(self,request,response):
print("中间件3返回")
return response

MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
'Middle.m1.Row1',
'Middle.m1.Row2',
'Middle.m1.Row3',
]

''' urlpatterns = [
url(正则表达式, views视图函数，参数，别名),
]参数说明： 一个正则表达式字符串
一个可调用对象，通常为一个视图函数或一个指定视图函数路径的字符串
可选的要传递给视图函数的默认参数（字典形式）
一个可选的name参数 '''

from django.conf.urls import urlfrom . import viewsurlpatterns = [
url(r'^articles/2003/$', views.special_case_2003),
url(r'^articles/([0-9]{4})/$', views.year_archive),
url(r'^articles/([0-9]{4})/([0-9]{2})/$', views.month_archive),
url(r'^articles/([0-9]{4})/([0-9]{2})/([0-9]+)/$', views.article_detail),
]

'''
NOTE:
一旦匹配成功则不再继续
若要从URL 中捕获一个值，只需要在它周围放置一对圆括号。
不需要添加一个前导的反斜杠，因为每个URL 都有。例如，应该是^articles 而不是 ^/articles。
每个正则表达式前面的'r' 是可选的但是建议加上。一些请求的例子： /articles/// 不匹配任何URL 模式，因为列表中的第三个模式要求月份应该是两个数字。
/articles// 将匹配列表中的第一个模式不是第二个，因为模式按顺序匹配，第一个会首先测试是否匹配。
/articles/// 请求将匹配列表中的第三个模式。Django 将调用函数
views.month_archive(request, '', '')。#设置项是否开启URL访问地址后面不为/跳转至带有/的路径
APPEND_SLASH=True'''

from django.conf.urls import urlfrom . import viewsurlpatterns = [
url(r'^articles/2003/$', views.special_case_2003),
url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),
url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$', views.month_archive),
url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/(?P<day>[0-9]{2})/$', views.article_detail),
]

/articles///
请求将调用views.month_archive(request, year='', month='')函数
/articles////
请求将调用函数views.article_detail(request, year='', month='', day='')。

# URLconf
from django.conf.urls import urlfrom . import viewsurlpatterns = [
url(r'^blog/$', views.page),
url(r'^blog/page(?P<num>[0-9]+)/$', views.page),
]# View (in blog/views.py)
def page(request, num=""): ...

#At any point, your urlpatterns can “include” other URLconf modules. This
#essentially “roots” a set of URLs below other ones.#For example, here’s an excerpt of the URLconf for the Django website itself.
#It includes a number of other URLconfs:from django.conf.urls import include, urlurlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^blog/', include('blog.urls')),
]

语法格式： {{var_name}}

Django模板使用比较

句点号查找实例

filter过滤器使用说明

自定义过滤器

调用自定义过滤器

语法格式: {% tags %}

{% if%}标签使用

{% for %}标签使用

{% url %}标签使用

{% with %}标签使用

新建母版文件（base.html）

子母版继承

继承的常见三层法

模板继承的诀窍

from mytest import viewsurlpatterns = [
# url(r‘^index/‘, views.index),
url(r‘^index/‘, views.Index.as_view()),
]
#注：url(r‘^index/‘, views.Index.as_view()), 是固定用法。

from django.views import Viewclass Index(View): def dispatch(self, request, *args, **kwargs):
res = super(AuthView,self).dispatch(request, *args, **kwargs)
return res def get(self, req):
print(‘method is :‘ + req.method)
return render(req, ‘index.html‘) def post(self, req):
print(‘method is :‘ + req.method)
return render(req, ‘index.html‘)
#注：、类要继承 View ，类中函数名必须小写。
、类中首先执行的是 dispatch方法

class AuthView(object):
def dispatch(self, request, *args, **kwargs):
if not request.session.get('user_info'):
return redirect('/login.html')
res = super(AuthView,self).dispatch(request, *args, **kwargs)
return res

from django.views import Viewclass Index(AuthView，View): def get(self, req):
print(‘method is :‘ + req.method)
return render(req, ‘index.html‘) def post(self, req):
print(‘method is :‘ + req.method)
return render(req, ‘index.html‘)
#继承AuthView验证类即可

from django.utils.decorators import method_decorator
from django.views import Viewdef test(func):
def inner(*args,**kwargs):
return func(*args,**kwargs)
return innerclass Index(View):
def dispatch(self, request, *args, **kwargs):
res = super(AuthView,self).dispatch(request, *args, **kwargs)
return res @method_decorator(test)
def get(self, req):
print(‘method is :‘ + req.method)
return render(req, ‘index.html‘) @method_decorator(test
def post(self, req):
print(‘method is :‘ + req.method)
return render(req, ‘index.html‘)

from django.shortcuts import render,HttpResponse,redirect
from django.views import View
from django.utils.decorators import method_decoratorclass LoginView(View):
@method_decorator(test)
def dispatch(self, request, *args, **kwargs):
return super(LoginView,self).dispatch(request, *args, **kwargs) def get(self,request):
return render(request,'login.html') def post(self,request):
return redirect('/index.html')

from django.shortcuts import render,HttpResponse,redirect
from django.views import View
from django.utils.decorators import method_decorator@method_decorator(test,name='get')
class LoginView(View): def dispatch(self, request, *args, **kwargs):
return super(LoginView,self).dispatch(request, *args, **kwargs) def get(self,request):
return render(request,'login.html') def post(self,request):
return redirect('/index.html')
#类上添加装饰器，name后面有哪些函数，哪些函数就添加了装饰器

from django.shortcuts import render,HttpResponse,redirect
from django.views import View
from django.utils.decorators import method_decoratorfrom django.views.decorators.csrf import csrf_exempt,csrf_protectclass LoginView(View):
@method_decorator(csrf_exempt)
def dispatch(self, request, *args, **kwargs):
return super(LoginView,self).dispatch(request, *args, **kwargs) def get(self,request):
return render(request,'login.html') def post(self,request):
return redirect('/index.html')
#csrf_exempt 其他需要，加此装饰器的不需要
#csrf_protect 其他不需要需要，加此装饰器的需要

from django.conf.urls import url, include# from django.contrib import admin
from mytest import viewsurlpatterns = [
# url(r‘^admin/‘, admin.site.urls),
url(r‘^index/‘, views.index),
]

from django.shortcuts import renderdef index(req):
if req.method == ‘POST‘:
print(‘method is :‘ + req.method)
elif req.method == ‘GET‘:
print(‘method is :‘ + req.method)
return render(req, ‘index.html‘)#注意此处定义的是函数【def index(req):】

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>index</title>
</head>
<body>
<form action="" method="post">
<input type="text" name="A" />
<input type="submit" name="b" value="提交" />
</form>
</body>
</html>

－－－－－－－－－－－－－－－render(request, template_name[, context]）结合一个给定的模板和一个给定的上下文字典，并返回一个渲染后的 HttpResponse 对象。参数：
request： 用于生成响应的请求对象。 template_name：要使用的模板的完整名称，可选的参数 context：添加到模板上下文的一个字典。默认是一个空字典。如果字典中的某个值是可调用的，视图将在渲染模板之前调用它。 content_type：生成的文档要使用的MIME类型。默认为DEFAULT_CONTENT_TYPE 设置的值。 status：响应的状态码。默认为200。
复制代码

-----------------------------------url.py url(r"login", views.login),
url(r"yuan_back", views.yuan_back),-----------------------------------views.py
def login(req):
if req.method=="POST":
if :
# return redirect("/yuan_back/")
name="yuanhao" return render(req,"my backend.html",locals()) return render(req,"login.html",locals())def yuan_back(req): name="苑昊" return render(req,"my backend.html",locals())-----------------------------------login.html<form action="/login/" method="post">
<p>姓名<input type="text" name="username"></p>
<p>性别<input type="text" name="sex"></p>
<p>邮箱<input type="text" name="email"></p>
<p><input type="submit" value="submit"></p>
</form>
-----------------------------------my backend.html
<h1>用户{{ name }}你好</h1>#总结: render和redirect的区别:
# if render的页面需要模板语言渲染,需要的将数据库的数据加载到html,那么所有的这一部分
# 除了写在yuan_back的视图函数中,必须还要写在login中,代码重复,没有解耦.# the most important: url没有跳转到/yuan_back/,而是还在/login/,所以当刷新后
# 又得重新登录.

from django.db import modelsclass userinfo(models.Model):
name = models.CharField(max_length=)
email = models.EmailField()
memo = models.TextField()

AutoField(Field)
- int自增列，必须填入参数 primary_key=True BigAutoField(AutoField)
- bigint自增列，必须填入参数 primary_key=True 注：当model中如果没有自增列，则自动会创建一个列名为id的列
from django.db import models class UserInfo(models.Model):
# 自动创建一个列名为id的且为自增的整数列
username = models.CharField(max_length=32) class Group(models.Model):
# 自定义自增列
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32) SmallIntegerField(IntegerField):
- 小整数 -32768 ～ 32767 PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
- 正小整数 0 ～ 32767
IntegerField(Field)
- 整数列(有符号的) -2147483648 ～ 2147483647 PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
- 正整数 0 ～ 2147483647 BigIntegerField(IntegerField):
- 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807 自定义无符号整数字段 class UnsignedIntegerField(models.IntegerField):
def db_type(self, connection):
return 'integer UNSIGNED' PS: 返回值为字段在数据库中的属性，Django字段默认的值为：
'AutoField': 'integer AUTO_INCREMENT',
'BigAutoField': 'bigint AUTO_INCREMENT',
'BinaryField': 'longblob',
'BooleanField': 'bool',
'CharField': 'varchar(%(max_length)s)',
'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
'DateField': 'date',
'DateTimeField': 'datetime',
'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
'DurationField': 'bigint',
'FileField': 'varchar(%(max_length)s)',
'FilePathField': 'varchar(%(max_length)s)',
'FloatField': 'double precision',
'IntegerField': 'integer',
'BigIntegerField': 'bigint',
'IPAddressField': 'char(15)',
'GenericIPAddressField': 'char(39)',
'NullBooleanField': 'bool',
'OneToOneField': 'integer',
'PositiveIntegerField': 'integer UNSIGNED',
'PositiveSmallIntegerField': 'smallint UNSIGNED',
'SlugField': 'varchar(%(max_length)s)',
'SmallIntegerField': 'smallint',
'TextField': 'longtext',
'TimeField': 'time',
'UUIDField': 'char(32)', BooleanField(Field)
- 布尔值类型 NullBooleanField(Field):
- 可以为空的布尔值 CharField(Field)
- 字符类型
- 必须提供max_length参数， max_length表示字符长度 TextField(Field)
- 文本类型 EmailField(CharField)：
- 字符串类型，Django Admin以及ModelForm中提供验证机制 IPAddressField(Field)
- 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制 GenericIPAddressField(Field)
- 字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6
- 参数：
protocol，用于指定Ipv4或Ipv6， 'both',"ipv4","ipv6"
unpack_ipv4， 如果指定为True，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启刺功能，需要protocol="both" URLField(CharField)
- 字符串类型，Django Admin以及ModelForm中提供验证 URL SlugField(CharField)
- 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号） CommaSeparatedIntegerField(CharField)
- 字符串类型，格式必须为逗号分割的数字 UUIDField(Field)
- 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证 FilePathField(Field)
- 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能
- 参数：
path, 文件夹路径
match=None, 正则匹配
recursive=False, 递归下面的文件夹
allow_files=True, 允许文件
allow_folders=False, 允许文件夹 FileField(Field)
- 字符串，路径保存在数据库，文件上传到指定目录
- 参数：
upload_to = "" 上传文件的保存路径
storage = None 存储组件，默认django.core.files.storage.FileSystemStorage ImageField(FileField)
- 字符串，路径保存在数据库，文件上传到指定目录
- 参数：
upload_to = "" 上传文件的保存路径
storage = None 存储组件，默认django.core.files.storage.FileSystemStorage
width_field=None, 上传图片的高度保存的数据库字段名（字符串）
height_field=None 上传图片的宽度保存的数据库字段名（字符串） DateTimeField(DateField)
- 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] DateField(DateTimeCheckMixin, Field)
- 日期格式 YYYY-MM-DD TimeField(DateTimeCheckMixin, Field)
- 时间格式 HH:MM[:ss[.uuuuuu]] DurationField(Field)
- 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型 FloatField(Field)
- 浮点型 DecimalField(Field)
- 10进制小数
- 参数：
max_digits，小数总长度
decimal_places，小数位长度 BinaryField(Field)
- 二进制类型

null 数据库中字段是否可以为空
db_column 数据库中字段的列名
db_tablespace
default 数据库中字段的默认值
primary_key 数据库中字段是否为主键
db_index 数据库中字段是否可以建立索引
unique 数据库中字段是否可以建立唯一索引
unique_for_date 数据库中字段【日期】部分是否可以建立唯一索引
unique_for_month 数据库中字段【月】部分是否可以建立唯一索引
unique_for_year 数据库中字段【年】部分是否可以建立唯一索引 verbose_name Admin中显示的字段名称
blank Admin中是否允许用户输入为空
editable Admin中是否可以编辑
help_text Admin中该字段的提示信息
choices Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
如：gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1) error_messages 自定义错误信息（字典类型），从而定制想要显示的错误信息；
字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date
如：{'null': "不能为空.", 'invalid': '格式错误'} validators 自定义错误验证（列表类型），从而定制想要的验证规则
from django.core.validators import RegexValidator
from django.core.validators import EmailValidator,URLValidator,DecimalValidator,\
MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator
如：
test = models.CharField(
max_length=32,
error_messages={
'c1': '优先错信息1',
'c2': '优先错信息2',
'c3': '优先错信息3',
},
validators=[
RegexValidator(regex='root_\d+', message='错误了', code='c1'),
RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'),
EmailValidator(message='又错误了', code='c3'), ]
)

class UserInfo(models.Model):
nid = models.AutoField(primary_key=True)
username = models.CharField(max_length=32)
class Meta:
# 数据库中生成的表名称 默认 app名称 + 下划线 + 类名
db_table = "table_name" # 联合索引
index_together = [
("pub_date", "deadline"),
] # 联合唯一索引
unique_together = (("driver", "restaurant"),) # admin中显示的表名称
verbose_name # verbose_name加s
verbose_name_plural 更多：https://docs.djangoproject.com/en/1.10/ref/models/options/

1.触发Model中的验证和错误提示有两种方式：
a. Django Admin中的错误信息会优先根据Admiin内部的ModelForm错误信息提示，如果都成功，才来检查Model的字段并显示指定错误信息
b. 调用Model对象的 clean_fields 方法，如：
# models.py
class UserInfo(models.Model):
nid = models.AutoField(primary_key=True)
username = models.CharField(max_length=32) email = models.EmailField(error_messages={'invalid': '格式错了.'}) # views.py
def index(request):
obj = models.UserInfo(username='', email='uu')
try:
print(obj.clean_fields())
except Exception as e:
print(e)
return HttpResponse('ok') # Model的clean方法是一个钩子，可用于定制操作，如：上述的异常处理。 2.Admin中修改错误提示
# admin.py
from django.contrib import admin
from model_club import models
from django import forms class UserInfoForm(forms.ModelForm):
username = forms.CharField(error_messages={'required': '用户名不能为空.'})
email = forms.EmailField(error_messages={'invalid': '邮箱格式错误.'})
age = forms.IntegerField(initial=1, error_messages={'required': '请输入数值.', 'invalid': '年龄必须为数值.'}) class Meta:
model = models.UserInfo
# fields = ('username',)
fields = "__all__" class UserInfoAdmin(admin.ModelAdmin):
form = UserInfoForm admin.site.register(models.UserInfo, UserInfoAdmin)

应用场景：一对多：当一张表中创建一行数据时，有一个单选的下拉框（可以被重复选择）
例如：创建用户信息时候，需要选择一个用户类型【普通用户】【金牌用户】【铂金用户】等。
多对多：在某表中创建一行数据是，有一个可以多选的下拉框
例如：创建用户信息，需要为用户指定多个爱好
一对一：在某表中创建一行数据时，有一个单选的下拉框（下拉框中的内容被用过一次就消失了
例如：原有含10列数据的一张表保存相关信息，经过一段时间之后，10列无法满足需求，需要为原来的表再添加5列数据

ForeignKey(ForeignObject) # ForeignObject(RelatedField)
to, # 要进行关联的表名
to_field=None, # 要关联的表中的字段名称
on_delete=None, # 当删除关联表中的数据时，当前表与其关联的行的行为
- models.CASCADE，删除关联数据，与之关联也删除
- models.DO_NOTHING，删除关联数据，引发错误IntegrityError
- models.PROTECT，删除关联数据，引发错误ProtectedError
- models.SET_NULL，删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空）
- models.SET_DEFAULT，删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值）
- models.SET，删除关联数据，
a. 与之关联的值设置为指定值，设置：models.SET(值)
b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象) def func():
return 10 class MyModel(models.Model):
user = models.ForeignKey(
to="User",
to_field="id"
on_delete=models.SET(func),)
related_name=None, # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()
related_query_name=None, # 反向操作时，使用的连接前缀，用于替换【表名】 如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
limit_choices_to=None, # 在Admin或ModelForm中显示关联数据时，提供的条件：
# 如：
- limit_choices_to={'nid__gt': 5}
- limit_choices_to=lambda : {'nid__gt': 5} from django.db.models import Q
- limit_choices_to=Q(nid__gt=10)
- limit_choices_to=Q(nid=8) | Q(nid__gt=10)
- limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
db_constraint=True # 是否在数据库中创建外键约束
parent_link=False # 在Admin中是否显示关联数据 OneToOneField(ForeignKey)
to, # 要进行关联的表名
to_field=None # 要关联的表中的字段名称
on_delete=None, # 当删除关联表中的数据时，当前表与其关联的行的行为 ###### 对于一对一 ######
# 1. 一对一其实就是 一对多 + 唯一索引
# 2.当两个类之间有继承关系时，默认会创建一个一对一字段
# 如下会在A表中额外增加一个c_ptr_id列且唯一：
class C(models.Model):
nid = models.AutoField(primary_key=True)
part = models.CharField(max_length=12) class A(C):
id = models.AutoField(primary_key=True)
code = models.CharField(max_length=1) ManyToManyField(RelatedField)
to, # 要进行关联的表名
related_name=None, # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()
related_query_name=None, # 反向操作时，使用的连接前缀，用于替换【表名】 如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
limit_choices_to=None, # 在Admin或ModelForm中显示关联数据时，提供的条件：
# 如：
- limit_choices_to={'nid__gt': 5}
- limit_choices_to=lambda : {'nid__gt': 5} from django.db.models import Q
- limit_choices_to=Q(nid__gt=10)
- limit_choices_to=Q(nid=8) | Q(nid__gt=10)
- limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
symmetrical=None, # 仅用于多对多自关联时，symmetrical用于指定内部是否创建反向操作的字段
# 做如下操作时，不同的symmetrical会有不同的可选字段
models.BB.objects.filter(...) # 可选字段有：code, id, m1
class BB(models.Model): code = models.CharField(max_length=12)
m1 = models.ManyToManyField('self',symmetrical=True) # 可选字段有: bb, code, id, m1
class BB(models.Model): code = models.CharField(max_length=12)
m1 = models.ManyToManyField('self',symmetrical=False) through=None, # 自定义第三张表时，使用字段用于指定关系表
through_fields=None, # 自定义第三张表时，使用字段用于指定关系表中那些字段做多对多关系表
from django.db import models class Person(models.Model):
name = models.CharField(max_length=50) class Group(models.Model):
name = models.CharField(max_length=128)
members = models.ManyToManyField(
Person,
through='Membership',
through_fields=('group', 'person'),
) class Membership(models.Model):
group = models.ForeignKey(Group, on_delete=models.CASCADE)
person = models.ForeignKey(Person, on_delete=models.CASCADE)
inviter = models.ForeignKey(
Person,
on_delete=models.CASCADE,
related_name="membership_invites",
)
invite_reason = models.CharField(max_length=64)
db_constraint=True, # 是否在数据库中创建外键约束
db_table=None, # 默认创建第三张表时，数据库中表的名称

# 增
#
# models.Tb1.objects.create(c1='xx', c2='oo') 增加一条数据，可以接受字典类型数据 **kwargs # obj = models.Tb1(c1='xx', c2='oo')
# obj.save() # 查
#
# models.Tb1.objects.get(id=) # 获取单条数据，不存在则报错（不建议）
# models.Tb1.objects.all() # 获取全部
# models.Tb1.objects.filter(name='seven') # 获取指定条件的数据 # 删
#
# models.Tb1.objects.filter(name='seven').delete() # 删除指定条件的数据 # 改
# models.Tb1.objects.filter(name='seven').update(gender='') # 将指定条件的数据更新，均支持 **kwargs
# obj = models.Tb1.objects.get(id=)
# obj.c1 = ''
# obj.save() # 修改单条数据
# save是更改所有字段，即使更改一个字段，也会将所有字段重新赋值， 不推荐
# update更改，只更改修改的字段，推荐使用 # update方式修改不能用get的原因是：update是QuerySet对象的方法，get返回的是一个model对象，它没有update方法，而filter返回的是一个QuerySet对象(filter里面的条件可能有多个条件符合，比如name＝'alvin',可能有两个name＝'alvin'的行数据)

# 查询相关API：# <>filter(**kwargs): 它包含了与所给筛选条件相匹配的对象# <>all(): 查询所有结果# <>get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。#-----------下面的方法都是对查询的结果再进行处理:比如 objects.filter.values()--------# <>values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列 model的实例化对象，而是一个可迭代的字典序列# <>exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象# <>order_by(*field): 对查询结果排序# <>reverse(): 对查询结果反向排序# <>distinct(): 从返回结果中剔除重复纪录# <>values_list(*field): 它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列# <>count(): 返回数据库中匹配查询(QuerySet)的对象数量。# <>first(): 返回第一条记录# <>last(): 返回最后一条记录# <>exists(): 如果QuerySet包含数据，就返回True，否则返回False

# 获取个数
#
# models.Tb1.objects.filter(name='seven').count() # 大于，小于
#
# models.Tb1.objects.filter(id__gt=1) # 获取id大于1的值
# models.Tb1.objects.filter(id__gte=1) # 获取id大于等于1的值
# models.Tb1.objects.filter(id__lt=10) # 获取id小于10的值
# models.Tb1.objects.filter(id__lte=10) # 获取id小于10的值
# models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值 # in
#
# models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据
# models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in # isnull
# Entry.objects.filter(pub_date__isnull=True) # contains
#
# models.Tb1.objects.filter(name__contains="ven")
# models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
# models.Tb1.objects.exclude(name__icontains="ven") # range
#
# models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and # 其他类似
#
# startswith，istartswith, endswith, iendswith, # order by
#
# models.Tb1.objects.filter(name='seven').order_by('id') # asc
# models.Tb1.objects.filter(name='seven').order_by('-id') # desc # group by
#
# from django.db.models import Count, Min, Max, Sum
# models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))
# SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id" # limit 、offset
#
# models.Tb1.objects.all()[10:20] # regex正则匹配，iregex 不区分大小写
#
# Entry.objects.get(title__regex=r'^(An?|The) +')
# Entry.objects.get(title__iregex=r'^(an?|the) +') # date
#
# Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
# Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1)) # year
#
# Entry.objects.filter(pub_date__year=2005)
# Entry.objects.filter(pub_date__year__gte=2005) # month
#
# Entry.objects.filter(pub_date__month=12)
# Entry.objects.filter(pub_date__month__gte=6) # day
#
# Entry.objects.filter(pub_date__day=3)
# Entry.objects.filter(pub_date__day__gte=3) # week_day
#
# Entry.objects.filter(pub_date__week_day=2)
# Entry.objects.filter(pub_date__week_day__gte=2) # hour
#
# Event.objects.filter(timestamp__hour=23)
# Event.objects.filter(time__hour=5)
# Event.objects.filter(timestamp__hour__gte=12) # minute
#
# Event.objects.filter(timestamp__minute=29)
# Event.objects.filter(time__minute=46)
# Event.objects.filter(timestamp__minute__gte=29) # second
#
# Event.objects.filter(timestamp__second=31)
# Event.objects.filter(time__second=2)
# Event.objects.filter(timestamp__second__gte=31)

class UserProfile(models.Model):
user_info = models.OneToOneField('UserInfo')
username = models.CharField(max_length=64)
password = models.CharField(max_length=64) def __unicode__(self):
return self.usernameclass UserInfo(models.Model):
user_type_choice = (
(0, u'普通用户'),
(1, u'高级用户'),
)
user_type = models.IntegerField(choices=user_type_choice)
name = models.CharField(max_length=32)
email = models.CharField(max_length=32)
address = models.CharField(max_length=128) def __unicode__(self):
return self.nameclass UserGroup(models.Model): caption = models.CharField(max_length=64) user_info = models.ManyToManyField('UserInfo') def __unicode__(self):
return self.captionclass Host(models.Model):
hostname = models.CharField(max_length=64)
ip = models.GenericIPAddressField()
user_group = models.ForeignKey('UserGroup') def __unicode__(self):
return self.hostname

user_info_obj = models.UserInfo.objects.filter(id=1).first()
print user_info_obj.user_type
print user_info_obj.get_user_type_display()
print user_info_obj.userprofile.passworduser_info_obj = models.UserInfo.objects.filter(id=1).values('email', 'userprofile__username').first()
print user_info_obj.keys()
print user_info_obj.values()

类似一对一
1、搜索条件使用 __ 连接
2、获取值时使用 . 连接

user_info_obj = models.UserInfo.objects.get(name=u'武沛齐')
user_info_objs = models.UserInfo.objects.all()group_obj = models.UserGroup.objects.get(caption='CEO')
group_objs = models.UserGroup.objects.all()# 添加数据
#group_obj.user_info.add(user_info_obj)
#group_obj.user_info.add(*user_info_objs)# 删除数据
#group_obj.user_info.remove(user_info_obj)
#group_obj.user_info.remove(*user_info_objs)# 添加数据
#user_info_obj.usergroup_set.add(group_obj)
#user_info_obj.usergroup_set.add(*group_objs)# 删除数据
#user_info_obj.usergroup_set.remove(group_obj)
#user_info_obj.usergroup_set.remove(*group_objs)# 获取数据
#print group_obj.user_info.all()
#print group_obj.user_info.all().filter(id=1)# 获取数据
#print user_info_obj.usergroup_set.all()
#print user_info_obj.usergroup_set.all().filter(caption='CEO')
#print user_info_obj.usergroup_set.all().filter(caption='DBA')

from django.db.models import Avg,Min,Sum,Max从整个查询集生成统计值。比如，你想要计算所有在售书的平均价钱。Django的查询语法提供了一种方式描述所有
图书的集合。>>> Book.objects.all().aggregate(Avg('price'))
{'price__avg': 34.35}aggregate()子句的参数描述了我们想要计算的聚合值，在这个例子中，是Book模型中price字段的平均值aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典。键的名称是聚合值的
标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。如果你想要为聚合值指定
一个名称，可以向聚合子句提供它:
>>> Book.objects.aggregate(average_price=Avg('price'))
{'average_price': 34.35}如果你也想知道所有图书价格的最大值和最小值，可以这样查询：
>>> Book.objects.aggregate(Avg('price'), Max('price'), Min('price'))
{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}

#、统计每一个出版社的最便宜的书
方法一：
publishList=Publish.objects.annotate(MinPrice=Min("book__price"))for publish_obj in publishList:
print(publish_obj.name,publish_obj.MinPrice)
方法二：
queryResult=Book.objects.values("publish__name").annotate(MinPrice=Min('price'))
#、统计每一本以py开头的书籍的作者个数
queryResult=Book.objects
.filter(title__startswith="Py")
.annotate(num_authors=Count('authors'))
#、 统计不止一个作者的图书：queryResult=Book.objects
.annotate(num_authors=Count('authors'))
.filter(num_authors__gt=)
#、根据一本图书作者数量的多少对查询集 QuerySet进行排序:Book.objects.annotate(num_authors=Count('authors')).order_by('num_authors') #、查询各个作者出的书的总价格:
# 按author表的所有字段 group by
queryResult=Author.objects
.annotate(SumPrice=Sum("book__price"))
.values_list("name","SumPrice")
print(queryResult) #按authors__name group by
queryResult2=Book.objects.values("authors__name")
.annotate(SumPrice=Sum("price"))
.values_list("authors__name","SumPrice")
print(queryResult2)

# F 使用查询条件的值,专门取对象中某列值的操作 # from django.db.models import F
# models.Tb1.objects.update(num=F('num')+)# Q 构建搜索条件
from django.db.models import Q # Q对象(django.db.models.Q)可以对关键字参数进行封装，从而更好地应用多个查询
q1=models.Book.objects.filter(Q(title__startswith='P')).all()
print(q1)#[<Book: Python>, <Book: Perl>] # 、可以组合使用&,|操作符，当一个操作符是用于两个Q的对象,它产生一个新的Q对象。
Q(title__startswith='P') | Q(title__startswith='J') # 、Q对象可以用~操作符放在前面表示否定，也可允许否定与不否定形式的组合
Q(title__startswith='P') | ~Q(pub_date__year=) # 、应用范围： # Each lookup function that takes keyword-arguments (e.g. filter(),
# exclude(), get()) can also be passed one or more Q objects as
# positional (not-named) arguments. If you provide multiple Q object
# arguments to a lookup function, the arguments will be “AND”ed
# together. For example: Book.objects.get(
Q(title__startswith='P'),
Q(pub_date=date(, , )) | Q(pub_date=date(, , ))
) #sql:
# SELECT * from polls WHERE question LIKE 'P%'
# AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06') # import datetime
# e=datetime.date(,,) #-- # 、Q对象可以与关键字参数查询一起使用，不过一定要把Q对象放在关键字参数查询的前面。
# 正确：
Book.objects.get(
Q(pub_date=date(, , )) | Q(pub_date=date(, , )),
title__startswith='P')
# 错误：
Book.objects.get(
question__startswith='P',
Q(pub_date=date(, , )) | Q(pub_date=date(, , )))

from django.contrib import adminfrom app01 import modelsadmin.site.register(models.UserType)
admin.site.register(models.UserInfo)
admin.site.register(models.UserGroup)
admin.site.register(models.Asset)

class UserType(models.Model):
name = models.CharField(max_length=) class Meta:
verbose_name = '用户类型'
verbose_name_plural = '用户类型'

list_display: 指定要显示的字段
search_fields: 指定搜索的字段
list_filter: 指定列表过滤器
ordering： 指定排序字段

class UserType(models.Model):
name = models.CharField(max_length=) def __unicode__(self):
return self.namefrom django.contrib import admin
from app01 import modelsclass UserInfoAdmin(admin.ModelAdmin):
list_display = ('username', 'password', 'email')admin.site.register(models.UserType)
admin.site.register(models.UserInfo,UserInfoAdmin)
admin.site.register(models.UserGroup)
admin.site.register(models.Asset)

from django.contrib import adminfrom app01 import modelsclass UserInfoAdmin(admin.ModelAdmin):
list_display = ('username', 'password', 'email')
search_fields = ('username', 'email')admin.site.register(models.UserType)
admin.site.register(models.UserInfo,UserInfoAdmin)
admin.site.register(models.UserGroup)
admin.site.register(models.Asset)

from django.contrib import adminfrom app01 import modelsclass UserInfoAdmin(admin.ModelAdmin):
list_display = ('username', 'password', 'email')
search_fields = ('username', 'email')
list_filter = ('username', 'email')admin.site.register(models.UserType)
admin.site.register(models.UserInfo,UserInfoAdmin)
admin.site.register(models.UserGroup)
admin.site.register(models.Asset)

HTTP（hypertext transport protocol），即超文本传输协议。这个协议详细规定了浏览器和万维网服务器之间互相通信的规则。

HTTP就是一个通信规则，通信规则规定了客户端发送给服务器的内容格式，也规定了服务器发送给客户端的内容格式。其实我们要学习的就是这个两个格式！客户端发送给服务器的格式叫“请求协议”；服务器发送给客户端的格式叫“响应协议”。

特点：

• HTTP叫超文本传输协议，基于请求/响应模式的！
• HTTP是无状态协议。

URL：统一资源定位符，就是一个网址：协议名://域名:端口/路径，例如：http://www.oldboy.cn:80/index.html

请求首行； // 请求方式 请求路径 协议和版本，例如：GET /index.html HTTP/1.1
请求头信息；// 请求头名称:请求头内容，即为key:value格式，例如：Host:localhost
空行； // 用来与请求体分隔开
请求体。 // GET没有请求体，只有POST有请求体。为一个个键值对实例：
GET请求：
"GET /index.html http1.1\r\nUser-Agent:Mozilla/5.0 (Windows NT 6.1; Win64; x6..\r\n\r\nAccept-Encoding:gzip\r\n\r\n"
POST请求：
"POST /index.html http1.1\r\nUser-Agent:Mozilla/5.0 (Windows NT 6.1; Win64; x6..\r\n\r\nAccept-Encoding:gzip\r\n\r\nuser=cqz&hobby=lihao"请求头以\r\n划分
请求体以\r\n\r\n划分

. 在浏览器的地址栏中直接给出URL，那么就一定是GET请求
. 点击页面上的超链接也一定是GET请求
. 提交表单时，表单默认使用GET请求，但可以设置为POST

(). 数据不会出现在地址栏中
(). 数据的大小没有上限
(). 有请求体
(). 请求体中如果存在中文，会使用URL编码！

我们都知道Http协议中参数的传输是"key=value"这种简直对形式的，如果要传多个参数就需要用“&”符号对键值对进行分割。如"?name1=value1&name2=value2"，这样在服务端在收到这种字符串的时候，会用“&”分割出每一个参数，然后再用“=”来分割出参数值。针对“name1=value1&name2=value2”我们来说一下客户端到服务端的概念上解析过程:
上述字符串在计算机中用ASCII吗表示为：
6E616D6531 3D 76616C756531 6E616D6532 3D 76616C756532。
6E616D6531：name1
3D：=
76616C756531：value1
：&
6E616D6532：name2
3D：=
76616C756532：value2
服务端在接收到该数据后就可以遍历该字节流，首先一个字节一个字节的吃，当吃到3D这字节后，服务端就知道前面吃得字节表示一个key，再想后吃，如果遇到26，说明从刚才吃的3D到26子节之间的是上一个key的value，以此类推就可以解析出客户端传过来的参数。 现在有这样一个问题，如果我的参数值中就包含=或&这种特殊字符的时候该怎么办。
比如说“name1=value1”,其中value1的值是“va&lu=e1”字符串，那么实际在传输过程中就会变成这样“name1=va&lu=e1”。我们的本意是就只有一个键值对，但是服务端会解析成两个键值对，这样就产生了奇异。如何解决上述问题带来的歧义呢？解决的办法就是对参数进行URL编码
URL编码只是简单的在特殊字符的各个字节前加上%，例如，我们对上述会产生奇异的字符进行URL编码后结果：“name1=va%26lu%3D”，这样服务端会把紧跟在“%”后的字节当成普通的字节，就是不会把它当成各个参数或键值对的分隔符。为什么要进行URL编码

#coding=utf8
import httplib
httpClient = None
try:
myheaders = { "category": "Books",
"id": "",
'My-Agent': "Super brower"
}
httpClient = httplib.HTTPConnection('10.14.1XX.XXX',,timeout=)
httpClient.request('GET','/headinfo/',headers=myheaders)
response = httpClient.getresponse()
print response.status
print response.reason
print response.read()
except Exception, e:
print e
finally:
if httpClient:
httpClient.close()

from django.http import HttpResponse
def headinfo(request):
category = request.META.get('HTTP_CATEGORY', 'unkown')
id = request.META.get('HTTP_ID','unkown')
agent = request.META.get('MY-AGENT','unkown')
html = "<html><body>Category is %s, id is %s, agent is %s</body></html>" % (category, id, agent)
return HttpResponse(html)

属性 描述
path 表示提交请求页面完整地址的字符串， 不包括域名，如 "/music/bands/the_beatles/" 。
method
表示提交请求使用的HTTP方法。 它总是大写的。例如：if request.method == 'GET':
do_something()
elif request.method == 'POST':
do_something_else()
GET 一个类字典对象，包含所有的HTTP的GET参数的信息。 见 QueryDict 文档。
POST
一个类字典对象，包含所有的HTTP的POST参数的信息。 见 QueryDict 文档。通过POST提交的请求有可能包含一个空的 POST 字典， 也就是说， 一个通过POST方法提交的表单可能不包含数据。 因此，不应该使用 if request.POST 来判断POST方法的使用， 而是使用if request.method == "POST" （见表中的 method 条目）。注意： POST 并 不 包含文件上传信息。 见 FILES 。REQUEST
为了方便而创建，这是一个类字典对象，先搜索 POST ， 再搜索 GET 。 灵感来自于PHP的$_REQEUST 。例如， 若 GET = {"name": "john"} ， POST = {"age": ''} ， REQUEST["name"] 会是 "john" ， REQUEST["age"] 会是 "" 。强烈建议使用 GET 和 POST ，而不是 REQUEST 。 这是为了向前兼容和更清楚的表示。COOKIES 一个标准的Python字典，包含所有cookie。 键和值都是字符串。cookie使用的更多信息见第12章。
FILES
一个类字典对象，包含所有上传的文件。 FILES 的键来自 <input type="file" name="" />中的 name 。 FILES 的值是一个标准的Python字典， 包含以下三个键：filename ：字符串，表示上传文件的文件名。
content-type ：上传文件的内容类型。
content ：上传文件的原始内容。
注意 FILES 只在请求的方法是 POST ，并且提交的 <form> 包含enctype="multipart/form-data" 时 才包含数据。否则， FILES 只是一个空的类字典对象。META
一个标准的Python字典，包含所有有效的HTTP头信息。 有效的头信息与客户端和服务器有关。 这里有几个例子：CONTENT_LENGTH
CONTENT_TYPE
QUERY_STRING ：未解析的原始请求字符串。
REMOTE_ADDR ：客户端IP地址。
REMOTE_HOST ：客户端主机名。
SERVER_NAME ：服务器主机名。
SERVER_PORT ：服务器端口号。
在 META 中有效的任一HTTP头信息都是带有 HTTP_ 前缀的 键，例如：HTTP_ACCEPT_ENCODING
HTTP_ACCEPT_LANGUAGE
HTTP_HOST ：客户端发送的 Host 头信息。
HTTP_REFERER ：被指向的页面，如果存在的。
HTTP_USER_AGENT ：客户端的user-agent字符串。
HTTP_X_BENDER ： X-Bender 头信息的值， 如果已设的话。
user
一个 django.contrib.auth.models.User 对象表示 当前登录用户。 若当前用户尚未登录，user 会设为 django.contrib.auth.models.AnonymousUser 的一个实例。 可以将它们与is_authenticated() 区别开：if request.user.is_authenticated():
# Do something for logged-in users.
else:
# Do something for anonymous users.
user 仅当Django激活 AuthenticationMiddleware 时有效。关于认证和用户的完整细节，见第12章。session 一个可读写的类字典对象，表示当前session。 仅当Django已激活session支持时有效。 见 http://djangobook.py3k.cn/chapter12/
raw_post_data POST的原始数据。 用于对数据的复杂处理。

方法 描述
__getitem__(key) 请求所给键的GET/POST值，先查找POST，然后是GET。 若键不存在，则引发异常KeyError 。该方法使用户可以以访问字典方式来访问一个 HttpRequest 实例。例如， request["foo"] 和先检查 request.POST["foo"] 再检查request.GET["foo"] 一 样。has_key() 返回 True 或 False ， 标识 request.GET 或 request.POST 是否包含所给的 键。get_full_path() 返回 path ，若请求字符串有效，则附加于其后。 例如，"/music/bands/the_beatles/?print=true" 。is_secure() 如果请求是安全的，则返回 True 。 也就是说，请求是以HTTPS的形式提交的。

、cookie不属于http协议范围，由于http协议无法保持状态，但实际情况，我们却又需要“保持状态”，因此cookie就是在这样一个场景下诞生。cookie的工作原理是：由服务器产生内容，浏览器收到请求后保存在本地；当浏览器再次访问时，浏览器会自动带上cookie，这样服务器就能通过cookie的内容来判断这个是“谁”了。、cookie虽然在一定程度上解决了“保持状态”的需求，但是由于cookie本身最大支持4096字节，以及cookie本身保存在客户端，可能被拦截或窃取，因此就需要有一种新的东西，它能支持更多的字节，并且他保存在服务器，有较高的安全性。这就是session。问题来了，基于http协议的无状态特征，服务器根本就不知道访问者是“谁”。那么上述的cookie就起到桥接的作用。我们可以给每个客户端的cookie分配一个唯一的id，这样用户在访问时，通过cookie，服务器就知道来的人是“谁”。然后我们再根据不同的cookie的id，在服务器上保存一段时间的私密资料，如“账号密码”等等。、总结而言：cookie弥补了http无状态的不足，让服务器知道来的人是“谁”；但是cookie以文本的形式保存在本地，自身安全性较差；所以我们就通过cookie识别不同的用户，对应的在session里保存私密的信息以及超过4096字节的文本。、另外，上述所说的cookie和session其实是共通性的东西，不限于语言和框架

制作一个登陆页面，在验证了用户名和密码的正确性后跳转到后台的页面。但是测试后也发现，如果绕过登陆页面。直接输入后台的url地址也可以直接访问的。这个显然是不合理的。其实我们缺失的就是cookie和session配合的验证。有了这个验证过程，我们就可以实现和其他网站一样必须登录才能进入后台页面了。 先说一下这种认证的机制。每当我们使用一款浏览器访问一个登陆页面的时候，一旦我们通过了认证。服务器端就会发送一组随机唯一的字符串（假设是123abc）到浏览器端，这个被存储在浏览端的东西就叫cookie。而服务器端也会自己存储一下用户当前的状态，比如login=true，username=hahaha之类的用户信息。但是这种存储是以字典形式存储的，字典的唯一key就是刚才发给用户的唯一的cookie值。那么如果在服务器端查看session信息的话，理论上就会看到如下样子的字典{'123abc':{'login':true,'username:hahaha'}}因为每个cookie都是唯一的，所以我们在电脑上换个浏览器再登陆同一个网站也需要再次验证。那么为什么说我们只是理论上看到这样子的字典呢？因为处于安全性的考虑，其实对于上面那个大字典不光key值123abc是被加密的，value值{'login':true,'username:hahaha'}在服务器端也是一样被加密的。所以我们服务器上就算打开session信息看到的也是类似与以下样子的东西{'123abc':dasdasdasd1231231da1231231}知道了原理，我们下面就来用代码实现

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>login</title>
<link rel="stylesheet" href="http://830909.blog.51cto.com/static/plugins/bootstrap-3.3.5-dist/css/bootstrap.min.css">
</head>
<body>
<div class="container">
<form action="login.html" method="post">
<div class="form-group">
<label class="sr-only">username</label>
<input type="text" class="form-control" name="username" placeholder="用户名"/>
</div>
<div class="form-group">
<label class="sr-only">Password</label>
<input type="password" class="form-control" name="passwd" placeholder="密码"/>
</div>
<div class="form-group">
<input class="btn btn-primary" type="submit" value="http://830909.blog.51cto.com/8311014/Submit">
</div>
</form>
</div>
<script type="application/Javascript" src="http://830909.blog.51cto.com/static/js/jquery-2.2.1.min.js"></script>
<script type="application/javascript" src="http://830909.blog.51cto.com/static/plugins/bootstrap-3.3.5-dist/js/bootstrap.min.js"></script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>backend</title>
<link rel="stylesheet" href="http://830909.blog.51cto.com/static/plugins/bootstrap-3.3.5-dist/css/bootstrap.min.css">
<link rel="stylesheet" href="http://830909.blog.51cto.com/static/css/commons.css">
</head>
<body>
<div class="container">
<h2>cookie 内容是 {{ cookie_content }}</h2>
<h2>session 内容是 {{ session_content }}</h2>
<h2>登录用户名 ：{{ username }}</h2>
<a href="http://830909.blog.51cto.com/logout/">注销</a>
</div>
<script type="application/javascript" src="http://830909.blog.51cto.com/static/js/jquery-2.2.1.min.js"></script>
<script type="application/javascript" src="http://830909.blog.51cto.com/static/plugins/bootstrap-3.3.5-dist/js/bootstrap.min.js"></script>
</body>
</html>

# /usr/bin/env python
# coding:utf-
from django.shortcuts import render
from django.shortcuts import redirect
def login(request):
if request.method=="POST":
username=request.POST['username']
pwd=request.POST['passwd']
if username=='abc' and pwd=='':
#设置session内部的字典内容
request.session['is_login']='true'
request.session['username']='abc'
#登录成功就将url重定向到后台的url
return redirect('/backend/')
#登录不成功或第一访问就停留在登录页面
return render(request,'login.html')
def backend(request):
"""
这里必须用读取字典的get()方法把is_login的value缺省设置为False，
当用户访问backend这个url先尝试获取这个浏览器对应的session中的
is_login的值。如果对方登录成功的话，在login里就已经把is_login
的值修改为了True,反之这个值就是False的
"""
is_login=request.session.get('is_login',False)
#如果为真，就说明用户是正常登陆的
if is_login:
#获取字典的内容并传入页面文件
cookie_content=request.COOKIES
session_content=request.session
username=request.session['username']
return render(request,'backend.html',
{
'cookie_content':cookie_content,
'session_content':session_content,
'username':username
})
else:
"""
如果访问的时候没有携带正确的session，
就直接被重定向url回login页面
"""
return redirect('/login/')
def logout(request):
"""
直接通过request.session['is_login']回去返回的时候，
如果is_login对应的value值不存在会导致程序异常。所以
需要做异常处理
"""
try:
#删除is_login对应的value值
del request.session['is_login']
except KeyError:
pass
#点击注销之后，直接重定向回登录页面
return redirect('/login/')

from django.conf.urls import url
from django.contrib import admin
from app01 import views
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^login/', views.login),
url(r'^backend/', views.backend),
url(r'^logout/', views.logout),
]

、login页面正确登录的话，后台页面可以获取到浏览器携带的cookie的。、第一行的sessionid其实就是cookie值、session的内容是加密的，从客户端获取不到session的内容、服务端可以通过预设的key值取出session的内容并打印到前段、django的session默认是存储在数据库里的，我们再到数据库查看一下真正session内容

# 、获取Cookie：
# request.COOKIES['key']
# request.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)
# 参数：
# default: 默认值
# salt: 加密盐
# max_age: 后台控制过期时间# 、设置Cookie：
# rep = HttpResponse(...) 或 rep ＝ render(request, ...)
#
# rep.set_cookie(key,value,...)
# rep.set_signed_cookie(key,value,salt='加密盐',...)
# 参数：
# key, 键
# value='', 值
# max_age=None, 超时时间
# expires=None, 超时时间(IE requires expires, so set it if hasn't been already.)
# path='/', Cookie生效的路径，/ 表示根路径，特殊的：跟路径的cookie可以被任何url的页面访问
# domain=None, Cookie生效的域名
# secure=False, https传输
# httponly=False 只能http协议传输，无法被JavaScript获取（不是绝对，底层抓包可以获取到也可以被覆盖）# 由于cookie保存在客户端的电脑上，所以，JavaScript和jquery也可以操作cookie。# <script src='/static/js/jquery.cookie.js'></script>
# $.cookie("list_pager_num", ,{ path: '/' });

Django默认支持Session，并且默认是将Session数据存储在数据库中，即：django_session 表中。a. 配置 settings.py SESSION_ENGINE = 'django.contrib.sessions.backends.db' # 引擎（默认） SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串（默认）
SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路径（默认）
SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名（默认）
SESSION_COOKIE_SECURE = False # 是否Https传输cookie（默认）
SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http传输（默认）
SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周）（默认）
SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否关闭浏览器使得Session过期（默认）
SESSION_SAVE_EVERY_REQUEST = False # 是否每次请求都保存Session，默认修改之后才保存（默认）b. 使用 def index(request):
# 获取、设置、删除Session中数据
request.session['k1']
request.session.get('k1',None)
request.session['k1'] = 123
request.session.setdefault('k1',123) # 存在则不设置
del request.session['k1'] # 所有 键、值、键值对
request.session.keys()
request.session.values()
request.session.items()
request.session.iterkeys()
request.session.itervalues()
request.session.iteritems() # 用户session的随机字符串
request.session.session_key # 将所有Session失效日期小于当前日期的数据删除
request.session.clear_expired() # 检查 用户session的随机字符串 在数据库中是否
request.session.exists("session_key") # 删除当前用户的所有Session数据
request.session.delete("session_key") ...

a. 配置 settings.py SESSION_ENGINE = 'django.contrib.sessions.backends.cache' # 引擎
SESSION_CACHE_ALIAS = 'default' # 使用的缓存别名（默认内存缓存，也可以是memcache），此处别名依赖缓存的设置 SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串
SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路径
SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名
SESSION_COOKIE_SECURE = False # 是否Https传输cookie
SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http传输
SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周）
SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否关闭浏览器使得Session过期
SESSION_SAVE_EVERY_REQUEST = False # 是否每次请求都保存Session，默认修改之后才保存b. 使用 同上

a. 配置 settings.py SESSION_ENGINE = 'django.contrib.sessions.backends.file' # 引擎
SESSION_FILE_PATH = None # 缓存文件路径，如果为None，则使用tempfile模块获取一个临时地址tempfile.gettempdir() # 如：/var/folders/d3/j9tj0gz93dg06bmwxmhh6_xm0000gn/T SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串
SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路径
SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名
SESSION_COOKIE_SECURE = False # 是否Https传输cookie
SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http传输
SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周）
SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否关闭浏览器使得Session过期
SESSION_SAVE_EVERY_REQUEST = False # 是否每次请求都保存Session，默认修改之后才保存b. 使用 同上

数据库用于做持久化，缓存用于提高效率a. 配置 settings.py SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db' # 引擎b. 使用 同上

a. 配置 settings.py SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies' # 引擎b. 使用 同上

def login(func):
def wrap(request, *args, **kwargs):
# 如果未登陆，跳转到指定页面
if request.path == '/test/':
return redirect('http://www.baidu.com')
return func(request, *args, **kwargs)
return wrap

提供了用户认证，即验证用户名以及密码是否正确,一般需要username password两个关键字参数如果认证信息有效，会返回一个 User 对象。authenticate()会在User 对象上设置一个属性标识那种认证后端认证了该用户，且该信息在后面的登录过程中是需要的。当我们试图登陆一个从数据库中直接取出来不经过authenticate()的User对象会报错的！！user=authenticate(username='someone',password='somepassword')

该函数接受一个HttpRequest对象，以及一个认证了的User对象此函数使用django的session框架给某个已认证的用户附加上session id等信息。from django.contrib.auth import authenticate, logindef my_view(request):
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
login(request, user)
# Redirect to a success page.
...
else:
# Return an 'invalid login' error message.
...

from django.contrib.auth import logoutdef logout_view(request):
logout(request)
# Redirect to a success page.
该函数接受一个HttpRequest对象，无返回值。当调用该函数时，当前请求的session信息会全部清除。该用户即使没有登录，使用该函数也不会报错

使用 create_user 辅助函数创建用户:from django.contrib.auth.models import User
user = User.objects.create_user（username='',password='',email=''）

这个方法是用来更改密码的，使用步骤：
user=User.objects.get(username='')
user.set_password(passeord='')
user.save

使用 set_password() 来修改密码user = User.objects.get(username='')
user.set_password(password='')
user.save

def sign_up(request): state = None if request.method == 'POST': password = request.POST.get('password', '')
repeat_password = request.POST.get('repeat_password', '')
email=request.POST.get('email', '')
if password == '' or repeat_password == '':
state = 'empty'
elif password != repeat_password:
state = 'repeat_error'
else:
username = request.POST.get('username', '')
if User.objects.filter(username=username):
state = 'user_exist'
else:
new_user = User.objects.create_user(username=username, password=password,email=email)
new_user.save()
new_my_user = MyUser(user=new_user, telephone=request.POST.get('telephone', ''))
new_my_user.save() return redirect('/book/')
content = {
'state': state,
'user': None,
}
return render(request, 'book/sign_up.html', content)

@login_required
def set_password(request):
user = request.user
state = None
if request.method == 'POST':
old_password = request.POST.get('old_password', '')
new_password = request.POST.get('new_password', '')
repeat_password = request.POST.get('repeat_password', '')
if user.check_password(old_password):
if not new_password:
state = 'empty'
elif new_password != repeat_password:
state = 'repeat_error'
else:
user.set_password(new_password)
user.save()
return redirect("/log_in/")
else:
state = 'password_error'
content = {
'user': user,
'state': state,
}
return render(request, 'book/set_password.html', content)

urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^register/', views.register),]

from django.db import models
from django.contrib.auth.models import AbstractUserclass UserInfo(AbstractUser):
"""
用户信息
"""
nid = models.BigAutoField(primary_key=True)
nickname = models.CharField(verbose_name='昵称', max_length=)
telephone = models.CharField(max_length=, blank=True, null=True, unique=True, verbose_name='手机号码')
avatar = models.FileField(verbose_name='头像', upload_to='upload/avatar/',default="/upload/avatar/default_avatar.jpg")
create_time = models.DateTimeField(verbose_name='创建时间',auto_now_add=True) fans = models.ManyToManyField(verbose_name='粉丝们',
to='UserInfo',
through='UserFans',
through_fields=('user', 'follower')) def __str__(self):
return self.username

from django import forms
from django.core.exceptions import NON_FIELD_ERRORS, ValidationError
class RegForm(forms.Form): username=forms.CharField(min_length=,error_messages={"required":"*用户名不能为空！","min_length":"*用户名太短！"},
widget=forms.TextInput(attrs={"id":"username","placeholder":"用户为2到12位数字或字母"})) password=forms.CharField(error_messages={"required":"*密码不能为空！"},
widget=forms.PasswordInput(attrs={"id":"passwordsignup","placeholder":"eg. 密码不能少于6位且不能为纯数字"})) repeat_password=forms.CharField(error_messages={"required":"*密码不能为空！"},
widget=forms.PasswordInput(attrs={"id":"passwordsignup_confirm","placeholder":"eg. 密码不能少于6位且不能为纯数字"})) email=forms.EmailField(error_messages={"required":"*邮箱不能为空！","invalid":"*邮箱格式不正确"},
widget=forms.EmailInput(attrs={"id":"emailsignup","placeholder":"mysupermail@mail.com"})) validcode=forms.CharField(error_messages={"required":"*验证码不能为空！"},
widget=forms.TextInput(attrs={"class":"validcode_input","id":"validcode","placeholder":"valid_code"})) def __init__(self,request,*args,**kwargs):
super(RegForm,self).__init__(*args,**kwargs)
self.request=request def clean_username(self): # if self.cleaned_data["username"].isdigit() or self.cleaned_data["username"].isalpha():
# raise ValidationError("*用户名必须包含数字与字母！")
# if len(self.cleaned_data["username"]) <:
# raise ValidationError("*用户名太短！")
if len(self.cleaned_data["username"]) >:
raise ValidationError("*用户名太长！")
else:
return self.cleaned_data["username"] def clean_password(self): # 关于密码字段的钩子
if len(self.cleaned_data["password"]) <:
raise ValidationError("*密码不能少于6位！")
elif self.cleaned_data["password"].isdigit():
raise ValidationError("*密码不能为纯数字！")
else:
return self.cleaned_data["password"] def clean_repeat_password(self): # 关于密码字段的钩子
if len(self.cleaned_data["repeat_password"]) < :
raise ValidationError("*密码不能少于6位！")
elif self.cleaned_data["repeat_password"].isdigit():
raise ValidationError("*密码不能为纯数字！")
else:
return self.cleaned_data["repeat_password"] def clean(self):
if self.cleaned_data.get("password") == self.cleaned_data.get("repeat_password"):
#self.cleaned_data.get("password") 与self.cleaned_data["password"] 的区别是后者取值是当值不存在时没有值会报错
return self.cleaned_data
else:
raise ValidationError("*密码不一致") def clean_validcode(self):
if self.cleaned_data["validcode"].upper() == self.request.session["validcode"].upper():
return self.cleaned_data["validcode"]
else:
raise ValidationError("验证码错误！")

def register(request): if request.is_ajax():
data = {"tag": False, "error_message": ""} form_obj=forms.RegForm(request,request.POST)
if form_obj.is_valid():
username=form_obj.cleaned_data["username"]
email = form_obj.cleaned_data["email"]
password = form_obj.cleaned_data["password"]
repeat_password = form_obj.cleaned_data["repeat_password"]
user_validcode = form_obj.cleaned_data["validcode"].upper()
validcode = request.session['validcode'].upper()
file_obj = request.FILES.get("img") models.UserInfo.objects.create_user(username=username,email=email,password=password,avatar=file_obj)
data["tag"]=True else:
errors=form_obj.errors data["error_message"] = errors return HttpResponse(json.dumps(data)) form_obj=forms.RegForm(request)
return render(request,"register.html",{"form_obj":form_obj})

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>添加个人信息</title>
<style>
.formset{
color: rebeccapurple;
border: dashed cadetblue;
}
</style>
</head>
<body>
<form action="/register/" method="post">
{% csrf_token %}
<h1>博客园-注册</h1>
<p>
<label for="username" class="uname" data-icon="u">用户名</label>
{{ form_obj.username }}
<span id="username_error" class="ajax_errors"></span>
</p>
<p>
<label for="emailsignup" class="youmail" data-icon="e"> 邮箱</label>
{{ form_obj.email }}
<span id="emailsignup_error" class="ajax_errors"></span>
</p>
<p>
<label for="passwordsignup" class="youpasswd" data-icon="p">密码 </label>
{{ form_obj.password }}
<span id="passwordsignup_error" class="ajax_errors"></span>
</p>
<p>
<label for="passwordsignup_confirm" class="youpasswd" data-icon="p">确认密码</label>
{{ form_obj.repeat_password }}
<span id="passwordsignup_confirm_error" class="ajax_errors"></span>
</p > <p class="file_avatar"><label for="avatar" >头像</label>
<img src="{% static 'images/default_avatar.jpg' %}" alt="" id="file_img" class="sol">
<input type="file" id="file_choose" class="sol"></p> <p>
<label for="validcode" class="validcode" data-icon="p" style="display: block"> 验证码 </label>
{{ form_obj.validcode }}
<span class="valid_img_box">
<img src="/validcode/" alt="" class="valid_img">
<span>看不清楚？</span>
</span>
</p> <p style="margin-bottom: 45px!important">
<spanp id="validcode_error" class="ajax_errors"></spanp>
</p> <p class="signin button">
<input type="button" class="register_but" value="注册" style="float: left"/>
<a href="/index/"><input type="button" value="返回"/></a> </p>
<p class="change_link">
已经有账号 ?
<a href="/login/" class="to_register"> 去登录 </a>
</p>
</form></body>
</html>

ModelForm
a. class Meta:
model, # 对应Model的
fields=None, # 字段
exclude=None, # 排除字段
labels=None, # 提示信息
help_texts=None, # 帮助提示信息
widgets=None, # 自定义插件
error_messages=None, # 自定义错误信息（整体错误信息from django.core.exceptions import NON_FIELD_ERRORS）
field_classes=None # 自定义字段类 （也可以自定义字段）
localized_fields=('birth_date',) # 本地化，如：根据不同时区显示数据
如：
数据库中
-- ::
setting中的配置
TIME_ZONE = 'Asia/Shanghai'
USE_TZ = True
则显示：
-- ::
b. 验证执行过程
is_valid -> full_clean -> 钩子 -> 整体错误 c. 字典字段验证
def clean_字段名(self):
# 可以抛出异常
# from django.core.exceptions import ValidationError
return "新值"
d. 用于验证
model_form_obj = XXOOModelForm()
model_form_obj.is_valid()
model_form_obj.errors.as_json()
model_form_obj.clean()
model_form_obj.cleaned_data
e. 用于创建
model_form_obj = XXOOModelForm(request.POST)
#### 页面显示，并提交 #####
# 默认保存多对多
obj = form.save(commit=True)
# 不做任何操作，内部定义 save_m2m（用于保存多对多）
obj = form.save(commit=False)
obj.save() # 保存单表信息
obj.save_m2m() # 保存关联多对多信息 f. 用于更新和初始化
obj = model.tb.objects.get(id=)
model_form_obj = XXOOModelForm(request.POST,instance=obj)
... PS: 单纯初始化
model_form_obj = XXOOModelForm(initial={...})

# -*- coding: UTF- -*-
from django.forms import ModelForm
from .models import Node,Line,Device #定义Node的Form,Form名字为 模式名+Form
class NodeForm(ModelForm):
#自定义ModelForm的内容
class Meta:
#该ModelForm参照Model: Node
model = Node
#在Form中不显示node_signer这个字段
exclude = ['node_signer'] class LineForm(ModelForm):
class Meta:
model = Line
exclude = ['line_signer'] class DeviceForm(ModelForm):
class Meta:
model = Device
exclude = ['device_signer']

# -*- coding: UTF- -*-
from .models import Node,Line,Device
from forms import NodeForm,LineForm,DeviceForm
from django.shortcuts import render, redirect
def add(request):
#获取来自NodeForm的表单数据
form = NodeForm(request.POST or None)
#判断form是否有效
if form.is_valid():
#创建实例，需要做些数据处理，暂不做保存
instance = form.save(commit=False)
#将登录用户作为登记人
instance.node_signer = request.user
#保存该实例
instance.save()
#跳转至列表页面
return redirect('/lists/') #创建context来集中处理需要传递到页面的数据
context = {
'form': form,
}
#如果没有有效提交，则仍留在原来页面
return render(request, 'add.html', context)

<!DOCTYPE html>
<html>
<head lang="en">
<meta charset="UTF-8">
<title></title>
</head>
<body>
<form method='POST' action=''>{% csrf_token %}
{{ form }}
<input type='submit' value='提交' />
</form> </body>
</html>

>>> from django.core.paginator import Paginator
>>> objects = ['john', 'paul', 'george', 'ringo']
>>> p = Paginator(objects, )>>> p.count #数据总数>>> p.num_pages #总页数>>> type(p.page_range) # `<type 'rangeiterator'>` in Python .
<class 'range_iterator'>
>>> p.page_range #页码的列表
range(, ) # =========[,]>>> page1 = p.page() #第1页的page对象
>>> page1
<Page of >
>>> page1.object_list #第1页的数据
['john', 'paul']>>> page2 = p.page()
>>> page2.object_list #第2页的数据
['george', 'ringo']
>>> page2.has_next() #是否有下一页
False
>>> page2.has_previous() #是否有上一页
True
>>> page2.has_other_pages() #是否有其他页
True
>>> page2.next_page_number() #下一页的页码
Traceback (most recent call last):
...
EmptyPage: That page contains no results
>>> page2.previous_page_number() #上一页的页码>>> page2.start_index() # 本页第一条记录的序数（从1开始）>>> page2.end_index() # 本页最后录一条记录的序数（从1开始）>>> p.page() #错误的页，抛出异常
Traceback (most recent call last):
...
EmptyPage: That page number is less than
>>> p.page() #错误的页，抛出异常
Traceback (most recent call last):
...
EmptyPage: That page contains no results

{% load staticfiles %}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title> <link rel="stylesheet" href="{% static 'bootstrap.css' %}"></head>
<body><div class="container"> <h4>分页器</h4>
<ul> {% for book in book_list %}
<li>{{ book.title }} {{ book.price }}</li>
{% endfor %}</ul> <ul class="pagination" id="pager"> {% if book_list.has_previous %}
<li class="previous"><a href="/blog/?page={{ book_list.previous_page_number }}">上一页</a></li>
{% else %}
<li class="previous disabled"><a href="#">上一页</a></li>
{% endif %} {% for num in paginator.page_range %} {% if num == currentPage %}
<li class="item active"><a href="/blog/?page={{ num }}">{{ num }}</a></li>
{% else %}
<li class="item"><a href="/blog/?page={{ num }}">{{ num }}</a></li> {% endif %}
{% endfor %} {% if book_list.has_next %}
<li class="next"><a href="/blog/?page={{ book_list.next_page_number }}">下一页</a></li>
{% else %}
<li class="next disabled"><a href="#">下一页</a></li>
{% endif %} </ul>
</div></body>
</html>

from django.shortcuts import render,HttpResponse# Create your views here.
from django.core.paginator import Paginator, EmptyPage, PageNotAnIntegerfrom app01.models import *
def index(request): '''
批量导入数据: Booklist=[]
for i in range():
Booklist.append(Book(title="book"+str(i),price=+i*i))
Book.objects.bulk_create(Booklist) ''' book_list=Book.objects.all() paginator = Paginator(book_list, )
page = request.GET.get('page',)
currentPage=int(page) try:
print(page)
book_list = paginator.page(page)
except PageNotAnInteger:
book_list = paginator.page()
except EmptyPage:
book_list = paginator.page(paginator.num_pages) return render(request,"index.html",locals())

开发调试
内存
文件
数据库
Memcache缓存（python-memcached模块）
Memcache缓存（pylibmc模块）

# 此为开始调试用，实际内部不做任何操作
# 配置：
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.dummy.DummyCache', # 引擎
'TIMEOUT': 300, # 缓存超时时间（默认300，None表示永不过期，0表示立即过期）
'OPTIONS':{
'MAX_ENTRIES': 300, # 最大缓存个数（默认300）
'CULL_FREQUENCY': 3, # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
},
'KEY_PREFIX': '', # 缓存key的前缀（默认空）
'VERSION': 1, # 缓存key的版本（默认1）
'KEY_FUNCTION' 函数名 # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
}
} # 自定义key
def default_key_func(key, key_prefix, version):
"""
Default function to generate keys. Constructs the key used by all other methods. By default it prepends
the `key_prefix'. KEY_FUNCTION can be used to specify an alternate
function with custom key making behavior.
"""
return '%s:%s:%s' % (key_prefix, version, key) def get_key_func(key_func):
"""
Function to decide which key function to use. Defaults to ``default_key_func``.
"""
if key_func is not None:
if callable(key_func):
return key_func
else:
return import_string(key_func)
return default_key_func

# 此缓存将内容保存至内存的变量中
# 配置：
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
'LOCATION': 'unique-snowflake',
}
} # 注：其他配置同开发调试版本

# 此缓存将内容保存至文件
# 配置： CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
'LOCATION': '/var/tmp/django_cache',
}
}
# 注：其他配置同开发调试版本

# 此缓存将内容保存至数据库 # 配置：
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
'LOCATION': 'my_cache_table', # 数据库表
}
} # 注：执行创建表命令 python manage.py createcachetable

# 此缓存使用python-memcached模块连接memcache CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
'LOCATION': '127.0.0.1:11211',
}
} CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
'LOCATION': 'unix:/tmp/memcached.sock',
}
} CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
'LOCATION': [
'172.19.26.240:11211',
'172.19.26.242:11211',
]
}
}

# 此缓存使用pylibmc模块连接memcache CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
'LOCATION': '127.0.0.1:11211',
}
} CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
'LOCATION': '/tmp/memcached.sock',
}
} CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
'LOCATION': [
'172.19.26.240:11211',
'172.19.26.242:11211',
]
}
}

使用中间件，经过一系列的认证等操作，如果内容在缓存中存在，则使用FetchFromCacheMiddleware获取内容并返回给用户，当返回给用户之前，判断缓存中是否已经存在，如果不存在则UpdateCacheMiddleware会将缓存保存至缓存，从而实现全站缓存 MIDDLEWARE = [
'django.middleware.cache.UpdateCacheMiddleware',
# 其他中间件...
'django.middleware.cache.FetchFromCacheMiddleware',
] CACHE_MIDDLEWARE_ALIAS = ""
CACHE_MIDDLEWARE_SECONDS = ""
CACHE_MIDDLEWARE_KEY_PREFIX = ""

方式一：
from django.views.decorators.cache import cache_page @cache_page(60 * 15)
def my_view(request):
... 方式二：
from django.views.decorators.cache import cache_page urlpatterns = [
url(r'^foo/([0-9]{1,2})/$', cache_page(60 * 15)(my_view)),
]

a. 引入TemplateTag {% load cache %} b. 使用缓存 {% cache 5000 缓存key %}
缓存内容
{% endcache %}

Model signals
pre_init # django的modal执行其构造方法前，自动触发
post_init # django的modal执行其构造方法后，自动触发
pre_save # django的modal对象保存前，自动触发
post_save # django的modal对象保存后，自动触发
pre_delete # django的modal对象删除前，自动触发
post_delete # django的modal对象删除后，自动触发
m2m_changed # django的modal中使用m2m字段操作第三张表（add,remove,clear）前后，自动触发
class_prepared # 程序启动时，检测已注册的app中modal类，对于每一个类，自动触发
Management signals
pre_migrate # 执行migrate命令前，自动触发
post_migrate # 执行migrate命令后，自动触发
Request/response signals
request_started # 请求到来前，自动触发
request_finished # 请求结束后，自动触发
got_request_exception # 请求异常后，自动触发
Test signals
setting_changed # 使用test测试修改配置文件时，自动触发
template_rendered # 使用test测试渲染模板时，自动触发
Database Wrappers
connection_created # 创建数据库连接时，自动触发

from django.core.signals import request_finished
from django.core.signals import request_started
from django.core.signals import got_request_exception from django.db.models.signals import class_prepared
from django.db.models.signals import pre_init, post_init
from django.db.models.signals import pre_save, post_save
from django.db.models.signals import pre_delete, post_delete
from django.db.models.signals import m2m_changed
from django.db.models.signals import pre_migrate, post_migrate from django.test.signals import setting_changed
from django.test.signals import template_rendered from django.db.backends.signals import connection_created def callback(sender, **kwargs):
print("xxoo_callback")
print(sender,kwargs) xxoo.connect(callback)
# xxoo指上述导入的内容

from django.core.signals import request_finished
from django.dispatch import receiver@receiver(request_finished)
def my_callback(sender, **kwargs):
print("Request finished!")

import django.dispatch
pizza_done = django.dispatch.Signal(providing_args=["toppings", "size"])

def callback(sender, **kwargs):
print("callback")
print(sender,kwargs) pizza_done.connect(callback)

from 路径 import pizza_done pizza_done.send(sender='seven',toppings=, size=)

from django.core import serializersret = models.BookType.objects.all()data = serializers.serialize("json", ret)

import json#ret = models.BookType.objects.all().values('caption')
ret = models.BookType.objects.all().values_list('caption')ret=list(ret) #将QuerySet进行转化result = json.dumps(ret)

datetime日期序列化

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title> <style>
.error{
color:red
}
</style>
</head>
<body><form class="Form"> <p>姓名&nbsp;&nbsp;<input class="v1" type="text" name="username" mark="用户名"></p>
<p>密码&nbsp;&nbsp;<input class="v1" type="text" name="email" mark="邮箱"></p>
<p><input type="submit" value="submit"></p></form><script src="jquery-3.1.1.js"></script><script> $(".Form :submit").click(function(){ flag=true; $("Form .v1").each(function(){ var value=$(this).val();
if (value.trim().length==){
var mark=$(this).attr("mark");
var $span=$("<span>");
$span.html(mark+"不能为空!");
$span.prop("class","error");
$(this).after($span); setTimeout(function(){
$span.remove();
},); flag=false;
return flag; }
});
return flag
});</script></body>
</html>

{% load staticfiles %}<!DOCTYPE html><html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<script src="{% static 'JS/jquery-3.1.1.js' %}"></script>
</head>
<body><button class="send_Ajax">send_Ajax</button><script>
//$.ajax的两种使用方式: //$.ajax(settings);
//$.ajax(url,[settings]); $(".send_Ajax").click(function(){ $.ajax({
url:"/handle_Ajax/",
type:"POST",
data:{username:"Yuan",password:}, success:function(data){
alert(data)
}, //=================== error============ error: function (jqXHR, textStatus, err) { // jqXHR: jQuery增强的xhr
// textStatus: 请求完成状态
// err: 底层通过throw抛出的异常对象，值与错误类型有关
console.log(arguments);
}, //=================== complete============ complete: function (jqXHR, textStatus) {
// jqXHR: jQuery增强的xhr
// textStatus: 请求完成状态 success | error
console.log('statusCode: %d, statusText: %s', jqXHR.status, jqXHR.statusText);
console.log('textStatus: %s', textStatus);
}, //=================== statusCode============
statusCode: {
'': function (jqXHR, textStatus, err) {
console.log(arguments); //注意：后端模拟errror方式：HttpResponse.status_code=500
}, '': function () {
}
} }) })</script>
</body>
</html>

import jsondef index(request): return render(request,"index.html")def handle_Ajax(request): username=request.POST.get("username")
password=request.POST.get("password") print(username,password) return HttpResponse(json.dumps("Error Data!"))views

######################------------data---------################ data: 当前ajax请求要携带的数据，是一个json的object对象，ajax方法就会默认地把它编码成某种格式
(urlencoded:?a=&b=)发送给服务端；此外，ajax默认以get方式发送请求。 function testData() {
$.ajax("/test",{ //此时的data是一个json形式的对象
data:{
a:,
b:
}
}); //?a=1&b=2
######################------------processData---------################processData：声明当前的data数据是否进行转码或预处理，默认为true，即预处理；if为false，
那么对data：{a:,b:}会调用json对象的toString()方法，即{a:,b:}.toString()
,最后得到一个［object，Object］形式的结果。######################------------contentType---------################contentType：默认值: "application/x-www-form-urlencoded"。发送信息至服务器时内容编码类型。
用来指明当前请求的数据编码格式；urlencoded:?a=&b=；如果想以其他方式提交数据，
比如contentType:"application/json"，即向服务器发送一个json字符串：
$.ajax("/ajax_get",{ data:JSON.stringify({
a:,
b:
}),
contentType:"application/json",
type:"POST", }); //{a: 22, b: 33} 注意：contentType:"application/json"一旦设定，data必须是json字符串，不能是json对象######################------------traditional---------################traditional：一般是我们的data数据有数组时会用到 ：data:{a:,b:,c:["x","y"]},
traditional为false会对数据进行深层次迭代；

/*dataType： 预期服务器返回的数据类型,服务器端返回的数据会根据这个值解析后，传递给回调函数。
默认不需要显性指定这个属性，ajax会根据服务器返回的content Type来进行转换；
比如我们的服务器响应的content Type为json格式，这时ajax方法就会对响应的内容
进行一个json格式的转换，if转换成功，我们在success的回调函数里就会得到一个json格式
的对象；转换失败就会触发error这个回调函数。如果我们明确地指定目标类型，就可以使用
data Type。
dataType的可用值：html｜xml｜json｜text｜script
见下dataType实例*/

from django.shortcuts import render,HttpResponse
from django.views.decorators.csrf import csrf_exempt
# Create your views here.import jsondef login(request): return render(request,'Ajax.html')def ajax_get(request): l=['alex','little alex']
dic={"name":"alex","pwd":} #return HttpResponse(l) #元素直接转成字符串alexlittle alex
#return HttpResponse(dic) #字典的键直接转成字符串namepwd
return HttpResponse(json.dumps(l))
return HttpResponse(json.dumps(dic))# 传到前端的是json字符串,要想使用,需要JSON.parse(data)//---------------------------------------------------
function testData() { $.ajax('ajax_get', {
success: function (data) {
console.log(data);
console.log(typeof(data));
//console.log(data.name);
//JSON.parse(data);
//console.log(data.name);
},
//dataType:"json",
}
)}注解:Response Headers的content Type为text/html,所以返回的是String;但如果我们想要一个json对象
设定dataType:"json"即可,相当于告诉ajax方法把服务器返回的数据转成json对象发送到前端.结果为object
当然，
return HttpResponse(json.dumps(a),content_type="application/json") 这样就不需要设定dataType:"json"了。
content_type="application/json"和content_type="json"是一样的！

$.ajaxSetup({
data: {csrfmiddlewaretoken: '{{ csrf_token }}' },
});

var formData=new FormData();var username= $("#username").val();
var email= $("#emailsignup").val();
var csrf=$("[name='csrfmiddlewaretoken']").val();formData.append("username",username);
formData.append("email",email);
formData.append("csrfmiddlewaretoken",csrf);$.ajax({
url:"/handle_Ajax/",
type:"POST",
data: formData,, success:function(data){
alert(data)
}, })

<!DOCTYPE html>
<html>
<head lang="en">
<meta charset="UTF-8">
<title></title>
</head>
<body> <p>
<input type="button" onclick="Jsonp1();" value='提交'/>
</p> <p>
<input type="button" onclick="Jsonp2();" value='提交'/>
</p> <script type="text/javascript" src="jquery-1.12.4.js"></script>
<script>
function Jsonp1(){
var tag = document.createElement('script');
tag.src = "http://c2.com:8000/test/";
document.head.appendChild(tag);
document.head.removeChild(tag); } function Jsonp2(){
$.ajax({
url: "http://c2.com:8000/test/",
type: 'GET',
dataType: 'JSONP',
success: function(data, statusText, xmlHttpRequest){
console.log(data);
}
})
} </script>
</body>
</html>

* 简单请求 OR 非简单请求条件：
、请求方式：HEAD、GET、POST
、请求头信息：
Accept
Accept-Language
Content-Language
Last-Event-ID
Content-Type 对应的值是以下三个中的任意一个
application/x-www-form-urlencoded
multipart/form-data
text/plain注意：同时满足以上两个条件时，则是简单请求，否则为复杂请求
* 简单请求和非简单请求的区别？ 简单请求：一次请求
非简单请求：两次请求，在发送数据之前会先发一次请求用于做“预检”，只有“预检”通过后才再发送一次请求用于数据传输。

* 关于“预检”- 请求方式：OPTIONS
- “预检”其实做检查，检查如果通过则允许传输数据，检查不通过则不再发送真正想要发送的消息
- 如何“预检”
=> 如果复杂请求是PUT等请求，则服务端需要设置允许某请求，否则“预检”不通过
Access-Control-Request-Method
=> 如果复杂请求设置了请求头，则服务端需要设置允许某请求头，否则“预检”不通过
Access-Control-Request-Headers

<!DOCTYPE html>
<html>
<head lang="en">
<meta charset="UTF-8">
<title></title>
</head>
<body> <p>
<input type="submit" onclick="XmlSendRequest();" />
</p> <p>
<input type="submit" onclick="JqSendRequest();" />
</p> <script type="text/javascript" src="jquery-1.12.4.js"></script>
<script>
function XmlSendRequest(){
var xhr = new XMLHttpRequest();
xhr.onreadystatechange = function(){
if(xhr.readyState == 4) {
var result = xhr.responseText;
console.log(result);
}
};
xhr.open('GET', "http://c2.com:8000/test/", true);
xhr.send();
} function JqSendRequest(){
$.ajax({
url: "http://c2.com:8000/test/",
type: 'GET',
dataType: 'text',
success: function(data, statusText, xmlHttpRequest){
console.log(data);
}
})
} </script>
</body>
</html>

class MainHandler(tornado.web.RequestHandler):
def get(self):
self.set_header('Access-Control-Allow-Origin', "http://www.xxx.com")
self.write('{"status": true, "data": "seven"}')

<!DOCTYPE html>
<html>
<head lang="en">
<meta charset="UTF-8">
<title></title>
</head>
<body> <p>
<input type="submit" onclick="XmlSendRequest();" />
</p> <p>
<input type="submit" onclick="JqSendRequest();" />
</p> <script type="text/javascript" src="jquery-1.12.4.js"></script>
<script>
function XmlSendRequest(){
var xhr = new XMLHttpRequest();
xhr.onreadystatechange = function(){
if(xhr.readyState == 4) {
var result = xhr.responseText;
console.log(result);
}
};
xhr.open('PUT', "http://c2.com:8000/test/", true);
xhr.setRequestHeader('k1', 'v1');
xhr.send();
} function JqSendRequest(){
$.ajax({
url: "http://c2.com:8000/test/",
type: 'PUT',
dataType: 'text',
headers: {'k1': 'v1'},
success: function(data, statusText, xmlHttpRequest){
console.log(data);
}
})
} </script>
</body>
</html>

class MainHandler(tornado.web.RequestHandler): def put(self):
self.set_header('Access-Control-Allow-Origin', "http://www.xxx.com")
self.write('{"status": true, "data": "seven"}') def options(self, *args, **kwargs):
self.set_header('Access-Control-Allow-Origin', "http://www.xxx.com")
self.set_header('Access-Control-Allow-Headers', "k1,k2")
self.set_header('Access-Control-Allow-Methods', "PUT,DELETE")
self.set_header('Access-Control-Max-Age', 10)

<!DOCTYPE html>
<html>
<head lang="en">
<meta charset="UTF-8">
<title></title>
</head>
<body> <p>
<input type="submit" onclick="XmlSendRequest();" />
</p> <p>
<input type="submit" onclick="JqSendRequest();" />
</p> <script type="text/javascript" src="jquery-1.12.4.js"></script>
<script>
function XmlSendRequest(){
var xhr = new XMLHttpRequest();
xhr.onreadystatechange = function(){
if(xhr.readyState == 4) {
var result = xhr.responseText;
console.log(result);
// 获取响应头
console.log(xhr.getAllResponseHeaders());
}
};
xhr.open('PUT', "http://c2.com:8000/test/", true);
xhr.setRequestHeader('k1', 'v1');
xhr.send();
} function JqSendRequest(){
$.ajax({
url: "http://c2.com:8000/test/",
type: 'PUT',
dataType: 'text',
headers: {'k1': 'v1'},
success: function(data, statusText, xmlHttpRequest){
console.log(data);
// 获取响应头
console.log(xmlHttpRequest.getAllResponseHeaders());
}
})
} </script>
</body>
</html>

class MainHandler(tornado.web.RequestHandler): def put(self):
self.set_header('Access-Control-Allow-Origin', "http://www.xxx.com") self.set_header('xxoo', "seven")
self.set_header('bili', "daobidao") self.set_header('Access-Control-Expose-Headers', "xxoo,bili") self.write('{"status": true, "data": "seven"}') def options(self, *args, **kwargs):
self.set_header('Access-Control-Allow-Origin', "http://www.xxx.com")
self.set_header('Access-Control-Allow-Headers', "k1,k2")
self.set_header('Access-Control-Allow-Methods', "PUT,DELETE")
self.set_header('Access-Control-Max-Age', 10)

<!DOCTYPE html>
<html>
<head lang="en">
<meta charset="UTF-8">
<title></title>
</head>
<body> <p>
<input type="submit" onclick="XmlSendRequest();" />
</p> <p>
<input type="submit" onclick="JqSendRequest();" />
</p> <script type="text/javascript" src="jquery-1.12.4.js"></script>
<script>
function XmlSendRequest(){
var xhr = new XMLHttpRequest();
xhr.onreadystatechange = function(){
if(xhr.readyState == 4) {
var result = xhr.responseText;
console.log(result);
}
}; xhr.withCredentials = true; xhr.open('PUT', "http://c2.com:8000/test/", true);
xhr.setRequestHeader('k1', 'v1');
xhr.send();
} function JqSendRequest(){
$.ajax({
url: "http://c2.com:8000/test/",
type: 'PUT',
dataType: 'text',
headers: {'k1': 'v1'},
xhrFields:{withCredentials: true},
success: function(data, statusText, xmlHttpRequest){
console.log(data);
}
})
} </script>
</body>
</html>

class MainHandler(tornado.web.RequestHandler): def put(self):
self.set_header('Access-Control-Allow-Origin', "http://www.xxx.com")
self.set_header('Access-Control-Allow-Credentials', "true") self.set_header('xxoo', "seven")
self.set_header('bili', "daobidao")
self.set_header('Access-Control-Expose-Headers', "xxoo,bili") self.set_cookie('kkkkk', 'vvvvv'); self.write('{"status": true, "data": "seven"}') def options(self, *args, **kwargs):
self.set_header('Access-Control-Allow-Origin', "http://www.xxx.com")
self.set_header('Access-Control-Allow-Headers', "k1,k2")
self.set_header('Access-Control-Allow-Methods', "PUT,DELETE")
self.set_header('Access-Control-Max-Age', 10)