django大全
数据库配置：
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME':'dbname',
'USER': 'root',
'PASSWORD': '123456',
'HOST': '',
'PORT': '',
}
}
模板配置
TEMPLATE_DIRS = (
os.path.join(BASE_DIR,'templates'),
)
静态文件配置
STATICFILES_DIRS = (
os.path.join(BASE_DIR,'static'),
)
MEDIA_ROOT：是本地路径的绝对路径，一般是这样写
MEDIA_URL：是指从浏览器访问时的地址前缀
MEDIA_URL = '/upload/' MEDIA_ROOT = os.path.join(BASE_DIR,'upload')
路由映射
1、每个路由规则对应一个view中的函数
url(r'^index/(\d*)', views.index),
url(r'^list/(\d*)/(\d*)/$', views.list),
url(r'^manage/(?P<name>\w*)/(?P<id>\d*)', views.manage),
url(r'^login/(?P<name>\w*)', views.login,{'id':333}),
复制代码
def index(request,id): # id形参的名字是随便定义的
return render_to_response('index.html')
def list(request,id1,id2): # id1,id2形参的名字是随便定义的
return render_to_response('list.html')
def manage(request,name,id): # name,id形参的名字是和(?P<name>\w*)/(?P<id>\d*)是一样的
return render_to_response('index.html')
def login(request,name,id): # name,id形参的名字是和(?P<name>\w*)，{'id':333}是一样的
return render_to_response('login.html')
复制代码
2、根据app对路由规则进行一次分类
1
2
3
4
5
6
from django.conf.urls import include
urlpatterns = patterns[
url(r'^web/', include('web.url')),
url(r'^app01/', include('app01.url')),
]
django中的路由系统和其他语言的框架有所不同，在django中每一个请求的url都要有一条路由映射，这样才能将请求交给对一个的view中的函数去处理。其他大部分的Web框架则是对一类的url请求做一条路由映射，从而是路由系统变得简洁。
models
同步数据库 python manage.py makemigrations python manage.py migrate1、创建Model，之后可以根据Model来创建数据库表
|
1
2
3
4
5
6
|
from django.db import models class userinfo(models.Model): name = models.CharField(max_length=30) email = models.EmailField() memo = models.TextField() |
更多字段：
1、models.AutoField 自增列 = int(11)
如果没有的话，默认会生成一个名称为 id 的列，如果要显示的自定义一个自增列，必须将给列设置为主键 primary_key=True。
2、models.CharField 字符串字段
必须 max_length 参数
3、models.BooleanField 布尔类型=tinyint(1)
不能为空，Blank=True
4、models.ComaSeparatedIntegerField 用逗号分割的数字=varchar
继承CharField，所以必须 max_lenght 参数
5、models.DateField 日期类型 date
对于参数，auto_now = True 则每次更新都会更新这个时间；auto_now_add 则只是第一次创建添加，之后的更新不再改变。
6、models.DateTimeField 日期类型 datetime
同DateField的参数
7、models.Decimal 十进制小数类型 = decimal
必须指定整数位max_digits和小数位decimal_places
8、models.EmailField 字符串类型（正则表达式邮箱） =varchar
对字符串进行正则表达式
9、models.FloatField 浮点类型 = double
10、models.IntegerField 整形
11、models.BigIntegerField 长整形
integer_field_ranges = {
'SmallIntegerField': (-32768, 32767),
'IntegerField': (-2147483648, 2147483647),
'BigIntegerField': (-9223372036854775808, 9223372036854775807),
'PositiveSmallIntegerField': (0, 32767),
'PositiveIntegerField': (0, 2147483647),
}
12、models.IPAddressField 字符串类型（ip4正则表达式）,django1.10逐步废弃使用下面一种
13、models.GenericIPAddressField 字符串类型（ip4和ip6是可选的）
参数protocol可以是：both、ipv4、ipv6
验证时，会根据设置报错
14、models.NullBooleanField 允许为空的布尔类型
15、models.PositiveIntegerFiel 正Integer
16、models.PositiveSmallIntegerField 正smallInteger
17、models.SlugField 减号、下划线、字母、数字
18、models.SmallIntegerField 数字
数据库中的字段有：tinyint、smallint、int、bigint
19、models.TextField 字符串=longtext
20、models.TimeField 时间 HH:MM[:ss[.uuuuuu]]
21、models.URLField 字符串，地址正则表达式
22、models.BinaryField 二进制
23、models.ImageField 图片,需要max_length
24、models.FilePathField 文件,需要max_length
更多参数：
1、null=True # 数据库中字段是否可以为空
2、blank=True # django的 Admin 中添加数据时是否可允许空值
3、primary_key = False #主键，对AutoField设置主键后，就会代替原来的自增 id 列
4、auto_now、auto_now_add
auto_now # 自动创建---无论添加或修改，都是当前操作的时间
auto_now_add # 自动创建---永远是创建时的时间
5、choices
GENDER_CHOICE = (
(u'M', u'Male'),
(u'F', u'Female'),
)
gender = models.CharField(max_length=2,choices = GENDER_CHOICE)
gender_choice = (
(0,'男'),
(1,'女'),
)
gender = models.IntergetFiled(choice=gener_choice) # 数据库中存储的是0，1但是显示的是男，女
6、max_length # 在charfield必须指定最大长度
7、default # 默认值
8、verbose_name # Admin中字段的显示名称
9、name|db_column # 数据库中的字段名称
10、unique=True # 不允许重复
11、db_index = True # 数据库索引
12、editable=True # 在Admin里是否可编辑
13、error_messages=None # 在Admin错误提示
14、auto_created=False # 自动创建
15、help_text # 在Admin中提示帮助信息
16、validators=[] # 自定义规则
17、upload-to # 指定上传的路径
18、class Meta():
verbose_name = '这张表的名字在admin后台的显示名字'
verbose_name_plural = verbose_name
ordering = ['-id'] # 根据id反向排序
数据库操作：
增加：create()
|
1
2
3
4
5
6
7
8
|
# 第一种方式models.类名.objects.create(hostname=name) # 第二种方式obj = models.类名(hostname=name)obj.save()注意：hostname是数据库中的字段名，name是变量 |
更新：update()
|
1
2
3
4
5
6
7
|
# 第一种方式models.类名.objects.filter(id=2).update(hostname='tomcat') # 第二种方式obj = models.类名.objects.get(id=2)obj.hostname = 'tomcat'obj.save() |
删除：delete()
|
1
2
3
|
models.类名.objects.get(id=2).delete()models.类名.objects.filter(id=2).delete()models.类名.objects.all().delete() |
查询：filter(),all(),get(),getlist()用于取多个值
|
1
2
3
|
models.类名.objects.get(id=123) # 获取单条数据，不存在则报错（不建议）models.类名.objects.all() # 获取全部models.类名.objects.filter(name='tomcat') # 获取指定条件的数据 |
显示指定字段：values(),values_list()
models.类名.objects.get(id=123).values('id','name') # 返回的是queryset字典
models.类名.objects.get(id=123).values__list('id','name') # 返回的是queryset元组
复杂查询：Q()表达式：
https://docs.djangoproject.com/en/1.9/topics/db/queries/#complex-lookups-with-q-objects
数量：count()
|
1
2
3
|
models.类名.objects.filter(name='tomcat').count()models.类名.objects.get(name='tomcat').count()models.类名.objects.all().count() |
去重：distinct()
models.类名.objects.values('字段').distinct()
大于小于：__gt,__lt,__gte,__lte
|
1
2
3
|
models.类名.objects.filter(id__gt=1) # 获取id大于1的值models.类名.objects.filter(id__lt=10) # 获取id小于10的值models.类名.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值 |
等于多个值：__in
|
1
2
|
models.类名.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据models.类名.objects.exclude(id__in=[11, 22, 33]) # not in |
模糊查询：__contains,__icontains
|
1
2
3
|
models.类名.objects.filter(name__contains="ven")models.类名.objects.filter(name__icontains="ven") # icontains大小写不敏感models.类名.objects.exclude(name__icontains="ven") |
范围查询：__range
|
1
|
models.类名.objects.filter(id__range=[1, 2]) # 范围bettwen and |
其他类似：__startswith,__endswith, __iendswith, __istartswith
排序：order_by("name") 相当于asc；order_by("-name") 相当于desc；
|
1
2
|
models.类名.objects.filter(name='seven').order_by('id') # asc,从小到大models.类名.objects.filter(name='seven').order_by('-id') # desc,从大到小 |
返回第n-m条：第n条[0]；前两条[0:2]
|
1
2
3
|
# limit 、offsetmodels.类名.objects.all()[10:20] |
分组与聚合：group_by,annotate,aggregate
annotate(*args, **kwargs)：可以为 QuerySet 中的每个对象添加注解。可以通过计算查询结果中每个对象所关联的对象集合，从而得出总计值(也可以是平均值或总和，等等)
aggregate(*args, **kwargs)：通过对 QuerySet 进行计算，返回一个聚合值的字典。 aggregate() 中每个参数都指定一个包含在字典中的返回值。用于聚合查询
- Avg(返回所给字段的平均值)
- Count(根据所给的关联字段返回被关联 model 的数量)
- Max(返回所给字段的最大值)
- Min(返回所给字段的最小值)
- Sum(计算所给字段值的总和)
|
1
2
3
4
|
# group byfrom django.db.models import Count, Min, Max, Sum# models.类名.objects.filter(c1=1).values('id').annotate(c=Count('num'))# SELECT "app01_类名"."id", COUNT("app01_类名"."num") AS "c" FROM "app01_类名" WHERE "app01_类名"."c1" = 1 GROUP BY "app01_类名"."id" |
还可以：
>>> Publisher.objects.filter(name='广东人民出版社').aggregate(Count('name'))
还可以自定义别名
>>> Publisher.objects.filter(name='广东人民出版社').aggregate(mycount = Count('name'))
查询胡大海出的书的总价格是多少
>>> Book.objects.filter(authors__name='胡大海').aggregate(Sum('price'))
查询各个作者出的书的总价格是多少
>>> Book.objects.values('authors__name').annotate(Sum('price'))
查询各个出版社最便宜的书价是多少
>>> Book.objects.values('publisher__name').annotate(Min('price'))
跨表操作
一对一
一对多
多对多
F和Q
F 使用查询条件的值
#
# from django.db.models import F
# models.Tb1.objects.update(num=F('num')+1)
# Q 构建搜索条件
from django.db.models import Q
# con = Q()
#
# q1 = Q()
# q1.connector = 'OR'
# q1.children.append(('id', 1))
# q1.children.append(('id', 10))
# q1.children.append(('id', 9))
#
# q2 = Q()
# q2.connector = 'OR'
# q2.children.append(('c1', 1))
# q2.children.append(('c1', 10))
# q2.children.append(('c1', 9))
#
# con.add(q1, 'AND')
# con.add(q2, 'AND')
#
# models.Tb1.objects.filter(con)
#
# from django.db import connection
# cursor = connection.cursor()
# cursor.execute("""SELECT * from tb where name = %s""", ['Lennon'])
# row = cursor.fetchone()
form验证
只要有表单提交就必须要有form验证
如：
forms
from django import forms
from hello.models import Publisher
class PublisherForm(forms.Form):
name = forms.CharField(label="名称", error_messages={"required": "这个项必须填写"})
address = forms.CharField(label="地址", error_messages={"required": "这个项必须填写"})
city = forms.CharField(label="城市", error_messages={"required": "这个项必须填写"})
state_province = forms.CharField(label="省份", error_messages={"required": "这个项必须填写"})
country = forms.CharField(label="国家", error_messages={"required": "这个项必须填写"})
website = forms.URLField(label="网址", error_messages={"required": "这个项必须填写"})
views
from django.shortcuts import render, render_to_response, redirect,HttpResponse from hello.models import Publisher from hello.forms import PublisherForm def add_publisher(request): if request.method == "POST": publisher_form = PublisherForm(request.POST) if publisher_form.is_valid(): Publisher.objects.create( name = publisher_form.cleaned_data['name'], address = publisher_form.cleaned_data['address'], city = publisher_form.cleaned_data['city'], state_province = publisher_form.cleaned_data['state_province'], country = publisher_form.cleaned_data['country'], website = publisher_form.cleaned_data['website'], ) return HttpResponse("添加出版社信息成功！") else: publisher_form = PublisherForm() return render(request, 'add_publisher.html', locals())
is_valid()验证成功
参数和models里面的参数类似
modelform 万金油
forms
from django import forms
from hello.models import Publisher
class PublisherForm(forms.ModelForm):
class Meta:
model = Publisher # 把models中的Publisher类绑定过来
exclude = ("id",) # 指定不要显示的字段,fields是指定要显示的字段
views
from django.shortcuts import render, render_to_response, redirect,HttpResponse
from hello.models import Publisher
from hello.forms import PublisherForm
def add_publisher(request):
if request.method == "POST":
publisher_form = PublisherForm(request.POST)
if publisher_form.is_valid():
publisher_form.save() # 这里这一句就把前端传过来的值全部写入数据库中了
return HttpResponse("添加出版社信息成功！")
else:
publisher_form = PublisherForm()
return render(request, 'add_publisher.html', locals())
自定义中间件
自定义中间件
1、创建中间件类
|
1
2
3
4
5
6
7
8
9
10
|
class defindemiddleware: def process_request(self,request): print(123) def process_view(self, request, callback, callback_args, callback_kwargs): print(456) def process_exception(self, request, exception): print(error) def process_response(self, request, response): print(end)<br> return response |
2、注册中间件
|
1
2
3
4
5
6
7
8
9
|
MIDDLEWARE_CLASSES = (<br> 'my.middleware.defindedmiddleware', # 目录结构my/middleware/类名 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.auth.middleware.SessionAuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware',) |
django 1.10中有点不一样,创建时需要继承父类：
from django.utils import deprecation
class defindemiddleware(deprecation.MiddlewareMixin):
def process_request(self,request):
print(123)
分页：
https://docs.djangoproject.com/en/1.9/topics/pagination/
缓存
Django-redis 文档：
http://niwinz.github.io/django-redis/latest/
http://django-redis-cache.readthedocs.org/en/latest/
Django-redis 缓存后端安装：
$ sudo apt-get install redis-server # 安装Redis Server $ . ~/myprojectenv/bin/active # Source 到虚拟环境 $ pip install django-redis-cache # 安装缓存后端
Django-redis 缓存后端配置：
CACHES = {
'default': {
'BACKEND': 'redis_cache.RedisCache',
'LOCATION': '127.0.0.1:6379',
'OPTIONS': {
'DB': 1,
'PASSWORD': 'yadayada',
'PARSER_CLASS': 'redis.connection.HiredisParser',
'CONNECTION_POOL_CLASS': 'redis.BlockingConnectionPool',
'PICKLE_VERSION': -1,
},
},
}
参数
(1)LOCATION：
Redis 服务器信息，可以是 address/port，也可以是 unix 域套接字。
可配置单个string，或者是 strings 的列表。
示例：
127.0.0.1:6379 #普通的TCP连接
/path/to/socket # Unix 域套接字连接
redis://[:password]@localhost:6379/0 # 普通的TCP连接
rediss://[:password]@localhost:6379/0 # SSL 封装的 TCP 连接
# http://redis.io/topics/encryption
unix://[:password]@/path/to/socket.sock?db=0 # Unix 域套接字连接
(2)Database Number：
设置存储空间， 可在 OPTIONS 和 LOCATION 中配置 ( Default DB: 1)
redis://@localhost:6379/0
CACHES = {
'default': {
'OPTIONS': {
'DB': 1,
..
},
...
}
}
(3)Password：
如果 Redis Server 设置了密码，则 CACHE 中也需要设置密码, 可在 OPTIONS 中配置，也可在 LOCATION 中配置
CACHES = {
'default': {
'OPTIONS': {
'PASSWORD': 'yadayada',
...
},
...
}
}
Django-redis 缓存后端配置(redis主从)：
CACHES = {
'default': {
'LOCATION': [
'127.0.0.1:6379', # Primary
'127.0.0.1:6380', # Secondary
'127.0.0.1:6381', # Secondary
],
'OPTIONS': {
'PASSWORD': 'yadayada',
'MASTER_CACHE': '127.0.0.1:6379',
...
},
...
}
}
例子：
这里使用redis主从架构,做之前需要配置好redis主从,配置好两份redis.conf配置文件即可，slaveof 127.0.0.1 6379
(1)配置好redis主从
$ sudo cp /etc/redis/redis.conf{,1}
$ sudo vi /etc/redis/redis.conf
37 daemonize yes
45 port 6379
64 bind 127.0.0.1
391 requirepass 123456
$ sudo vi /etc/redis/redis.conf1
37 daemonize yes
45 port 6380
64 bind 127.0.0.1
206 slaveof 127.0.0.1 6379
391 requirepass 123456
$ sudo redis-server /etc/redis/redis.conf
$ sudo redis-server /etc/redis/redis.conf1
$ ps -ef | grep redis-server
root 44429 1627 0 14:53 ? 00:00:00 redis-server 127.0.0.1:6379
root 44447 1627 1 14:54 ? 00:00:00 redis-server 127.0.0.1:6380
xiaozhi+ 44480 27618 0 14:54 pts/1 00:00:00 grep --color=auto redis-server
(2)配置settings
CACHES = {
'default': {
'BACKEND': 'redis_cache.RedisCache',
'LOCATION': ['127.0.0.1:6379','127.0.0.1:6380'],
'OPTIONS': {
'MASTER_CACHE': '127.0.0.1:6379',
'DB': 2,
'PASSWORD': '123456',
},
'KEY_PREFIX': 'MyProject',
'TIMEOUT': 480
}
}
(3)使用url方式进行view缓存
from django.views.decorators.cache import cache_page
urlpatterns = [
url(r'^admin/', include(admin.site.urls)),
url(r'^$',cache_page(60 * 15)(Index.as_view())=,name='INDEX'),
url(r'^index2/$',Index2.as_view(),name='INDEX2'),
]
或者在views中的方法上调用装饰器
from django.views.decorators.cache import cache_page
@cache_page(60 * 15, key_prefix='index2')
def Index2(request):
return render(request,'index.html')
(4)使用template片段缓存
{% extends 'base.html' %}
{% load cache %}
{% load staticfiles %}
.
.
{% cache 500 sidebar %}
.
{% endcache %}
信号： （想不起来用法想地雷就可以了）
一般把信号卸载和项目同名的__init__文件中
内置信号
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 # 创建数据库连接时，自动触发
对于Django内置的信号，仅需注册指定信号，当程序执行相应操作时，自动触发注册函数：
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!")
2、自定义信号
a. 定义信号
|
1
2
|
import django.dispatchpizza_done = django.dispatch.Signal(providing_args=["toppings", "size"]) |
b. 注册信号
|
1
2
3
4
5
|
def callback(sender, **kwargs): print("callback") print(sender,kwargs) pizza_done.connect(callback) |
c. 触发信号
|
1
2
3
|
from 路径 import pizza_done pizza_done.send(sender='seven',toppings=123, size=456) |
