Django框架开发

web应用程序框架
web应用程序本质：

• 接收并解析http请求，获取具体的请求信息
• 处理本次http请求，即完成本次请求的业务逻辑处理
• 构造并返回处理结果，就是http响应

  wsgiref

• web server gateway interface
• wsgi只是一个协议规定了两个规范确定客户端请求如何到达服务应用的规范以及服务应用如何把处理的结果返回

解析请求数据，封装响应数据

原理：

1. 浏览器到WSGI Server：浏览器发送的请求会先到WSGI Server。
2. environ：WSGI Server会将HTTP请求中的参数等信息封装到environ（一个字典）中。
3. WSGI Server到WSGI App：App就是我们自己编写的后台程序，每个URL会映射到对应的入口处理函数(或其他可调用对象），WSGI Server调用后台App时，会将environ和WSGI Server中自己的一个start_response函数注入到后台App中。
4. 逻辑处理：后台函数（或其他可调用对象）需要接收environ和start_response，进行逻辑处理后返回一个可迭代对象，可迭代对象中的元素为HTTP正文。
5. WSGI App到WSGI Server：后台函数处理完后，会先调用start_response函数将HTTP状态码、报文头等信息（响应头）返回给WSGI Server，然后再将函数的返回值作为HTTP正文（响应body）返回给WSGI Server。
6. WSGI Server到浏览器：WSGI Server将从App中得到的所有信息封装为一个response返回给浏览器。

from wsgiref.simple_server import make_server
def application(environ,start_response):
    # 按照http协议解析数据：environ  解析的数据是字典类型
    # 按照http封装响应数据：start_response
    path = environ.get("PATH_INFO")#当前请求路径
    start_response("200 OK",[])
    if  path == "/login":
        with open("login.html","r") as f:
            data = f.read()
    elif path == "/index":
        with open("index.html","r") as f:
            data = f.read()
    return[data.encode("utf8")]
httpd = make_server("127.0.0.1","8080",application) # 服务端地址  端口 回调函数  封装socket
httpd.serve_forever()  # 等待连接，有连接的时候执行application函数

from wsgiref.simple_server import make_server
def application(environ,start_response):
    path = environ.get("PATH_INFO")
    start_response("200 OK",[('content-type','text/html')])
    if  path == "/login":
        with open("login.html","r") as f:
            data = f.read()
    elif path == "/index":
        with open("index.html","r") as f:
            data = f.read()
    return[data.encode("utf8")]
httpd = make_server("127.0.0.1","8080",application) 
httpd.serve_forever()

Django简介

MVC与MTV

web服务器开发领域里著名的mvc模式，就是把web应用分为模型(M),控制器(C),和视图(V)三层，他们之间是以一种插件方式的，松耦合的方式连接在一起的模型负责业务对象与数据库的映射(ORM)，视图负责与用户的交互页面，控制器接收用户的输入调用模型和视图完成用户的请求

Django的MTV模式本质上和mvc是一样的，也是为了各组件间保持松耦合关系，只是定义上有些许不同，
Django的MTV分别是指：

• M：模型model ：用于和数据库进行交互,负责业务对象和数据库的关系映射(ORM) object relation mapping 对象关系映射
• T:模板template： view将数据传递给模板层进行渲染,负责如何把页面展示给用户(HTML)
• V:视图view: 负责处理业务逻辑和用户的请求已经响应，并在适当的时候调用Model和Template

除了上面的3层外，还需要一个URL分发器，作用是将一个URL的页面请求分发给不同的VIEW处理，view再调用响应的model和template

一般是用户通过游览器像我们的服务器发起一个请求，这个请求会去访问视图函数，(如如果不涉及到数据调用，那么这个时候视图函数返回一个模板也就是一个页面给用户，)视图函数调用模型去数据库查找数据，然后逐级返回，视图函数把返回的数据填充到模板中空格中，最后返回给网页用户

Django的下载与基本命令

pip3 install django

创建一个django项目

django-admin.py startproject 项目名

manage.py

• Django项目里面的工具，通过他可以调用django shell 和数据库等,
• manage.py就是django-admin区别是django-admin会被加入到环境变量可以在任何目录下使用,manage.py只能在该项目下使用

mysite文件夹： 这个django项目的全局配置文件，主应用开发目录,保存了项目中的所有开发人员编写的代码, 目录是生成项目时指定的

settings.py

• 包含了项目的默认配置包括数据库信息，调试标志以及一些其他的变量,项目的配置文件

urls.py

• 负责把url模式映射到应用程序，绑定url和视图的映射关系

wsgi.py

• 封装socket模块，就是项目在运行wsgi服务器时的入口文件

__init__.py

让python将当前目录识别为一个包

asgi.py django3.0以后新增的，用于让django运行在异步编程模式的一个web应用对象

应用文件夹下： models:该应用的模型类模块 views: 该应用的视图模块 tests: 该应用的单元测试模块 apps: 该应用的一些配置，自动生成 admin.py 该应用的后台管理系统配置

在mysite目录下创建应用

python manage.py startapp 应用名

启动项目

python manage.py runserver ip 端口号

不指定端口默认为8000

Django简单实例

1.创建项目

给前端页面返回用户登录

2.在url控制器里面添加路径信息以及视图函数

3.在视图里面创建相应的函数来处理逻辑关系

4.在templates里面创建相应的html文件

静态文件配置

1.项目目录下新建：static文件夹,用于存放静态文件如css和js文件

2.settings.py文件下增加路径：STATICFILES_DIRS=[os.path.join(BASE_DIR,”static”)]

3.用户访问static路径的时候就会自动访问static文件夹，也就是拼接的路径

4.在做其他配置的时候涉及到static文件夹都要使用别名也就是static

为什么要配置静态文件

1.给用户返回网页，用户在点击的时候可以改变颜色案例

1.在返回的模板文件引入js，实现点击功能

2.用户访问该网站

3.解决办法：

项目目录下新建static文件夹存放js文件并且settings.py文件下增加配置STATICFILES_DIRS=[os.path.join(BASE_DIR,”static”)]

路由控制器

Route路由是一种映射关系，路由是客户端请求的url路径和用户请求的应用程序，（也就是django里面的视图进行绑定映射的一种关系）

路由配置就是根据收到的url路由配置视图函数 在django中所有的路由最终都被保存到 urlpatterns变量中，urlpatterns必须声明在主应用下的urls.py总路由中，这是由配置文件setting设置的

在django运行中，当客户端发的送了一个http请求到服务端，服务端的web服务器会从http协议中提取url地址，从程序内部中找到项目中添加到urlpatterns里面的所有路由信息的url进行遍历匹配，如果相等或者匹配成功，则调用当前url对象的视图方法

注意点：

如果从URL中捕获一个值，只需要在他周围放置一对圆括号()

不需要添加一个前导的反斜杠，因为每个url都有，例,应该是artic而不是/artic

每个正则表达式前面的r是可选的，是用于告诉python这个字符串是原始的字符串中的任何字符都不应该转义

路由控制——-> 有名分组

给分组起个名字

加括号的作用是执行函数的时候会将正则匹配到的值自动传参给函数，如果不加的话就不会传参但是还是根据整个匹配

路由控制———>路由分发

需要引入 include函数

如果一个项目存在多个应用的情况下，不应该将所有的url都写在全局的urls的配置文件中，而是在全局urls中配置路由分发，具体url应该是放在该应用的文件夹下创建urls.py文件，在该文件配置该应用的url

1.在全局urls下配置路由分发

2.在应用下的urls进行具体的路由配置

3.用户访问

路由控制之登录验证实例

1.在全局urls下配置路由分发

2.在应用下的urls中配置具体的路由信息

3.编写登录验证页面

4.编写视图函数来处理登录验证请求

路由控制———>反向解析（模板中配置的）

当urls文件中的路由更改名称后,模板文件里的路径也需要更改比如(form表单的提交地址)，否则数据提交不上来，且手动修改路径不好维护，可以通过模板的反向解析来实现

实现

1.在urls路由中给url起个别名

2.在模板文件中将需要写路径地址的地方用{% url ‘别名’ %} 来替代

{% url ‘别名’ %} 语法 是视图函数里的render在渲染的时候执行的，意思是去urls里面找name = 别名的然后找到的路径来替换这个占位，然后将页面返回给客户端

3.客户端访问

路由控制———>反向解析（视图函数配置的）

可以在视图函数中反向解析到urls中的路径信息

1.在urls中为路由起个名字

2.在函数视图中配置

路由控制———>名称空间

如果存在多个app，在做路由分发的时候起的别名重复 了，那么在做反向解析的时候解析就会出错都解析为一个，因为name别名是没有作用域的，django在做解析的时候会在全局顺序搜索，当查到第一个name’指定的url时候会立即返回如：

1.创建两个app，在全局urls进行路由分发

2.在各个应用里面进行详细的urls路由分发

3.在视图函数里面创建视图函数并返回解析的路径

4.用户访问

5.解决办法，使用名称空间来解决

路由控制——->path方法

1. 在url控制中如果路径有分组则会向相应的函数视图传参，传参默认是str类型的，如果涉及到类型转换会出现TypeError或者ValueError 如何解决？
2. 路由控制中要是多个路径中的匹配规则是一样的，需要重复写多次，如果修改的话也需要修改多次。如何解决？
3. 用path解决
   使用规则：
   • 使用<>从url中捕获值
   • 捕获值中可以包含一个转换器类型，比如用 < int:name >捕获一个整数变量如果没有转换器，将匹配任何字符串包括/字符
   • 无需添加前导斜杠

Django默认支持5个转换器

• str,匹配除了路径分隔符/之外的非空字符串这是默认的
• int,匹配正整数包含0
• slug，匹配字母数字以及横杠下划线组成的字符串
• uuid，匹配格式化的uuid如0751443d-123-123e-1234-6c931e272f00
• path,匹配任何非空字符串包含了路径分隔符

自定义转换器

• 新建py文件存放定义的转换器

• 在urls中调用

路由控制———>路由转发器

有时候内置的url转换器并不能满足我们的需求，一次django给我们提供了一个接口可以让我们自己定义自己的url转换器，自己定义路由的匹配规则

from django.urls import register_converter
from django.shortcuts import HttpResponse
#自定义路由转换器
class Mobile(object):
    regex = "1[3-9]\d{9}" #必须叫regex，代表规则
    #下面的方法名都是固定的
    def to_python(self,value):
        print(type(value))
        #value接收的是根据regex规则匹配成功的值
        #将匹配结果传到视图内部使用
        #返回什么类型的数据，看需求
        return value
    def to_url(self,value):
        #将匹配结果用于反向解析传值时使用
        return value
#register_converter(定义的路由转换器类名,调用时的别名)
register_converter(Mobile,'moile')
在urls中使用自定义的路由转发器
#当路径是index\开头，且后面根的值满足自定义的转换规则的时候，执行视图函数
path('index\<mobile:moile>',视图函数名)
#在视图函数中定义函数的时候要加形参，因为会给函数传参，传参就是to_python方法中return的值如：
def index(request,mobile):
    print(mobile)

视图层（视图函数）

一个视图函数（FBV），简称视图，就是一个python函数，接收web请求并返回web响应，响应可以是一张网页的html内容，一个重定向，或者错误代码等等，无论视图本身包含什么逻辑都要返回响应, 还有类视图（CBV）

视图请求对象常用属性：

response 和 request 都是由wsgi进行封装的
def index(request):
    # 获取请求方式 GET POST
    met = request.method
    # 获取所有的get请求的数据字典形式，获取数据首先发送的数据要包含数据，对于get是在地址栏中输入用？分隔
    get_data = request.GET
    # 获取所有的post请求的数据字典形式，只会把url-encoded格式的数据解析到post中
    post_data = request.POST
    #获取请求体中的数据
    data = request.body
    # 获取路径信息，url组成是 协议://ip:端口/路径/?数据，只写协议ip端口匹配到的是跟路径/，要保证路由控制中可以匹配到/
    path_data = request.path
    #获取请求路径包含了请求参数
    data = request.get_full_path()
    #  一个字符串，表示提交数据的编码方式如果是None表示用的DEFAULE_CHARSET也就是utf8
    encoding_data = request.encoding
    #  包含所有的HTTP头部信息是一个字典形式
    '''
    CONTENT_LENGTH —— 请求的正文的长度（是一个字符串）。
    CONTENT_TYPE —— 请求的正文的MIME 类型。
    HTTP_ACCEPT —— 响应可接收的Content-Type。
    HTTP_ACCEPT_ENCODING —— 响应可接收的编码。
    HTTP_ACCEPT_LANGUAGE —— 响应可接收的语言。
    HTTP_HOST —— 客服端发送的HTTP Host 头部。
    HTTP_REFERER —— Referring 页面。
    HTTP_USER_AGENT —— 客户端的user-agent 字符串。
    QUERY_STRING —— 单个字符串形式的查询字符串（未解析过的形式）。
    REMOTE_ADDR —— 客户端的IP 地址。
    REMOTE_HOST —— 客户端的主机名。
    REMOTE_USER —— 服务器认证后的用户。
    REQUEST_METHOD —— 一个字符串，例如"GET" 或"POST"。
    SERVER_NAME —— 服务器的主机名。
    SERVER_PORT —— 服务器的端口（是一个字符串）。
 　从上面可以看到，除 CONTENT_LENGTH 和 CONTENT_TYPE 之外，请求中的任何 HTTP 首部转换为 META 
   的键时，都会将所有字母大写并将连接符替换为下划线最后加上 HTTP_  前缀。 所以，一个叫做 X-Bender
   的头部将转换成 META 中的 HTTP_X_BENDER 键。
    '''
    meta_data = request.META
    #  类似与字典的对象包含所有的上传文件信息
    '''
    FILES 中的每个键为<input type="file" name="" /> 中的name，值则为对应的数据。
　　 注意，FILES 只有在请求的方法为POST 且提交的<form> 带有enctype="multipart/form-data" 的情况
   下才会包含数据。否则，FILES 将为一个空的类似于字典的对象。
    '''
    files_data = request.FILES
    #  字典形式包含所有的cookie信息，键值都是字符串
    cook_data = request.COOKIES
    #  类似与字典的对象可以读写，表示当前的会话只有Gjango启用会话支持时候才可以用
    session_data = request.session
    #  一个AUTH_USER_MODEL 类型的对象表示当前登录的用户，没有用户登录user将设置为
    django.contrib.auth.models.AnonymousUser 的一个实例。你可以通过is_authenticated() 区分它们
    '''
    例如：  
    if request.user.is_authenticated():
        # Do something for logged-in users.
    else:
        # Do something for anonymous users.
     　　user 只有当Django 启用 AuthenticationMiddleware 中间件时才可用。
 ------------------------------------------------------------------------
    匿名用户
    class models.AnonymousUser
    django.contrib.auth.models.AnonymousUser 类实现了django.contrib.auth.models.User 接口，
    但具有下面几个不同点：
    id 永远为None。
    username 永远为空字符串。
    get_username() 永远返回空字符串。
    is_staff 和 is_superuser 永远为False。
    is_active 永远为 False。
    groups 和 user_permissions 永远为空。
    is_anonymous() 返回True 而不是False。
    is_authenticated() 返回False 而不是True。
    set_password()、check_password()、save() 和delete() 引发 NotImplementedError。
    New in Django 1.8:
    新增 AnonymousUser.get_username() 以更好地模拟 django.contrib.auth.models.User。
    '''
    user_data = request.user
    return HttpResponse(request.GET)

视图请求对象常用方法：

1.HttpRequest.get_full_path()
　　返回 path，包含路径信息和数据信息
2.HttpRequest.is_ajax()
　　如果请求是通过XMLHttpRequest 发起的，则返回True，方法是检查 HTTP_X_REQUESTED_WITH 相应的
    首部是否是字符串'XMLHttpRequest'。
　　大部分现代的 JavaScript 库都会发送这个头部。如果你编写自己的 XMLHttpRequest 调用（在浏览器端），你必须手工设置这个值来让 is_ajax() 可以工作。
　　如果一个响应需要根据请求是否是通过AJAX 发起的，并且你正在使用某种形式的缓存例如Django 的 cachemiddleware，你应该使用 vary_on_headers('HTTP_X_REQUESTED_WITH') 装饰你的视图以让响应能够正确地缓存。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>index</title>
</head>
<body>
{#默认不写是使用当前页面的url，如果只写路径，默认使用当前url的ip和端口#}
<form action="index/" method="post"> 
    年龄： <input type="text" name="age">
    姓名：<input type="text" name="name">
    <input type="submit">
</form>
</body>
</html>

视图函数响应对象

响应对象主要有四种形式：

• HttpResponse()

HttpResponse()括号内直接跟一个具体的字符串作为响应体，比较直接很简单，所以这里主要介绍后面两种形式。 django服务器接收客户端发送过来的请求后，会将提交上来的数据封装成http request对象传给视图函数，那么视图函数在处理完相关的逻辑后，需要返回一个响应给游览器，这个响应，必须用 httpresponseBase 或 其他的子类的对象，而http request base 和 response base 是用的最多的
常用的属性有：
content ：返回的内容
status : 返回的http响应状态码
content-type： 返回的数据的mime类型
设置响应头： response[‘xxx’] =’xxx’

• jsonResponse()

jsonresponse只能解析字典数据，如果是其他数据要加上safe=false,jsonresponse(dict,safe=false)

• render ```python render(request, ‘template_name.html’,context） 结合一个给定的模板和一个给定的上下文字典，并返回一个渲染后的 HttpResponse 对象。

参数： request： 用于生成响应的请求对象。 template_name：要使用的模板的完整名称，可选的参数 context：添加到模板上下文的一个字典。默认是一个空字典。如果字典中的某个值是可调用的，视图将在渲染模板之前调用它。

- redirect()
```python
 redirect传递要重定向的一个硬编码的URL
def my_view(request):
    ...
    return redirect('/some/url/')
也可以是一个完整的URL：
def my_view(request):
    ...
    return redirect('http://example.com/')
key：两次请求　
1）301和302的区别。
　　301和302状态码都表示重定向，就是说浏览器在拿到服务器返回的这个状态码后会自动跳转到一个新的URL地址，这个地址可以从响应的Location首部中获取
  （用户看到的效果就是他输入的地址A瞬间变成了另一个地址B）——这是它们的共同点。
　　他们的不同在于。301表示旧地址A的资源已经被永久地移除了（这个资源不可访问了），搜索引擎在抓取新内容的同时也将旧的网址交换为重定向之后的网址；
　　302表示旧地址A的资源还在（仍然可以访问），这个重定向只是临时地从旧地址A跳转到地址B，搜索引擎
    会抓取新的内容而保存旧的网址。 SEO302好于301
2）重定向原因：
（1）网站调整（如改变网页目录结构）；
（2）网页被移到一个新地址；
（3）网页扩展名改变(如应用需要把.php改成.Html或.shtml)。
这种情况下，如果不做重定向，则用户收藏夹或搜索引擎数据库中旧地址只能让访问客户得到一个404
页面错误信息，访问流量白白丧失；再者某些注册了多个域名的网站，也需要通过重定向让访问这些域名的用户自动跳转到主站点等。
django append——slash:如果我们在地址栏输入url时候如果最后一个/没有输入，就发起访问，django会发起一个重定向给我们补上最后一个/，前提是访问的url路径能匹配上只是缺少/的情况
用redirect可以解释APPEND_SLASH的用法！

模板语法———>变量，标签

模板就是templates文件夹下的html文件，setting中自动配置了temtemplates的路径是在项目的根路径下。django查找模板文件夹的顺序是先去项目目录下查找如果没有就根据app的注册顺序去app目录下查找。

模板引擎是一种可以让开发者把服务端数据填充到html网页中完成渲染效果的技术，他实现了把前端代码和服务端代码分离的作用，让项目中的业务逻辑代码和数据表现代码分离。

django框架中内置了web开发领域非常出名的一个django template模板引擎 DTL.

要在django框架中使用模板引擎把视图函数中的数据更好的展现给客户端，需要完成3个步骤

• 在项目文件中指定保存模板文件的模板目录，一般目录是设置在项目根目录或主应用目录下的
• 在视图中基于django提供的渲染函数绑定模板文件和需要展示的数据变量
• 在模板目录下创建对应的模板文件，并根据模板引擎内置的模板语法，填写输出视图传递过来的数据。

DTL模板文件与普通html文件的区别？
DTL模板文件是一种带有特殊语法的HTML文件，这个HTML文件可以被Django编译，可以传递参数进去，实现数据动态变化，再编译完成后，生成一个普通的html，然后返回给客户端。

html文件：
    <h3> hi {{name}} <h3>
views文件：
from django.template.loader import get_template
from django.shortcuts import render
def index(request):
    #获取模板文件
    template = get_template('index.html')
    #获取数据
    context = {"name":"si"}
    #渲染,找到模板文件中为name的占位符 替换为context字典中 name键对应的值
    html = template.render(context,request)
    #快捷步骤
    return render(request,'index.html',{"name":"si"})

1.渲染变量：{{ }}

深度查询 句点符 用点来完成.

2.过滤器

将视图中render传过来的变量加以修饰
{{obj | filter_name:param}}
{{变量名|过滤器名称：过滤器参数}}

• 自带的过滤器

  - default

如果变量是false或者是空，则使用给定的默认值否则使用其他变量

{{value|default:"数据是空"}}
变量value如果是空或者false就使用数据是空

  - length

{{value | length}}
返回值的长度。它对字符串和列表都起作用

  - data    

value=datetime.datetime.now()
{{value | data:"Y-m-d"}}
将value的显示格式修改为2001-12-13的形式

  - slice

 value="hello world"
{{ value|slice:"2:-1" }} 切片

  - truncatechars

如果字符串字符多于指定的字符数量，那么会被截断。截断的字符串将以可翻译成省略号序列（“...”）结尾。
参数：要截断的字符数
{{ value|truncatechars:9 }}

  - safe

Django的模板中会对HTML标签和JS等语法标签进行自动转义，原因显而易见，这样是为了安全。但是有的时候我们可能不希望这些HTML元素被转义，比如我们做一个内容管理系统，后台添加的文章中是经过修饰的，这些修饰可能是通过一个类似于FCKeditor编辑加注了HTML修饰符的文本，如果自动转义的话显示的就是保护HTML标签的源文件。为了在Django中关闭HTML的自动转义有两种方式，如果是一个单独的变量我们可以通过过滤器“|safe”的方式告诉Django这段代码是安全的不必转义。比如：
value="<a href="">点击</a>"
{{ value|safe}}

  - last

{books|last} 
#取books中的最后一个值

过滤器举例：
视图代码 home.views.py;
def index(request):
    """过滤器 filters"""
    content = "<a href='http://baidu.com'>baidu</a>"
    # content1 = '<script>alert(1);</script>'
    from datetime import datetime
    now = datetime.now()
    content2= "hello wrold!"
    return render(request,"index.html",locals())
# 模板代码,templates/index.html:
    {{ content | safe }}
    {{ content1 | safe }}
    {# 过滤器本质就是函数,但是模板语法不支持小括号调用,所以需要使用:号分割参数 #}
    <p>{{ now | date:"Y-m-d H:i:s" }}</p>
    <p>{{ conten1 | default:"默认值" }}</p>
    {# 一个数据可以连续调用多个过滤器 #}
    <p>{{ content2 | truncatechars:6 | upper }}</p>

3.渲染标签{% %}

标签是这样的{%tag%},标签比变更更加复杂，一些在输出中创建文本，一些通过循环或者逻辑来控制流程，一些加载其后的变量将使用的额外信息加载到模板中，一些标签需要开始和结束标签（例如{%tag%}….标签内容…..{%endtag%}）

• for 标签 ``` {% for i in L%} # 循环函数视图传过来的L变量，每循环一次显示其中的一个元素

  {{i}}

  {%endfor%}

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ {% for i in L%}

{{forloop.counter}} {{i}}

forloop是内置的

{{forloop.first}} # 判断是否是第一次循环，返回值是True或False

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ {% for i in L%}

{{forloop.counter}} {{i}}

列表为空

循环中, 模板引擎提供的forloop对象,用于给开发者获取循环次数或者判断循环过程的.
| **属性** | **描述** |
| --- | --- |
| forloop.counter | 显示循环的次数,从1开始 |
| forloop.counter0 | 显示循环的次数,从0开始 |
| forloop.revcounter0 | 倒数显示循环的次数,从0开始 |
| forloop.revcounter | 倒数显示循环的次数,从1开始 |
| forloop.first | 判断如果本次是循环的第一次,则结果为True |
| forloop.last | 判断如果本次是循环的最后一次,则结果为True |
| forloop.parentloop | 在嵌套循环中，指向当前循环的上级循环 |
- if 标签

{% if %}会对一个变量求值，如果它的值是“True”（存在、不为空、且不是boolean类型的false值），对应的内容块会输出。

{% if num > 100 or num < 0 %}

无效

优秀

凑活吧

- **with 标签**

使用一个简单地名字缓存一个复杂的变量，当你需要使用一个“昂贵的”方法（比如访问数据库）很多次的时候是非常有用的，也可以用于从对象中取值并且赋值别名 例如： {% with total=business.employees.count %} {{ total }} employee{{ total|pluralize }} {% endwith %}

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ {%with 对象.属性 as 别名%}

别名就等于从对象中取道的值

- c**srf_token** 标签用于跨站请求伪造保护

def file_put(request): if request.method==”POST”: print(request.POST) print(request.FILES) file_obj = request.FILES.get(‘tx’) #获取上传的文件对象 with open(file_obj.name,’wb’) as f: for line in file_obj: f.write(line)

上传成功的数据放在request.Files里面不是在request.POST里 file_obj.name是上传文件的文件名

<a name="6110ff0c"></a>
### 请求头之contentType
```python
contentType 决定了传输的数据也就是请求体以什么格式进行编码
multipart/form-data 格式：可以包含文件传输
application/x-www-form-urlencoded 格式：默认的，数据以键值对的形式传输 user=123&pwd=456
#request.POST只有contentType为application/x-www-form-urlencoded的时候才可以取到数据
#contentType为json格式的时候 数据在 request.body里面
#里面就是请求体的原数据
# 所有的原本的请求体数据都在request.body，只有当contentType为application/x-www-form-urlencoded
的时候django会把传输过来的数据给解析成queryDict格式方便取数据

模型层ORM

Django中内嵌了ORM框架，不需要直接编写SQL语句进行数据库操作，而是通过定义模型类，操作模型类来完成对数据库中表的增删改查和创建等操作。

MVC框架中的一个重要部分ORM，实现了数据模型与数据库的解耦，就是数据模型的涉及不需要依赖与特定的数据库，通过简单的配置就可以轻松更换数据库，减轻了开发人员的工作量，不需要面对因数据库变更而导致的无效劳动

ORM就是 对象>>>>关系>>>>>映射

用python写数据表的描述信息，orm可以将python写的代码翻译成sql语句，对表操作无法对库操作

定义的模型类 相当于数据库中的表
类成员变量，相当于数据库表中的字段，变量值相当于字段的类型以及约束
类实例化的对象，相当于 sql表中的表记录

orm优点

• 数据模型类都在一个地方定义，更容易更新和维护，也利于重用代码。
• ORM 有现成的工具，很多功能都可以自动完成，比如数据消除、预处理、事务等等。
• 它迫使你使用 MVC 架构，ORM 就是天然的 Model，最终使代码更清晰。
• 基于 ORM 的业务代码比较简单，代码量少，语义性好，容易理解。
• 新手对于复杂业务容易写出性能不佳的 SQL,有了ORM不必编写复杂的SQL语句, 只需要通过操作模型对象即可同步修改数据表中的数据.
• 开发中应用ORM将来如果要切换数据库.只需要切换ORM底层对接数据库的驱动【修改配置文件的连接地址即可】

orm缺点

• ORM 库不是轻量级工具，需要花很多精力学习和设置，甚至不同的框架，会存在不同操作的ORM。
• 对于复杂的业务查询，ORM表达起来比原生的SQL要更加困难和复杂。
• ORM操作数据库的性能要比使用原生的SQL差。
• ORM 抽象掉了数据库层，开发者无法了解底层的数据库操作，也无法定制一些特殊的 SQL。【自己使用pymysql另外操作即可，用了ORM并不表示当前项目不能使用别的数据库操作工具了。】

可以通过以下步骤来使用django的数据库操作

1. 配置数据库连接信息
2. 在models.py中定义模型类
3. 生成数据库迁移文件并执行迁文件[注意：数据迁移是一个独立的功能，这个功能在其他web框架未必和ORM一块的]
4. 通过模型类对象提供的方法或属性完成数据表的增删改查操作

数据类型：

字段约束条件：

注意：null是数据库范畴的概念，blank是表单验证范畴的

外键

如一对一，一对多，多对多
在设置外键时，需要通过on_delete选项指明主表删除数据时，对于外键引用表数据如何处理，django.db.models中包含了可选常量：

• CASCADE 级联，删除主表数据时连通一起删除外键表中数据
• PROTECT 保护，通过抛出ProtectedError异常，来阻止删除主表中被外键应用的数据
• SET_NULL 设置为NULL，仅在该字段null=True允许为null时可用 ,删除该字段以后，对应表里的关联字段的值全部被改成null
• SET_DEFAULT 设置为默认值，仅在该字段设置了默认值时可用
• SET() 设置为特定值或者调用特定方法，例如： ```python from django.conf import settings from django.contrib.auth import get_user_model from django.db import models

def get_sentinel_user(): return get_user_model().objects.get_or_create(username=’deleted’)[0]

class UserModel(models.Model): user = models.ForeignKey( settings.AUTH_USER_MODEL, on_delete=models.SET(get_sentinel_user), )

- **DO_NOTHING** 不做任何操作，如果数据库前置指明级联性，此选项会抛出**IntegrityError**异常
<a name="203076dd"></a>
### 单表操作------>生成表模型
1.创建模型<br />django会为表创建自动增长的主键列，每个模型只能有一个主键列，如果使用选项设置某个字段的约束条件为主键列（permary_key）后，django不会在自动创建自增的主键列。在django中主键的调用别名为pk
```python
在app下的models.py中创建模型
from django.db import models
class Book(models.Model):#必须继承django.db.models.Model类。
    #自增，主键
    # 字段名 = models.数据类型(约束选项1,约束选项2, verbose_name="注释")
    id = models.AutoField(primary_key = True)
    title =models.CharField(max_length = 32)
    state = models.BooleanField()
    pub_date = models.DateField()
    price = models.DecimalField(max_digits=8,decimal_places=2)
    # 一共允许8位包括小数点后的位数
    publish = models.CharField(max_length=32,verbose_name='注释')
    class Meta:#数据表结构信息
        db_table ='book',#设置表名为book,没有指定是app名_类名
        verbose_name = '学生信息表',# 在admin站点中显示的名称
        verbose_name_plural = verbose_name,# 显示的复数名称
    #自定义数据库操作方法
    def __str__(self):
        """定义每个数据对象的显示信息"""
        return "<titile" % self.title

2.配置settings文件

若想将模型转为mysql数据库中的表，需要在settings中配置：
DATABASES = {
        'default':{
        'ENGINE':'django.db.backends.mysql',
         # 设置mysql引擎设置为mysql
        'NAME':'数据库名称',  #需要提前创建好
        'USER':'数据库用户',
        'PASSWORD':'数据库密码',
        'HOST':'数据库连接地址',
        'PORT':数据库端口号    
    }  
}
最后通过两条数据库迁移命令即可在指定的数据库中创建表 ：在终端页面输入
python manage.py makemigrations  应用名
# 将记录提交到本地就是应用下的migrations文件夹
python manage.py migrate
# 同步数据库操作

注意1：
NAME即数据库的名字，在mysql连接前该数据库必须已经创建，而上面的sqlite数据库下的db.sqlite3则是项目自动创建 USER和PASSWORD分别是数据库的用户名和密码，不需要修改自带的DATABASES。
设置完后，再启动我们的Django项目前，我们需要激活我们的mysql。然后，启动项目，会报错：no module named MySQLdb 。这是因为django默认你导入的驱动是MySQLdb，可是MySQLdb 对于py3有很大问题，py3对mysql的操作是通过
pymysql来完成的，所以我们需要的驱动是PyMySQL 所以，我们只需要找到项目名文件下的init文件,
在里面写入：
import pymysql
pymysql.install_as_MySQLdb()
#作用是让Django的ORM能以mysqldb的方式来调用PyMySQL。
注意2:确保settings配置文件中的INSTALLED_APPS中写入我们创建的app名称,INSTALLED_APPS中自带的是django的默认的应用,需要将自己新建的应用加进去用于激活app
注意3:如果报错如下：
django.core.exceptions.ImproperlyConfigured: mysqlclient 1.3.3 or newer is required;  you have 0.7.11.None
MySQLclient目前只支持到python3.4，因此如果使用的更高版本的python，需要修改如下：
    通过查找路径"C:\Programs\Python\Python36-32\Lib\site-packages\Django-2.0-py3.6.egg\
    django\db\backends\mysql" 这个路径里的文件把
    if version < (1, 3, 3):
     raise ImproperlyConfigured("mysqlclient 1.3.3 or newer is required; you have %s" % 
      Database.__version__)注释掉
注意4: 如果想打印orm转换过程中的sql，需要在settings中进行如下配置：
        LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console':{
            'level':'DEBUG',
            'class':'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
    }
}

单表操作———>增加记录

1.在视图函数中引入models中创建数据库表的类
2.根据创建数据表的类实例化记录对象

from django.shortcuts import render
from app.models import Book
# Create your views here.
def index(request):
    # 添加记录
   #方式1
   book_obj = Book(id="1", title="算法书", price=100, pub_data="2012-1-1", publish="人民出版社")
   book_obj.save() #创建对应的sql语句并执行增加记录的操作
    # 方式2 通过create方法，他的返回值是当前生成的对象记录也就是book_obj
    # Book.objects.create,objects就是表的管理器，也就是生成表那个类的管理器 create是增加
    #  book_obj就是当前生成的对象记录,可以直接查询字段值,如:book_obj.title
   book_obj = Book.objects.create(id="2", title="算法书1", price=100, pub_data="2012-1-12", publish="人民出版社")

单表操作———> 查询API

ORM中针对查询结果的限制

1. all()方法
info = BOOK.objects.all() 
# 查询所有的结果返回值是Queryset类型，类似与列表，列表里面放的是查询出来的每个对象,一个记录是一个对象
# 想返回具体的信息可以通过 __str__方法，在生成表的类中定义__str__方法
# 返回值是Queryset类型  [<Book:记录信息> # model对象,<Book:记录信息>]  model对象支持.操作等
# 调用者是objects
2. first() 和 last()
info = BOOK.objects.all().first()
# 取all返回值的第一个对象和最后一个对象
# 等于BOOK.objects.all()[0]
# 调用者是Queryset 返回值是model对象
3.filter()
info = BOOK.objects.filter(title='php',price=100)
# 过滤title等于php并且价格是100的那条记录
# 返回值是Queryset对象 
# 调用者是objects
4.get()
info = BOOK.objects.get(title='go')
# 查询title是go的记录
# 返回值是model对象 有且只有一个查询结果的时候才有意义，超过一个或者没有都报错
# 调用者是objects
5.excelude()
info = BOOK.objects.exclude(title='go')
# 查询title不等于go的记录
# 返回值是Queryset对象 
# 调用者是objects
6.order_by() 
info = BOOK.objects.all().order_by('id')
# 查询所有的内容按照id字段升序排序，'-id'是降序排序'
# 返回值是Queryset对象 
# 调用者是Queryset对象 
7.reverse()
8.count()
info = BOOK.objects.all().count()
# 对查询的所有结果进行计数
# 返回值是整形
# 调用者是Queryset对象
9.exist()
info = BOOK.objects.all().exist()
# 判断Queryset是否包含数据，是返回True 否则返回False，只取1条
# 返回值是bool
# 调用者是Queryset对象
10.values()
info = BOOK.objects.all().values("title")
# 取值，循环取Queryset中的model对象的title值
# 返回值是Queryset，[{'title':'python'},{'title':'go'},]
# 调用者是Queryset对象、
实现原理
temp = []
for obj in BOOK.objects.all():
   temp.append({"title":obj.title})
return temp
11.values_list()
info = BOOK.objects.all().values_list("title")
# 取值，循环取Queryset中的model对象的title值
# 返回值是Queryset，[('python'),('go'),]
# 调用者是Queryset对象
12.distinct()
info = BOOK.objects.all().values('price').distinct()
# 去重,对查询出来的价格字段去重
# 返回值是Queryset，
# 调用者是Queryset对象

单表操作———>模糊查询

1. __in 
Book.objects.filter(price__in=[100,200,300]) # 价格等于 100 200 300的
2. __gt
Book.objects.filter(price__gt=100) # 大于
3.__lt
Book.objects.filter(price__lt=100) # 大于
4.__range
Book.objects.filter(price__range=[100,200]) # 价格在100-200 之间的
5.__contains
Book.objects.filter(title__contains="h") # 标题里面包含h的
6.__icontains
Book.objects.filter(title__icontains="h") # # 标题里面包含h的 不区分大小写
7.__startswith
Book.objects.filter(title__startswith="py")  # 标题以py开头的
8.__year  # __year只有data类型的可以使用，
Book.objects.filter(pub_date__year=2012) # 查询出版日期是2012年的
9.__isnull  #查询字段值是否为空
Book.objects.filter(title__isnull=True) # 查询title值为空的

单表操作———>删除/修改

1. delete()
info = Book.objects.filter(price=200).delete()
# 删除价格等于200的记录，需要先查询出来再删除
# 返回值是元组，（2，｛'app01.book':2｝） 删除了2个记录删除的是app01.book表
# delete()的调用者是Queryset对象和model对象
info = BOOK.objects.all().first().delete()
2. update()
info = Book.objects.filter(title="php").update(title='go')
# 将查询出来的title等于php的修改为title等于go
# 返回值是元组，
# update()的调用者必须是Queryset对象
3.save()
stu = Book.objects.get(pk=1)
stu.price =88
stu.save()
#将pk=1的书籍的价格修改为88
#这种方式会对id=1的记录的所有字段重新赋值，效率低
# save之所以能提供给我们添加数据的同时，还可以更新数据的原因？
# save会找到模型的字段的主键id的值，
# 主键id的值如果是none，则表示当前数据没有被数据库，所以save会自动变成添加操作
# 主键id有值，则表示当前数据在数据库中已经存在，所以save会自动变成更新数据操作

多表操作——->生成关联表模型

一、创建模型
实例：我们来假定下面这些概念，字段和关系
作者模型：一个作者有姓名和年龄。
作者详细模型：把作者的详情放到详情表，包含生日，手机号，家庭住址等信息。作者详情模型和作者模型之间
是一对一的关系（one-to-one）
出版商模型：出版商有名称，所在城市以及email。
书籍模型： 书籍有书名和出版日期，一本书可能会有多个作者，一个作者也可以写多本书，所以作者和书籍的
关系就是多对多的关联关系(many-to-many);一本书只应该由一个出版商出版，所以出版商和书籍是一对多关联
关系(one-to-many)。
模型建立如下：
from django.db import models
# Create your models here.
class Author(models.Model):
nid = models.AutoField(primary_key=True)
name=models.CharField( max_length=32)
age=models.IntegerField()
# 与AuthorDetail表的nid字段建立一对一的关系
authorDetail=models.OneToOneField(to="AuthorDetail",to_fileld="nid"，
 on_delete=models.CASCADE)
class AuthorDetail(models.Model):
nid = models.AutoField(primary_key=True)
birthday=models.DateField()
telephone=models.BigIntegerField()
addr=models.CharField( max_length=64)
class Publish(models.Model):
    nid = models.AutoField(primary_key=True)
    name=models.CharField( max_length=32)
    city=models.CharField( max_length=32)
    email=models.EmailField()
class Book(models.Model):
    nid = models.AutoField(primary_key=True)
    title = models.CharField( max_length=32)
    publishDate=models.DateField()
    price=models.DecimalField(max_digits=5,decimal_places=2)
class Emp(models.Model):
    name =models.CharFiled(max_length=32)
    age=models.IntegerFiled()
    salary=models.DecimalFiled(max_digits=8,decimal_places=2)
    dep-models.CharFiled(max_length=32)
    province=models.CharField(max_length=32)
# 与Publish建立一对多的关系,外键字段建立在多的一方
# 会自动建一个字段叫publish_id用于关联
# on_delete 是指删除其他表的内容时此表的关联字段设置为空 null是允许为空
# db_constraint=False 是指不建立外键约束，默认值是True
# related_name是指正向查询的时候用publish字段就可以，当然这是默认的，
但是反向查询的时候通常是表名小写_set的方式，还有一种方式就是根据related_name字段的值进行反向查询
#通过Emp.objects.publish得到的是对象类型的数据且是包含该字段关联的另一个表里的一条或多条记录
publish=models.ForeignKey(to="Publish",to_field="nid",on_delete=models.CASCADE,related_name='pb',null=True,db_constraint=False)
转换为sql相当与
publish_id int, # 自动创建的字段
foreign key (publish_id) references publish(id),
# 与Author表建立多对多的关系,ManyToManyField可以建在两个模型中的任意一个，自动创建第三张表,
这个第三张表orm告诉数据库生成后orm无法直接操作这个数据表，但是可以通过接口操作，这个接口就是生成多
对多关系的那个字段authors
#db_table是设置第三张表的表名，可以不设置
authors=models.ManyToManyField(to='Author',db_table='111')
转换为sql相当与
表名是自动拼接的
create table book_author(
id int primary key auto_increment,
book_id int,
author_id int,
foreign key (book_id) references book(id),
foreign key (author_id) references author(id),
)

注意事项：
表的名称是app名称_类名也就是表名，是根据 模型中的元数据自动生成的，也可以覆写为别的名称　　
id 字段是自动添加的
对于外键字段，Django 会在字段名上添加"_id" 来创建数据库中的列名
这个例子中的CREATE TABLE SQL 语句使用PostgreSQL 语法格式，要注意的是Django 会根据settings 中指定
的数据库类型来使用相应的SQL 语句。
定义好模型之后，你需要告诉Django _使用_这些模型。你要做的就是修改配置文件中的INSTALL_APPSZ中设置，
在其中添加models.py所在应用的名称。
外键字段 ForeignKey 有一个 null=True 的设置(它允许外键接受空值 NULL)，你可以赋给它空值 None 。

多表操作——-> 一对多添加记录

# 单表添加记录
from app01.models import *
def add(request):
# 在出版社表添加记录,返回值就是生成的记录对象
obj=Publish.objects.create(name="人民出版社"，email="123@123.com")
return HttpResponses('ok')
# 有绑定关系的表添加记录  一对多
# 方式一
# 在书籍表添加记录
book_obj=Book.objects.create(title="123"，price=100,publishDate="2012-12-13",publish_id=1)
# 方式二
pub_obj =Publish.objects.filter(nid=1).first()
book_obj = Book.objects.create(title="123"，price=100,publishDate="2012-12-13",publish=
pub_obj)
# create会将publish翻译成publish_id 将pub_obj的主键值取出来，组成publish_id=1
#book_obj.publish = pub_obj
方式一给publish_id传的值是1 方式二给publish传的值是一个对象
方式一在传值的时候会去找nid=1的那个出版社对象然后将这个对象赋值给publish_id，但是在取值的时候只有
方式二可以通过对象.的方式取值如：booj_obj.publish.email

多表操作——-> 多对多添加记录

# 给一本书添加多个作者
# 新增一本书的记录
book_obj = Book.objects.create(title="go",price=100,publishData="2013-13-13",)
# 从作者表里找两个作者
egon = Author.objects.get(name="egon")
alex = Author.objects.get(name="alex")
# 书籍表里的authors在原表里就是生成多对多表的实例对象，调用authors相当于操作多对多的表 ，表里面的记录是根据book_obj和alex以及egon的主键生成的
book_obj.authors.add(egon,alex)
#也就是给一本书增加了两个作者,在多对多表关系里也就是第三张表，用book_obj的主键与egon,alex的主键分别组成一条记录

解除多对多关系记录

# 找到nid为4 的那本书籍对象
book = Book.objects.filter(nid=4).first()
# 删除 book(主键为4） 与作者为 1的那条记录
book.authors.remove(1)
# 删除所有 book的记录也就是删除所有nid为4的那本书的记录
book.authors.clear()
# 获取与这本书关联的所有作者对象的集合 queryset类型的
book.authors.all()
# 查询主键为4的书籍的所有作者的名字
book.authors.all().values("name")
#重置主键为4的数据的所有作者的名字
book.authors.set([查询出来的作者对象，查询出来的作者对象])

基于对象的跨表查询——->一对多

根据模型管理器的关联字段查询，查询出来的是模型对象。
根据模型管理器的关联字段_id查询,查询出来的是具体的值
翻译成sql就是子查询的方式

查询 西游记 这本书出版社的名字
book_obj= Book.objects.filter(title="西游记").first()
book_obj.publish  # 这本书关联的出版社对象
book_obj.publish.name # 这本书关联的出版社的名字

正反向查询

A表关联B表，关联字段在A表中 A查找B就是 正向查询 按字段查找 如： 根据书籍查找出版社的名字 book_obj= Book.objects.filter(title="西游记").first() book_obj.publish book_obj.publish.name B查找A就是 反向查询 按表名_set 查找 或者用related_name='XX' 如：查询出版社出版过的书籍 pub = Publish.objects.filter(name="人民出版社").first() pub.book_set.all() #queryset对象 或 用一对多中一的模型对象.related_name字段的值也就是xx，就可以进行反向查询

基于对象的跨表查询——->多对多

book表和authors表是多对多关系 关联属性在book表里
正向查询按字段
如：查询西游记这本书的所有作者的名字
book_obj=Book.objects.filter(title="西游记").first()
author_List = book_obj.authors.all() # queryset类型
for i  in authors_list:
    print(i.name)
反向查询按表名_set
如： 查找alex这个作者出版过的所有书籍
alex = Authors.objects.fifter(name="alex").first()
book_list = alex.book_set.all()
for i in book_list:
    print(i.title)

基于对象的跨表查询——->一对一

作者表和作者详情表是一对一
正向查询按字段
如： 查找alex的手机号
alex = Authors.objects.fifter(name="alex").first()
alex.authordetail.telephone
反向查询按表名
如： 查询手机号为111的作者的年龄和名字
ad = AuthorDetail.objects.filter(telephone="111")
.first()
ad.author.name
ad.author.age

基于双下划线的跨表查询——->一对多

对应sql的联表查询 join查询

正向查询按字段 反向查找按表名用来告诉ORM引擎join哪张表
正向查询：
如：查询西游记这本书的出版社的名字
Book.object.filter(title='西游记').values("publish__name")
values里面放的就是建立关联关系的字段__后面跟需要显示的字段相当与join表的操作 
(values相当与sql的 select)
在查询西游记这本书的出版社的名字的时候首先拿到西游记这本书的对象也就是Book.object.filter(title=
'西游记')，然后查询的是出版社的名字因为出版社不在book表里所以要联表也就是.values("publish__name")
，为什么联表操作要放在values里面是因为要查询的也就是要显示的出版社的名字在book里没有，
反向查询：
如：查询哪个出版社出版过西游记这本书
Publish.objects.filter(book__title="西游记").valuse("name")
filter里面是告诉orm join连接book表，查找的是（__title）等于西游记的 (filter相当于sql的while) 
在查询哪个出版社出版过西游记这本书时候首先要找到出版过西游记这本书的出版社的对象，那我们就需要过滤
也就是Publish.objects.filter(book__title="西游记")，为什么此时联表操作放在filter()里面，
因为在找西游记这本书的时候在出版社表里面找不到，而我们又需要以此作为条件进行过滤所以放在filter()
里面，然后显示出版社的名字.valuse("name")
基于双下划线的跨表查询__联表的语法是可以灵活使用的，不是固定的放在某个参数里面
也可以理解为  正向查询的时候一般是需要查询被关联表里的字段，过滤条件当前表的字段就可以满足，但是显示
的时候当前表的字段是没有的所以要把联表操作放到values()里面

基于双下划线的跨表查询——->多对多

查询西游记这本书的所有作者的名字，一本书有多个作者，一个作者可以写多本书
select app01_author.name  from app01_book inner join app01_book_authors on app01_book.nid =
app01_book_authors.book_id inner join app01_author on app01_book_authors.author_id = 
app01_author.nid where app01_book.title ="西游记"
正向查询：
# 通过book表join与其关联的author表
# 按照字段authors通知orm引擎join book_authors表与authors，因为两个表都是借助第三张表来关联关系的
，第三张表是authors字段生成的所以用authors字段来查询
Book.objects.filter(title="西游记").values("authors__name")
反向查询：
查询哪些作者写过西游记
通过Authors表join与其关联的Book表
# 按照表名book通知orm引擎join book_authors 和 book 表
Authors.objects.filter(book__title="西游记").values("name")

基于双下划线的跨表查询——->一对一

查询alex的手机号，作者表里的一条记录只能对应作者详情表的一条记录反之也是
正向查询：
Authors_objects.filter(name="alex").vlaues("authorsdetail__telphone")
# 查询alex的手机号filter(name="alex")是过滤，__telphone是显示手机号，authorsdetail是因为alex的
手机号不在authors表里，通过authorsdetai字段与authorsdetai表进行链表
反向查询：
# 查询手机号是属于alex的
# 通过authorsdetail表join与其关联的authors表
AuthorDetail.objects.filter(author_name="alex").values("telephone")

基于双下划线的跨表查询——->连续跨表

查询手机号以151开头的作者出版过的所有的书籍名称以及出版社名称
正向查询：
# 通过book表join authordetail表，book表与authordetail无关联，所以要连续跨表 ，通过authors表进
行跨表
Book.objects.filter(authors__authordetail __telephone__startswitch="151").values("title",
"publish__name")
反向查询：
Author.objects.filter(authordetail__telephone__startswitch="151").values("book__title",
 "book__publish__name ")
1.确定那个是基表
2.两个表之间是否有关系
3.没关系跨表 
4.有关系的话，判断是正向还是反向

聚合查询

查询所有书籍的平均价格
select avg(price) from book
from django.db.models import Avg,Max,Min,Count
Book.objects.all().aggregate(avg12=Avg("price"))
# aggregate（）是聚合统计函数 ，返回值是一个字典{"price__avg":151}
# 不加名称的时候自动拼接做为字典的键，也可以起名，avg12就是起的名字

单表下的分组查询

QuerySet对象.annotate()
查询每一个部门名称以及对应的员工数
select count(id) from 员工表 group by(部门字段)
查询每一个部门的名称以及员工的平均薪资
select dep,avg(salary) from emp group by dep
from django.db.models import Avg,Max,Min,Count
Emp.objects.values("dep").annotate(avg("salary"))
# annotate是分组统计函数 ,values里放分组的字段,语法是固定的
# 也就是.annotate前面select的字段是那个，就按照哪个字段分组
#Emp.objects.values("dep")，相当于select dep
# annotate()返回值是queryset类型<queryset[{'avg_salary':5000,'dep':教学部}]，
{'avg_salary':6000,'dep':管理部}>

多表下的分组查询

# 查询每个出版社的名称以及出版的书籍个数
# 一对多关系  一本书只能被一个出版社出版，一个出版社可以出多本书
select publish.name,count("title") from book inner join Publish on book.publish_id =
publish.id group by publish.id
Publish.object.values("name").annotate(count("book__title"))
Publish.object.values("nid").annotate(c=count("book__title")).values("name","c") 
# 如果不加.values("name","c") 默认显示nid字段和c字段，加上后就不显示nid和c了显示 name和c ,
values里面可以放的字段有表模型的所有字段以及统计的字段

# 查询每一个作者的名字以及出版过的书籍的最高价格
# 多对多关系  一本书有多个作者 一个作者写多本书
select max(book.price),author.name  from book inner join book_authors on book.nid =
book_authoes.book_id inner join author on author.nid = book_author.author_id
group by author.nid 
Authors.objects.values("nid").annotate(c=Max("book__price")).values("name",c)

# 查询每一个书籍的名称以及对应作者的个数
select Book.title,count(author.name)  from book inner join book_authors on book.nid =
book_authoes.book_id inner join author on author.nid = book_author.author_id
group by Book.nid
Book.objects.values("pk").annotate(c=count("authors__name")).values("title","c")
# pk是主键的意思

跨表分组查询的语法模型
每一个后的表模型.objects.values("分组字段").annotate(聚合函数(关联表__统计字段)).values
("表模型的所有字段，以及统计字段")

F查询与Q查询

#两个属性比较的时候使用F函数
# 查询阅读数大于阅读数的书籍
from django.db.models import F
Book.objects.filter(comment_num__gt=F("red_num"))
# 将所有书籍的价格提高10元
Book.objects.all().update(price=F("price")+10)
#查询书籍名称叫红楼梦的且价格等于101的
Book.objects.filter(title="红楼梦"，price=100)
#多个过滤器逐个调用表示逻辑与关系，同sql语句中where部分的and关键字。
from django.db.models import Q
#查询书籍名称叫红楼梦的或价格等于101的
Q里面是两个条件，条件之间是且就用&连接，或就是|连接  
Book.objects.filter(Q(title="红楼梦") | Q(price=100))
# ~Q(title="红楼梦")  title不等于红楼梦的
Book.objects.filter(Q(title="红楼梦") | Q(price=100),comment_num__gt=F("red_num")) 
#多个条件时把Q条件放在前面

批量插入数据

from  .models import Book
book_list = []
for i in range(100):
    book =Book(title="book_%s"%i,price=i*i)#实例化一个对象此时和数据库操作还没关系
    book_list.append(book)
Book.objects.bulk_create(book_list)
# 将多条数据写入到数据库相当于一条insert语句后面跟多条记录

orm进阶

queryset特性

• 可切片

使用python的切片语法来限制查询集记录的数目，等同于sql的limit和offset语法
不支持负的索引，通常，查询集 的切片返回一个新的查询集 —— 它不会执行查询

BOOK.objects.all()[:5]   # (LIMIT 5)
BOOK.objects.all()[5:10]    # (OFFSET 5 LIMIT 5)

• 可迭代 ```python articleList=models.Article.objects.all()

for article in articleList: print(article.title)

- **惰性查询**
查询集 是惰性执行的 —— 创建`查询集`不会带来任何数据库的访问。你可以将过滤器保持一整天，直到`查询集` 需要求值时，Django 才会真正运行这个查询
 一般来说，只有在请求，查询集 的结果时才会到数据库中去获取它们。当你确实需要结果时，查询集通过访问数据库来求值。 
```python
queryResult=models.Article.objects.all() # 未命中数据库
print(queryResult) # 命中数据库
for article in queryResult:
    print(article.title)    # 命中数据库

• 缓存机制

每个查询集都包含一个缓存来最小化对数据库的访问。理解它是如何工作的将让你编写最高效的代码。
在一个新创建的查询集中，缓存为空。首次对查询集进行求值 —— 同时发生数据库查询 ——Django 将保存查询的结果到查询集的缓存中并返回明确请求的结果（例如，如果正在迭代查询集，则返回下一个结果）。接下来对该查询集 的求值将重用缓存的结果。
请牢记这个缓存行为，因为对查询集使用不当的话，它会坑你的。例如，下面的语句创建两个查询集，对它们求值，然后扔掉它们：

queryset = Book.objects.all()
print(queryset) # 命中数据库
print(queryset) # 命中数据库
注：简单地打印查询集不会填充缓存。
这意味着相同的数据库查询将执行两次，显然倍增了你的数据库负载。同时，还有可能两个结果列表并不包含相同的数据库记录，因为在两次请求期间有可能有Article被添加进来或删除掉。为了避免这个问题，只需保存`查询集`并重新使用它：

queryset = Book.objects.all()
ret = [i for i in queryset] # 命中数据库
print(queryset) # 使用缓存
print(queryset) # 使用缓存

查询集什么时候才会被缓存？

• 遍历queryset时
• if语句（为了避免这个，可以用exists()方法来检查是否有数据）

所以单独queryset的索引或者切片都不会缓存。

queryset = Book.objects.all()
one = queryset[0] # 命中数据库
two = queryset[1] # 命中数据库
print(one)
print(two)

• exists()与iterator()方法

exists()
简单的使用if语句进行判断也会完全执行整个queryset并且把数据放入cache，虽然你并不需要这些 数据！为了避免这个，可以用exists()方法来检查是否有数据：

if queryResult.exists():
    #SELECT (1) AS "a" FROM "blog_article" LIMIT 1; args=()
        print("exists...")

iterator()
当queryset非常巨大时，cache会成为问题。
处理成千上万的记录时，将它们一次装入内存是很浪费的。更糟糕的是，巨大的queryset可能会锁住系统 进程，让你的程序濒临崩溃。要避免在遍历数据的同时产生queryset cache，可以使用iterator()方法 来获取数据，处理完数据就将其丢弃。

objs = Book.objects.all().iterator()
# iterator()可以一次只从数据库获取少量数据，这样可以节省内存
for obj in objs:
    print(obj.title)
#BUT,再次遍历没有打印,因为迭代器已经在上一次遍历(next)到最后一次了,没得遍历了
for obj in objs:
    print(obj.title)
相当于生成器

当然，使用iterator()方法来防止生成cache，意味着遍历同一个queryset时会重复执行查询。所以使 #用iterator()的时候要当心，确保你的代码在操作一个大的queryset时没有重复执行查询。
queryset的cache是用于减少程序对数据库的查询，在通常的使用下会保证只有在需要的时候才会查询数据库。 使用exists()和iterator()方法可以优化程序对内存的使用。不过，由于它们并不会生成queryset cache，可能 会造成额外的数据库查询。
总结:在使用缓存机制还是生成器机制的选择上如果是，数据量大情况主要使用生成器；数据少使用次数多的情况使用缓存机制。

中介模型

处理类似搭配 配料 和 披萨 这样简单的多对多关系时，使用标准的ManyToManyField 就可以了。但是，有时你可能需要关联数据到两个模型之间的关系上。
例如，有这样一个应用，它记录音乐家所属的音乐小组。我们可以用一个ManyToManyField 表示小组和成员之间的多对多关系。但是，有时你可能想知道更多成员关系的细节，比如成员是何时加入小组的。
对于这些情况，Django 允许你指定一个中介模型来定义多对多关系。 你可以将其他字段放在中介模型里面。源模型的ManyToManyField 字段将使用through 参数指向中介模型。对于上面的音乐小组的例子，代码如下：
也就是多对多关系的时候不自动生成第三张表，而是使用自己定义的表作为第三张表，第三张表中的字段自己定义，并且要注意外键的关系

from django.db import models
class Person(models.Model):#音乐家模型类
    name = models.CharField(max_length=128)
    def __str__(self):              
        return self.name
class Group(models.Model): #音乐组模型类
    name = models.CharField(max_length=128)
    members = models.ManyToManyField(Person, through='Membership')
    def __str__(self):            
        return self.name
class Membership(models.Model):#关联的模型类，也就是自定义的中介模型
    person = models.ForeignKey(Person,on_delete=models.CASCADE)
    group = models.ForeignKey(Group,on_delete=models.CASCADE)
    date_joined = models.DateField()
    invite_reason = models.CharField(max_length=64)

既然你已经设置好ManyToManyField 来使用中介模型（在这个例子中就是Membership），接下来你要开始创建多对多关系。也就是添加记录，要做的就是创建中介模型的实例用实例进行关系的添加，而不是通过多对对字段进行关系的添加（此处的多对多字段是group表中的members），因为通过字段我们只能添加组和人的关系，没法添加中介表中的date_joined和invite_reason字段

ringo = Person.objects.create(name="Ringo Starr") # 添加一个音乐家
paul = Person.objects.create(name="Paul McCartney") # 添加一个音乐家
beatles = Group.objects.create(name="The Beatles") #添加一个组
m1 = Membership(person=ringo, group=beatles,
    date_joined=date(1962, 8, 16),
    invite_reason="Needed a new drummer.") #通过中介表进行记录的添加，而不是多对多的字段
m1.save()
beatles.members.all() #查询beatles这个组下的所有的人
[<Person: Ringo Starr>]
ringo.group_set.all() #查询ringo这个人所在的组
[<Group: The Beatles>]
m2 = Membership.objects.create(person=paul, group=beatles,
date_joined=date(1960, 8, 1),
invite_reason="Wanted to form a band.") # 添加记录
m2.save()
beatles.members.all() # 查询beatles这个组下的所有的人
[<Person: Ringo Starr>, <Person: Paul McCartney>]

中介模型与普通的多对多字段不同，你不能使用多对多字段的add、 create和赋值语句（比如，beatles.members = […]）来创建关系。

#这个不行
beatles.members.add(john)
#这个不行
beatles.members.create(name="George Harrison")
#这个不行
beatles.members = [john, paul, ringo, george]

为什么不能这样做？ 这是因为你不能只创建 Person和 Group之间的关联关系，你还要指定 Membership模型中所需要的所有信息；而简单的add、create 和赋值语句是做不到这一点的。所以它们不能在使用中介模型的多对多关系中使用。此时，唯一的办法就是创建中介模型的实例。

remove()方法被禁用也是出于同样的原因。但是clear() 方法却是可用的。它可以清空某个实例所有的多对多关系：

#清除中介表中beatles组所对应的关系
beatles.members.clear()

数据库表反向生成模型类

众所周知，Django较为适合原生开发，即通过该框架搭建一个全新的项目，通过在修改models.py来创建新的数据库表。但是往往有时候，我们需要利用到之前的已经设计好的数据库，数据库中提供了设计好的多种表单。那么这时如果我们再通过models.py再来设计就会浪费很多的时间。所幸Django为我们提供了inspecdb的方法。他的作用即使根据已经存在对的mysql数据库表来反向映射结构到models.py中.

我们在展示django ORM反向生成之前，我们先说一下怎么样正向生成代码。

• 正向生成，指的是先创建model.py文件，然后通过django内置的编译器，在数据库如mysql中创建出符合model.py的表。
• 反向生成，指的是先在数据库中create table，然后通过django内置的编译器，生成model代码。

  python manage.py inspectdb > models文件名

  查询优化

1. select_related()

对于一对一字段（OneToOneField）和外键字段（ForeignKey），可以使用select_related 来对QuerySet进行优化。

select_related 返回一个QuerySet，当执行它的查询时它沿着外键关系查询关联的对象的数据。它会生成一个复杂的查询并引起性能的损耗，但是在以后使用外键关系时将不需要数据库查询。

简单说，在对QuerySet使用select_related()函数后，Django会获取相应外键对应的对象，从而在之后需要的时候不必再查询数据库了。

下面的例子解释了普通查询和select_related() 查询的区别。
查询id=2的的书籍的出版社名称,下面是一个标准的查询：

# 命中数据库
book= models.Book.objects.get(nid=2)
# 再次命中数据库
print(book.publish.name)

使用select_related()

#相当与join表后的结果，再次使用books后就不需要取数据库查询了，而是使用join起来的这个大表
books=models.Book.objects.select_related("publish").all()
for book in books:
     #  不会命中数据库
     #  因为已经在上一个查询中进行了预填充
     print(book.publish.name)

• 多外键查询

就是使用表中的多个一对一或外键关联字段进行join
这是针对publish的外键查询，如果是另外一个外键呢？让我们一起看下：

book=models.Book.objects.select_related("publish").get(nid=1)
print(book.authors.all())

观察logging结果，发现依然需要查询两次，所以需要改为：

book=models.Book.objects.select_related("publish","").get(nid=1)
print(book.publish)

或者：

book=models.Article.objects
　　　　　　　　　　　　　.select_related("publish")
　　　　　　　　　　　　　.select_related("")
　　　　　　　　　　　　　.get(nid=1)  # django 1.7 支持链式操作
print(book.publish)

1. prefetch_related()

对于多对多字段（ManyToManyField）和一对多字段，可以使用prefetch_related()来进行优化。

prefetch_related()和select_related()的设计目的很相似，都是为了减少SQL查询的数量，但是实现的方式不一样。select_related()是通过JOIN语句，在SQL查询内解决问题。但是对于多对多关系，使用SQL语句解决就显得有些不太明智，因为JOIN得到的表将会很长，会导致SQL语句运行时间的增加和内存占用的增加。若有n个对象，每个对象的多对多字段对应Mi条，就会生成Σ(n)Mi 行的结果表。

prefetch_related()的解决方法是，分别查询每个表，然后用Python处理他们之间的关系。

# 查询所有文章关联的所有标签
books=models.Book.objects.all()
for book in books:
      print(book.authors.all())  #4篇文章: 命中数据库 5次
#先去数据库seclect * from book 表
#每执行一次循环就去join一次authors表

改为prefetch_related：

# 查询所有文章关联的所有标签
books=models.Book.objects.prefetch_related("authors").all()
for book in books:
      print(book.authors.all())  #4篇文章: 命中数据库 2次
#Book.objects.prefetch_related("authors")就是 将book表和authors表join在一起
#再循环的时候就不会去数据库查询了
#两次 是 一次是查询book数据的 另一次是join表的

1. extra()

   extra(select=None, where=None, params=None, 
      tables=None, order_by=None, select_params=None)

   有些情况下，Django的查询语法难以简单的表达复杂的 WHERE 子句，对于这种情况, Django 提供了 extra()，QuerySet修改机制 — 它能在 QuerySet生成的SQL从句中注入新子句
   extra可以指定一个或多个 参数,例如 select, where or tables. 这些参数都不是必须的，但是你至少要使用一个!要注意这些额外的方式对不同的数据库引擎可能存在移植性问题.(因为你在显式的书写SQL语句),除非万不得已,尽量避免这样。

• 参数之select

The select 参数可以让你在 SELECT 从句中添加其他字段信息，它应该是一个字典，存放着属性名到 SQL 从句的映射。

queryResult=models.Article.objects.extra(select={'is_recent': "create_time > '2017-09-05'"})
#is_recent是自定义的名字，create_time是数据中的字段，> '2017-09-05'是条件。查询create_time > '2017-09-05'的数据
此时queryResult可以.is_recent

结果集中每个 Entry 对象都有一个额外的属性is_recent, 它是一个布尔值，表示 Article对象的create_time 是否晚于2017-09-05.

• 参数之where / tables

您可以使用where定义显式SQL WHERE子句 - 也许执行非显式连接。您可以使用tables手动将表添加到SQL FROM子句。
where和tables都接受字符串列表。所有where参数均为“与”任何其他搜索条件。
举例来讲：

queryResult=models.Article.objects.extra(where=['nid in (3，4) OR title like "py%" ','nid>2'])

Ajax请求

客户端（浏览器）向服务端发起请求的形式：

1. 地址栏：GET
2. 超链接标签：GET
3. form表单：GET或POST
4. Ajax（重要）：GET或POST或PUT或DELETE

Ajax (Asynchoronous Javascript And Xml) 异步javascript和xml，就是使用javascript语言与服务器
进行异步交互传输的数据为xml现在更多使用json数据
Ajax支持get请求和post请求
同步交互：客户端发出一个请求后需要等待服务器响应结束后，才能发出第二个请求
异步交互：客户端发出一个请求后无需等待服务器响应结束就可以发出第二个请求
Ajax除了异步的特点外还有一个特点就是游览器页面局部刷新（可以让用户无感知的完成请求和响应过程 ）

Ajax简单实现

基于juqer实现
<script src="jQuery cdn"></script>
<button class="Ajax">Ajax</button>
<script>
$(".ajax").click(
    function(){
        //发送Ajax请求
        $.ajax(
            {url:"请求URL",
            type:"请求方式",
            data:{"123":1,'456':2} # 发送到请求url的数据
            success:function(data){ #回调函数  data接收的是响应的数据
                console.log(data)
            }
            }
        )
    }
)
</script>