Django 开发相关知识 整理

前言

旨在记录Django web常用的开发技术,帮助开发者更加快速开发

前端ajax

详细注意:post提交时,url对后缀一定要补齐'/'

$.ajax({
url: "/cookie_ajax/",
type: "POST",
data: {
"username": "Q1mi",
"password": 123456,
"csrfmiddlewaretoken": $("[name = 'csrfmiddlewaretoken']").val() // 使用jQuery取出csrfmiddlewaretoken的值,拼接到data中
},
success: function (data) {
console.log(data);
}
})
// 原生ajax,XMLHttpRequest
以下两函数功能一样。
function Ajax1()
{
$.ajax({
url:'index.html',
type:'GET',
data:{'p':123},
success:function(arg){
console.log(arg);
}
})
} function Ajax2()
{
var xhr = new XMLHttpRequest();
xhr.onreadystatechange=function(){
if(xhr.readyState==4){
//状态‘4’表示将服务器的返回的数据全部接收完毕
console.log(xhr.responseText); //xhr.responseText表示服务器端返回的数据
}
}
xhr.open('GET','/index.html?p=123'). //GET请求只能将data数据写在url中
xhr.send(null)
} 而POST请求而只要改动以下
xhr.open('POST','/index.html')
xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset-UTF-8');
     xhr.send('p=123')
//send中字符串参数是post请求,而且必须带请求头,否则django不会解析,即request.POST会无数据,
//但是request.body中可以查看到数据确实发过去了。jquery的ajax已经帮我们封装好请求头了。并且可能有其他框架会指定要特有的请求头。
//注意,若前端使用Formdata封装数据(因为不需要头,jquery的ajax中也要做特殊处理),则不用请求头也可

HTTP请求头

首先理解一下HTTP协议
1.建立在tcp协议之上,属于应用层的协议
2.我把它理解为一个规范的传输数据格式,即请求和响应(请求头\r\n\r\n请求体、响应头\r\n\r\n响应体)
3.无状态,短链接(一次请求一次响应,然后断开链接)

常用请求头

    content-type :服务器端给客户端发送的数据类型
accept :服务器端告诉客户端要接收数据类型
User-agent
COOKIE

django的request.POST里面有值要求有
1.请求头要求:
如果请求头中的 Content-Type: application/x-www-form-urlencoded,request.POST中才有值,django会去request.body中解析数据
2.数据格式要求:
即使请求头中的 Content-Type为 application/x-www-form-urlencoded。request.POST也不一定有值,还要request.body要满足name=alex&age=18&gender=男 这种格式
form表单提交默认的 Content-Type为 application/x-www-form-urlencoded

ajax可以序列化和定制请求头

        // 默认:(和form表单一样的头)
$.ajax({
url:...
type:POST,
data:{name:alex,age=18} # 内部转化 name=alex&age=18&gender=男
}) // 情况二:(定制了请求头,Content-Type 不再是 application/x-www-form-urlencoded)
$.ajax({
url:...
type:POST,
headers:{'Content-Type':"application/json"}
data:{name:alex,age=18} # 内部转化 name=alex&age=18&gender=男
})
# body有值;POST无
// 情况三:(序列化,数据格式不满足,而且头也不满足)
$.ajax({
url:...
type:POST,
headers:{'Content-Type':"application/json"}
data:JSON.stringfy({name:alex,age=18}) # {name:alex,age:18...}
})
// body有值;POST无
// json.loads(request.body)

ajax上传文件

使用ajax文件上传,ajax配置必须带以下参数
1.processData:false
2.contentType:false
3.data必须是formData()

        // #avatar是文件上传按钮
$('#avatar').click(function () {
if (!$('#avatar-img').val()) {
// $('#avatar-img').val() 是文件路径名
// $('#avatar-img')[0].files[0] 是文件对象,后台从request.FILES里取出就是它
}
var formData = new FormData();
formData.append('csrfmiddlewaretoken', $('[name = "csrfmiddlewaretoken"]').val());
formData.append('img', $('#avatar-img')[0].files[0]);
$.ajax({
url: '/account/upload_avatar/',
type: 'post',
processData: false,
contentType: false,
data: formData,
dataType: 'json',
success: function (data) {
console.log(typeof(data), data);
}
})
});

jsonp跨域

同源策略是检测网页js脚本是不是向同一个域的url发送请求,ajax刚好受到同源策略限制,而script标签则没有。
而script标签的工作原理是向src指向的url发送GET请求,然后将请求到的数据包裹在标签里面。
所以我们可以创建一个标签<script src=‘http://xxx.com/fuck'> <script>
例如:
<script> egon </script>
#return HttpResponse('egon')
但是,由于数据是直接被包裹在标签里面,相当于声明一个变量名,而js不支持所以报错
所以常见的做法是,本地声明一个回调函数,jsonp返回该函数包裹的跨域数据字符串。
例如:
HttpResponse("func({'a':1,'b':2})")
更深一层,我们可以通过传递GET参数告诉服务器毁掉函数,实现动态的返回指定包裹函数
例如:127.0.0.1:9999?callback=myfunc

Django 开发相关知识 整理

jquery版小技巧:不写JsonpCallback,这样做jquery会随机生成一串字符串作为callback函数名,这样jquery会直接将返回的数据取出作为success函数的参数
视图:
HttpResponse("%s('%s')"%(callback,data))
Django 开发相关知识 整理

URL

设计

多个url对应一个视图
利用是‘子类’在前,‘父类’在后,多余的参数使用**kwargs接收

url(r'^(?P<type>type_[1-3])', views.index),
url(r'^$', views.index),

在URL传递搜索条件
一般是以GET参数传递,这个了解一下也好

# 该正则表示按标签或者日期或者种类过滤
url(r'^(?P<site>\w+)/(?P<condition>((tag)|(date)|(category))/(?P<val>\w+).html$',home.filter)

分发

url匹配有两种,一种是路径对视图,另一种则是分发
- url分发的格式

url('^yuan',([],None,None))

正则对应不再是一个视图函数,而是一个元组。
元组的第一个元素是列表,里面有多个url,一般url对象里面是路径对视图,但是你若喜欢可以再嵌套分发
第二元素为App名,第三元素为名字空间
Django 开发相关知识 整理

url参数编码

将空格等特殊字符编码,常用于处理GET传参的特别参数

from django.utils.http import urlquote
def parse_filter_kwargs(kwargs):
# kwargs: {'title':1,'price':12000}
# return: title=1&price=12000
l = [] for k, v in kwargs.items():
l.append('%s=%s' % (k, urlquote(v)))
return '&'.join(l)

反向生成url

视图

from django.core.urlresolvers import reverse
#kwargs参数接收 一个字典,代表命名正则的名 和 对应的值
if kwargs:
base_url = reverse('index', kwargs=kwargs)
else:
base_url = '/'
html
# 默认版
url('all/(\d+).html$',home.index,name='index')
{%url "index" 1%} # 在html中
reverse('index',kwargs=(1,)) # 在view中 # 命名正则版
url('all/(?<my_id>\d+).html$',home.index,name='index')
{%url "index" my_id=1%} # 在html中:
reverse('index',kwargs={"my_id":1}) #在view中 # 命名空间的url反转
{% url 'org:org_list'%}

视图

request对象

POST

1. input 类型像checkbox这种多值的,要用values = request.POST.getlist('hobby',None)
2. requst.body #请求体,若要去这里拿值时,一定是post方式进来的

url信息

Django 开发相关知识 整理

视图返回值

HttpResponse

1. input 类型像checkbox这种多值的,要用values = request.POST.getlist('hobby',None)
2. requst.body #请求体,若要去这里拿值时,一定是post方式进来的

JsonRespone

from django.http import JsonRespone
#注意:默认JsonRespone只能返回字典,若一定要返回列表,则需要加参数
return JsonRespone([11,22,33],safe=False)

shortcuts

- render

1.render的context参数可以传递locals()函数,将当前作用域所有的变量传递到模板里面去

- redirect

详细
1.redirect函数对于ajax提交没用
2.redirect('/index') 和 redirect('index')的区别:前者跳转到127.0.0.1:8000/index,后者在现有url的网址后面追加index
 例如:现访问的是127.0.0.1:8000/backend,追加为:127.0.0.1:8000/backend/index

返回值响应头和状态设置

# HttpResponse可以带几个参数:

"""

content: 返回的内容
content_type: 返回内容的类型
status """ def index(request):
    return HttpResponse('<p>this is a test</p>', content_type="text/html", status="")

- 响应头设置

 res = HttpRespone('xxxxx')
 res['Access-Control-Allow-Origin']='*'
 return res

CBV

- 更好对代码复用

例如:自定义cbv的login验证mixin

from django.contrib.auth.decorators import login_required
from django.utils.decorators import method_decorator
from django.views import View class LoginRequiredMixin(object):
@method_decorator(login_required(login_url='/url/'))
def dispatch(self, request, *args, **kwargs):
return super(LoginRequiredMixin, self).dispatch(request, *args, **kwargs) # 注意继承顺序
class CommentView(LoginRequiredMixin, View):
pass

 

- CBV装饰器使用

要在CBV视图中使用我们上面的check_login装饰器,有以下三种方式:

1. 加在CBV视图的get或post方法上

from django.utils.decorators import method_decorator

class HomeView(View):

    def dispatch(self, request, *args, **kwargs):
return super(HomeView, self).dispatch(request, *args, **kwargs) def get(self, request):
return render(request, "home.html") @method_decorator(check_login)
def post(self, request):
print("Home View POST method...")
return redirect("/index/")

2. 加在dispatch方法上,因为CBV中首先执行的就是dispatch方法,所以这么写相当于给get和post方法都加上了登录校验。

from django.utils.decorators import method_decorator

class HomeView(View):

    @method_decorator(check_login)
def dispatch(self, request, *args, **kwargs):
return super(HomeView, self).dispatch(request, *args, **kwargs) def get(self, request):
return render(request, "home.html") def post(self, request):
print("Home View POST method...")
return redirect("/index/")

3. 直接加在视图类上,但method_decorator必须传 name 关键字参数,如果get方法和post方法都需要登录校验的话就写两个装饰器。

from django.utils.decorators import method_decorator

@method_decorator(check_login, name="get")
@method_decorator(check_login, name="post")
class HomeView(View): def dispatch(self, request, *args, **kwargs):
return super(HomeView, self).dispatch(request, *args, **kwargs) def get(self, request):
return render(request, "home.html") def post(self, request):
print("Home View POST method...")
return redirect("/index/")

cookie与session

详细

# cookie
request.COOKIES.get('username111')
res = render(request,'index.html')
res.set_cookie('key',"value",max_age=10) # 设置cookie, N秒后失效 #session
x = request.session['xx']
request.session['xx'] = 1
request.session.set_expiry(value)
# * 如果value是个整数,session会在些秒数后失效。
# * 如果value是个datatime或timedelta,session就会在这个时间后失效。
# * 如果value是0,用户关闭浏览器session就会失效。
# * 如果value是None,session会依赖全局session失效策略。

自定义404页面

1.全局urls.py上

# 指明函数路径
handler404 = 'users.views.page_not_found'

2.编写函数

def page_not_found(request):
from django.shortcuts import render_to_response
response = render_to_response('404.html',{})
response.status_code = 404
return response

3.设置settings.py的DEBUG=false,ALLOW_HOSTS=['*']
4.注意:DEBUG=false之后,django的static静态文件处理会实现。所以,要跟处理media一样,自己编写url路由

url(r'^static/(?P<path>.*)$,serve,{"document_root":STATIC_ROOT})

ORM

详细

    # django setting里面的database的初始化命令
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'imoocc',
'USER': 'imoocc',
'PASSWORD': 'imoocccom',
'HOST': '127.0.0.1',
'PORT': '',
'OPTIONS': {},
'init_command': 'SET storage_engine=INNODB,'
'SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED, autocommit=1, names "utf8";',
}
}

字段

注意:定义数据库字段时,小心那些冲突的关键字,例如date, datetime这些就不要取了

- obj.get_xxx_display可以显示将本来数据库存储的数字按照choice的定义转换为相应字符串

status = models.IntegerField(choices=[(-1, '未处理'), (0, '待处理'), (1, '已处理')])
  # obj.get_status_choice

- default参数可以传入一个无参函数,当对象创建时便会调用

send_time = models.DateTimeFIeld(default=datetime.now)

-一对一

和ForeignKey类似,但是多了一个不能重复的约束
OnetoOne常用于分表
即当一张表的某一些字段查询的比较频繁,另外一些字段查询的不是特别频繁,把不怎么常用的字段 单独拿出来做成一张表 然后用过一对一关联起来,
好处是既保证数据都完整的保存下来,又能保证大部分的检索更快

- 多对多
注意:ManytoMany 通常设置在正向查询多的那边
两种方式混合定义多对多

# 如果有额外的字段的时候
tags=models.ManyToManyField(
to='Tag',
through = 'Article2Tag',
through_fields = ('article','tag'),
) 

注意:使用此种方式创建多对多表的时候,没有 add() remove() 等方法
即创建时候就需要直接使用第三张表

models.Author2Book.objects.get(author_id=1,book_id=1).delete()

- 文件字段
 文件字段都设置了upload_to参数,upload_to指向的字符串,若存在'/',则表示文件夹,若文件夹不存在则会自动创建
例如:upload_to = 'head'表示放在settings配置uploads文件下的head文件夹里面
也可以指向一个函数,该函数返回一个动态的文件夹路径

# 例如:为每个用户创建一个指定的文件夹
def upload_to(instance, filename):
import uuid
filename = '%s-%s' % (str(uuid.uuid4())[:8], filename)
return '/'.join(['head', instance.username, filename])

这个参数可以让django内部帮助我们处理文件上传,只要将数据库的文件字段指向文件对象即可

    UserInfo.objects.create(img=request.FILES)
# 或者:
username = form.cleaned_data['username']
headImg = form.cleaned_data['headImg']
#写入数据库
user = User()
user.username = username
user.headImg = headImg
user.save()
upload_to可以支持%Y%m表示年月,换句话说,他会自动将上传时间传入
image = models.ImageField(upload_to="courses/%Y/%m")
 
- content-type
一般而言,表数量可以动态变化,表结构不能变化。注意表结构设计时,表结构不随着其有关系的表的数量增加而改变结构。有时候需要一个定义一个外键关联不同的表,就显得有点麻烦。
为此,Django提供了ContentType,ContenType是django给我们写好的处理一张表关联混合类型外键的组件。所谓混合关联,指的是这个外键字段可能关联到不同的表
from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
from django.contrib.contenttypes.models import ContentType class Course(models.Model):
"""
普通课程
"""
title = models.CharField(max_length=32)
# 不生成表列,仅用于反向查找
price_policy_list = GenericRelation("PricePolicy") # 用于反向查找的特殊字段(一个课程可以对应多个价格策略),由于不能用xxx_set。
# 注意:GenericRelation("PricePolicy")要定义在一对多的‘一’处
# course = models.Course.objects.filter(id=1).first()
# price_policys = course.price_policy_list.all() # 反向查找出课程所有的价格策略 class DegreeCourse(models.Model):
"""
学位课程
"""
title = models.CharField(max_length=32) price_policy_list = GenericRelation("PricePolicy") class PricePolicy(models.Model):
"""
价格策略
"""
price = models.IntegerField()
period = models.IntegerField() # ContentType是django生成一张管理所有表的表,会自动将所有表的名称存进去进行管理
content_type = models.ForeignKey(ContentType, verbose_name='关联的表') #
object_id = models.IntegerField(verbose_name='关联的表中的数据行的ID') # 帮助你快速实现带contenttype关联字段的表对象创建工作,不会数据库中生成列
content_object = GenericForeignKey('content_type', 'object_id') # 1. 为学位课“Python全栈”添加一个价格策略:一个月 9.9
"""
obj = DegreeCourse.objects.filter(title='Python全栈').first()
# obj.id
cobj = ContentType.objects.filter(model='course').first()
# cobj.id
PricePolicy.objects.create(price='9.9',period='30',content_type_id=cobj.id,object_id=obj.id)
""" # 增加GenericForeignKey("conten_type","object_id")之后,会自动识别obj的表的名称,并将表在contenType中的id赋予GenericForeignKey第二个参数
# obj = DegreeCourse.objects.filter(title='Python全栈').first()
# PricePolicy.objects.create(price='9.9',period='30',content_object=obj)

查询

QuerySet的查询时惰性的,即当我们去执行all,filter,get等时是不会去执行sql的,只有当我们调用查询结果集的时候才会真正执行sql 

管理器自带api

- get()
返回model对象,若没有符合条件的对象,触发DoesNotExist异常

try:
  aricle = Article.objects.get(pk=id)
except Article.DoesNotExist:
  return render(request,'failure.html',{'reason':'没有找到对应的文章'})

- 跨表
‘__’可以在filter和values或者相关函数中使用,并且是双向的,只要存在关系即可

# 注:两种用法,可以做条件,也可以取值
 BookInfo.object.filter(heroinfo__hgender__exact = False)
#取值
v2 = models.Host.objects.filter(nid__gt=0).values('nid','hostname','b_id','b__caption')
v3 = models.Host.objects.filter(nid__gt=0).values_list('nid','hostname','b_id','b__caption')

- values与values_list

values 可以提取反向的关联对象
注意:反向查询的参数是小写的orm类名,可以看作是关联表id另一种表示法

a = CategoryInfo.objects.values('articleinfo')
# a = CategoryInfo.objects.filter(articleinfo=1) #可以看作articleinfo__id

values 可以提取外键字段
注意:通过双下划线链接

ArticleInfo.objects.values('category__title') #即使是manytomany也行

- 复杂查询extra()函数

extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
 select和select_params是一组,用于子查询
 where和params是一组,用于附加过滤条件
tables表示要引入哪些新表(会有笛卡尔积),order_by表示数据条目按本表的哪个字段排序

# 附加where条件
Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
# 先filter筛选出指定博客掉文章,再按指定年月过滤
article_list = modles.Article.objects.filter(blog=blog).extra(where=['strftime("%%Y-%%m",create_time)=%s'],params=[val,]) # 自定义一个“子查询”字段
Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid']) 
# 查询语句对比:
models.UserInfo.objects.extra(
select={'newid':'select count(1) from app01_usertype where id>%s'},
select_params=[1,],
where = ['age>%s'],
params=[18,],
order_by=['-age'],
tables=['app01_usertype']
)
"""
select
app01_userinfo.id,
(select count(1) from app01_usertype where id>1) as newid
from app01_userinfo,app01_usertype
where
app01_userinfo.age > 18
order by
app01_userinfo.age desc
"""

- 统计函数 aggregate

没有groupby效果,并且查出来之后就不死queryset对象了,是一个字典。适用于没有groupby的统计

TableInfo.objects.aggregate(c=Count('category_id')) 

- 统计聚合函数annotate
 注意:annotate前面必须有个的value来指定group by后面的字段,默认是以自己的id分组

from django.db.models import Sum, Count
Comment.objects.values(‘article’).annotate(comment_count=Count(‘article’)).order_by(‘-comment_count)。
# select count(article) as c from Evainfo group by aricle ordey by c
# annotate前面的value指定group by后面的字段,默认是以自己的id分组
# 注:comment_count是自定义查询字典的key

annotate统计操作默认以发起表的id进行group by,配合反向查询非常好用

# 查询不同种类对应的书籍数目
CategoryInfo.objects.filter(blog_id=1).values(c=Count('articleinfo')).values('title', 'c')
# 按日期归档
archive_list = models.Article.objects.filter(user=user).extra(
select={"archive_ym": "date_format(create_time,'%%Y-%%m')"}).values("archive_ym").annotate(c=Count("nid")).values("archive_ym", "c") # 标签,种类归档
category_list = models.Category.objects.filter(blog=blog).annotate(c=Count("article")).values("title", "c")
tag_list = models.Tag.objects.filter(blog=blog).annotate(c=Count("article")).values("title", "c")


- 其他不常用

# like查询
filter(sname__contains='黄') #也适用于整型等其他类型,并且要配合比较运算符使用 等同于select * from table where sname like "黄%" #字段排序
order_by('-price') #支持多字段排序 order_by('id','-price','title') #判断查询集中是否有数据,返回bool值
exists() #返回查询集的总条数
count() # 去重
distinct() # 排除指定条件,常用作不等于
exclude()
obj = Permission2Action.objects.filter().exclude(p__menu_isnull =True) #根据字段排序,支持多字段排序
order_by('id','-price','title') # 附:查看执行的sql原生语句
#obj.query

django提供api(get_object_or_404 与 get_list_or_404)

一般都会有这么一个需求,若查找不出指定对象,返回404页面

from django.http import Http404

try:
product = Product.objects.get(pk=1)
except MyModel.DoesNotExist:
raise Http404

get_object_or_404 会简化这个操作

from django.shortcuts import get_object_or_404
product = get_object_or_404(Product, pk=1)

原生查询

- Manger.extra()
常用于附加复杂条件,子查询

# 查询语句对比:
models.UserInfo.objects.extra(
select={'newid':'select count(1) from app01_usertype where id>%s'},
select_params=[1,],
where = ['age>%s'],
params=[18,],
order_by=['-age'],
tables=['app01_usertype']
)
"""
select
app01_userinfo.id,
(select count(1) from app01_usertype where id>1) as newid
from app01_userinfo,app01_usertype
where
app01_userinfo.age > 18
order by
app01_userinfo.age desc
"""
 

Manager.raw()
注意,raw查询,查询结果一定要包含主键

Topic.objects.raw('select * form forum_topic')

# 异常,因为返回的结果没有包含主键
blog_article.objects.raw(‘select distinct date_format(r‘blog_article’.’date_publist’,’%Y-%m’) from blog_article’)
- DB-API
直接使用了MySQLbd的api,使用原生语句查询 )
from django.db import connection, transaction
cursor = connection.cursor()
  # cursor = connections['default'].cursor() # 数据修改操作——提交要求
cursor.execute("UPDATE bar SET foo = 1 WHERE baz = %s", [self.baz])
transaction.commit_unless_managed() # 数据检索操作,不需要提交
cursor.execute("SELECT foo FROM bar WHERE baz = %s", [self.baz])
row = cursor.fetchone()

连表查询

注意的是:selected_related不支持ManytoMany,而prefetch_related支持所有关系
Django 开发相关知识 整理

用于查询的对象

Q对象

from django.db.models import Q

Q(Q(account='fuck_man') & Q(status=0) | Q(birthday_lte=ctime))

# 多个Q对象组装复杂条件
q = Q() q1 = Q()
q1.connector = 'AND'
q1.children.append('account', 'fuck_man')
q1.children.append('status', 0)
q1.children.append('birthday_lte', ctime) q2 = Q()
q2.connector = 'AND'
q2.children.append('title', 'fuck') q.add(q1, 'OR')
q.add(q2, 'OR')


- filter 的 != 条件应该使用Q查询

from django.db.models.query import Q
queryset = UserInfo.objects.filter(~Q(name=""))

- 条件的“或”操作- 动态实现Q条件 
比如简单的搜索功能(搜索一个文章的标题或内容或作者名称包含某个关键字):

import operator
from django.db.models.query import Q # 用户要查询的值
q = request.GET.get('q', '').strip()
# 可能的查询键值列表
key_list = ['title__contains', 'content__contains','author__name__contains']
# 实现Q(title__contains=q)|Q(content__contains=q)|Q(author__name__contains=q)
l = [Q(**{key:q}) for key in key_list]
#reduce相当于c++的accumulate,累加函数, operator.or_(x,y)是二进制的'或'操作, 从列表里将所有Q对象一起'或'起来,得到最终的结果
queryset = Entry.objects.filter(reduce(operator.or_, l))

F对象

- 字段间比较
例如:查询书id小于价格的书籍

models.Book.objects.filter(id__lt=F("price"))

-  django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作

models.Book.objects.filter(id__lt=F("price")/2)

- 将对象的一个字段经过修改(加减乘除),赋值给另一个字段,以此进行更新

models.Book.objects.all().update(price=F("price")+30) 

序列化

1、serializers

from django.core import serializers

ret = models.BookType.objects.all()

data = serializers.serialize("json", ret)

2、json.dumps

    import json

    #ret = models.BookType.objects.all().values('caption')
ret = models.BookType.objects.all().values_list('caption') ret=list(ret) result = json.dumps(ret)

由于json.dumps时无法处理datetime日期,所以可以通过自定义处理器来做扩展,如:

import json
from datetime import date
from datetime import datetime class JsonCustomEncoder(json.JSONEncoder): def default(self, field): if isinstance(field, datetime):
return o.strftime('%Y-%m-%d %H:%M:%S')
elif isinstance(field, date):
return o.strftime('%Y-%m-%d')
else:
return json.JSONEncoder.default(self, field) # ds = json.dumps(d, cls=JsonCustomEncoder)

自定义Manager

class MyCustomManager(models.Manager):
# 连接查询时也生效
use_for_related_fields = True def get_queryset(self):
return super(MyCustomManager, self).get_queryset().filter(isDelete=False) # 配置 use_for_related_fields = True,一定要写在外面。不知道是不是bug,一定要再类的外面的实例化
custom_manager = MyCustomManager() class BaseModel(models.Model):
create_time = models.DateTimeField(verbose_name='创建时间', auto_now=True)
isDelete = models.BooleanField(verbose_name='是否已经删除', default=False) default_objects = models.Manager() # objects = BaseManger会被覆盖
objects = custom_manager class Meta:
abstract = True def delete(self, using=None, keep_parents=False):
"""重写数据库删除方法实现逻辑删除"""
self.isDelete = True
self.save()
print('isDelete = false')

模型继承

详细

数据库事务

详细

资源共享问题

数据资源共享问题,需要借助返回值(受影响的行数)

row = Trouble.objects.filter(id=nid,status=1).update(**form.cleaned_data)
if not row:
return HttpResponse('来晚一步,被人抢走了')
  # 需要考虑多个用户抢同一个资源的问题,update返回的是数字,若返回是0,表示单子被抢走了。
else:
return redirect('/backend/trouble-list.html')

分库

分库的方法

- 手动路由

# 查询,使用using函数,参数就是要查询的数据库
User.objects.using('user1').all()
# 保存或者更新,使用save的using参数,值就是要使用的数据库
my_object.save(using='user1')
#删除,使用delete的using参数
user_obj.delete(using='user1')

- 自动路由
详细

分库的思路

- 垂直分库
即一个app对应一个数据库,上面自动路由的例子就是一个垂直分库的例子,auth1使用user1数据库,auth2使用user2数据库。当然也可以使用手动路由。

- 水平分库
水平分库建议使用手动路由,因为每个model的分库机制可能都不一样,自动路由实现起来有些麻烦会造成性能不高,而手动路由,每个model根据自己的规则来获得不同的数据库。

模板

- 注意点
1.  函数在模版里面不能加括号
2. 模版里面统计反向集合数据条数 要用{{ article.commentinfo_set.count }} #{{article.commentinfo_set|length}}不行
3.  默认request对象已经传入模版里面,例如:
  {% if request.session.user|default:'' != '' %}
4. 在模版语言中,变量类型不会因为输出语句,例如{{name}},而改变类型,比如说,int类型还是int类型,不回变为字符串

- 模板html文件加载顺序
Django会依次到以下目录查找模板文件,如果都找不到,则报错:

1.项目配置的模板目录
2.admin应用的templates模板目录
3.auth应用的templates模板目录
4. 应用本身的templates模板目录

内置过滤器

# 注意的是,模版的传入的参数都是为字符串,并且传参时都要带‘:’
{{courses | length}} #集合的长度
{{ time_obj|date:"Y-m-d H:i:s"}} # 对传入转为日期时间格式
{{ str_obj|truncatewords:"" }} # 截取前三十个字符,无法截取中文
{{str_obj| slice:""}} #截取中文
{{ my_list|first|upper }} # 把第一个字符大写
{{ article.summary |default:'' }} #这个可以保障模版不输出None,因为从数据库取出的值若没有则为None
{{ name|lower }} # 把传入值小写
{{ article.date_publish | date:"Y-m-d" }}
  {{html_str|safe}} #让html_str给浏览器解析,默认出于安全考虑不解析

  {% autoescape off %} #批量转义
  {{ course.detail }}
  {% endautoescape %} 注:还有另一种方式可以让浏览器解析,
from django.utils.safestring import mark_safe
  html_str=mark_safe(html_str)

- 循环计数

        {% for row in v1 %}           # 假设3条数据
{{ forloop.counter}} # 依次为:1、2、3
{{ forloop.counter0}} # 依次为:0、1、2
{{ forloop.revcounter}} # 依次为:3、2、1
{{ forloop.revcounter0}} # 依次为:2、1、0
{{ forloop.last }} # 是否最后一个,是为True,其他False
{{ forloop.first }} # 是否第一个
{{ forloop.parentloop }} # 嵌套循环,表示上层循环的上面的六个值别是多少。
{% endfor %}

自定义过滤器

from django import template
register = template.Library() # 定义一个将日期中月份转换为大写的过滤器,如8转换为八 @register.filter
def month_to_upper(key):
return ['一','二','三','四','五','六','七','八','九','十','十一','十二'][key] # 使用,模版文件要load一下才能使用,filter是filter.py文件的文件名
{%load filter%}
<div class='month'>{{article.date_publish | month_to_upper}}</div> # article.date_publish会被当做month_to_upper的参数
{{ cls_verbose_name |test:app_name }} # 如果过滤器有参数时,一定要确定没有空格,即过滤器test后面一定要紧贴':'
# 配置
注意的是:一定要在指定App目录下建立templatetags目录,并且要在setting.py设置
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [os.path.join(BASE_DIR, 'templates')]
,
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
], 'libraries': {
'my_tags': 'web.templatetags.filter', #my_tags为自定义键值, web.templatyetags.filter为路径
}
},
},

自定义simple_tag

过滤器最多只能带1个额外参数只能带1个额外参数,而自定义simple_tag可以带无数个

# 可以接收多个参数
@register.simple_tag
def create_filter_str(order, q, filter_dict, field, value=''):
d = copy.copy(filter_dict)
remove_previous_field(d, field)
d[field] = value order_str = 'order=%s' % order
q_str = 'q=%s' % q
filter_str = parse_filter_kwargs(d)
return '?' + '&'.join([order_str, q_str, filter_str]) #调用
<a href="{% create_filter_str args.order args.q args.filter data_dict.field %}">全部</a> #或者{% create_filter_str args.order args.q args.filter data_dict.field as filter_str%}
{{filter_str}}

页面分离与导入

传入参数经过计算渲染装饰器所指定的页面,这个页面可以被其他模板通过调用引入

@register.inclusion_tag('web/sub/common_bar.html')
def get_common_bar(blog):
tag_statistics = TagInfo.objects.filter(blog=blog). \
annotate(article_count=Count('articleinfo')).values('id', 'article_count', 'title') category_statistics = CategoryInfo.objects.filter(blog=blog). \
annotate(article_count=Count('articleinfo')).values('id', 'article_count', 'title') date_statistics = ArticleInfo.objects.filter(blog_id=1). \
extra(select={'create_date': 'date_format(time,"%%Y-%%m")'}). \
values('create_date').annotate(article_count=Count('id')).values('article_count', 'create_date') # 粉丝数
fans_count = Star2Fans.objects.filter(star_user=blog.user).count()
# 关注数
star_count = Star2Fans.objects.filter(fans_user=blog.user).count() # 模版只会根据这个函数返回的上下文进行渲染
return locals()

- 使用

{% get_common_bar blog %}

settings.py配置

多个setting文件

详细

静态文件与上传文件配置

# 原理就是url拼配成功后,截取剩下的路径去指定目录下查找
STATIC_URL = '/static/'
STATICFILES_DIRS = (
os.path.join(BASE_DIR,'static'),
)
MEDIA_URL = '/uploads/'
MEDIA_ROOT = os.path.join(BASE_DIR,'uploads')
# 注意:upload_to 设置的路径是相对于MEDIA_ROOT下创建 # 模板中引用静态文件
<link href ="{% static 'css/base.css' %}" rel="stylesheet"} #配置能访问upload的文件 from django.views.static import serve
from django.conf import settings urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^uploads/(?P<path>.*)$', serve, {'document_root': settings.MEDIA_ROOT}),
] #配置在模版中使用{{MEDIA_URL}} 代表 ‘/uploads/'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [os.path.join(BASE_DIR, 'templates')]
,
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
'django.template.context_processors.media',
],

日志配置

BASE_LOG_DIR = os.path.join(BASE_DIR, "log")
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]'
'[%(levelname)s][%(message)s]'
},
'simple': {
'format': '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
},
'collect': {
'format': '%(message)s'
}
},
'filters': {
'require_debug_true': {
'()': 'django.utils.log.RequireDebugTrue',
},
},
'handlers': {
'console': {
'level': 'DEBUG',
'filters': ['require_debug_true'], # 只有在Django debug为True时才在屏幕打印日志
'class': 'logging.StreamHandler',
'formatter': 'simple'
},
'SF': {
'level': 'INFO',
'class': 'logging.handlers.RotatingFileHandler', # 保存到文件,根据文件大小自动切
'filename': os.path.join(BASE_LOG_DIR, "xxx_info.log"), # 日志文件
'maxBytes': 1024 * 1024 * 50, # 日志大小 50M
'backupCount': 3, # 备份数为3 xx.log --> xx.log.1 --> xx.log.2 --> xx.log.3
'formatter': 'standard',
'encoding': 'utf-8',
},
'TF': {
'level': 'INFO',
'class': 'logging.handlers.TimedRotatingFileHandler', # 保存到文件,根据时间自动切
'filename': os.path.join(BASE_LOG_DIR, "xxx_info.log"), # 日志文件
'backupCount': 3, # 备份数为3 xx.log --> xx.log.2018-08-23_00-00-00 --> xx.log.2018-08-24_00-00-00 --> ...
'when': 'D', # 每天一切, 可选值有S/秒 M/分 H/小时 D/天 W0-W6/周(0=周一) midnight/如果没指定时间就默认在午夜
'formatter': 'standard',
'encoding': 'utf-8',
},
'error': {
'level': 'ERROR',
'class': 'logging.handlers.RotatingFileHandler', # 保存到文件,自动切
'filename': os.path.join(BASE_LOG_DIR, "xxx_err.log"), # 日志文件
'maxBytes': 1024 * 1024 * 5, # 日志大小 50M
'backupCount': 5,
'formatter': 'standard',
'encoding': 'utf-8',
},
'collect': {
'level': 'INFO',
'class': 'logging.handlers.RotatingFileHandler', # 保存到文件,自动切
'filename': os.path.join(BASE_LOG_DIR, "xxx_collect.log"),
'maxBytes': 1024 * 1024 * 50, # 日志大小 50M
'backupCount': 5,
'formatter': 'collect',
'encoding': "utf-8"
}
},
'loggers': {
'': { # 默认的logger应用如下配置
'handlers': ['SF', 'console', 'error'], # 上线之后可以把'console'移除
'level': 'DEBUG',
'propagate': True,
},
'collect': { # 名为 'collect'的logger还单独处理
'handlers': ['console', 'collect'],
'level': 'INFO',
}
},
}
# 用户使用logging.getLogger([name])获取logger实例,如果没有名字,返回logger层级中的根logger(root logger)
# django名字的logger可能是默认终端的输出,未验证
logger = logging.getLogger(‘django’)
logger.info(“This is an error msg”)

sql查询语句显示配置

LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
'console':{
'level':'DEBUG',
'class':'logging.StreamHandler',
},
},
'loggers': {
'django.db.backends': {
'handlers': ['console'],
'propagate': True,
'level':'DEBUG',
},
}
}

django内置组件

Form组件

详细

字段

# 常用字段
# CharField
# IntegerField
# DeimalField
# DateField
# DateTimeField
# EmailField
# ChoiceField
# FileField
# RegexField
# GenericIPAddressField
from django import forms
from django.forms import fields
#forms的单选框
auto = forms.CharField(
label='一个月内自动登录',
widget=widgets.CheckboxInput(attrs={'id': "auto", 'name': 'auto'}),
required=False,
)

例如:手机号码定义

    phone = fields.CharField(
min_length=11,
max_length=12,
error_messages={'required': 'server:手机号码不能为空',
'min_length': 'server:号码必须为11位或者12位',
'max_length': 'server:号码必须为11位或者12位',
},
validators=[RegexValidator(r'^1[0-9]{10,11}$', '手机号码格式错误'), ],
label='电话号码',
widget=widgets.TextInput(attrs={'name': 'phone', 'placeholder': "请输入手机号码", \
'class': 'form-control', 'id': 'phone'}),
)

例如:根据model的choices字段生产选项组框

    city = forms.ChoiceField(
choices =models.CityInfo.objects.all().values_list('id','name'),
# choices = [(1,"东莞"),(2,"广州"),(3,"深圳")],
label = "城市",
initial = 1,
widget = forms.widgets.Select
)

#注意:以上的做法,当数据库更新时,不会实时更新。这时候需要自定义form的构造方法
class MyForm(Form): user = fields.ChoiceField(
# choices=((1, '上海'), (2, '北京'),),
initial=2,
widget=widgets.Select
) def __init__(self, *args, **kwargs):
super(MyForm,self).__init__(*args, **kwargs)
# self.fields['user'].choices = ((1, '上海'), (2, '北京'),)
self.fields['user'].choices = models.Classes.objects.all().values_list('id','caption')

验证顺序

先验证了min_length那些参数字段之后再执行clean_xx钩子函数,最后执行整体验证clean()

  • 无论之前定义的min_length那些验证成功与否,都会执行clean_xx函数,所以在里面操作时应当使用request.POST,而不是self.clean_data。(因为当验证失败时会取不到值)
  • 如果验证成功需要return self.clean_data['xx']回去,不然clean_data里面那操作过的那个字段会是None
#单一字段的验证,clean_xxx()
def clean_verify(self):
user_verify_code = self.request.POST.get('verify', '').upper()
verify_code = self.request.session.get('verify_code').upper()
if user_verify_code != verify_code:
raise ValidationError(message='验证码错误', code='invalid') # 整体验证例子
def clean(self):
value_dict = self.clean_data
v1 = value_dict.get('username')
v2 = value_dict.get('user_id')
if v1!='root' and v2 !=1:
raise ValidationError('整体错误信息')
return self.cleaned_data

后续增加错误信息

# form.errors['username'] = ['用户名不存在或者密码错误', ]
form.add_error(field, error)

只读字段处理

#form.fields['title'].widget.attr['readonly']=True
#form.fields['title'].widget.attr.update(['disabled':'true'})
form.fields['title'].disabled = True

使用接口

form = UserForm(request.POST,request.FILE)
if form.is_valid():
form.cleaned_data #验证过的数据,字典形式,键是name属性
else:
# 错误数据,字典形式,键是name属性,不过它的__str__默认返回errors.as_ul(),也就是字符串。html的ul代码
form.errors

注意:使用字典参数作为自定义form的data参数,传入的的值会被自己定义的规则所验证。若不想验证,则传入参数为initial

form = TroubleMaker(initial={'title':'标题1','detail':'XXXX'}) 

模板中使用

errors内部格式

{'username:['错误信息1','错误信息2'],'password':['错误信息1,]}

取错误列表里面的第一个

{{ form.errors.username.0}}

在模板中显示Django’__all__’形式的错误,即整体错误信息

{{ form.non_field_errors }}

验证器

Django将验证器定义为一个可调用的对象,它接受一个值,并在不符合一些规则时抛出ValidationError异常。 
换句话说,满足以上定义的都是验证器,那我们就可以欢快地来自定义验证器吧!

例如,这个验证器只允许偶数:

from django.core.exceptions import ValidationError

def validate_even(value):
if value % 2 != 0:
raise ValidationError('%s is not an even number' % value)

你可以通过字段的validators参数将它添加到模型字段中:

from django.db import models

class MyModel(models.Model):
even_field = models.IntegerField(validators=[validate_even])

由于值在验证器运行之前会转化为Python,你可以在表单上使用相同的验证器:

from django import forms

class MyForm(forms.Form):
even_field = forms.IntegerField(validators=[validate_even])

你也可以使用带有 __call__()方法的类,来实现更复杂或可配置的验证器。例如,RegexValidator就用了这种技巧。

RegexValidator
class RegexValidator([regex=None, message=None, code=None, _inversematch=None, flags=0])[source] regex
用于搜索提供的value的正则表达式,或者是预编译的正则表达式对象。通常在找不到匹配时抛出带有 message 和code的 ValidationError异常。这一标准行为可以通过设置inverse_match 为True来反转,这种情况下,如果找到匹配则抛出 ValidationError异常。通常它会匹配任何字符串(包括空字符串)。
message
验证失败时ValidationError所使用的错误信息。默认为"Enter a valid value"。
code
验证失败时ValidationError所使用的错误代码。默认为"invalid"。
inverse_match
New in Django 1.7.regex的匹配模式。默认为False。
flags
New in Django 1.7.编译正则表达式字符串regex时所用的标识。如果regex是预编译的正则表达式,并且覆写了flags,会产生TypeError异常。默认为 0

modelform

class UserCreationForm(forms.ModelForm):
"""A form for creating new users. Includes all the required
fields, plus a repeated password."""
password1 = forms.CharField(label='密码', widget=forms.PasswordInput(attrs={'class': 'form-control'}), \
max_length=32, min_length=8)
password2 = forms.CharField(label='重复密码', widget=forms.PasswordInput(attrs={'class': 'form-control'})) class Meta:
model = UserInfo
fields = ('email', 'username')
labels = {
'username': '用户名',
'email': '邮箱',
}
error_messages = {
'__all__': {}, 'email': {
'required': '邮箱不能为空',
'invalid': '邮箱格式错误',
},
'username': {
'required': '用户名不能为空',
'invalid': '用户名格式错误..',
}
} widgets = {
'username': widgets.TextInput(attrs={'class': 'form-control'}),
'email': widgets.TextInput(attrs={'class': 'form-control'})
} def clean_password2(self):
# Check that the two password entries match
password1 = self.cleaned_data.get("password1")
password2 = self.cleaned_data.get("password2")
if password1 and password2 and password1 != password2:
raise forms.ValidationError("两次密码输入不一致")
return password2 def save(self, commit=True):
# Save the provided password in hashed format
user = super(UserCreationForm, self).save(commit=False)
user.set_password(self.cleaned_data["password1"])
if commit:
user.save()
return user

视图中使用

 # instance参数表示和data参数共同融合
form = form_cls(instance=obj, data=request.POST)
if form.is_valid():
   obj = form.save() #存储对象,返回model对象

模板中使用

{%for field in form %}
{{ field.label }} # verbose_name
{{ field.name}} # modelinfo原始定义的字段名,例如price
{{ field }} # input组件
{{ field.errors.0 }} #错误信息
{%endfor%}

动态modelform

class FormClassFactory(object):
@classmethod
def from_admin(cls, admin):
class Meta:
model = admin.cls_info
fields = '__all__'
exclude = admin.readonly_fields def __new__(cls, *args, **kwargs):
for field_name in cls.base_fields:
field_obj = cls.base_fields[field_name]
field_obj.widget.attrs.update({'class': 'form-control'}) # 传入组件属性
return ModelForm.__new__(cls) form_cls = type('DynamicModelForm', (ModelForm,), {'Meta': Meta, '__new__': __new__})
return form_cls

缓存

from django.core.cache import cache
is_had_read = cache.get(article_id)
if not is_had_read:
article.read_num += 1
article.save()
cache.set(article_id, 1, 60 * 60 * 24 * 30) #一个月过期

中间件

详细
 -中间件执行流程。
a. - 请求到来走wsgi,wsgi负责按照HTTP协议的规则解析请求成请求头
b. 先执行所有安装中间件的process_request
c. - 绕回去匹配url
d. 执行所有中间件的process_view #这里和process_request的区别是,这里已经找到了要执行的视图函数
e. -执行视图函数返回
f. 执行所有中间件的process_response
g. 若报错,执行所有的process_excepiton
h. 若用render返回,则执行所有的process_render方法

异常

脚本运行环境配置

import os
import django
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "project_name.settings") # project_name 改成你自己的项目名称
django.setup()

APP

自定义AppConfig

方法1

# 第一步在app的apps.py中
class AccountConfig(AppConfig):
name = 'account'
verbose_name = u'用户信息' # 更改app的在admin中的显示 # 第二步,在该app的__init__.py中
default_app_config = 'account.apps.AccountConfig'

方法2

直接在settings的INSTALLED_APPS中后面加上.apps.UsersConfig
例如:'users.apps.AppConfig'

- ready方法

app一被加载就自动调用的方法

 from django.apps import AppConfig
class App01Config(AppConfig):
name = 'app01' def ready(self):
from django.utils.module_loading import autodiscover_modules
# 在项目所有的目录下查找并调用aaaa.py文件
autodiscover_modules("aaaa")

app设计

一般我们通过“名词+动词分析”进行数据库设计,但进行app设计时,models可能会有循环导入问题。
一般解决的方法是,定义一个动作app(operation,operation可以根据角色的动作去设计),导入其他名词app(user,organization,course)

- 整理app文件夹
即将所有app存放于一个文件夹中

1.新建包apps
2.移动app至apps,注意不要勾选search on xx这个选项,要的不是from apps.course.models import * 这种效果
3.改掉编辑器的错误提示,右键-->Mark Directory as--->Sources Root,这样会使得编辑器查找模块时,也会将apps作为跟文件夹开始搜索
4.settings.py文件增加
sys.path.insert(0,os.path.join(BASE_DIR,'apps')
5.注意:当要从新migration时会报错,因为django默认会将外键的路径加上apps这个文件夹,导致错误。所以搜索出来删掉(ctrl+H全局搜索)

信号

Django中提供了“信号调度”,用于在框架执行操作时解耦。通俗来讲,就是一些动作发生的时候,信号允许特定的发送者去提醒一些接受者。

1、Django内置信号

    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. 定义信号

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

b. 注册信号

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

c. 触发信号

        from 路径 import pizza_done

        pizza_done.send(sender='seven',toppings=123, size=456)

由于内置信号的触发者已经集成到Django中,所以其会自动调用,而对于自定义信号则需要开发者在任意位置触发。

时区

LANGUAGE_CODE = 'zh-hans'
TIME_ZONE = 'Asia/Shanghai'
USE_TZ = False # 防止django存储数据库时采用utc时间,而use_tz为false则表示使用本地时间

- 注意
1. 如果直接用标准库的datetime,可能会出现以下警告,因为你使用的是一个不带时区的时间

Django 开发相关知识 整理

 这个问题的隐患是,假如你的django如果用了时区,而标准库是当前系统时区,那么就很可能出现时间查
  解决办法:安装django的指定的时区来
  from django.utils.timezone import datetime

闪现

详细

csrf

跨站请求伪造,重点在跨站二字
钓鱼网站的页面和正经网站的页面对浏览器来说有什么区别?
- 钓鱼网站的页面是由 钓鱼网站的服务端给你返回的
- 正经网站的网页是由 正经网站的服务端给你返回的
钓鱼网站的目的是:真正的目的是你要交互的合法网站所存储的cookie,这是你的身份凭证。
手段是:引导你生成不合法的数据,或者直接借由自己双手提交一个已经设计好的非法表单数据。

csrf_protect,为当前函数强制设置防跨站请求伪造功能,即便settings中没有设置全局中间件。
csrf_exempt,取消当前函数防跨站请求伪造功能,即便settings中设置了全局中间件。

from django.views.decorators.csrf import csrf_exempt, csrf_protect

auth组件

详细

 
自定义authenticate,实现用户可以通过邮箱或者用户名登录
    # settings.py文件中配置,指明路径
AUTHENTICATION_BACKENDS = (
'users.views.CustomBackend',
) from django.contrib.auth.backends import ModelBackend
from django.db.models import Q
class CustomBackend(ModelBackend):
def authenticate(self, username=None, password=None, **kwargs):
try:
user = UserProfile.objects.get(Q(username=username)|Q(email=username))
if user.check_password(password):
return user
except Exception as e:
return None

admin

详细

邮件

# Email settings smtp/pop3
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = "smtp.163.com" # smtp加上指定的域名
EMAIL_PORT = 25
EMAIL_HOST_USER = "jdecree@163.com"
EMAIL_HOST_PASSWORD = "xxxxx" # 授权码
# EMAIL_USE_TLS = True
EMAIL_FROM = "jdecree@163.com"
class EmailHelper(object):
def __init__(self):
self.email_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
self.email_from = settings.EMAIL_FROM # 发送人 def send_captcha(self, receive_email):
"""
发送验证码
"""
captcha_helper = CaptchaHelper()
captcha = captcha_helper.create_and_save_captcha(email=receive_email)
# 邮件发送参数
email_title = '修仔科技'
email_body = '%s' % (captcha,)
status = send_mail(email_title, email_body, self.email_from, [self.email_from, receive_email])
return status def set_user_activate_link(self):
"""
发送注册后的激活邮件
:return:
"""
pass def send_password_reset_link(self):
"""
发送密码重置链接
:return:
""" def send_email_reset_link(self):
"""
发送邮箱重置链接
:return:
"""
# 附上邮箱model

class EmailVerifyRecord(models.Model):
code = models.CharField(max_length=20, verbose_name=u"验证码")
email = models.EmailField(max_length=50, verbose_name=u"邮箱")
send_type = models.CharField(verbose_name=u"验证码类型",
choices=(("register", u"注册"), ("forget", u"找回密码"), ("update_email", u"修改邮箱")),
max_length=30)
send_time = models.DateTimeField(verbose_name=u"发送时间", default=datetime.now) class Meta:
verbose_name = u"邮箱验证码"
verbose_name_plural = verbose_name # 点击邮箱链接激活
# 通过随机字符串找出邮箱,再通过邮箱找出用户 class AciveUserView(View):
def get(self, request, active_code):
all_records = EmailVerifyRecord.objects.filter(code=active_code)
if all_records:
for record in all_records:
email = record.email
user = UserProfile.objects.get(email=email)
user.is_active = True
user.save()
else:
return render(request, "active_fail.html")
return render(request, "login.html")

第三方库

二级域名组件(django-hosts)

详细

cors跨域处理包(django-cors-headers)

安装
pip install django-cors-headers
添加应用
在settings里面配置 INSTALLED_APPS = (
...
'corsheaders',
...
)
中间层设置
MIDDLEWARE = [
'corsheaders.middleware.CorsMiddleware',
...
]
添加白名单
# CORS
CORS_ORIGIN_WHITELIST = (
'127.0.0.1:8080',
'localhost:8080', #凡是出现在白名单中的域名,都可以访问后端接口
)
CORS_ALLOW_CREDENTIALS = True # 指明在跨域访问中,后端是否支持对cookie的操作 

调试工具(django-pdb)

1. pip install django-pdb
2. INSTALLED_APPS = (
  # 放在第一位置
  'django_pdb',)
3.MIDDLEWARE = [
  # 放在第一位置
  'django_pdb.middleware.PdbMiddleware',]
4.settings.DEBUG = True
5. 再pdb中输入c,到视图中执行

- pdb命令
命令 解释
break 或 b 设置断点
continue 或 c 继续执行程序
list 或 l 查看当前行的代码段
step 或 s 进入函数
return 或 r 执行代码直到从当前函数返回
exit 或 q 中止并退出
next 或 n 执行下一行
pp 打印变量的值
help 帮助

redis(django-redis)

g. Redis缓存(依赖:pip3 install django-redis)

CACHES = {
"default": {
"BACKEND": "django_redis.cache.RedisCache",
"LOCATION": "redis://127.0.0.1:6379",
"OPTIONS": {
"CLIENT_CLASS": "django_redis.client.DefaultClient",
"CONNECTION_POOL_KWARGS": {"max_connections": 100,'decode_responses': True}
# "PASSWORD": "密码",
}
}
}
from django_redis import get_redis_connection
conn = get_redis_connection("default")

视图中链接并操作

2、应用

a. 全站使用

   使用中间件,经过一系列的认证等操作,如果内容在缓存中存在,则使用FetchFromCacheMiddleware获取内容并返回给用户,当返回给用户之前,判断缓存中是否已经存在,如果不存在则UpdateCacheMiddleware会将缓存保存至缓存,从而实现全站缓存

    MIDDLEWARE = [
'django.middleware.cache.UpdateCacheMiddleware',
# 其他中间件...
'django.middleware.cache.FetchFromCacheMiddleware',
] CACHE_MIDDLEWARE_ALIAS = ""
CACHE_MIDDLEWARE_SECONDS = ""
CACHE_MIDDLEWARE_KEY_PREFIX = ""

b. 单独视图缓存

    方式一:
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)),
]

c、局部视图使用

    a. 引入TemplateTag

        {% load cache %}

    b. 使用缓存

        {% cache 5000 缓存key %}
缓存内容
{% endcache %}

- redis API

详细

celery(django-celery)

详细

# celery
# pip install redis==2.10.6
djcelery.setup_loader()
BROKER_BACKEND = 'redis'
BROKER_URL = 'redis://127.0.0.1:6379/0'
CELERY_RESULT_BACKEND = 'redis://127.0.0.1:6379/1'
# 设置路径让celery能找到tasks文件
CELERY_IMPORTS = ['web_chat.tasks', ]
# 设置时区
CELERY_TIMEZONE = TIME_ZONE
# 防止死锁
CELERYD_FORCE_EXECV = True
# 并发数
CELERYD_CONCURRENCY = 4
# 允许重试
CELERYD_ACKS_LATE = True
# 一个worker最多执行任务数
CELERYD_MAX_TASKS_PER_CHILD = 100
# 单个任务最大运行时间
CELERY_TASK_TIME_LIMIT = 60

验证码(django-simple-captcha)

详细

第三方分页组件(django-pure-pagination)

详细

富文本编辑器(DjangoUeditor)

详细

xadmin

详细1详细2
后台管理三大要素(权限管理,少前端样式,快速开发)
1. pip install xadmin
2. pip uninstall xadmin
3. gitclone https://github.com/J-Decree/mxonline_resources
4. 新建一个extra_apps存放,跟整理app的步骤一样
5. INSTALL_APP加上xadmin
6. urls.py中(和django-admin统一文件)
  urlpatterns=[url(r'^xadmin/',xadmin.site.urls),]

注意:
- model显示

class Meta:
verbose_name = u"邮箱验证码"
verbose_name_plural = verbose_name #这个是复数形式的显示,默认会加个s

- 将UserProfile这个表移动到自己定义应用account下管理

1.UserAdmin在xadmin的auth.py下,里面有个UserAdmin
2.还是再plugin/auth.py下替换User,不然一些修改密码的链接会报错
Django 开发相关知识 整理

3.还是auth.py的最下面,修改url,默认是users/user,改密码时会找不到

Django 开发相关知识 整理

- 权限说明

针对于表,django为每个表都生成增删改查4个权限,拥有的权限差别会导致操作的不同甚至可能连表都看不到

- modeladmin方法:保存对象时,可以所做的操作

Django 开发相关知识 整理

 - 怎么写插件
需求1:以xadmin遇到UeditorField字段可以显示富文本

1.在xadmin/plugin文件夹中新增ueditor.py(点我)
2.修改xadmin/plugin/__init__.py中的PLUGIN列表增加ueditor,注意要跟文件名一样
3.adminx的modeladmin添加style_fields = {'detail':'ueditor'} 指明哪个字段生效,detail是字段名

需求2: excel导入插件

1.在xadmin/plugin文件夹中新增excel.py(点我)
2.在xadmin/templates增加上面的蓝色标记的excel.html(点我)
3.在需要按钮的modeladmin下定义import_excel = True,并增加post方法,导入按钮的方法的逻辑就是在这里编写

def post(self, request, *args, **kwargs):
if 'excel' in request.FILES:
pass
return super(CourseAdmin, self).post(request, args, kwargs)

4.xadmin/__init__.py的PLUGIN列表中增加excel

支付宝

详细

易错点:
1. 运行报错,注意看有没有安装pycryptodope:pip install pycryptodope
2. 支付使用的是商户的私钥+支付宝的公钥,而不是你个人的公钥(注意:支付宝公钥是根据公钥自动生成的)
3. 支付宝支付成功后,首先页面做了跳转,支付宝会往你指定的url里发了一个post请求
4. 支付宝要求处理post请求的视图函数返回HttpResponse('success') #如果没有返回success,一天以内一直给你发相同post请求

开发环境

pip

# 批量安装
pip install -r requirements.txt #注,如果有报错,先注释掉报错模块,然后单独安装
# 生成requirement.txt文件
pip freeze > requirements.txt
# 查找指定模块
pip frzeeze | grep 'pexpect'

虚拟环境

详细

pycharm断点调试

详细  

Django推荐项目布局

详细

生产环境

uWSGI

#启动
uwsgi --ini uwsgi.ini
#查看
ps ajx|grep uwsgi
#停止
uwsgi --stop uwsgi.pid 

nginx

详细

- nginx常用命令

启动
# 启动nginx,可以浏览器访问一下本地地址 127.0.0.1:8080
nginx -c /path/to/nginx.conf
# 测试nginx配置文件是否正确
nginx -t -c /path/to/nginx.conf

 查看
 lsof -i:80
 ps aux | grep nginx

更新
# 平滑重启nginx
kill -HUP 主进程号
#修改配置后重新加载生效
nginx -s reload
#重新打开日志文件
nginx -s reopen 关闭
# 快速停止nginx
nginx -s stop
# 完整有序的停止nginx
nginx -s quit kill关闭
ps -ef | grep nginx
# 从容停止Nginx
kill -QUIT 主进程号
# 快速停止Nginx
kill -TERM 主进程号
# 强制停止Nginx
pkill -9 主进程号

- 配置

首先,简单地复习一下配置语法
若配置语法忘了,点击这里,简洁明了
基础的场景配置,点击这里

一些指令(坑)
index指令
alias和root指令对比
error_page指令(例子说明,自定义404页面)
location指令(顺序)

部署流程

一.代码准备

第一步,setting.py更改变量

DEBUG = False
ALLOWED_HOSTS = ['*']

第二步,指明静态文件路径
注:  1.DEBUG为False时,django的开发环境的自动静态文件代理失效,要使用STATIC_ROOT来指明你的静态文件在哪里,就像MEDIA_ROOT一样。
  2.STATIC_ROOT还跟django的python manage.py collectstatic命令联系,指定的文件夹会指定为用于静态文件收集的文件夹
  3.若使用uwsgi和nginx都可以代理静态文件,其实指不指明没什么影响

#setting.py:
STATIC_ROOT = os.path.join(BASE_DIR, "static")
#ErrorReport/urls.py:
url(r'^static/(?P<path>.*)$', serve, {'document_root': settings.STATIC_ROOT}),

第三步,收集静态文件
1.STATIC_ROOT = os.path.join(BASE_DIR, "static1")
2.python manage.py collectstatic
3.删除原有的static,将static1重命名为static

二.环境准备

第一步,pip freeze > plist.txt
第二步,将项目代码和plist.txt上传
第三步,虚拟环境准备

pip install virtualenv
pip install virtualenvwrapper
mkvirtualenv -p python3. env36

三.配置uWSGI

第一步,安装uwsgi

pip install uwsgi

第二步,命令行启动测试

uwsgi --http 127.0.0.1:8080 --file ErrorReport/wsgi.py --static-map=/static=static

注意:若出现异常,cant not import django 解决办法
  第一步:先重装
  pip install django==1.11.12
  第二步:若django已经存在,则在wsgi.py中
  sys.path.append('/Users/yi/.virtualenvs/yi3/lib/python3.6/site-packages')  

第三步:新建配置文件wsgi.ini进行配置(若浏览器访问127.0.0.1:8080 正常,则进行第三步)
 项目目录下创建script文件夹,里面新建wsgi.ini

[uwsgi]
# 项目目录
chdir = /Users/yi/PycharmProjects/djangos/ErrorReport/
# 指定虚拟环境。防止虚拟virtualenv环境的包,而在真实环境没有安装相关包的导致错误
home = /Users/yi/.virtualenvs/yi3
# 指定项目的application
module = ErrorReport.wsgi:application
# 指定sock的文件路径
# socket = /Users/yi/PycharmProjects/djangos/ErrorReport/script/uwsgi.sock
# 启用主进程
master = true
# 进程个数
process=4
pidfile = /Users/yi/PycharmProjects/djangos/ErrorReport/script/uwsgi.pid
# 指定HTTP IP端口,若是有上游服务器,则这里为socket
http = 127.0.0.1:9000
# socket = 127.0.0.1:9000 # 使用静态文件挂载点
#“映射”指定请求前缀到你的文件系统上的物理目录,--static-map mountpoint=path
# 例如:--static-map /images=/var/www/img
static-map = /static=static
# 启动uwsgi的用户名和用户组
uid = root
gid = root
# 自动移除unix Socket和pid文件当服务停止的时候
vacuum = true
# 序列化接受的内容,如果可能的话
thunder-lock = true
# 启用线程
enable-threads = true
# 设置自中断时间
harakiri = 30
# 设置缓冲
post-buffering = 4096
# 设置日志目录
daemonize = /Users/yi/PycharmProjects/djangos/ErrorReport/script/uwsgi.log
#每个进程可以接受的最大请求
max-requests = 5000
# buffer-size,表明收到的最大请求size,默认是4096,可以将其改成65535
buffer-size = 65535

第四步:更改uwsgi为上游服务器(若浏览器测试127.0.0.1:9000访问成功)
注: 当单独测试uwsgi,http = 127.0.0.1:9000。当nginx做前端服务器时,要改成socket = 127.0.0.1:9000
uwsgi.ini中:
http = 127.0.0.1:9000 => socket = 127.0.0.1:9000

四.配置nginx

第一步,安装
这里我用的是macOS电脑,主要用于开发测试,所以使用brew install nginx安装即可。
若到真正的生产环境上,对nginx的模块定制有更加严格的要求,则需要编译安装

macOS中使用brew安装后,nginx的配置文件所在目录为

/usr/local/etc/nginx

第二步,更改目录
macOS原本的nginx.conf非常不科学,我们按照ubuntu的目录结构来改造
在 /usr/local/etc/nginx中创建以下文件夹

conf.d # 通用一般配置
sites-available # 存放当前的server配置, 在这里修改
sites-enabled # 激活并使用的server配置(从sites_available的文件创建快捷方式到sites-enabled)

第三步,更改nginx.conf文件
macOS的nginx.conf配置成ubuntu的默认nginx.conf。

worker_processes auto;

events {
worker_connections 768;
# multi_accept on;
} http { ##
# Basic Settings
## sendfile on;
tcp_nopush on;
tcp_nodelay on;
keepalive_timeout 65;
types_hash_max_size 2048;
# server_tokens off; # server_names_hash_bucket_size 64;
# server_name_in_redirect off; include mime.types;
default_type application/octet-stream; ##
# SSL Settings
## ssl_protocols TLSv1 TLSv1.1 TLSv1.2; # Dropping SSLv3, ref: POODLE
ssl_prefer_server_ciphers on; ##
# Logging Settings
## access_log /var/log/nginx/access.log;
error_log /var/log/nginx/error.log; ##
# Gzip Settings
## gzip on;
gzip_disable "msie6"; # gzip_vary on;
# gzip_proxied any;
# gzip_comp_level 6;
# gzip_buffers 16 8k;
# gzip_http_version 1.1;
# gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript; ##
# Virtual Host Configs
## include conf.d/*.conf;
include sites-enabled/*.conf;
} #mail {
# # See sample authentication script at:
# # http://wiki.nginx.org/ImapAuthenticateWithApachePhpScript
#
# # auth_http localhost/auth.php;
# # pop3_capabilities "TOP" "USER";
# # imap_capabilities "IMAP4rev1" "UIDPLUS";
#
# server {
# listen localhost:110;
# protocol pop3;
# proxy on;
# }
#
# server {
# listen localhost:143;
# protocol imap;
# proxy on;
# }
#}

第四步,在sites-available下新增要部署项目的server配置
  例如:新建ErrorReport.conf

server {
listen 80;
server_name myblog;
client_max_body_size 75m;
charset utf-8; # 静态文件代理
location /static{
alias /Users/yi/PycharmProjects/djangos/ErrorReport/static;
} # 上传的静态文件代理
location /uploads{
alias /Users/yi/PycharmProjects/djangos/ErrorReport/uploads;
} # uwsgi转发配置
location /{
include /usr/local/etc/nginx/uwsgi_params;
uwsgi_pass 127.0.0.1:9000;
} #location / {
# root /usr/local/etc/nginx/html;
# index index.html;
#}
}

第五步,在sites-enabled新建一个软连接指向上一步新建的配置文件

从/usr/local/etc/nginx可以看到,http块下用include导入conf.d,sites-enabled的配置文件

 ln -s sites-available/ErrorReport.conf sites-enabled/ErrorReport.conf 

第六步,启动nginx测试

sudo nginx -t
sudo nginx
sudo nginx -s stop
sudo nginx -s reload

若访问127.0.0.1成功,则部署成功
注:也可以按照你所配置第server_name来测试访问,但是要更改本地第host文件

通过supervisor管理进程

上面我们已经用到了uwsgi,后面可能还会用到redis、celery,都需要开启守护进程,其中celery自身还不支持守护进程。那么如何管理这么多进程呢,这时候可以考虑下supervisor

pip install supervisor

配置

我们可以配置redis,celery,uwsgi进去,比如向下面一样

[program:redis]
;指定运行目录
directory=%(here)s/
;执行命令(redis-server redis配置文件路径)
command=redis-server /etc/redis.conf ;启动设置
numprocs=1 ;进程数
autostart=true ;当supervisor启动时,程序将会自动启动
autorestart=true ;自动重启 ;停止信号
stopsignal=INT [program:celery.worker.default]
;指定运行目录
directory=%(here)s/
;运行目录下执行命令
command=celery -A DjangoProject worker --loglevel info --logfile log/celery_worker.log -Q default -n %%h-%(program_name)s-%(process_num)02d
process_name=%(process_num)02d ;启动设置
numprocs=2 ;进程数
autostart=true ;当supervisor启动时,程序将会自动启动
autorestart=true ;自动重启 ;停止信号,默认TERM
;中断:INT (类似于Ctrl+C)(kill -INT pid),退出后会将写文件或日志(推荐)
;终止:TERM (kill -TERM pid)
;挂起:HUP (kill -HUP pid),注意与Ctrl+Z/kill -stop pid不同
;从容停止:QUIT (kill -QUIT pid)
stopsignal=INT [program:uwsgi]
;指定运行目录
directory=%(here)s/
;运行目录下执行命令
command=uwsgi -i conf/uwsgi/uwsgi9090.ini ;启动设置
numprocs=1 ;进程数
autostart=true ;当supervisor启动时,程序将会自动启动
autorestart=true ;自动重启 ;停止信号,默认TERM
;中断:INT (类似于Ctrl+C)(kill -INT pid),退出后会将写文件或日志(推荐)
;终止:TERM (kill -TERM pid)
;挂起:HUP (kill -HUP pid),注意与Ctrl+Z/kill -stop pid不同
;从容停止:QUIT (kill -QUIT pid)
stopsignal=INT

使用

启动supervisor输入如下命令,使用具体的配置文件执行:

supervisord -c supervisord.conf

关闭supervisord需要通过supervisor的控制器:

supervisorctl -c supervisord.conf shutdown

重启supervisord也是通过supervisor的控制器:

supervisorctl -c supervisord.conf reload

一些特殊的变量

%(here)s   配置文件所在路径
(program_name)s program的名字
%(process_num)02d 多进程时的进程号

注意:1.command中如果含有%,需要进行转义%%
   2.多进程时如果不指定process_name会遇到如下错误

Error: Format string 'celery -A INTProject worker --loglevel info --logfile log/celery_worker.log -Q diff_task,caller_task -n %h' for 'program:celery.worker.mac.command' is badly formatted: incomplete format in section 'program:celery.worker.mac' (file: 'supervisord.conf')
上一篇:咬碎STL空间配置器


下一篇:C#中is、as的区别