首页  思维导图  详情

django

2017-10-27 14:16:04   194  举报





AI智能生成

django的思维导图

django

结构图

作者其他创作

大纲/内容

2.django的基础

1.视图(views)

1.介绍

创建一个项目

myproject

├── manage.py

└── mysite

├── __init__.py

├── settings.py

├── urls.py

└── wsgi.py

创建一个应用

myapp

├── __init__.py

├── admin.py

├── models.py

├── tests.py

└── views.py

这里的views就是视图

每一个视图都是一个函数

2.项目引入

新建的一个app需要在

myproject/myproject/settings.py路径下

把我们新定义的app加到settings.py中的INSTALL_APPS中

如：

INSTALLED_APPS = (

'django.contrib.admin',

'django.contrib.auth',

'django.contrib.contenttypes',

'django.contrib.sessions',

'django.contrib.messages',

'django.contrib.staticfiles',

'myapp',

)

3.定义是视图函数

4.关于返回值

1.HttpResponse

2.render

3.redirect

2.路由(urls)

1.介绍

2.两种发放方式

1.项目发放

2.项目转发应用发放

3.模板(templates)

1.介绍

如果说我们光知道视图和路由转发之前只能用HttpResponse返回给浏览器的话，那么模板就是我们商用上的给用户真正看到的界面

在视图上用到的返回值render就是用来调用渲染的函数

这里的模板语言我们会做一个大的分类进行详细讲解

4.django的views

1.http协议

1.web框架本质

# ！/usr/bin/env python

# -*- coding:utf-8 -*-

# __Author__ Jianer

import socket

def handle_request(client):

buf = client.recv(1024)

client.send("HTTP/1.1 200 OK\r\n\r\n")

client.send("Hello, Seven")

def main():

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

sock.bind(('localhost',8000))

sock.listen(5)

while True:

connection, address = sock.accept()

handle_request(connection)

connection.close()

if __name__ == '__main__':

main()

2.简介

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

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

HTTP是无连接：无连接的含义是限制每次连接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开连接。采用这种方式可以节省传输时间。

HTTP是无状态：HTTP协议是无状态协议。无状态是指协议对于事务处理没有记忆能力。缺少状态意味着如果后续处理需要前面的信息，则它必须重传，这样可能导致每次连接传送的数据量增大。另一方面，在服务器不需要先前信息时它的应答就较快。

URL：统一资源定位符，就是一个网址：协议名://域名:端口/路径

3.http的请求流程

在接受一个Http请求之前的准备

启动一个支持WSGI网关协议的服务器监听端口等待外界的Http请求，比如Django自带的开发者服务器或者uWSGI服务器。

服务器根据WSGI协议指定相应的Handler来处理Http请求，并且初始化该Handler，在Django框架中由框架自身负责实现这一个Handler。

此时服务器已处于监听状态，可以接受外界的Http请求

当一个http请求到达服务器的时候

服务器根据WSGI协议从Http请求中提取出必要的参数组成一个字典（environ）并传入Handler中进行处理。

在Handler中对已经符合WSGI协议标准规定的http请求进行分析，比如加载Django提供的中间件，路由分配，调用路由匹配的视图等。

返回一个可以被浏览器解析的符合Http协议的HttpResponse。

2.wsgi

# ！/usr/bin/env python

# -*- coding:utf-8 -*-

# __Author__ Jianer

from wsgiref.simple_server import make_server

def application(request_info,response_info):

print(request_info) # 包装了请求的诸多信息

response_info('200 OK',[('Content-Type','text/html')]) # 反馈响应信息

return [b'<h1>Hello World</h1>']

httpd = make_server("127.0.0.1", 8080, application)

# 开启循环监听http请求

httpd.serve_forever()

3.简单的python框架

1.一个简单的前端模板

在上一步骤中，对于所有的login、index均返回给用户浏览器一个简单的字符串，在现实的Web请求中一般会返回一个复杂的符合HTML规则的字符串，所以一般将要返回给用户的HTML写在指定文件中，然后再返回。如下：

<!DOCTYPE html>

<html>

</head>

<body>

<h1>Index</h1>

</body>

</html>

index.html

</code></pre>

2.一个form页面

<!DOCTYPE html>

<html>

</head>

<body>

<form>

</form>

</body>

</html>

</code></pre>

3.继承

from wsgiref.simple_server import make_server

def index():

# return 'index'

f = open('index.html','rb')

data = f.read()

return data

def login():

# return 'login'

f = open('login.html','rb')

data = f.read()

return data

def routers():

urlpatterns = (

('/index/', index),

('/login/', login),

)

return urlpatterns

def run_server(environ, start_response):

start_response('200 OK', [('Content-Type', 'text/html')])

url = environ['PATH_INFO']

urlpatterns = routers()

func = None

for item in urlpatterns:

if item[0] == url:

func = item[1]

break

if func:

return [func()]

else:

return [b'404 not found']

if __name__ == '__main__':

httpd = make_server('127.0.0.1', 8080, run_server)

print("Serving HTTP on port 8080...")

httpd.serve_forever()

</code></pre>

4.请求协议

2.get请求

HTTP默认的请求方法就是GET

没有请求体

数据必须在1K之内！

GET请求数据会暴露在浏览器的地址栏中

GET请求常用的操作：

在浏览器的地址栏中直接给出URL，那么就一定是GET请求

点击页面上的超链接也一定是GET请求

提交表单时，表单默认使用GET请求，但可以设置为POST

如在一个网页中右击检查点击network，可以看到一些请求信息并作出一些解释

GET 127.0.0.1:8080/login HTTP/1.1：GET请求，请求服务器路径为 127.0.0.1:8080/login ，协议为1.1；

Host:localhost：请求的主机名为localhost；

*User-Agent: Mozilla/5.0 (Windows NT 5.1; rv:5.0) Gecko/20100101 Firefox/5.0：与浏览器和OS相关的信息。有些网站会显示用户的系统版本和浏览器版本信息，这都是通过获取User-Agent头信息而来的；

Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8：告诉服务器，当前客户端可以接收的文档类型，其实这里包含了*/*，就表示什么都可以接收；

Accept-Language: zh-cn,zh;q=0.5：当前客户端支持的语言，可以在浏览器的工具?选项中找到语言相关信息；

Accept-Encoding: gzip, deflate：支持的压缩格式。数据在网络上传递时，可能服务器会把数据压缩后再发送；

Accept-Charset: GB2312,utf-8;q=0.7,*;q=0.7：客户端支持的编码；

Connection: keep-alive：客户端支持的链接方式，保持一段时间链接，默认为3000ms；

Cookie: JSESSIONID=369766FDF6220F7803433C0B2DE36D98：因为不是第一次访问这个地址，所以会在请求中把上一次服务器响应中发送过来的Cookie在请求中一并发送去过；这个Cookie的名字为JSESSIONID，然后在讲会话是讲究它！

3.post请求

数据不会出现在地址栏中

数据的大小没有上限

有请求体

请求体中如果存在中文，会使用URL编码！

# 例如：username=%E5%BC%A0%E4%B8%89&password=123

我们都知道Http协议中参数的传输是"key=value"这种简直对形式的，如果要传多个参数就需要用“&”符号对键值对进行分割。如"?name1=value1&name2=value2"，这样在服务端在收到这种字符串的时候，会用“&”分割出每一个参数，然后再用“=”来分割出参数值。

针对“name1=value1&name2=value2”我们来说一下客户端到服务端的概念上解析过程:

上述字符串在计算机中用ASCII吗表示为：

6E616D6531 3D 76616C756531 26 6E616D6532 3D 76616C756532。

6E616D6531：name1

3D：=

76616C756531：value1

26：&

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编码

</code></pre>

4.两者区别

Referer请求头

Referer请求头是比较有用的一个请求头，它可以用来做统计工作，也可以用来做防盗链。

统计工作：我公司网站在百度上做了广告，但不知道在百度上做广告对我们网站的访问量是否有影响，那么可以对每个请求中的Referer进行分析，如果Referer为百度的很多，那么说明用户都是通过百度找到我们公司网站的。

防盗链：我公司网站上有一个下载链接，而其他网站盗链了这个地址，例如在我网站上的index.html页面中有一个链接，点击即可下载JDK7.0，但有某个人的微博中盗链了这个资源，它也有一个链接指向我们网站的JDK7.0，也就是说登录它的微博，点击链接就可以从我网站上下载JDK7.0，这导致我们网站的广告没有看，但下载的却是我网站的资源。这时可以使用Referer进行防盗链，在资源被下载之前，我们对Referer进行判断，如果请求来自本网站，那么允许下载，如果非本网站，先跳转到本网站看广告，然后再允许下载。

Referer的应用

5.django的httprequest

1.path

请求页面的全路径，不包括域名—例如，

“/music/bands/the_beatles/”

2.method

请求中使用的HTTP方法的字符串表示。全大写表示。例如：

if request.method == 'GET':

do_something()

elif request.method == 'POST':

do_something_else()　　　　

3.GET

包含所有HTTP GET参数的类字典对象。参见QueryDict文档。

4.POST

包含所有HTTP POST参数的类字典对象。参见QueryDict文档。

服务器收到空的POST请求的情况也是有可能发生的。也就是说，表单form通过HTTP POST方法提交

请求，但是表单中可以没有数据。不能使用语句if request.POST来判断是否使用HTTP POST方法；

应该使用if request.method == 'POST' (参见本表的method属性)。

注意：POST不包括file-upload信息。参见FILES属性。

5.COOKIES

包含所有cookies的标准python字典对象。Keys和values都是字符串。

6.FILES

包含所有上传文件的类字典对象。FILES中的每个Key都是<input type="file" name=""/>标签中

name属性的值。FILES中的每个value同时也是一个标准Python字典对象，包含下面三个Keys:

filename:上传文件名，用Python字符串表示

content-type:上传文件的Content type

content:上传文件的原始内容

注意：只有在请求方法是POST，并且请求页面中<form>有enctype="multipart/form-data"属性时FILES才拥有数据。否则，FILES是一个空字典。

7.META　

包含所有可用HTTP头部信息的字典。例如：

CONTENT_LENGTH

CONTENT_TYPE

QUERY_STRING:未解析的原始查询字符串

REMOTE_ADDR:客户端IP地址

REMOTE_HOST:客户端主机名

SERVER_NAME:服务器主机名

SERVER_PORT:服务器端口

META中这些头加上前缀HTTP_最为Key，例如：

HTTP_ACCEPT_ENCODING

HTTP_ACCEPT_LANGUAGE

HTTP_HOST:客户发送的HTTP主机头信息

HTTP_REFERER:referring页

HTTP_USER_AGENT:客户端的user-agent字符串

HTTP_X_BENDER:X-Bender头信息

8.user

是一个django.contrib.auth.models.User对象，代表当前登录的用户。如果访问用户当前没有登录，user将被初始化为django.contrib.auth.models.AnonymousUser的实例。你可以通过user的is_authenticated()方法来辨别用户是否登录；

if request.user.is_authenticated():

#Do something for logged-in users.

else:

#Do something for anonymous users.

只有激活Django中的AuthenticationMiddleware时该属性才可用

9.session

唯一可读写的属性，代表当前会话的字典对象。只有激活Django中的session支持时该属性才可用

10.raw_post_data

原始HTTP POST数据。未解析过。高级处理时会有用处。

11.body

更完整的request请求包，或者说完整的信息

6.django的httpresponse

5.views的FBV

1.urls的写法

from django.conf.urls import url, include

# from django.contrib import admin

from mytest import views

urlpatterns = [

# url(r‘^admin/‘, admin.site.urls),

url(r‘^index/‘, views.index),

]

</code></pre>

2.views的写法

from django.shortcuts import render

def 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‘)

</code></pre>

3.html的写法

<!DOCTYPE html>

<head>

<title>index</title>

</head>

<body>

</form>

</body>

</html>

</code></pre>

6.views的CBV

1.urls的写法

from mytest import views

urlpatterns = [

# url(r‘^index/‘, views.index),

url(r‘^index/‘, views.Index.as_view()),

]

2.views的写法

from django.views import View

class Index(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‘)

3.注意事项

类要继承 View ，类中函数名必须小写。

一般只会用到post和get

6.django的urls

1.url的本质

1.视图与urls的映射

它的本质是 URL 模式以及要为该 URL 模式调用的视图函数之间的映射表。

django-admin.py startproject 运行时，该脚本会自动为你建了一份 URLconf(URL configuration)（即 urls.py 文件）。由于它是纯Python代码(pure Python code)，可以动态创建(Dynamically Constructed).

2.创建

Django 把这个记录到ROOT_URLCONF 中

自动创建的settings.py包含一个ROOT_URLCONF配置用来指向自动产生的urls.py. 打开文件settings.py你将看到如下：

ROOT_URLCONF = 'mysite.urls'

相对应的文件是mysite/urls.py

一个字符串代表完整的Python导入路径URLconf根，如’mydjangoapps.urls’,可以覆盖根据每条请求通过设置属性urlconf传入的HttpRequest对象。

3.循环匹配

当访问 URL /hello/ 时，

Django根据 ROOT_URLCONF 的设置装URLconf

然后按顺序逐个匹配URLconf里的URLpatterns，直到找到一个匹配的。当找到这个匹配的URLpatterns就调用相关联的view函数，并把 HttpRequest 对象作为第一个参数。

4.进行web返回

视图函数必须返回一个HttpResponse，Django转换HttpResponse为一个适合的HTTP response，以Web page显示出来

2.patterns函数

1.用法

多个视图函数在patterns中的简洁写法：每一个视图对应一个patterns，在patterns中指定视图所在的位置

from django.conf.urls.defaults import *

from django.contrib import admin

admin.autodiscover()

urlpatterns = patterns('dapp1.views', #第一个参数指定视图所在的位置

(r'^hello/$','hello'), #引用视图中的hello函数，注意这里需要使用单引号

(r'^world/$','world'),

(r'^$', 'home'),

)

urlpatterns += patterns('contact.views', #第二个视图，urlpatterns是个元组，满足可加性

(r'^contact/$','contact'),

)

2.传参用法

传递额外参数到视图函数中（额外参数也称为关键字参数）

# urls.py

from django.conf.urls.defaults import *

from mysite import views

urlpatterns = patterns('',

(r'^foo/$', views.foobar_view, {'template_name': 'template1.html'}), #不同路径对应同一个视图

(r'^bar/$', views.foobar_view, {'template_name': 'template2.html'}), #但展现的模板不同

)

# views.py

from django.shortcuts import render_to_response

from mysite.models import MyModel

def foobar_view(request, template_name): # 捕获第二个参数

m_list = MyModel.objects.filter(is_new=True)

return render_to_response(template_name, {'m_list': m_list})

3.正则匹配传参

在url路径中给传递参数命名，在对应的视图函数中根据命名参数获取他的值（传递参数也称为位置参数）

/mydata/jan/01/

/mydata/jan/02/

/mydata/jan/03/

# ...

/mydata/dec/30/

/mydata/dec/31/

urls.py

urlpatterns = patterns('',

(r'^mydata/(?P<month>\w{3})/(?P<day>\d\d)/$', views.my_view), #在正则表达式前加上?<name>命名参数

=================

(?<name>exp) 匹配exp,并捕获文本到名称为name的组里，也可以写成(?'name'exp)

=====================

views.py

def my_view(request, month, day):

# ....

4.正则同时额外加参

另外，根据url的提示，给定参数值，作为额外参数进行传递额

urlpatterns = patterns('',

(r'^mydata/birthday/$', views.my_view, {'month': 'jan', 'day': '06'}),#

(r'^mydata/(?P<month>\w{3})/(?P<day>\d\d)/$', views.my_view),

)

views.py

def my_view(request, month, day):

# ....

5.额外覆盖正则

如果URLconf捕捉到的一个命名组变量和一个额外URLconf参数包含的变量同名时，额外URLconf参数的值会被使用。

urlpatterns = patterns('',

(r'^mydata/(?P<id>\d+)/$', views.my_view, {'id': 3}),

)

6.缺省视图

# urls.py

from django.conf.urls.defaults import *

from mysite import views

urlpatterns = patterns('',

(r'^blog/$', views.page), #URLconf中把特殊情况放在首位的处理

(r'^blog/page(?P<num>\d+)/$', views.page),

)

# views.py

def page(request, num='1'):

# Output the appropriate page of blog entries, according to num.

# ...

在这里，两个URL表达式都指向了同一个视图 views.page ，但是第一个表达式没有传递任何参数。如果匹配到了第一个样式， page() 函数将会对参数 num 使用默认值 "1" ，如果第二个表达式匹配成功， page() 函数将使用正则表达式传递过来的num的值。（注：我们已经注意到设置默认参数值是字符串 `` ‘1’`` ，不是整数`` 1`` 。为了保持一致，因为捕捉给`` num`` 的值总是字符串。每个被捕获的参数将被作为纯Python字符串来发送。

7.urls转发

包含其他urls

from django.conf.urls.defaults import *

urlpatterns = patterns('',

(r'^weblog/', include('mysite.blog.urls')), #注意这里不使用$来匹配结束，因为路径后面的参数可能会被包含urls中的patterns匹配

(r'^photos/', include('mysite.photos.urls')),

(r'^about/$', 'mysite.views.about'),

)

一个被包含的URLconf接收任何来自parent URLconfs的被捕获的参数，被捕获的 username 变量将传递给被包含的 URLconf，进而传递给那个URLconf中的每一个视图函数。

urlpatterns = patterns('',

(r'^(?P<username>\w+)/blog/', include('foo.urls.blog')),

)

另外，传递额外的URLconf选项到 include() , 就像你可以通过字典传递额外的URLconf选项到普通的视图。当你这样做的时候，被包含URLconf的每一行都会收到那些额外的参数。与捕获参数时等价的

urlpatterns = patterns('',

(r'^blog/', include('inner'), {'blogid': 3}),

)

这种技术仅当你确信在涉及到的接受到额外你给出的选项的每个URLconf时有用的才奏效。

3.include函数

1.功能

include(<module or pattern_list>)

your urlpatterns can “include” other URLconf modules！

通常用于分类处理，使项目中urls高度统一

from django.conf.urls import url，include

urlpatterns +=patterns('',

(r'^blog/',include('myblog.urls')), #myblog app 中urls

(r'^manage/',include('manager.urls')), #manage app 中urls

)

2.注意事项

1.不能包含$

include() 的正则表达式并不包含一个 $ （字符串结尾匹配符），但是包含了一个斜杆／。

2.排除匹配部分

每当Django遇到 include() 时，它将截断匹配的URL，并把剩余的字符串发往包含的URLconf作进一步处理。

如在 myblog.app中urls如下：

#myblog.app 中的urls

urlpatterns =patterns('myblog.views',

(r'^index/$','index'), #博客首页

)

3.匹配模式

1.不含变量参数

如在url输入框中输入 http://127.0.0.1:8000/blog/index/ 则，它会截取include()中匹配的url，这里是”blog” 接下来找到了宿主了也就是myblog.urls，那么剩余的部分这里是”index” 去匹配myblog.urls中的url模式。

2.含有变量参数

#root urls

urlpatterns += patterns('',

(r'^(?P<username>\w+)/blog/',include('blog.urls')),

)

#blog.urls

urlpatterns = patterns('blog.views',

(r'^index/$','index'),

(r'^other/$','other'),

)

#blog.views

def index(request):

return HttpResponse('ok')

#参数变量处理

def other(request,username):

return HttpResponse(username)

被捕获的 username 变量将传递给被包含的 URLconf，进而传递给那个URLconf中的每一个视图函数。

那么在浏览器输入：http://127.0.0.1:8000/BeginMan/blog/other/

则输出：BeginMan

3.复杂型

(r'^blog/(?P<username>\w+)/(?P<user_id>\d+)/',include('blog.urls'))

#.....

def index(request,username,user_id):

return HttpResponse('ok:%s,%s' %(username,user_id))

输入：http://127.0.0.1:8000/blog/BeginMan/20/index/

输出：ok:BeginMan,20

注意后面不要忘了去匹配blog urls的哪个urls。如(r'^index/$’)

app blog

(r'^index/$',views.index)

4.高级配置

1命名组

1.无命名

('^position/(\d{4})/(\d{2})/$','position'), #无命名正则表达式组

地址

http://127.0.0.1:8000/position/2013/15/

结果

#以位置参数的形式，如果位置改变，如(request,month,year)，则相应的值也会随之改变

def position(request,year,month):

return HttpResponse('position:%s--%s' %(year,month))

#输出：position:2013--10

2.命名

('^name/(?P<year>\d{4})/(?P<month>\d{2})/$','name'),

地址

http://127.0.0.1:8000/name/2013/15/

结果

#关键字参数，key-value映射关系，与位置无关，所以当位置改变，值不变

def name(request,month,year):

return HttpResponse('name:%s--%s' %(year,month))

3.常见匹配模式

. 任意单个字符

\d 匹配任意数字

[A-Z] 匹配A-Z任意大写字母

[a-z] 匹配a-z任意小写字母

[A-Za-z] 匹配a-z任意字母不论大小写

+ 匹配一个或多个（如:\d+）

[^xxx]+ 匹配一个或多个不为xxx的(如[^name]+)

？匹配零个或一个(如：\d?)

* 匹配零个或更多(如：\d*)

{a,b} 匹配介于a ,b之间（如：\d{1,3}一个或两个或三个数字）

8.django中的form

1.forms

1.由来

在Django社区上会经常看到django.newforms这个词语。当人们讨论django.newforms，其实就是我们本章里面介绍的django.forms。

改名其实有历史原因的。当Django一次向公众发行时，它有一个复杂难懂的表单系统：django.forms。后来它被完全重写了，新的版本改叫作：django.newforms，这样人们还可以通过名称，使用旧版本。当Django 1.0发布时，旧版本django.forms就不再使用了，而django.newforms也终于可以名正言顺的叫做：django.forms。

2.功能

表单框架最主要的用法是，为每一个将要处理的HTML的`` <Form>`` 定义一个Form类。这样我们就可以不用通过手动编写，来使用一个form表单了

3.实践

1.我们只需定义一个Form类。这个类可以存在于任何地方，甚至直接写在`` views.py`` 文件里也行，但是社区的惯例是把Form类都放到一个文件中：forms.py。在存放`` views.py`` 的目录中，创建这个文件，然后输入

2.继承django的forms.Form

from django import forms

class ContactForm(forms.Form):

subject = forms.CharField()

email = forms.EmailField(required=False)

message = forms.CharField()

这看上去简单易懂，并且很像在模块中使用的语法。表单中的每一个字段（域）作为Form类的属性，被展现成Field类。这里只用到CharField和EmailField类型。每一个字段都默认是必填。要使email成为可选项，我们需要指定required=False。

3.用python解释器进行查看会发现，如果打印会产生一些html标签

1.默认情况下使用的label标签

2.使用ul标签

>>> print f.as_ul()

<li><label for="id_subject">Subject:</label> <input type="text" name="subject" id="id_subject" /></li>

<li><label for="id_email">Email:</label> <input type="text" name="email" id="id_email" /></li>

<li><label for="id_message">Message:</label> <input type="text" name="message" id="id_message" /></li>

3.使用p标签

>>> print f.as_p()

<p><label for="id_subject">Subject:</label> <input type="text" name="subject" id="id_subject" /></p>

<p><label for="id_email">Email:</label> <input type="text" name="email" id="id_email" /></p>

<p><label for="id_message">Message:</label> <input type="text" name="message" id="id_message" /></p>

4.只显示某一个字段

>>> print f['subject']

<input type="text" name="subject" id="id_subject" />

>>> print f['message']

<input type="text" name="message" id="id_message" />

4.合法性

1.当你前端做一次提交，或者实例化form类时传入了参数，就相当于做了一次form对象的生成

f = ContactForm({'subject': 'Hello', 'email': 'adrian@example.com', 'message': 'Nice site!'}

2.合法性判断is_valid()

如果我们对于每一个参数都传值那么是合法的

2.required=False如果我们对于这样的字段不传值那么也是合法的

>>> f = ContactForm({'subject': 'Hello', 'message': 'Nice site!'})

>>> f.is_valid()

True

3.如果留空subject或message，整个Form就不再合法了：

>>> f = ContactForm({'subject': 'Hello'})

>>> f.is_valid()

False

>>> f = ContactForm({'subject': 'Hello', 'message': ''})

>>> f.is_valid()

False

3.error查看

1.逐一查看每个字段的出错消息

>>> f = ContactForm({'subject': 'Hello', 'message': ''})

>>> f['message'].errors

[u'This field is required.']

>>> f['subject'].errors

[]

>>> f['email'].errors

[]

2.每一个对象都继承了errors方法

>>> f = ContactForm({'subject': 'Hello', 'message': ''})

>>> f.errors

{'message': [u'This field is required.']}

4.完全合法

如果一个Form实体的数据是合法的，它就会有一个可用的cleaned_data属性。这是一个包含干净的提交数据的字典。 Django的form框架不但校验数据，它还会把它们转换成相应的Python字典类型数据，这叫做清理数据

>>> f = ContactForm({subject': Hello, email: adrian@example.com, message: Nice site!})

>>> f.is_valid()

True

>>> f.cleaned_data

{message': uNice site!, email: uadrian@example.com, subject: uHello}

5.注意事项

我们的contact form只涉及字符串类型，它们会被清理成Unicode对象。如果我们使用整数型或日期型，form框架会确保方法使用合适的Python整数型或datetime.date型对象。

5.设置规则

django的model可以制定很多需要的规则，比方说输入的字符数大于10等

name = models.CharField(max_length=64)

1.如果不填写那么报错

name = forms.CharField(validators=[validate_name],label='姓名',error_messages={'required':'必填'})

email=forms.EmailField(error_messages={'required':'默认报错方式','invalid':"邮箱格式错误"})

2.设置css样式

email=forms.EmailField(error_messages={'required':'默认报错','invalid':"邮箱格式错误"},
    widget=forms.EmailInput(
        attrs={
            "class": "form-control email", "placeholder": "email","id":"exampleInputemal1"
        }))

3.clean全局规则验证

def clean(self):
    if self.cleaned_data.get("password") is not None:
        if self.cleaned_data.get("password")==self.cleaned_data.get("reqeat_password"):
            return self.cleaned_data
        else:
            raise ValidationError("抛出两次密码不一致错误")
    else:
        return self.cleaned_data

4.某一项规则验证

def clean_password(self):
    if len(self.cleaned_data.get("password"))>8:
        return self.cleaned_data.get("password")
    else:
        raise ValidationError("密码长度不到8位")

5.注意事项

1.django源代码中规定，clean_func会在clean之前运行

2.如果clean_func中验证不通过，那么这条数据会变成errors数据

3.在出现errors数据后如果clean和clean_func调用了同样的一组数据，那么clean会报错，所以

尽量使用get的方式取字典，不要用[]的形式

2.modelform

1.导入

from django import forms

2.创建

class UserInfoModelForm(forms.ModelForm):

is_rmb = Ffields.CharField(widget=Fwidgets.CheckboxInput())

class Meta:

model = models.UserInfo

fields = '__all__'

# fields = ['username','email']

# exclude = ['username']

labels = {

'username': '用户名',

'email': '邮箱',

}

help_texts = {

'username': '...'

}

widgets = {

'username': Fwidgets.Textarea(attrs={'class': 'c1'})

}

error_messages = {

'__all__':{ # 整体错误信息

'email': {

'required': '邮箱不能为空',

'invalid': '邮箱格式错误..',

}

field_classes = { # 定义字段的类是什么

# 'email': Ffields.URLField # 这里只能填类，加上括号就是对象了。

}

# localized_fields=('ctime',) # 哪些字段做本地化

3.储存数据

if obj.is_valid():

obj.save() # 创建数据

4.一对多和多对多

model例子

class UserType(models.Model):

caption = models.CharField(max_length=32)

class UserGroup(models.Model):

name = models.CharField(max_length=32)

class UserInfo(models.Model):

username = models.CharField(max_length=32)

email = models.EmailField()

user_type = models.ForeignKey(to='UserType',to_field='id')

u2g = models.ManyToManyField(UserGroup)

views中的操作

def index(request):

if request.method == "GET":

obj = UserInfoModelForm()

return render(request,'index.html',{'obj': obj})

elif request.method == "POST":

obj = UserInfoModelForm(request.POST)

if obj.is_valid():

obj.save() # 等价以下三句

# instance = obj.save(False)

# instance.save()

# obj.save_m2m()

return render(request,'index.html',{'obj': obj})

5.修改数据

1.解释

修改表数据是，记得把instance信息也传进去，不然是新建数据，而不是对某行数据进行修改。

编辑用户信息，新url方式保留默认数据

2.urls

url(r'^user_list/', views.user_list),

url(r'^edit-(\d+)/', views.user_edit),

3.views

def user_list(request):

li = models.UserInfo.objects.all().select_related('user_type') # 这里只能是外键，多对多字段也不可以

return render(request,'user_list.html',{'li': li})

def user_edit(request, nid):

# 获取当前id对象的用户信息

# 显示用户已经存在数据

if request.method == "GET":

user_obj = models.UserInfo.objects.filter(id=nid).first()

mf = UserInfoModelForm(instance=user_obj) # 把默认数据传递进去

return render(request,'user_edit.html',{'mf': mf, 'nid': nid})

elif request.method == 'POST':

# 数据修改的信息，给数据库的哪一行做修改？

user_obj = models.UserInfo.objects.filter(id=nid).first()

mf = UserInfoModelForm(request.POST,instance=user_obj) # 指定给谁做修改

if mf.is_valid():

mf.save()

else:

print(mf.errors.as_json())

return render(request,'user_edit.html',{'mf': mf, 'nid': nid})

4.htmls

<body>

<ul>

{% for row in li %}

<li>{{ row.username }} - {{ row.user_type.caption }} - <a href="/edit-{{ row.id }}/">编辑</a></li>

{% endfor %}

</ul>

</body>

<body>

{% csrf_token %}

</form>

</body>

6.钩子

从上面的Form和ModelForm中，他们都是继承了BaseForm，而is_valid是在BaseForm中定义的，所以ModelForm也能和Form一样使用各种钩子

额外字段

class UserInfoModelForm(forms.ModelForm):

is_rmb = fields.CharField(widget=widgets.CheckboxInput()) # 额外字段

class Meta:

model = models.UserInfo

fields = '__all__'

7.总结

1. 生成HTML标签：class Meta: ...

2. mf = xxxModelForm(instance=ModelObj) 生成默认值

3. 额外的标签， is_rmb = Ffields.CharField(widget=Fwidgets.CheckboxInput())

4. 各种验证 is_valid() -> 各种钩子...

5. mf.save()

# 或

instance = mf.save(False)

instance.save()

mf.save_m2m()

10.补充二

1.ajax

2.laccess

3.分页

1.常用函数

>>> from django.core.paginator import Paginator

>>> objects = ['john', 'paul', 'george', 'ringo']

>>> p = Paginator(objects, 2)

>>> p.count #数据总数

>>> p.num_pages #总页数

>>> type(p.page_range) # `<type 'rangeiterator'>` in Python 2.

>>> p.page_range #页码的列表

range(1, 3) # =========[1,2]

>>> page1 = p.page(1) #第1页的page对象

>>> page1

>>> page1.object_list #第1页的数据

['john', 'paul']

>>> page2 = p.page(2)

>>> 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(0) #错误的页，抛出异常

Traceback (most recent call last):

...

EmptyPage: That page number is less than 1

>>> p.page(3) #错误的页，抛出异常

Traceback (most recent call last):

...

EmptyPage: That page contains no results

2.html功能

<!DOCTYPE html>

<head>

<title>Title</title>

</head>

<body>

<ul>

{% for i in booklist %}

<li>{{ i.title }},,,,,{{ i.price }}</li>

{% endfor %}

</ul>

</div>

<li>

{% if booklist.has_previous %}

{% else %}

{% endif %}

</li>

{% for i in p_obj_page %}

{% endfor %}

<li>

{% if booklist.has_next %}

{% else %}

{% endif %}

</li>

</ul>

</nav>

</div>

integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa"

crossorigin="anonymous"></script>

</body>

</html>

3.views功能

def showbook(request):

booklist=Book.objects.all()

p_obj=Paginator(booklist,20)

booklist = p_obj.page(1)

p_obj_page=p_obj.page_range#这里知道了多少页，是一个页数的列表

if request.GET:

number=request.GET.get("page")

try:

booklist=p_obj.page(number)

except EmptyPage:

booklist = p_obj.page(1)

except PageNotAnInteger:

booklist=p_obj.page(5)

return render(request, "showbook.html", locals())

################################p_obj的对象

# print(p_obj.count)可以看到总个数

# print(p_obj.num_pages)总共能分多少页

# print(p_obj.page_range)是一个列表里面是[1,2,3,4,5]

######################################

# p_obj.page(1)这里就是第二页相关的内容

# book_list=[]

# for i in range(100):

# book_list.append(Book(title="book%s"%i,price=30+i*i))

# Book.objects.bulk_create(book_list)

return render(request,"showbook.html",locals())

4.文件上传

html要求

type='file'

{%csrf_token%}

views要求

def login(request):

if request.method=='POST':

print ("is fileobj str",request.POST.get('fileobj'))

print ("is fileobj file",request.FILES.get('fileobj'))

#如何存储

fileobj=request.FILES.get("fileobj")

f=open(fileobj.name,'wb')

for i in fileobj.chunks(): #这里是块的方式来读取

f.write()

f.close()

1初识django

1.怎么才能学django

1. Django是 python 语言写的一个Web框架包，所以你得知道一些 Python 基础知识。

2. 其次你最好有一些做网站的经验，懂一些网页 HTML, CSS, JavaScript 的知识。

没有经验也没有关系，慢慢来就好了，你一定可以学会，Django 很简单！

2.特点

1.强大的数据库功能

用python的类继承，几行代码就可以拥有一个丰富，动态的数据库操作接口（API），如果需要你也能执行SQL语句

2.自带的强大的后台功能(admin)

几行简单的代码就让你的网站拥有一个强大的后台，轻松管理你的内容！

3.优雅的网址（urls）

用正则匹配网址，传递到对应函数，随意定义，如你所想！

4.模板系统（templates）

强大，易扩展的模板系统，设计简易，代码，样式分开设计，更容易管理。

5.缓存系统(memcached)

与memcached或其它的缓存系统联用，更出色的表现，更快的加载速度。

6.国际性特别的强（默认utf-8）

完全支持多语言应用，允许你定义翻译的字符，轻松翻译成不同国家的语言

3.简介

4.开发环境

1.python（3.6）

2.django版本(1.11.x)

1.下载方式pip intall Django

2.判断是否下载成功

5.基本命令

1.创建项目

django-admin.py startproject name

这里的name是项目的名字

2.创建应用

python manage.py startapp app_name

注意不要出现于现有名称重合的问题

3.创建数据表（创建更改的文件）python manage.py makemigrations

4.生成数据库文件

python manage.py migrate

5.运行django服务器

python manage.py runserver

默认8000

默认127.0.0.1

python manage.py runserver 0.0.0.0:8000

手动输入ip和端口

6.命令删除数据库python manage.py flush

7.创建一个管理员

python manage.py createsuperuser

这里创建管理员可以考虑不输入邮箱回车跳过就剋了

8.修改密码

python manage.py changepassword username

这里的username是已有的用户名

9.强大的shell命令终端python manage.py shell

10.数据库shell终端python manage.py dbshell

11.终端上输入 python manage.py 可以看到详细的列表

3.django模板

1.解决的问题

1，显然，任何页面的改动会牵扯到Python代码的改动

网站的设计改动会比Python代码改动更频繁，所以如果我们将两者分离开会更方便

2，其次，写后台Python代码与设计HTML是不同的工作，更专业的Web开发应该将两者分开

页面设计者和HTML/CSS程序员不应该编辑Python代码，他们应该与HTML打交道

3，程序员写Python代码同时页面设计者写HTML模板会更高效，而不是一个人等待另一个人编辑同样的文件

因此，使用Django的模板系统分离设计和Python代码会更干净更易维护

2.介绍

Django模板是一个string文本，它用来分离一个文档的展现和数据

模板定义了placeholder和表示多种逻辑的tags来规定文档如何展现

通常模板用来输出HTML，但是Django模板也能生成其它基于文本的形式

3.简单举例

<html>

<head><title>Ordering notice</title></head>

<body>

<p>Dear {{ person_name }},</p>

<p>Thanks for placing an order from {{ company }}. It's scheduled to

ship on {{ ship_date|date:"F j, Y" }}.</p>

<p>Here are the items you've ordered:</p>

<ul>

{% for item in item_list %}

{% endfor %}

</ul>

{% if ordered_warranty %}

<p>Your warranty information will be included in the packaging.</p>

{% endif %}

<p>Sincerely,<br />{{ company }}</p>

</body>

</html>

4.几种方法

1，用{{}}包围的是变量，如{{person_name}}，这表示把给定变量的值插入，如何指定这些变量的值我们即将说明

2，用{%%}包围的是块标签，如{%if ordered_warranty%}

块标签的含义很丰富，它告诉模板系统做一些事情

在这个例子模板中包含两个块标签:for标签表现为一个简单的循环结构，让你按顺序遍历每条数据

if标签则表现为逻辑的if语句

在这里，上面的标签检查ordered_warranty变量的值是否为True

如果是True，模板系统会显示{%if ordered_warranty%}和{%endif%}之间的内容

否则，模板系统不会显示这些内容

模板系统也支持{%else%}等其它逻辑语句

3，上面还有一个过滤器的例子，过滤器是改变变量显示的方式

上面的例子中{{ship_date|date:"F j, Y"}}把ship_date变量传递给过滤器

并给date过滤器传递了一个参数“F j, Y”，date过滤器以给定参数的形式格式化日期

类似于Unix，过滤器使用管道字符“|”

Django模板支持多种内建的块标签，并且你可以写你自己的标签

5.使用模板系统

1，用模板代码创建一个Template对象

Django也提供指定模板文件路径的方式创建Template对象

2，使用一些给定变量context调用Template对象的render()方法

这将返回一个完全渲染的模板，它是一个string，其中所有的变量和块标签都会根据context得到值

6.系统出发的报错

系统触发TemplateSyntaxError异常可能出于以下情况：

1，不合法的块标签

2，合法块标签接受不合法的参数

3，不合法的过滤器

4，合法过滤器接受不合法的参数

5，不合法的模板语法

6，块标签没关

7.内置的标签

1.if/else

1.基础用法

{% if today_is_weekend %}

<p>Welcome to the weekend!</p>

{% else %}

{% endif %}

2.and，not，or用法

{% if %}标签接受and，or或者not来测试多个变量值或者否定一个给定的变量，例如：

{% if athlete_list and coach_list %}

Both athletes and coaches are available.

{% endif %}

{% if not athlete_list %}

There are no athletes.

{% endif %}

{% if athlete_list or coach_list %}

There are some athletes or some coaches.

{% endif %}

{% if not athlete_list or coach_list %}

There are no athletes or there are some coaches.

{% endif %}

{% if athlete_list and not coach_list %}

There are some athletes and absolutely no coaches.

{% endif %}

3.嵌套的使用and，or

{% if %}标签接受and，or或者not来测试多个变量值或者否定一个给定的变量，例如：

{% if today_is_weekend %}

<p>Welcome to the weekend!</p>

{% else %}

{% endif %}

4.多个逻辑交级

多次使用同一个逻辑符号是合法的：

{% if athlete_list or coach_list or parent_list or teacher_list %}

5.没有elif标签

没有{% elif %}标签，使用嵌套的{% if %}标签可以做到同样的事情：

{% if athlete_list %}

<p>Here are the athletes: {{ athlete_list }}.</p>

{% else %}

<p>No athletes are available.</p>

{% if coach_list %}

<p>Here are the coaches: {{ coach_list }}.</p>

{% endif %}

6.神奇的endif

鬼知道为啥要有

确认使用{% endif %}来关闭{% if %}标签，否则Django触发TemplateSyntaxError

2.for

1.循环列表

例如，显示给定athlete_list变量来显示athlete列表：

<ul>

{% for athlete in athlete_list %}

<li>{{ athlete.name }}</li>

{% endfor %}

</ul>

2.reversed反序循环列表

{% for athlete in athlete_list reversed %}

...

{% endfor %}

{% for %}标签可以嵌套：

{% for country in countries %}

<h1>{{ country.name }}</h1>

<ul>

{% for city in country.city_list %}

{% endfor %}

</ul>

{% endfor %}

</code></pre>

3.没有continue

系统不支持中断循环，如果你想这样，你可以改变你想遍历的变量来使得变量只包含你想遍历的值

类似的，系统也不支持continue语句

4.内置forloop变量

1.forloop.counter

表示循环次数int型

它从1开始计数，第一次循环设为1

{% for item in todo_list %}

<p>{{ forloop.counter }}: {{ item }}</p>

{% endfor %}

2.forloop.counter0

代表从零计数

3.forloop.revcounter

表示循环中剩下的items数量，第一次循环时设为items总数，最后一次设为1

倒数

4.forloop.revcounter0

总数减一然后在倒数

5.forloop.first

forloop.first当第一次循环时值为True，在特别情况下很有用比如第一次要不要：

{% for object in objects %}

{% if forloop.first %}<li class="first">{% else %}<li>{% endif %}

</li>

{% endfor %}

6.forloop.last

forloop.last当最后一次循环时值为True

就是最后一个我要不要

{% for link in links %}{{ link }}{% if not forloop.last %} | {% endif %}{% endfor %}

</code></pre>

7.forloop.parentloop

这把不要自己的循环计数，我要父级循环的

{% for country in countries %}

<table>

{% for city in country.city_list %}

<tr>

<td>Country #{{ forloop.parentloop.counter }} </td>

<td>City #{{ forloop.counter }}</td>

</tr>

{% endfor %}

</table>

{% endfor %}

</code></pre>

8.其他

富有魔力的forloop变量只能在循环中得到，当模板解析器到达{% endfor %}时forloop就消失了

如果你的模板context已经包含一个叫forloop的变量，Django会用{% for %}标签替代它

Django会在for标签的块中覆盖你定义的forloop变量的值

在其他非循环的地方，你的forloop变量仍然可用

我们建议模板变量不要使用forloop，如果你需要这样做来访问你自定义的forloop，你可以使用forloop.parentloop

3.ifequal/ifnotequal

1. ifequal

{% ifequal %}比较两个值，如果相等，则显示{% ifequal %}和{% endifequal %}之间的所有内容：

{% ifequal user currentuser %}

<h1>Welcome!</h1>

{% endifequal %}

2.可以使用字符串

参数可以是硬编码的string，单引号和双引号均可，下面的代码是合法的：

{% ifequal section 'sitenews' %}

{% endifequal %}

{% ifequal section "community" %}

<h1>Community</h1>

{% endifequal %}

3.支持else

和{% if %}一样，{% ifequal %}标签支持{% else %}

{% ifequal section 'sitenews' %}

{% else %}

{% endifequal %}

4.也支持数字

其它的模板变量，strings，integers和小数都可以作为{% ifequal %}的参数：

{% ifequal variable 1 %}

{% ifequal variable 1.23 %}

{% ifequal variable 'foo' %}

{% ifequal variable "foo" %}

5.不支持其他

其它的Python类型，如字典、列表或booleans不能硬编码在{% ifequal %}里面，下面是不合法的：

{% ifequal variable True %}

{% ifequal variable [1, 2, 3,]%}

{% ifequal variable {'key': 'value'} %

不可以使用

所以bool值还是老实用if吧

8.内置过滤器

1.例子

这将显示通过lower过滤器过滤后{{ name }}变量的值，它将文本转换成小写

使用(|)管道来申请一个过滤器

过滤器可以串成链，即一个过滤器的结果可以传向下一个

下面是escape文本内容然后把换行转换成p标签的习惯用法：

2.带参过滤器

有些过滤器需要参数，需要参数的过滤器的样子：

这将显示bio标量的前30个字，过滤器参数一直使用双引号

必须双引号

3.addslashed

在任何后斜线，单引号，双引号前添加一个后斜线

当你把一些文本输出到一个JavaScript字符串时这会十分有用

4.date日期

根据一个格式化string参数来格式化date或datetime对象，例如：

5.escape

避免给定的string里出现and符，引号，尖括号

当你处理用户提交的数据和确认合法的XML和XHTML数据时这将很有用

escape将作如下的一些转换：

Converts & to &amp;

Converts < to &lt;

Converts > to &gt;

Converts "(双引号) to &quot;

Converts '(单引号) to &#39;

6.length

返回值的长度，你可以在一个list或string上做此操作

或者在任何知道怎样决定自己的长度的Python对象上做此操作(即有一个__len__()方法的对象)

9.template的思想

现在我们对于Django地模板系统有了一个感性的认识，下面我们将指出一些有意为之的限制和它工作的哲学

不像其他Web程序组件，程序员对模板系统的意见非常不一致

一个很有意思的事实：Python至少拥有数十个——如果没有上百个——的开源模板语言实现，而且看来每一个都是因为其创造者认为现有的模板不能满足他们的要求。

（事实上，据说写一个自己的模板系统是已经成了Python开发者必经的仪式了。如果你还没有写过自己的模板系统，试试看吧，真是很有意思。）

所以，Django的第一个哲学就是Django不强求你使用它的模板语言

Django的目标是提供一个full-stack框架，提供所有必须的web开发模块进行高效开发

很多时候，使用Django的模板系统很方便，但不强求你使用它

下面的“在视图中使用模板”一节我们会看到在Django中使用另一套模板语言，它同样简单易用

但我们仍强烈需要Django的模板语言的工作方式，模板系统深植于World Online和Django发明者的

Web开发方式中，下面是其中一些哲学：

1，业务逻辑应该和呈现逻辑分离

模板系统应该只负责控制显示和显示相关的逻辑我们视模板为一种控制显示和显示相关逻辑的工具，仅此而已。模板系统的功能就止于此。

基于这个原因，Django模板无法直接调用Python代码。在Django模板里，所有的程序设计活动都止于对标签的使用。

虽然你可以自定义模板标签来做任意的事情，但Django自己的模板标签不允许执行Python代码。

2，语法应该和HTML/XML解耦

Django的模板系统采用非HTML格式，如普通的文本，有些其它的模板语言是基于XML的

XML的格式容易输错，并且XML的模板解析速度也容易变得很慢而难以接受

3，页面设计者被假定为熟悉HTML代码

Django模板系统没有设计成可以在Dreamweaver等WYSISYG编辑器中显示良好

这类编辑器有很多限制，Django希望模板作者直接编辑HTML时感到舒适

4，页面设计者被假定为不是Python程序员

模板系统的作者意识到大部分Web页面的模板是页面设计者写的而不是Python程序员写的

他们不具备Python知识，但Django也允许模板用Python来写，它提供了一种直接编写Python代码

来扩展模板系统的方法

5，目标不是发明一种编程语言

目标只是提供足够的编程功能，如分支和循环等决定呈现相关的逻辑用

由于上述的设计哲学，Django模板系统产生如下限制：

1，模板不能设置和改变变量的值

可以通过自定义模板标签来达到这个目标(I参看第10章)，但是内置Django模板标签不允许这样做

2，模板不能调用原生Python代码

但是也可以通过自定义标签来做这件事情

10.模板继承

1.例子

定义子模板可以覆盖的“块”，让我们看看前面的例子，编辑a.html文件：

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">

<head>

<title>The current time</title>

</head>

<body>

<h1>My helpful timestamp site</h1>

<p>It is now {{ current_date }}.</p>

<hr>

<p>Thanks for visiting my site.</p>

</body>

</html>

2.block

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">

<head>

<title>{% block title %}{% endblock %}</title>

</head>

<body>

<h1>My helpful timestamp site</h1>

{% block content %}{% endblock %}

{% block footer %}

<hr>

<p>Thanks for visiting my site.</p>

{% endblock %}

</body>

</html>

我们把这个模板叫做base.html，它定义了我们用来在其它页面使用的基本HTML框架

现在就是子模板覆盖的工作了，要么添加内容，要么不改变块的内容

(如果你在照着例子做，把base.html保存到模板目录下)

这里我们使用了{% block %}模板标签，它告诉模板引擎一个子模板可能覆盖模板的这部分内容

3.子模板引用

既然我们有了基本模板，下面我们来编辑a.html来使用它：

{% extends "base.html" %}

{% block title %}The current time{% endblock %}

{% block content %}

<p>It is now {{ current_date }}.</p>

{% endblock %}

4.解释

这样是不是更美观一些？每个模板只包含属于自己的代码，根本没有冗余

如果你想做整个网站的改动，只需要更改base.html即可，其它的模板也会立即响应改动

它是这样工作的：

1，当你载入模板current_datetime.html，模板引擎发现{% extends %}标签，注意到这是一个子模板

模板引擎马上载入父模板base.html

2，模板引擎在base.html里发现了3个{% block %}标签，就用子模板的内容替换了这些块

于是我们定义的{% block title %}和{% block content %}被使用

注意，既然子模板没有定义footer块，那么模板系统直接使用父模板的值

父模板里{% block %}标签的内容一直可以作为后援方案

你可以使用任意等级的继承，使用继承的常用方式是按以下三个步骤：

1，创建base.html模板来掌控你的网站的整体外观，它的内容很少改变

2，为你的网站创建base_SECTION.html模板，例如，base_photos.html，base_forum.html

这些模板继承base.html并且包括部分专有的风格和设计

3，为每个类别的页面创建单独的模板，例如论坛页面护着照片图库页面

这些模板继承相应的部分模板

这个方法最大化了代码重用并且很容易向公用区域添加东西，例如部分专有的导航

下面是一些关于模板继承的小提示：

1，如果在模板里使用{% extends %}的话，这个标签必须在所有模板标签的最前面，否则模板继承不工作

2，通常基本模板里的{% block %}越多越好，子模板不必定义所有的父block，钩子越多越好

3，如果你在很多模板里复制代码，很可能你应该把这些代码移动到父模板里

4，如果你需要得到父模板的块内容，{{ block.super }}变量可以帮你完成工作

当你需要给父块添加内容而不是取代它的时候这就很有用

5，不能在同一模板里定义多个同名的{% block %}，因为块标签同时在两个地方工作，不仅仅

在子模板中，而且在父模板中也填充内容，如果子模板有两个同名的标签，父模板将不能决定

使用哪个块内容来使用

6，你给{% extends %}传递的模板名同样会被get_template()使用，所以会加上TEMPLATE_DIRS设置

7，大部分情况下，{% extends %}的参数是string，但是也可以是变量，如果知道运行时才知道

父模板的名字，这可以帮助你做一些很cool的动态内容

5.django的生命周期

2.路由系统

1.路由规则

在Django的urls中我们可以根据一个URL对应一个函数名来定义路由规则

2.代码

from cmdb import views

urlpatterns = [

url(r'^login/$', views.login),

url(r'^index/$', views.index),

url(r'^lists/$', views.lists),

url(r'^add/$', views.add),

]

3.中间件看

1.定义

中间件是一个、一个的管道，如果相对任何所有的通过Django的请求进行管理都需要自定义中间件

　　中间件可以对进来的请求和出去的请求进行控制

　　中间件是一类。

2.django的代码演示

看下面的代码在settings里中间件的类：

MIDDLEWARE_CLASSES = [

'django.middleware.security.SecurityMiddleware',

'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',

]

4.自定义中间件

1.代码展示

class Testmiddle(object):

def process_request(self,request):

print 'Testmiddle process_request'

def process_view(self, request, callback, callback_args, callback_kwargs):

print 'Testmiddle process_view'

def process_exception(self, request, exception):

pass

def process_response(self, request, response):

print 'Testmiddle process_response'

return response

class Nextmiddle(object):

def process_request(self,request):

print 'Nextmiddle process_request'

def process_view(self, request, callback, callback_args, callback_kwargs):

print 'Nextmiddle process_view'

def process_exception(self, request, exception):

pass

def process_response(self, request, response):

print 'Nextmiddle process_response'

return response

2.使用中间件

MIDDLEWARE_CLASSES = [

'django.middleware.security.SecurityMiddleware',

'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',

'middleware.middle.Testmiddle',

'middleware.middle.Nextmiddle',

]

3.演示urls

from app01 import views

urlpatterns = [

url(r'^admin/', admin.site.urls),

url(r'^index/$', views.index),

]

4.演示views

def index(request):

print 'This app01 Views.index'

return HttpResponse('OK')

5.结果展示

'''

Testmiddle process_request

Nextmiddle process_request

Testmiddle process_view

Nextmiddle process_view

This app01 Views.index

Nextmiddle process_response

Testmiddle process_response

'''

6.结果解释

从输出结果可以看出：

他是先执行Testmiddle 的request 方法又执行了Nextmiddle的 process_request方法。。。。

7.原理

当请求进来了到达中间件

去settings里面找到MIDDLEWARE_CLASSES，MIDDLEWARE_CLASSES是一个元组

有4个列表：

process_request_lsit = []

process_view_list = []

process_response_list = []

然后他循环MIDDLEWARE_CLASSES这个类：

for 类 in MIDDLEWARE_CLASSES：

　　obj = 类()

　　if obj里有process_request方法：

　　　　process_request_lsit.append(obj.process_request)

然后运行

for i in process_request_list:

　　i() #加括号执行方法

for i in process_view_list:

i()

............

8.源码展示

def load_middleware(self):

"""

Populate middleware lists from settings.MIDDLEWARE_CLASSES.

Must be called after the environment is fixed (see __call__ in subclasses).

"""

self._view_middleware = []

self._template_response_middleware = []

self._response_middleware = []

self._exception_middleware = []

request_middleware = []

for middleware_path in settings.MIDDLEWARE_CLASSES:

mw_class = import_string(middleware_path)

try:

mw_instance = mw_class()

except MiddlewareNotUsed as exc:

if settings.DEBUG:

if six.text_type(exc):

logger.debug('MiddlewareNotUsed(%r): %s', middleware_path, exc)

else:

logger.debug('MiddlewareNotUsed: %r', middleware_path)

continue

if hasattr(mw_instance, 'process_request'):

request_middleware.append(mw_instance.process_request)

if hasattr(mw_instance, 'process_view'):

self._view_middleware.append(mw_instance.process_view)

if hasattr(mw_instance, 'process_template_response'):

self._template_response_middleware.insert(0, mw_instance.process_template_response)

if hasattr(mw_instance, 'process_response'):

self._response_middleware.insert(0, mw_instance.process_response)

if hasattr(mw_instance, 'process_exception'):

self._exception_middleware.insert(0, mw_instance.process_exception)

# We only assign to this when initialization is complete as it is used

# as a flag for initialization being complete.

self._request_middleware = request_middleware

middleware

5.中间件流程梳理

1.为什么response没有返回值

首先看下自定义的中间件中的process_response方法他是有返回值的其他的是没有返回值的。这个return response是什么呢？

2.解答

这个response就是咱们自定义的views.index返回的结果！

def process_response(self, request, response):

print 'Testmiddle process_response'

return response

3.如果又返回值

4.如果在request和views有返回

5.process_exception的触发机制

6.django的缓存机制

1.settings的配置

CACHES = {

'default': {

#定义已文件的方式进行cache

'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',

#cache文件的存放路径

'LOCATION': os.path.join(BASE_DIR, 'cache'),

#超时时间为600妙

'TIMEOUT': 600,

'OPTIONS': {

'MAX_ENTRIES': 1000

}

2.如何引用的

给请求应用，就是使用装饰器

from django.views.decorators.cache import cache_page

#这里设置的是 60秒 * 15 ,15分钟之后

@cache_page(60 * 15)

def cache_page(request):

current = str(time.time())

return HttpResponse(current)

7.Session&Cookie

1.解释

Cookie就是一段字符串，保存于本机电脑上。

session 保存于服务器,用来保存用户的会话信息，依赖于Cookies

2.流程

3.结构

4.操作

1.例子

def login(request):

if request.method == 'POST':

username = request.POST.get('username')

password = request.POST.get('password')

if username == 'shuai' and password == '123':

result = request.session.get('IS_LOGIN', None)

print result

request.session['IS_LOGIN'] = True

return redirect('/index/')

obj = forms.LoginForm()

# 如果登录成功，写入session，跳转index

return render(request, 'account/login.html', {'model': obj})

def index(request):

'''

如果用户已经登录

'''

is_login = request.session.get('IS_LOGIN',False)

if is_login:

return render(request, 'home/index.html')

else:

return redirect('/login/')

2.解释

这里需要注意在session中，我们可以设置多个key：value的值，方便我们做很多事情，比如判断哪个用户：

　　如果用户登录后，那么他肯定有一个cookie那么他在访问购物车的时候，怎么判断是哪个用户呢？我们可以在session设置，当用户登录的时候，我们把的用户名，增加到session中，那么用户携带cookie访问的时候，我们就能判断是哪个一用来访问的！

3.对应关系

user1

cookie ：aaaa

server session（举例格式）

{session:aaaa{'IS_LOGIN':'True',username:'shuaige'}}

5.好处

使用Session和Cookie的好处：Cookie可以理解为一个身份证ID，你只能拿着他去和Server端进行通信，如果你没有这个ID那么server端也不知道你是谁！

我在做Cookie和Session的实验，把Cookie删掉了！当我保存的时候直接给我提出来了，为什么呢？就是因为，server端不知道我是谁了，我已经没有密钥了。

所以，只要Session和Cookie任意一方失效，就可以理解为：

Cookie失效就相当于身份证ID过期，需要重新认证才可以继续使用。Session失效就相当于银行里的数据标识此ID无效，也需要重新申请。

7.django的orm

1.简介

2.怎么学习

1.理解

2.models

3 .url的配置

4.views的配置

5.插入测试数据

6.orm方式插入数据

7.通过对象进行添加

8.注意事项

3.orm的一对多

1.介绍

2.查找

1.正向查找

2.反向查找

1.实例

子主题

3.总结

4.多对多

1.介绍

2.初始化

1.models

2.查看

3.添加数据

1.正向添加

2.反向添加

3.自定义多对多第三章表

1.初始化

def index(req):

models.HostInfo.objects.create(hostname='alex.test.com', port=80)

models.HostInfo.objects.create(hostname='seven.test.com', port=80)

models.HostInfo.objects.create(hostname='mosson.test.com', port=80)

models.UserMap.objects.create(username='alex', email='alex@qq.com')

models.UserMap.objects.create(username='seven', email='seven@qq.com')

models.UserMap.objects.create(username='mosson', email='mosson@qq.com')

return HttpResponse('ok')

2.手动输入第三章表

def index(request):

models.HostRelation.objects.create(

user = models.UserMap.objects.get(id=1),

host = models.HostInfo.objects.get(id=1)

)

return HttpResponse('OK')

4.自动创建和手动输入对比

5.查询

1.方法一

‘第一种方式都是基于表中的对象去找到第三张表！通过间接的方式找到这张表的句柄！

#正向查

admin_obj = models.HostAdmin.objects.get(id=1)

admin_obj.host.all()

#反相差

host_obj = models.Host.objects.get(id=1)

host_obj.hostadmin_set.all()

2.方法二

用第二种方法就没有正向和反向这么一说了，直接查即可！

relation_list = models.HostRelation.objects.all()

for item in relation_list: #每一个item就是一个关系

print (item.user.username)

print( item.host.hostname)

relation_list = models.HostRelation.objects.filter(user__username='mosson')

for item in relation_list: #每一个item就是一个关系

print( item.user.username)

print (item.host.hostname)

3.对比

第一种方式只能找到某一个人管理的机器，不能把有的对应关系找到！

5.select_related的作用

1.实例

class UserType(models.Model):

caption = models.CharField(max_length=32)

class UserInfo(models.Model):

user_type = models.ForeignKey('UserType') #这个user_type是一个对象,对象里面封装了ID和caption

username = models.CharField(max_length=32)

age = models.IntegerField()

2.功能

select_related的作用，他就是用来优化查询的，没有他也可以，用它主要是用来优化ForeignKey

def index(request):

ret = models.UserInfo.objects.all()

#咱们看下他执行的什么SQL语句

print( ret.query)

'''

SELECT "app01_userinfo"."id", "app01_userinfo"."user_type_id", "app01_userinfo"."username", "app01_userinfo"."age" FROM "app01_userinfo"

'''

带有select_related的样子

def user_info(request):

ret = models.UserInfo.objects.all().select_related()

#咱们看下他执行的什么SQL语句

print ret.query

SELECT "app01_userinfo"."id",

"app01_userinfo"."user_type_id",

"app01_userinfo"."username",

"app01_userinfo"."age",

"app01_usertype"."id",

"app01_usertype"."caption"

FROM

"app01_userinfo" INNER JOIN "app01_usertype" ON ("app01_userinfo"."user_type_id" = "app01_usertype"."id")

如果我们带有了select_related()那么我们就可以在第一次查询的时候直接查询好相关联的第三正表的信息算是一种优化手段，一种减少sql的手段

6.链表操作梳理

1.一对多的创建

1、创建数据　　　　

通过对象创建　　　　

或者通过对象字段_id创建

2.查找

查找　　　　

正向查找

在通过filter的时候跨表使用双下划线 '__'　　　　　　

在获取值得时候通过.跨表　　　　

反向查找　　　　　　

Django自动生成表名_set　　　　　　

其他操作和正向查找一样

3.多对多

自动生成关系表

　　　　间接的方式获取关系表，如果是正向的：一行数据的对象.ManyToMany字典就行反向：一行数据的对象.表名_set

4.select_related

用于优化查询，一次性将查询的表和ForiegnKey关联的表一次性加载到内存。

7.Django中的F和Q

1.F查询

用来批量修改数据（使用查询条件的值）

例子

demo：比如我有个price这个列，我想让price自增10或者某一些自增10

# from django.db.models import F

# models.Tb1.objects.update(num=F('num')+10)

2.Q查询

用来做条件查询的

默认的django的查询只是且操作如下：

models.UserInfo.objects.filter(username='mosson',age='18')

有没有这么一种情况：username=mosson或 username=wusir 或 username=alex 并且 age=18的需求？原生的查询是不支持的!所以就用到了Q~

第一步：

#生成一个搜索对象

search_q = Q()

#在生成两个搜索对象

search1 = Q()

search2 = Q()

第二步：

#标记search1中的搜索条件为 ‘ 或’ 查询

search1.connector = 'OR'

#把搜索条件加入到search1中

search1.children.append(('字段名','字段内容'))

#标记search2中的搜索条件为 ‘ 或’ 查询

search2.connector = 'OR'

#把搜索条件加入到search2中

search2.children.append(('字段名','字段内容'))

第三步：

#把多个搜索条件进行合并

search_q.add(search1,'AND')

search_q.add(search2,'AND')

第四步：

#执行搜索

models.HostInfo.objects.filter(search_q)

8.分组和聚合查询

aggregate(*args,**kwargs):

通过对QuerySet进行计算，返回一个聚合值的字典。aggregate()中每一个参数都指定一个包含在字典中的返回值。即在查询集上生成聚合。

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')}

annotate(*args,**kwargs):

可以通过计算查询结果中每一个对象所关联的对象集合，从而得出总计值(也可以是平均值或总和)，即为查询集的每一项生成聚合。

查询alex出的书总价格

查询各个作者出的书的总价格,这里就涉及到分组了，分组条件是authors__name

查询各个出版社最便宜的书价是多少

9.双下划线__

1.下划线单表查询

#    models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值
#
#    models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据
#    models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
#
#    models.Tb1.objects.filter(name__contains="ven")
#    models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
#
#    models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and
#
#    startswith，istartswith, endswith, iendswith,

2.下划线多表查询

1.正向查找

#     ret3=models.Book.objects.filter(title='Python').values('id')
#     print(ret3)#[{'id': 1}]

      #正向查找(条件)之一对多

      ret4=models.Book.objects.filter(title='Python').values('publisher__city')
      print(ret4)  #[{'publisher__city': '北京'}]

      #正向查找(条件)之多对多
      ret5=models.Book.objects.filter(title='Python').values('author__name')
      print(ret5)
      ret6=models.Book.objects.filter(author__name="alex").values('title')
      print(ret6)

      #注意
      #正向查找的publisher__city或者author__name中的publisher,author是book表中绑定的字段
      #一对多和多对多在这里用法没区别

2.反向查找

#反向查找之一对多:
    ret8=models.Publisher.objects.filter(book__title='Python').values('name')
    print(ret8)#[{'name': '人大出版社'}]  注意,book__title中的book就是Publisher的关联表名

    ret9=models.Publisher.objects.filter(book__title='Python').values('book__authors')
    print(ret9)#[{'book__authors': 1}, {'book__authors': 2}]

    #反向查找之多对多:
    ret10=models.Author.objects.filter(book__title='Python').values('name')
    print(ret10)#[{'name': 'alex'}, {'name': 'alvin'}]

    #注意
    #正向查找的book__title中的book是表名Book
    #一对多和多对多在这里用法没区别

10.改update和save

1.实例

实例

注意项

<1> 第二种方式修改不能用get的原因是：update是QuerySet对象的方法，get返回的是一个model对象，它没有update方法，而filter返回的是一个QuerySet对象(filter里面的条件可能有多个条件符合，比如name＝'alvin',可能有两个name＝'alvin'的行数据)。

<2>在“插入和更新数据”小节中，我们有提到模型的save()方法，这个方法会更新一行里的所有列。而某些情况下，我们只需要更新行里的某几列。

2.update

#---------------- update方法直接设定对应属性----------------
    models.Book.objects.filter(id=3).update(title="PHP")
    ##sql:
    ##UPDATE "app01_book" SET "title" = 'PHP' WHERE "app01_book"."id" = 3; args=('PHP', 3)

3.save

#--------------- save方法会将所有属性重新设定一遍,效率低-----------
    obj=models.Book.objects.filter(id=3)[0]
    obj.title="Python"
    obj.save()
# SELECT "app01_book"."id", "app01_book"."title", "app01_book"."price", 
# "app01_book"."color", "app01_book"."page_num", 
# "app01_book"."publisher_id" FROM "app01_book" WHERE "app01_book"."id" = 3 LIMIT 1; 
# 
# UPDATE "app01_book" SET "title" = 'Python', "price" = 3333, "color" = 'red', "page_num" = 556,
# "publisher_id" = 1 WHERE "app01_book"."id" = 3;

4.补充

此外，update()方法对于任何结果集（QuerySet）均有效，这意味着你可以同时更新多条记录update()方法会返回一个整型数值，表示受影响的记录条数。

11.在django查看sql命令

注意，这里因为update返回的是一个整形，所以没法用query属性；对于每次创建一个对象，想显示对应的raw sql，需要在settings加上日志记录部分：

12.都是基于搜索的删除

>>> Book.objects.filter(id=1).delete()
(3, {'app01.Book_authors': 2, 'app01.Book': 1})

我们表面上删除了一条信息，实际却删除了三条，因为我们删除的这本书在Book_authors表中有两条相关信息，这种删除方式就是django默认的级联删除。

13.关于orm和SQLAlchemy的看法

Django 的 Model 驱动对数据库层面上的实现细节关注的非常少，开发者定义模型的过程非常接近声明式而非过程式，对于新项目来说，可能是这个原因让 Django Model 比 SQLAlchemy 讨人喜欢。

传统的 SQLAlchemy 的使用方法是不入侵模型，在单独的地方定义表结构、映射规则，然后用 SQLAlchemy 驱动注入到模型类里去，这种方法可以完全避免模型与数据库的耦合，但是定义繁琐，要求开发者完全明白 engine、metadata、table、column、mapper 等概念，如果没有读过《企业应用架构模式》一类书籍会被弄得很乱。

现在 SQLAlchemy 提供了 declarative 的方式，和 Django Model 很像，但是和声明式模型还是有一定的距离，好在对于灵活性几乎没损失。但是我对比了一下 Django Model 和 SQLAlchemy declarative，发现 Django Model 还是更简洁一些。例如对于类关联，Django 只要直接声明外键，就自动产生关联对象，而 SQLAlcyhemy 要定义外键、relationship 对象，如果有多个外键还要自己指定 join 规则…… 总之灵活性是好东西，但是不是什么情况下都讨人喜欢的。

我本来想说这个是 ActiveRecord style 和 Data Mapper style 区别导致的，但是细想了一下，Django Model 并不是简单的 ActiveRecord，其对于复杂关联甚至继承的映射都有很好的适应性，应该和 SQLAlchemy 的 declarative 是同类型的，是对 Data Mapper 的 Active Record style 包装。

sqlalchemy使用上有两个层次，1是使用sql expression, 说白可以让你用python写sql， 2是它的orm, orm是使用session的，自行管理session生存期，自行在多个过程中传递session，自行管理事务。写法上是通常的transaction script（java常说的贫血的domain model)模式。实际编码通常1和2混合编程。
django通过中间件部分隐藏了连接/事务管理的概念，写法上也比较简单，接近java常说的充血的domain model. 内容上也没有sqlalchemy 的sql expression层次。易用性就体现出来了。

不过用过的orm中，能达到sqlalchemy这样高度的orm, 还没有在其他语言中看到。 ruby有sequal, java的jooq都有部分sqlalchemy思想的影子

因为在Django世界中它的ORM就是事实标准。Django最重要的特色是什么？从ORM快速生成后台管理界面！另外还有ModelForm、数据迁移(migration)等等从Django ORM延伸出去的概念……如果你选用了SQLAlchemy，那么这一切都没有了，你必须自行搭建，或者选用第三方库。话说，没有了内置ORM、没有了内置后台管理界面、没有了内置ModelForm、没有了数据迁移的Django，还是Django吗？不如直接用其它更轻量或更松散的框架好了！

另外，在Django之外单独使用Django ORM是不靠谱的。如果是其它环境，使用SQLAlchemy就好了。

9.杂项补充

1.序列化

关于Django中的序列化主要应用在将数据库中检索的数据返回给客户端用户，特别的Ajax请求一般返回的为Json格式。

2.第一种方式

from django.core import serializers

ret = models.BookType.objects.all()

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

3.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)

4.json处理date

由于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)

2.内置信号量

1常用的信号量

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 # 创建数据库连接时，自动触发

2.导入方式

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指上述导入的内容

3.使用方法

from django.core.signals import request_finished
from django.dispatch import receiver

@receiver(request_finished)
def my_callback(sender, **kwargs):
    print("Request finished!")