Django框架_URLconf、Views、template、ORM

时间 2019-11-12

标签 django 框架 urlconf views template orm 栏目 Python 繁體版

原文原文链接

MTV模型

Django的MTV分别表明：css

Model(模型)：负责业务对象与数据库的对象(ORM)html

Template(模版)：负责如何把页面展现给用户python

View(视图)：负责业务逻辑，并在适当的时候调用Model和Templatejquery

此外，Django还有一个urls分发器，它的做用是将一个个URL的页面请求分发给不一样的view处理，view再调用相应的Model和Templatenginx

Django基本命令

一、下载Django：

pip3 install django

二、建立一个django project

django-admin.py startproject mysite

当前目录下会生成mysite的工程，目录结构以下：git

manage.py ----- Django项目里面的工具，经过它能够调用django shell和数据库等。
settings.py ---- 包含了项目的默认设置，包括数据库信息，调试标志以及其余一些工做的变量。
urls.py ----- 负责把URL模式映射到应用程序。

三、在mysite目录下建立应用

python manage.py startapp blog

四、启动django项目

python manage.py runserver 8080

这样咱们的django就启动起来了！当咱们访问：http://127.0.0.1:8080/时就能够看到：程序员

五、同步更改数据库表或字段

'''
    python manage.py syncdb
     
    注意：Django 1.7.1 及以上的版本须要用如下命令
    python manage.py makemigrations
    python manage.py migrate
    
'''

这种方法能够建立表，当你在models.py中新增了类时，运行它就能够自动在数据库中建立表了，不用手动建立。web

六、清空数据库

python manage.py flush

此命令会询问是 yes 仍是 no, 选择 yes 会把数据所有清空掉，只留下空表。正则表达式

七、建立超级管理员

'''
    python manage.py createsuperuser
     
    # 按照提示输入用户名和对应的密码就行了邮箱能够留空，用户名和密码必填
     
    # 修改 用户密码能够用：
    python manage.py changepassword username
    
'''

八、Django 项目环境终端

python manage.py shell

这个命令和直接运行 python 进入 shell 的区别是：你能够在这个 shell 里面调用当前项目的 models.py 中的 API，对于操做数据的测试很是方便。sql

九、Django 项目环境终端

ython manage.py dbshell

Django 会自动进入在settings.py中设置的数据库，若是是 MySQL 或 postgreSQL,会要求输入数据库用户密码。

在这个终端能够执行数据库的SQL语句。若是您对SQL比较熟悉，可能喜欢这种方式。

十、更多命令

python manage.py

查看全部的命令，忘记子名称的时候特别有用。

11 静态文件配置

概述：

     静态文件交由Web服务器处理，Django自己不处理静态文件。简单的处理逻辑以下(以nginx为例)：

              URI请求-----> 按照Web服务器里面的配置规则先处理，以nginx为例，主要求配置在nginx.
                             conf里的location

                         |---------->若是是静态文件，则由nginx直接处理

                         |---------->若是不是则交由Django处理，Django根据urls.py里面的规则进行匹配

    以上是部署到Web服务器后的处理方式，为了便于开发，Django提供了在开发环境的对静态文件的处理机制，方法是这样：

static配置：

STATIC主要指的是如css,js,images这样文件：

STATIC_URL = '/static/'      # 别名
STATICFILES_DIRS = (
            os.path.join(BASE_DIR,"static"),  #实际名 ,即实际文件夹的名字
        )

'''

注意点1:
 django对引用名和实际名进行映射,引用时,只能按照引用名来,不能按实际名去找
        <script src="/statics/jquery-3.1.1.js"></script>
        ------error－－－－－不能直接用，必须用STATIC_URL = '/static/':
        <script src="/static/jquery-3.1.1.js"></script>

注意点2:
 STATICFILES_DIRS = (
    ("app01",os.path.join(BASE_DIR, "app01/statics")),
        )

 <script src="/static/app01/jquery.js"></script>

'''

have a try：

http://127.0.0.1:8000/static/jquery.js

media配置：

# in settings:

MEDIA_URL="/media/"
MEDIA_ROOT=os.path.join(BASE_DIR,"app01","media","upload")

# in urls:
from django.views.static import serve
url(r'^media/(?P<path>.*)$', serve, {'document_root': settings.MEDIA_ROOT}),

have a try:

http://127.0.0.1:8000/media/1.png

        '''
        静态文件的处理又包括STATIC和MEDIA两类，这每每容易混淆，在Django里面是这样定义的：
        
        MEDIA:指用户上传的文件，好比在Model里面的FileFIeld，ImageField上传的文件。若是你定义
        
        MEDIA_ROOT=c:\temp\media，那么File=models.FileField(upload_to="abc/")＃，上传的文件就会被保存到c:\temp\media\abc

        eg：
            class blog(models.Model):
                   Title=models.charField(max_length=64)
                   Photo=models.ImageField(upload_to="photo")
          上传的图片就上传到c:\temp\media\photo，而在模板中要显示该文件，则在这样写
          在settings里面设置的MEDIA_ROOT必须是本地路径的绝对路径，通常是这样写:
                 BASE_DIR= os.path.abspath(os.path.dirname(__file__))
                 MEDIA_ROOT=os.path.join(BASE_DIR,'media/').replace('\\','/')

        MEDIA_URL是指从浏览器访问时的地址前缀，举个例子：
            MEDIA_ROOT=c:\temp\media\photo
            MEDIA_URL="/data/"
        在开发阶段,media的处理由django处理：

           访问http://localhost/data/abc/a.png就是访问c:\temp\media\photo\abc\a.png

           在模板里面这样写<img src="/media/abc/a.png">

           在部署阶段最大的不一样在于你必须让web服务器来处理media文件，所以你必须在web服务器中配置，
           以便能让web服务器能访问media文件
           以nginx为例，能够在nginx.conf里面这样：

                 location ~/media/{
                       root/temp/
                       break;
                    }

           具体能够参考如何在nginx部署django的资料。
           
           
           '''

View Code

视图层之路由配置系统(views)

URL配置(URLconf)就像Django 所支撑网站的目录。它的本质是URL与要为该URL调用的视图函数之间的映射表；你就是以这种方式告诉Django，对于这个URL调用这段代码，对于那个URL调用那段代码。

    '''
 
 urlpatterns = [
 url(正则表达式, views视图函数，参数，别名),
]


参数说明：

 一个正则表达式字符串
 一个可调用对象，一般为一个视图函数或一个指定视图函数路径的字符串
 可选的要传递给视图函数的默认参数（字典形式）
 一个可选的name参数

 '''

2.1 URLconf的正则字符串参数

2.1.1 简单配置

from django.conf.urls import url

from . import views

urlpatterns = [
    url(r'^articles/2003/$', views.special_case_2003),
    url(r'^articles/([0-9]{4})/$', views.year_archive),
    url(r'^articles/([0-9]{4})/([0-9]{2})/$', views.month_archive),
    url(r'^articles/([0-9]{4})/([0-9]{2})/([0-9]+)/$', views.article_detail),
]

    '''
    NOTE:
    1 一旦匹配成功则再也不继续
    2 若要从URL 中捕获一个值，只须要在它周围放置一对圆括号。
    3 不须要添加一个前导的反斜杠，由于每一个URL 都有。例如，应该是^articles 而不是 ^/articles。
    4 每一个正则表达式前面的'r' 是可选的可是建议加上。

一些请求的例子：

    /articles/2005/3/ 不匹配任何URL 模式，由于列表中的第三个模式要求月份应该是两个数字。
    /articles/2003/ 将匹配列表中的第一个模式不是第二个，由于模式按顺序匹配，第一个会首先测试是否匹配。
    /articles/2005/03/ 请求将匹配列表中的第三个模式。Django 将调用函数
                       views.month_archive(request, '2005', '03')。
    '''

#设置项是否开启URL访问地址后面不为/跳转至带有/的路径
APPEND_SLASH=True

SLASH

2.1.2 有名分组(named group)

上面的示例使用简单的、没有命名的正则表达式组（经过圆括号）来捕获URL 中的值并以位置参数传递给视图。在更高级的用法中，可使用命名的正则表达式组来捕获URL 中的值并以关键字参数传递给视图。

在Python 正则表达式中，命名正则表达式组的语法是(?P<name>pattern)，其中name 是组的名称，pattern 是要匹配的模式。

下面是以上URLconf 使用命名组的重写：

from django.conf.urls import url

from . import views

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

这个实现与前面的示例彻底相同，只有一个细微的差异：捕获的值做为关键字参数而不是位置参数传递给视图函数。例如：

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

在实际应用中，这意味你的URLconf 会更加明晰且不容易产生参数顺序问题的错误 —— 你能够在你的视图函数定义中从新安排参数的顺序。固然，这些好处是以简洁为代价；有些开发人员认为命名组语法丑陋而繁琐。

2.1.3 URLconf 在什么上查找

URLconf 在请求的URL 上查找，将它当作一个普通的Python 字符串。不包括GET和POST参数以及域名。

例如，http://www.example.com/myapp/ 请求中，URLconf 将查找myapp/。

在http://www.example.com/myapp/?page=3 请求中，URLconf 仍将查找myapp/。

URLconf 不检查请求的方法。换句话讲，全部的请求方法 —— 同一个URL的POST、GET、HEAD等等 —— 都将路由到相同的函数。

2.1.4 捕获的参数永远是字符串

每一个捕获的参数都做为一个普通的Python 字符串传递给视图，不管正则表达式使用的是什么匹配方式。例如，下面这行URLconf 中：

url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),

views.year_archive() 的year 参数将是一个字符串

2.1.5 指定视图参数的默认值

有一个方便的小技巧是指定视图参数的默认值。下面是一个URLconf 和视图的示例：

# URLconf
from django.conf.urls import url

from . import views

urlpatterns = [
    url(r'^blog/$', views.page),
    url(r'^blog/page(?P<num>[0-9]+)/$', views.page),
]

# View (in blog/views.py)
def page(request, num="1"):

    ...

在上面的例子中，两个URL模式指向同一个视图views.page —— 可是第一个模式不会从URL 中捕获任何值。若是第一个模式匹配，page() 函数将使用num参数的默认值"1"。若是第二个模式匹配，page() 将使用正则表达式捕获的num 值。

2.1.6 Including other URLconfs

#At any point, your urlpatterns can “include” other URLconf modules. This
#essentially “roots” a set of URLs below other ones.

#For example, here’s an excerpt of the URLconf for the Django website itself.
#It includes a number of other URLconfs:


from django.conf.urls import include, url

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

2.2 传递额外的选项给视图函数(了解)

URLconfs 具备一个钩子，让你传递一个Python 字典做为额外的参数传递给视图函数。

django.conf.urls.url() 函数能够接收一个可选的第三个参数，它是一个字典，表示想要传递给视图函数的额外关键字参数。

例如：

from django.conf.urls import url
from . import views

urlpatterns = [
    url(r'^blog/(?P<year>[0-9]{4})/$', views.year_archive, {'foo': 'bar'}),
]

在这个例子中，对于/blog/2005/请求，Django 将调用views.year_archive(request, year='2005', foo='bar')。

这个技术在Syndication 框架中使用，来传递元数据和选项给视图。

2.3 URL 的反向解析

在使用Django 项目时，一个常见的需求是得到URL 的最终形式，以用于嵌入到生成的内容中（视图中和显示给用户的URL等）或者用于处理服务器端的导航（重定向等）。

人们强烈但愿不要硬编码这些URL（费力、不可扩展且容易产生错误）或者设计一种与URLconf 绝不相关的专门的URL 生成机制，由于这样容易致使必定程度上产生过时的URL。

换句话讲，须要的是一个DRY 机制。除了其它有点，它还容许设计的URL 能够自动更新而不用遍历项目的源代码来搜索并替换过时的URL。

获取一个URL 最开始想到的信息是处理它视图的标识（例如名字），查找正确的URL 的其它必要的信息有视图参数的类型（位置参数、关键字参数）和值。

Django 提供一个办法是让URL 映射是URL 设计惟一的地方。你填充你的URLconf，而后能够双向使用它：

根据用户/浏览器发起的URL 请求，它调用正确的Django 视图，并从URL 中提取它的参数须要的值。
根据Django 视图的标识和将要传递给它的参数的值，获取与之关联的URL。

第一种方式是咱们在前面的章节中一直讨论的用法。第二种方式叫作反向解析URL、反向URL 匹配、反向URL 查询或者简单的URL 反查。

在须要URL 的地方，对于不一样层级，Django 提供不一样的工具用于URL 反查：

在模板中：使用url 模板标签。
在Python 代码中：使用django.core.urlresolvers.reverse() 函数。
在更高层的与处理Django 模型实例相关的代码中：使用get_absolute_url() 方法。

例子：

考虑下面的URLconf：

from django.conf.urls import url

from . import views

urlpatterns = [
    #...
    url(r'^articles/([0-9]{4})/$', views.year_archive, name='news-year-archive'),
    #...
]

根据这里的设计，某一年nnnn对应的归档的URL是/articles/nnnn/。

你能够在模板的代码中使用下面的方法得到它们：

<a href="{% url 'news-year-archive' 2012 %}">2012 Archive</a>

<ul>
{% for yearvar in year_list %}
<li><a href="{% url 'news-year-archive' yearvar %}">{{ yearvar }} Archive</a></li>
{% endfor %}
</ul>

在Python 代码中，这样使用：

from django.core.urlresolvers import reverse
from django.http import HttpResponseRedirect

def redirect_to_year(request):
    # ...
    year = 2006
    # ...
    return HttpResponseRedirect(reverse('news-year-archive', args=(year,)))

若是出于某种缘由决定按年归档文章发布的URL应该调整一下，那么你将只须要修改URLconf 中的内容。

在某些场景中，一个视图是通用的，因此在URL 和视图之间存在多对一的关系。对于这些状况，当反查URL 时，只有视图的名字还不够。

2.4 命名URL 模式

为了完成上面例子中的URL 反查，你将须要使用命名的URL 模式。URL 的名称使用的字符串能够包含任何你喜欢的字符。不仅限制在合法的Python 名称。

当命名你的URL 模式时，请确保使用的名称不会与其它应用中名称冲突。若是你的URL 模式叫作comment，而另一个应用中也有一个一样的名称，当你在模板中使用这个名称的时候不能保证将插入哪一个URL。

在URL 名称中加上一个前缀，好比应用的名称，将减小冲突的可能。咱们建议使用myapp-comment 而不是comment。

2.5 CBV

url(r'^login.html$', views.Login.as_view()),

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
from django.views import View
class Login(View):
    
    def dispatch(self, request, *args, **kwargs):
        print('before')
        obj = super(Login,self).dispatch(request, *args, **kwargs)
        print('after')
        return obj

    def get(self,request):
       
        return render(request,'login.html')

    def post(self,request):
        print(request.POST.get('user'))
        return HttpResponse('Login.post')

d视图层之视图函数(views)

一个视图函数，简称视图，是一个简单的Python 函数，它接受Web请求而且返回Web响应。响应能够是一张网页的HTML内容，一个重定向，一个404错误，一个XML文档，或者一张图片. . . 是任何东西均可以。不管视图自己包含什么逻辑，都要返回响应。代码写在哪里也无所谓，只要它在你的Python目录下面。除此以外没有更多的要求了——能够说“没有什么神奇的地方”。为了将代码放在某处，约定是将视图放置在项目或应用程序目录中的名为views.py的文件中。

一个简单的视图

下面是一个返回当前日期和时间做为HTML文档的视图：

from django.http import HttpResponse
import datetime

def current_datetime(request):
    now = datetime.datetime.now()
    html = "<html><body>It is now %s.</body></html>" % now
    return HttpResponse(html)

让咱们逐行阅读上面的代码：

首先，咱们从 django.http模块导入了HttpResponse类，以及Python的datetime库。
接着，咱们定义了current_datetime函数。它就是视图函数。每一个视图函数都使用HttpRequest对象做为第一个参数，而且一般称之为request。

注意,视图函数的名称并不重要；不须要用一个统一的命名方式来命名，以便让Django识别它。咱们将其命名为current_datetime，是由于这个名称可以精确地反映出它的功能。
这个视图会返回一个HttpResponse对象，其中包含生成的响应。每一个视图函数都负责返回一个HttpResponse对象。

HttpRequest对象

属性：

'''
path：       请求页面的全路径，不包括域名

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

               if  req.method=="GET":

                         do_something()

               elif req.method=="POST":

                         do_something_else()

GET:         包含全部HTTP GET参数的类字典对象

POST：       包含全部HTTP POST参数的类字典对象

COOKIES:     包含全部cookies的标准Python字典对象；keys和values都是字符串。

FILES：      包含全部上传文件的类字典对象；FILES中的每个Key都是<input type="file" name="" />标签中
             name属性的值，FILES中的每个value同时也是一个标准的python字典对象，包含下面三个Keys：

             filename：      上传文件名，用字符串表示
             content_type:   上传文件的Content Type
             content：       上传文件的原始内容


user：       是一个django.contrib.auth.models.User对象，表明当前登录的用户。若是访问用户当前
             没有登录，user将被初始化为django.contrib.auth.models.AnonymousUser的实例。你
             能够经过user的is_authenticated()方法来辨别用户是否登录：
             if req.user.is_authenticated();只有激活Django中的AuthenticationMiddleware
             时该属性才可用

session：    惟一可读写的属性，表明当前会话的字典对象；本身有激活Django中的session支持时该属性才可用。

'''

方法：

get_full_path()

注意：键值对的值是多个的时候,好比checkbox类型的input标签，select标签，须要用：

request.POST.getlist("hobby")

render 函数

render(request, template_name[, context]）

结合一个给定的模板和一个给定的上下文字典，并返回一个渲染后的 HttpResponse 对象。

参数：
     request： 用于生成响应的请求对象。

     template_name：要使用的模板的完整名称，可选的参数

     context：添加到模板上下文的一个字典。默认是一个空字典。若是字典中的某个值是可调用的，视图将在渲染模板以前调用它。

     content_type：生成的文档要使用的MIME类型。默认为DEFAULT_CONTENT_TYPE 设置的值。

     status：响应的状态码。默认为200。

redirect 函数

参数能够是：

一个模型：将调用模型的get_absolute_url() 函数
一个视图，能够带有参数：将使用urlresolvers.reverse 来反向解析名称
一个绝对的或相对的URL，将原封不动的做为重定向的位置。

默认返回一个临时的重定向；传递permanent=True 能够返回一个永久的重定向。

示例:

你能够用多种方式使用redirect() 函数。

传递一个对象

将调用get_absolute_url() 方法来获取重定向的URL：

from django.shortcuts import redirect

def my_view(request):
    ...
    object = MyModel.objects.get(...)
    return redirect(object)

传递一个视图的名称

能够带有位置参数和关键字参数；将使用reverse() 方法反向解析URL：　

def my_view(request):
    ...
    return redirect('some-view-name', foo='bar')

传递要重定向的一个硬编码的URL

def my_view(request):
    ...
    return redirect('/some/url/')

也能够是一个完整的URL：

def my_view(request):
    ...
    return redirect('http://example.com/')

默认状况下，redirect() 返回一个临时重定向。以上全部的形式都接收一个permanent 参数；若是设置为True，将返回一个永久的重定向：

def my_view(request):
    ...
    object = MyModel.objects.get(...)
    return redirect(object, permanent=True)

跳转（重定向）应用

-----------------------------------url.py

 url(r"login",   views.login),
 url(r"yuan_back",   views.yuan_back),

-----------------------------------views.py
def login(req):
    if req.method=="POST":
        if 1:
            # return redirect("/yuan_back/")
            name="yuanhao"

            return render(req,"my backend.html",locals())

    return render(req,"login.html",locals())


def yuan_back(req):

    name="苑昊"

    return render(req,"my backend.html",locals())

-----------------------------------login.html

<form action="/login/" method="post">
    <p>姓名<input type="text" name="username"></p>
    <p>性别<input type="text" name="sex"></p>
    <p>邮箱<input type="text" name="email"></p>
    <p><input type="submit" value="submit"></p>
</form>
-----------------------------------my backend.html
<h1>用户{{ name }}你好</h1>

View Code

注意：render和redirect的区别:

一、 if 页面须要模板语言渲染,须要的将数据库的数据加载到html,那么render方法则不会显示这一部分。

二、 the most important: url没有跳转到/yuan_back/,而是还在/login/,因此当刷新后又得从新登陆。

模板层(template)

你可能已经注意到咱们在例子视图中返回文本的方式有点特别。也就是说，HTML被直接硬编码在 Python代码之中。

def current_datetime(request):
    now = datetime.datetime.now()
    html = "<html><body>It is now %s.</body></html>" % now
    return HttpResponse(html)

尽管这种技术便于解释视图是如何工做的，但直接将HTML硬编码到你的视图里却并非一个好主意。让咱们来看一下为何：

对页面设计进行的任何改变都必须对 Python 代码进行相应的修改。站点设计的修改每每比底层 Python 代码的修改要频繁得多，所以若是能够在不进行 Python 代码修改的状况下变动设计，那将会方便得多。

Python 代码编写和 HTML 设计是两项不一样的工做，大多数专业的网站开发环境都将他们分配给不一样的人员（甚至不一样部门）来完成。设计者和HTML/CSS的编码人员不该该被要求去编辑Python的代码来完成他们的工做。

程序员编写 Python代码和设计人员制做模板两项工做同时进行的效率是最高的，远胜于让一我的等待另外一我的完成对某个既包含 Python又包含 HTML 的文件的编辑工做。

基于这些缘由，将页面的设计和Python的代码分离开会更干净简洁更容易维护。咱们可使用 Django的 模板系统 (Template System)来实现这种模式，这就是本章要具体讨论的问题。

python的模板：HTML代码＋模板语法

模版包括在使用时会被值替换掉的变量，和控制模版逻辑的标签。

def current_time(req):
    # ================================原始的视图函数
    # import datetime
    # now=datetime.datetime.now()
    # html="<html><body>如今时刻：<h1>%s.</h1></body></html>" %now


    # ================================django模板修改的视图函数
    # from django.template import Template,Context
    # now=datetime.datetime.now()
    # t=Template('<html><body>如今时刻是:<h1>{{current_date}}</h1></body></html>')
    # #t=get_template('current_datetime.html')
    # c=Context({'current_date':str(now)})
    # html=t.render(c)
    #
    # return HttpResponse(html)


    #另外一种写法(推荐)
    import datetime
    now=datetime.datetime.now()
    return render(req, 'current_datetime.html', {'current_date':str(now)[:19]})

模板语法之变量

在 Django 模板中遍历复杂数据结构的关键是句点字符 .

语法：

 {{var_name}}

views：

def index(request):
    import datetime
    s="hello"
    l=[111,222,333]    # 列表
    dic={"name":"yuan","age":18}  # 字典
    date = datetime.date(1993, 5, 2)   # 日期对象

    class Person(object):
        def __init__(self,name):
            self.name=name

    person_yuan=Person("yuan")  # 自定义类对象
    person_egon=Person("egon")
    person_alex=Person("alex")

    person_list=[person_yuan,person_egon,person_alex]


    return render(request,"index.html",{"l":l,"dic":dic,"date":date,"person_list":person_list})

template：

<h4>{{s}}</h4>
<h4>列表:{{ l.0 }}</h4>
<h4>列表:{{ l.2 }}</h4>
<h4>字典:{{ dic.name }}</h4>
<h4>日期:{{ date.year }}</h4>
<h4>类对象列表:{{ person_list.0.name }}</h4>

注意：句点符也能够用来引用对象的方法(无参数方法)。

<h4>字典:{{ dic.name.upper }}</h4>

模板之过滤器

语法：

{{obj|filter__name:param}}

`default`

若是一个变量是false或者为空，使用给定的默认值。不然，使用变量的值。例如：

{{ value|default:"nothing" }}

length

返回值的长度。它对字符串和列表都起做用。例如：

{{ value|length }}

若是 value 是 ['a', 'b', 'c', 'd']，那么输出是 4。

`filesizeformat`

将值格式化为一个 “人类可读的” 文件尺寸（例如 '13 KB', '4.1 MB', '102 bytes', 等等）。例如：

{{ value|filesizeformat }}

若是 value 是 123456789，输出将会是 117.7 MB。　　

date

若是 value=datetime.datetime.now()

{{ value|date:"Y-m-d" }}

slice

若是 value="hello world"

{{ value|slice:"2:-1" }}

truncatechars

若是字符串字符多于指定的字符数量，那么会被截断。截断的字符串将以可翻译的省略号序列（“...”）结尾。

参数：要截断的字符数

例如：

{{ value|truncatechars:9 }}

若是value是“Joel 是 a >，输出将为“Joel i ...”。

safe

Django的模板中会对HTML标签和JS等语法标签进行自动转义，缘由显而易见，这样是为了安全。可是有的时候咱们可能不但愿这些HTML元素被转义，好比咱们作一个内容管理系统，后台添加的文章中是通过修饰的，这些修饰多是经过一个相似于FCKeditor编辑加注了HTML修饰符的文本，若是自动转义的话显示的就是保护HTML标签的源文件。为了在Django中关闭HTML的自动转义有两种方式，若是是一个单独的变量咱们能够经过过滤器“|safe”的方式告诉Django这段代码是安全的没必要转义。好比：

value="<a href="">点击</a>"

{{ value|safe}}

这里简单介绍一些经常使用的模板的过滤器，更多详见

模板之标签　

标签看起来像是这样的： {% tag %}。标签比变量更加复杂：一些在输出中建立文本，一些经过循环或逻辑来控制流程，一些加载其后的变量将使用到的额外信息到模版中。

一些标签须要开始和结束标签（例如{% tag %} ...标签内容 ... {% endtag %}）。

for标签

遍历每个元素：

{% for person in person_list %}
    <p>{{ person.name }}</p>
{% endfor %}

能够利用{% for obj in list reversed %}反向完成循环。

遍历一个字典：

{% for key,val in dic.items %}
    <p>{{ key }}:{{ val }}</p>
{% endfor %}

注：循环序号能够经过｛｛forloop｝｝显示　　

forloop.counter	        The current iteration of the loop (1-indexed)
forloop.counter0	The current iteration of the loop (0-indexed)
forloop.revcounter	The number of iterations from the end of the loop (1-indexed)
forloop.revcounter0	The number of iterations from the end of the loop (0-indexed)
forloop.first	        True if this is the first time through the loop
forloop.last	        True if this is the last time through the loop

for ... empty

for 标签带有一个可选的{% empty %} 从句，以便在给出的组是空的或者没有被找到时，能够有所操做。

{% for person in person_list %}
    <p>{{ person.name }}</p>

{% empty %}
    <p>sorry,no person here</p>
{% endfor %}

if 标签

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

{% if num > 100 or num < 0 %}
    <p>无效</p>
{% elif num > 80 and num < 100 %}
    <p>优秀</p>
{% else %}
    <p>凑活吧</p>
{% endif %}

with

使用一个简单地名字缓存一个复杂的变量，当你须要使用一个“昂贵的”方法（好比访问数据库）不少次的时候是很是有用的

例如：

{% with total=business.employees.count %}
    {{ total }} employee{{ total|pluralize }}
{% endwith %}

csrf_token

这个标签用于跨站请求伪造保护

自定义标签和过滤器

一、在settings中的INSTALLED_APPS配置当前app，否则django没法找到自定义的simple_tag.

二、在app中建立templatetags模块(模块名只能是templatetags)

三、建立任意 .py 文件，如：my_tags.py

from django import template
from django.utils.safestring import mark_safe

register = template.Library()   #register的名字是固定的,不可改变


@register.filter
def filter_multi(v1,v2):
    return  v1 * v2


@register.simple_tag
def simple_tag_multi(v1,v2):
    return  v1 * v2


@register.simple_tag
def my_input(id,arg):
    result = "<input type='text' id='%s' class='%s' />" %(id,arg,)
    return mark_safe(result)

四、在使用自定义simple_tag和filter的html文件中导入以前建立的 my_tags.py

{% load my_tags %}

五、使用simple_tag和filter（如何调用）

-------------------------------.html
{% load xxx %}   
     
# num=12
{{ num|filter_multi:2 }} #24

{{ num|filter_multi:"[22,333,4444]" }}

{% simple_tag_multi 2 5 %}  参数不限,但不能放在if for语句中
{% simple_tag_multi num 5 %}

注意：filter能够用在if等语句后，simple_tag不能够

{% if num|filter_multi:30 > 100 %}
    {{ num|filter_multi:30 }}
{% endif %}

模板继承 (extend)

Django模版引擎中最强大也是最复杂的部分就是模版继承了。模版继承可让您建立一个基本的“骨架”模版，它包含您站点中的所有元素，而且能够定义可以被子模版覆盖的 blocks 。

经过从下面这个例子开始，能够容易的理解模版继承：

<!DOCTYPE html>
<html lang="en">
<head>
    <link rel="stylesheet" href="style.css" />
    <title>{% block title %}My amazing site{%/span> endblock %}</title>
</head>

<body>
    <div id="sidebar">
        {% block sidebar %}
        <ul>
            <li><a href="/">Home</a></li>
            <li><a href="/blog/">Blog</a></li>
        </ul>
        {% endblock %}
    </div>

    <div id="content">
        {% block content %}{% endblock %}
    </div>
</body>
</html>

这个模版，咱们把它叫做 base.html，它定义了一个能够用于两列排版页面的简单HTML骨架。“子模版”的工做是用它们的内容填充空的blocks。

在这个例子中， block 标签订义了三个能够被子模版内容填充的block。 block 告诉模版引擎：子模版可能会覆盖掉模版中的这些位置。

子模版可能看起来是这样的：

{% extends "base.html" %}

{% block title %}My amazing blog{% endblock %}

{% block content %}
{% for entry in blog_entries %}
    <h2>{{ entry.title }}</h2>
    <p>{{ entry.body }}</p>
{% endfor %}
{% endblock %}

extends 标签是这里的关键。它告诉模版引擎，这个模版“继承”了另外一个模版。当模版系统处理这个模版时，首先，它将定位父模版——在此例中，就是“base.html”。

那时，模版引擎将注意到 base.html 中的三个 block 标签，并用子模版中的内容来替换这些block。根据 blog_entries 的值，输出可能看起来是这样的：

<!DOCTYPE html>
<html lang="en">
<head>
    <link rel="stylesheet" href="style.css" />
    <title>My amazing blog</title>
</head>

<body>
    <div id="sidebar">
        <ul>
            <li><a href="/">Home</a></li>
            <li><a href="/blog/">Blog</a></li>
        </ul>
    </div>

    <div id="content">
        <h2>Entry one</h2>
        <p>This is my first entry.</p>

        <h2>Entry two</h2>
        <p>This is my second entry.</p>
    </div>
</body>
</html>

请注意，子模版并无定义 sidebar block，因此系统使用了父模版中的值。父模版的 {% block %} 标签中的内容老是被用做备选内容（fallback）。

这种方式使代码获得最大程度的复用，而且使得添加内容到共享的内容区域更加简单，例如，部分范围内的导航。

这里是使用继承的一些提示：

若是你在模版中使用 {% extends %} 标签，它必须是模版中的第一个标签。其余的任何状况下，模版继承都将没法工做。
在base模版中设置越多的 {% block %} 标签越好。请记住，子模版没必要定义所有父模版中的blocks，因此，你能够在大多数blocks中填充合理的默认内容，而后，只定义你须要的那一个。多一点钩子总比少一点好。
若是你发现你本身在大量的模版中复制内容，那可能意味着你应该把内容移动到父模版中的一个 {% block %} 中。
If you need to get the content of the block from the parent template, the {{ block.super }} variable will do the trick. This is useful if you want to add to the contents of a parent block instead of completely overriding it. Data inserted using {{ block.super }} will not be automatically escaped (see the next section), since it was already escaped, if necessary, in the parent template.
为了更好的可读性，你也能够给你的 {% endblock %} 标签一个名字。例如：
```
{% block content %}
...
{% endblock content %}　　
```
在大型模版中，这个方法帮你清楚的看到哪个　 {% block %} 标签被关闭了。

最后，请注意您并不能在一个模版中定义多个相同名字的 block 标签。这个限制的存在是由于block标签的做用是“双向”的。这个意思是，block标签不只提供了一个坑去填，它还在 _父模版_中定义了填坑的内容。若是在一个模版中有两个名字同样的 block 标签，模版的父模版将不知道使用哪一个block的内容。

Django-model基础

ORM

映射关系：

　　　  表名  <－－－－－－－> 类名

       字段  <－－－－－－－> 属性

　　　　表记录 <－－－－－－－>类实例对象

建立表(创建模型)

实例：咱们来假定下面这些概念，字段和关系

做者模型：一个做者有姓名和年龄。

做者详细模型：把做者的详情放到详情表，包含生日，手机号，家庭住址等信息。做者详情模型和做者模型之间是一对一的关系（one-to-one）

出版商模型：出版商有名称，所在城市以及email。

书籍模型：书籍有书名和出版日期，一本书可能会有多个做者，一个做者也能够写多本书，因此做者和书籍的关系就是多对多的关联关系(many-to-many);一本书只应该由一个出版商出版，因此出版商和书籍是一对多关联关系(one-to-many)。

模型创建以下：

class Author(models.Model):
    nid = models.AutoField(primary_key=True)
    name=models.CharField( max_length=32)
    age=models.IntegerField()

    # 与AuthorDetail创建一对一的关系
    authorDetail=models.OneToOneField(to="AuthorDetail")

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)
    keepNum=models.IntegerField()
    commentNum=models.IntegerField()

    # 与Publish创建一对多的关系,外键字段创建在多的一方
    publish=models.ForeignKey(to="Publish",to_field="nid")

    # 与Author表创建多对多的关系,ManyToManyField能够建在两个模型中的任意一个，自动建立第三张表
    authors=models.ManyToManyField(to='Author')

经过logging能够查看翻译成的sql语句

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

注意事项：

一、表的名称myapp_modelName，是根据模型中的元数据自动生成的，也能够覆写为别的名称　　

二、id 字段是自动添加的

三、对于外键字段，Django 会在字段名上添加"_id" 来建立数据库中的列名

四、这个例子中的CREATE TABLE SQL 语句使用PostgreSQL 语法格式，要注意的是Django 会根据settings 中指定的数据库类型来使用相应的SQL 语句。

五、定义好模型以后，你须要告诉Django _使用_这些模型。你要作的就是修改配置文件中的INSTALL_APPSZ中设置，在其中添加models.py所在应用的名称。

六、外键字段 ForeignKey 有一个 null=True 的设置(它容许外键接受空值 NULL)，你能够赋给它空值 None 。

字段选项

每一个字段有一些特有的参数，例如，CharField须要max_length参数来指定VARCHAR数据库字段的大小。还有一些适用于全部字段的通用参数。这些参数在文档中有详细定义，这里咱们只简单介绍一些最经常使用的：

(1)null

若是为True，Django 将用NULL 来在数据库中存储空值。 默认值是 False.

(1)blank

若是为True，该字段容许不填。默认为False。
要注意，这与 null 不一样。null纯粹是数据库范畴的，而 blank 是数据验证范畴的。
若是一个字段的blank=True，表单的验证将容许该字段是空值。若是字段的blank=False，该字段就是必填的。

(2)default

字段的默认值。能够是一个值或者可调用对象。若是可调用 ，每有新对象被建立它都会被调用。

(3)primary_key

若是为True，那么这个字段就是模型的主键。若是你没有指定任何一个字段的primary_key=True，
Django 就会自动添加一个IntegerField字段作为主键，因此除非你想覆盖默认的主键行为，
不然不必设置任何一个字段的primary_key=True。

(4)unique

若是该值设置为 True, 这个数据字段的值在整张表中必须是惟一的

(5)choices
由二元组组成的一个可迭代对象（例如，列表或元组），用来给字段提供选择项。 若是设置了choices ，默认的表单将是一个选择框而不是标准的文本框，并且这个选择框的选项就是choices 中的选项。

这是一个关于 choices 列表的例子：

YEAR_IN_SCHOOL_CHOICES = (
    ('FR', 'Freshman'),
    ('SO', 'Sophomore'),
    ('JR', 'Junior'),
    ('SR', 'Senior'),
    ('GR', 'Graduate'),
)
每一个元组中的第一个元素，是存储在数据库中的值；第二个元素是在管理界面或 ModelChoiceField 中用做显示的内容。 在一个给定的 model 类的实例中，想获得某个 choices 字段的显示值，就调用 get_FOO_display 方法(这里的 FOO 就是 choices 字段的名称 )。例如：

from django.db import models

class Person(models.Model):
    SHIRT_SIZES = (
        ('S', 'Small'),
        ('M', 'Medium'),
        ('L', 'Large'),
    )
    name = models.CharField(max_length=60)
    shirt_size = models.CharField(max_length=1, choices=SHIRT_SIZES)


>>> p = Person(name="Fred Flintstone", shirt_size="L")
>>> p.save()
>>> p.shirt_size
'L'
>>> p.get_shirt_size_display()
'Large'

View Code

更多详见模型字段参考

一旦你创建好数据模型以后，django会自动生成一套数据库抽象的API，可让你执行关于表记录的增删改查的操做。

添加表记录

普通字段

方式1
publish_obj=Publish(name="人民出版社",city="北京",email="renMin@163.com")
publish_obj.save() # 将数据保存到数据库

方式2 
返回值publish_obj是添加的记录对象
publish_obj=Publish.objects.create(name="人民出版社",city="北京",email="renMin@163.com")

外键字段

 方式1:
    publish_obj=Publish.objects.get(nid=1)
    Book.objects.create(title="金瓶眉",publishDate="2012-12-12",price=665,pageNum=334,publish=publish_obj)

 方式2:
    Book.objects.create(title="金瓶眉",publishDate="2012-12-12",price=665,pageNum=334,publish_id=1)

关键点：book_obj.publish是什么？

多对多字段

book_obj=Book.objects.create(title="追风筝的人",publishDate="2012-11-12",price=69,pageNum=314,publish_id=1)

author_yuan=Author.objects.create(name="yuan",age=23,authorDetail_id=1)
author_egon=Author.objects.create(name="egon",age=32,authorDetail_id=2)

book_obj.authors.add(author_egon,author_yuan)    #  将某个特定的 model 对象添加到被关联对象集合中。   =======    book_obj.authors.add(*[])

book_obj.authors.create()      #建立并保存一个新对象，而后将这个对象加被关联对象的集合中，而后返回这个新对象。

关键点：book_obj.authors是什么？　　

解除关系：

book_obj.authors.remove()     # 将某个特定的对象从被关联对象集合中去除。    ======   book_obj.authors.remove(*[])
book_obj.authors.clear()       #清空被关联对象集合。

class RelatedManager

"关联管理器"是在一对多或者多对多的关联上下文中使用的管理器。它存在于下面两种状况：

ForeignKey关系的“另外一边”。像这样：

from django.db import models

class Reporter(models.Model):
    # ...
    pass

class Article(models.Model):
    reporter = models.ForeignKey(Reporter)

在上面的例子中，管理器reporter.article_set拥有下面的方法。

ManyToManyField关系的两边：

class Topping(models.Model):
    # ...
    pass

class Pizza(models.Model):
    toppings = models.ManyToManyField(Topping)

这个例子中，topping.pizza_set 和pizza.toppings都拥有下面的方法。

add(obj1[, obj2, ...])

把指定的模型对象添加到关联对象集中。

例如：

>>> b = Blog.objects.get(id=1)
>>> e = Entry.objects.get(id=234)
>>> b.entry_set.add(e) # Associates Entry e with Blog b.

在上面的例子中，对于ForeignKey关系，e.save()由关联管理器调用，执行更新操做。然而，在多对多关系中使用add()并不会调用任何 save()方法，而是由QuerySet.bulk_create()建立关系。

create(**kwargs)

建立一个新的对象，保存对象，并将它添加到关联对象集之中。返回新建立的对象：

>>> b = Blog.objects.get(id=1)
>>> e = b.entry_set.create(
...     headline='Hello',
...     body_text='Hi',
...     pub_date=datetime.date(2005, 1, 1)
... )

# No need to call e.save() at this point -- it's already been saved.

这彻底等价于（不过更加简洁于）：

>>> b = Blog.objects.get(id=1)
>>> e = Entry(
...     blog=b,
...     headline='Hello',
...     body_text='Hi',
...     pub_date=datetime.date(2005, 1, 1)
... )
>>> e.save(force_insert=True)

要注意咱们并不须要指定模型中用于定义关系的关键词参数。在上面的例子中，咱们并无传入blog参数给create()。Django会明白新的 Entry对象blog 应该添加到b中。

remove(obj1[, obj2, ...])

从关联对象集中移除执行的模型对象：

>>> b = Blog.objects.get(id=1)
>>> e = Entry.objects.get(id=234)
>>> b.entry_set.remove(e) # Disassociates Entry e from Blog b.

对于ForeignKey对象，这个方法仅在null=True时存在。

clear()

从关联对象集中移除一切对象。

>>> b = Blog.objects.get(id=1)
>>> b.entry_set.clear()

注意这样不会删除对象 —— 只会删除他们之间的关联。

就像 remove() 方法同样，clear()只能在 null=True的ForeignKey上被调用。

注意

对于全部类型的关联字段，add()、create()、remove()和clear()都会立刻更新数据库。换句话说，在关联的任何一端，都不须要再调用save()方法。

直接赋值：

经过赋值一个新的可迭代的对象，关联对象集能够被总体替换掉。

>>> new_list = [obj1, obj2, obj3]
>>> e.related_set = new_list

若是外键关系知足null=True，关联管理器会在添加new_list中的内容以前，首先调用clear()方法来解除关联集中一切已存在对象的关联。不然， new_list中的对象会在已存在的关联的基础上被添加。　　

查询表记录

查询相关API

 <1> all():                 查询全部结果

 <2> filter(**kwargs):      它包含了与所给筛选条件相匹配的对象

 <3> get(**kwargs):         返回与所给筛选条件相匹配的对象，返回结果有且只有一个，
                            若是符合筛选条件的对象超过一个或者没有都会抛出错误。

 <5> exclude(**kwargs):     它包含了与所给筛选条件不匹配的对象

 <4> values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet，运行后获得的并非一系列
                            model的实例化对象，而是一个可迭代的字典序列

 <9> values_list(*field):   它与values()很是类似，它返回的是一个元组序列，values返回的是一个字典序列

 <6> order_by(*field):      对查询结果排序

 <7> reverse():             对查询结果反向排序

 <8> distinct():            从返回结果中剔除重复纪录

 <10> count():              返回数据库中匹配查询(QuerySet)的对象数量。

 <11> first():              返回第一条记录

 <12> last():               返回最后一条记录

 <13> exists():             若是QuerySet包含数据，就返回True，不然返回False

注意：必定区分object与querySet的区别！！！

双下划线之单表查询

   models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值

   models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于十一、2二、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

基于对象的跨表查询

一对多查询（Publish 与 Book）

正向查询(按字段：publish)：

# 查询nid=1的书籍的出版社所在的城市

book_obj=Book.objects.get(nid=1)
print(book_obj.publish.city) # book_obj.publish 是nid=1的书籍对象关联的出版社对象

反向查询(按表名：book_set)：

# 查询 人民出版社出版过的全部书籍

    publish=Publish.objects.get(name="人民出版社")

    book_list=publish.book_set.all()  # 与人民出版社关联的全部书籍对象集合

    for book_obj in book_list:
        print(book_obj.title)

一对一查询(Author 与 AuthorDetail)

正向查询(按字段：authorDetail)：

# 查询egon做者的手机号

    author_egon=Author.objects.get(name="egon")
    print(author_egon.authorDetail.telephone)

反向查询(按表名：author)：

# 查询全部住址在北京的做者的姓名

    authorDetail_list=AuthorDetail.objects.filter(addr="beijing")

    for obj in authorDetail_list:
        print(obj.author.name)

多对多查询 (Author 与 Book)

正向查询(按字段：authors)：

# 金瓶眉全部做者的名字以及手机号

    book_obj=Book.objects.filter(title="金瓶眉").first()

    authors=book_obj.authors.all()

    for author_obj in authors:

        print(author_obj.name,author_obj.authorDetail.telephone)

反向查询(按表名：book_set)：

# 查询egon出过的全部书籍的名字

    author_obj=Author.objects.get(name="egon")
    book_list=author_obj.book_set.all() #与egon做者相关的全部书籍

    for book_obj in book_list:
        print(book_obj.title)

注意：

你能够经过在 ForeignKey() 和ManyToManyField的定义中设置 related_name 的值来覆写 FOO_set 的名称。例如，若是 Article model 中作一下更改： publish = ForeignKey(Blog, related_name='bookList')，那么接下来就会如咱们看到这般：

 # 查询 人民出版社出版过的全部书籍

    publish=Publish.objects.get(name="人民出版社")

    book_list=publish.bookList.all()  # 与人民出版社关联的全部书籍对象集合

基于双下划线的跨表查询

Django 还提供了一种直观而高效的方式在查询(lookups)中表示关联关系，它能自动确认 SQL JOIN 联系。要作跨关系查询，就使用两个下划线来连接模型(model)间关联字段的名称，直到最终连接到你想要的 model 为止。

# 练习1:  查询人民出版社出版过的全部书籍的名字与价格(一对多)

    # 正向查询 按字段:publish

    queryResult=Book.objects
　　　　　　　　　　　　.filter(publish__name="人民出版社")
　　　　　　　　　　　　.values_list("title","price")

    # 反向查询 按表名:book

    queryResult=Publish.objects
　　　　　　　　　　　　　　.filter(name="人民出版社")
　　　　　　　　　　　　　　.values_list("book__title","book__price")



# 练习2: 查询egon出过的全部书籍的名字(多对多)

    # 正向查询 按字段:authors:
    queryResult=Book.objects
　　　　　　　　　　　　.filter(authors__name="yuan")
　　　　　　　　　　　　.values_list("title")

    # 反向查询 按表名:book
    queryResult=Author.objects
　　　　　　　　　　　　　　.filter(name="yuan")
　　　　　　　　　　　　　　.values_list("book__title","book__price")


# 练习3: 查询人民出版社出版过的全部书籍的名字以及做者的姓名


    # 正向查询
    queryResult=Book.objects
　　　　　　　　　　　　.filter(publish__name="人民出版社")
　　　　　　　　　　　　.values_list("title","authors__name")
    # 反向查询
    queryResult=Publish.objects
　　　　　　　　　　　　　　.filter(name="人民出版社")
　　　　　　　　　　　　　　.values_list("book__title","book__authors__age","book__authors__name")


# 练习4: 手机号以151开头的做者出版过的全部书籍名称以及出版社名称

    queryResult=Book.objects
　　　　　　　　　　　　.filter(authors__authorDetail__telephone__regex="151")
　　　　　　　　　　　　.values_list("title","publish__name")

注意：

反向查询时，若是定义了related_name ，则用related_name替换表名，例如： publish = ForeignKey(Blog, related_name='bookList')：

# 练习1:  查询人民出版社出版过的全部书籍的名字与价格(一对多)

    # 反向查询 再也不按表名:book,而是related_name:bookList

    queryResult=Publish.objects
　　　　　　　　　　　　　　.filter(name="人民出版社")
　　　　　　　　　　　　　　.values_list("bookList__title","bookList__price")

聚合查询与分组查询

`聚合：aggregate`(*args, **kwargs)

# 计算全部图书的平均价格
    >>> from django.db.models import Avg
    >>> Book.objects.all().aggregate(Avg('price'))
    {'price__avg': 34.35}

aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典。键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。若是你想要为聚合值指定一个名称，能够向聚合子句提供它。

>>> Book.objects.aggregate(average_price=Avg('price'))
{'average_price': 34.35}

若是你但愿生成不止一个聚合，你能够向aggregate()子句中添加另外一个参数。因此，若是你也想知道全部图书价格的最大值和最小值，能够这样查询：

>>> from django.db.models import Avg, Max, Min
>>> Book.objects.aggregate(Avg('price'), Max('price'), Min('price'))
{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}

分组：annotate()　

为QuerySet中每个对象都生成一个独立的汇总值。　

(1) 练习：统计每一本书的做者个数

    bookList=Book.objects.annotate(authorsNum=Count('authors'))
    for book_obj in bookList:
        print(book_obj.title,book_obj.authorsNum)

SELECT 
"app01_book"."nid", 
"app01_book"."title", 
"app01_book"."publishDate", 
"app01_book"."price", 
"app01_book"."pageNum", 
"app01_book"."publish_id", 
COUNT("app01_book_authors"."author_id") AS "authorsNum" 
FROM "app01_book" LEFT OUTER JOIN "app01_book_authors" 
ON ("app01_book"."nid" = "app01_book_authors"."book_id") 
GROUP BY 
"app01_book"."nid", 
"app01_book"."title", 
"app01_book"."publishDate", 
"app01_book"."price", 
"app01_book"."pageNum", 
"app01_book"."publish_id"

sql

(2) 若是想对所查询对象的关联对象进行聚合：

练习：统计每个出版社的最便宜的书

    publishList=Publish.objects.annotate(MinPrice=Min("book__price"))

    for publish_obj in publishList:
        print(publish_obj.name,publish_obj.MinPrice)

annotate的返回值是querySet，若是不想遍历对象，能够用上valuelist：

queryResult= Publish.objects
　　　　　　　　　　　　.annotate(MinPrice=Min("book__price"))
　　　　　　　　　　　　.values_list("name","MinPrice")
print(queryResult)

方式2:　

queryResult=Book.objects.values("publish__name").annotate(MinPrice=Min('price'))

注意：values内的字段即group by的字段

(3) 统计每一本以py开头的书籍的做者个数：

 queryResult=Book.objects
　　　　　　　　　　 .filter(title__startswith="Py")
　　　　　　　　　 　.annotate(num_authors=Count('authors'))

(4) 统计不止一个做者的图书：

queryResult=Book.objects
　　　　　　　　　　.annotate(num_authors=Count('authors'))
　　　　　　　　　　.filter(num_authors__gt=1)

(5) 根据一本图书做者数量的多少对查询集 QuerySet进行排序:

Book.objects.annotate(num_authors=Count('authors')).order_by('num_authors')

(6) 查询各个做者出的书的总价格:

# 按author表的全部字段 group by
    queryResult=Author.objects
　　　　　　　　　　　　　　.annotate(SumPrice=Sum("book__price"))
　　　　　　　　　　　　　　.values_list("name","SumPrice")
    print(queryResult)
    
#按authors__name group by
    queryResult2=Book.objects.values("authors__name")
　　　　　　　　　　　　　　.annotate(SumPrice=Sum("price"))
　　　　　　　　　　　　　　.values_list("authors__name","SumPrice")
    print(queryResult2)

F查询与Q查询

F查询

在上面全部的例子中，咱们构造的过滤器都只是将字段值与某个常量作比较。若是咱们要对两个字段的值作比较，那该怎么作呢？

Django 提供 F() 来作这样的比较。F() 的实例能够在查询中引用字段，来比较同一个 model 实例中两个不一样字段的值。

 # 查询评论数大于收藏数的书籍

    from django.db.models import F
    Book.objects.filter(commnetNum__lt=F('keepNum'))

Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操做。

# 查询评论数大于收藏数2倍的书籍
    Book.objects.filter(commnetNum__lt=F('keepNum')*2)

修改操做也可使用F函数,好比将每一本书的价格提升30元：

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

Q查询

filter() 等方法中的关键字参数查询都是一块儿进行“AND” 的。若是你须要执行更复杂的查询（例如OR 语句），你可使用Q 对象。

from django.db.models import Q
Q(title__startswith='Py')

Q 对象可使用& 和| 操做符组合起来。当一个操做符在两个Q 对象上使用时，它产生一个新的Q 对象。

bookList=Book.objects.filter(Q(authors__name="yuan")|Q(authors__name="egon"))

等同于下面的SQL WHERE 子句：

WHERE name ="yuan" OR name ="egon"

你能够组合& 和| 操做符以及使用括号进行分组来编写任意复杂的Q 对象。同时，Q 对象可使用~ 操做符取反，这容许组合正常的查询和取反(NOT) 查询：

 bookList=Book.objects.filter(Q(authors__name="yuan") & ~Q(publishDate__year=2017)).values_list("title")

查询函数能够混合使用Q 对象和关键字参数。全部提供给查询函数的参数（关键字参数或Q 对象）都将"AND”在一块儿。可是，若是出现Q 对象，它必须位于全部关键字参数的前面。例如：

    bookList=Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017),
                                  title__icontains="python"
                                 )

修改表记录

注意：

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

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

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

注意，这里由于update返回的是一个整形，因此无法用query属性；对于每次建立一个对象，想显示对应的raw sql，须要在settings加上日志记录部分

删除表记录

删除方法就是 delete()。它运行时当即删除对象而不返回任何值。例如：

e.delete()

你也能够一次性删除多个对象。每一个 QuerySet 都有一个 delete() 方法，它一次性删除 QuerySet 中全部的对象。

例如，下面的代码将删除 pub_date 是2005年的 Entry 对象：

Entry.objects.filter(pub_date__year=2005).delete()

要牢记这一点：不管在什么状况下，QuerySet 中的 delete() 方法都只使用一条 SQL 语句一次性删除全部对象，而并非分别删除每一个对象。若是你想使用在 model 中自定义的 delete() 方法，就要自行调用每一个对象的delete 方法。(例如，遍历 QuerySet，在每一个对象上调用 delete()方法)，而不是使用 QuerySet 中的 delete()方法。

在 Django 删除对象时，会模仿 SQL 约束 ON DELETE CASCADE 的行为，换句话说，删除一个对象时也会删除与它相关联的外键对象。例如：

b = Blog.objects.get(pk=1)
# This will delete the Blog and all of its Entry objects.
b.delete()

要注意的是： delete() 方法是 QuerySet 上的方法，但并不适用于 Manager 自己。这是一种保护机制，是为了不意外地调用 Entry.objects.delete() 方法致使全部的记录被误删除。若是你确认要删除全部的对象，那么你必须显式地调用：

Entry.objects.all().delete()

Django-model进阶

QuerySet

可切片

使用Python 的切片语法来限制查询集记录的数目。它等同于SQL 的LIMIT 和OFFSET 子句。

>>> Entry.objects.all()[:5]      # (LIMIT 5)

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

不支持负的索引（例如Entry.objects.all()[-1]）。一般，查询集 的切片返回一个新的查询集 —— 它不会执行查询。

可迭代

articleList=models.Article.objects.all()

for article in articleList:
    print(article.title)

惰性查询

查询集 是惰性执行的 —— 建立查询集不会带来任何数据库的访问。你能够将过滤器保持一成天，直到查询集 须要求值时，Django 才会真正运行这个查询。

    queryResult=models.Article.objects.all() # not hits database

    print(queryResult) # hits database

    for article in queryResult:
        print(article.title)    # hits database

通常来讲，只有在“请求”查询集 的结果时才会到数据库中去获取它们。当你确实须要结果时，查询集 经过访问数据库来求值。关于求值发生的准确时间，参见什么时候计算查询集。

缓存机制

每一个查询集都包含一个缓存来最小化对数据库的访问。理解它是如何工做的将让你编写最高效的代码。

在一个新建立的查询集中，缓存为空。首次对查询集进行求值 —— 同时发生数据库查询 ——Django 将保存查询的结果到查询集的缓存中并返回明确请求的结果（例如，若是正在迭代查询集，则返回下一个结果）。接下来对该查询集 的求值将重用缓存的结果。

请牢记这个缓存行为，由于对查询集使用不当的话，它会坑你的。例如，下面的语句建立两个查询集，对它们求值，而后扔掉它们：

print([a.title for a in models.Article.objects.all()])
print([a.create_time for a in models.Article.objects.all()])

这意味着相同的数据库查询将执行两次，显然倍增了你的数据库负载。同时，还有可能两个结果列表并不包含相同的数据库记录，由于在两次请求期间有可能有Article被添加进来或删除掉。为了不这个问题，只需保存查询集并从新使用它：

queryResult=models.Article.objects.all()
print([a.title for a in queryResult])
print([a.create_time for a in queryResult])

什么时候查询集不会被缓存?

查询集不会永远缓存它们的结果。当只对查询集的部分进行求值时会检查缓存，若是这个部分不在缓存中，那么接下来查询返回的记录都将不会被缓存。因此，这意味着使用切片或索引来限制查询集将不会填充缓存。

例如，重复获取查询集对象中一个特定的索引将每次都查询数据库：

>>> queryset = Entry.objects.all()
>>> print queryset[5] # Queries the database
>>> print queryset[5] # Queries the database again

然而，若是已经对所有查询集求值过，则将检查缓存：

>>> queryset = Entry.objects.all()
>>> [entry for entry in queryset] # Queries the database
>>> print queryset[5] # Uses cache
>>> print queryset[5] # Uses cache

下面是一些其它例子，它们会使得所有的查询集被求值并填充到缓存中：

>>> [entry for entry in queryset]
>>> bool(queryset)
>>> entry in queryset
>>> list(queryset)

注：简单地打印查询集不会填充缓存。

queryResult=models.Article.objects.all()
print(queryResult) #  hits database
print(queryResult) #  hits database

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，可能会形成额外的数据库查询。　

中介模型

处理相似搭配 pizza 和 topping 这样简单的多对多关系时，使用标准的ManyToManyField 就能够了。可是，有时你可能须要关联数据到两个模型之间的关系上。

例如，有这样一个应用，它记录音乐家所属的音乐小组。咱们能够用一个ManyToManyField 表示小组和成员之间的多对多关系。可是，有时你可能想知道更多成员关系的细节，好比成员是什么时候加入小组的。

对于这些状况，Django 容许你指定一个中介模型来定义多对多关系。你能够将其余字段放在中介模型里面。源模型的ManyToManyField 字段将使用through 参数指向中介模型。对于上面的音乐小组的例子，代码以下：

from django.db import models

class Person(models.Model):
    name = models.CharField(max_length=128)

    def __str__(self):              # __unicode__ on Python 2
        return self.name

class Group(models.Model):
    name = models.CharField(max_length=128)
    members = models.ManyToManyField(Person, through='Membership')

    def __str__(self):              # __unicode__ on Python 2
        return self.name

class Membership(models.Model):
    person = models.ForeignKey(Person)
    group = models.ForeignKey(Group)
    date_joined = models.DateField()
    invite_reason = models.CharField(max_length=64)

既然你已经设置好ManyToManyField 来使用中介模型（在这个例子中就是Membership），接下来你要开始建立多对多关系。你要作的就是建立中介模型的实例：

>>> 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()
[<Person: Ringo Starr>]
>>> ringo.group_set.all()
[<Group: The Beatles>]
>>> m2 = Membership.objects.create(person=paul, group=beatles,
...     date_joined=date(1960, 8, 1),
...     invite_reason="Wanted to form a band.")
>>> beatles.members.all()
[<Person: Ringo Starr>, <Person: Paul McCartney>]

与普通的多对多字段不一样，你不能使用add、 create和赋值语句（好比，beatles.members = [...]）来建立关系：

# THIS WILL NOT WORK
>>> beatles.members.add(john)
# NEITHER WILL THIS
>>> beatles.members.create(name="George Harrison")
# AND NEITHER WILL THIS
>>> beatles.members = [john, paul, ringo, george]

为何不能这样作？这是由于你不能只建立 Person和 Group之间的关联关系，你还要指定 Membership模型中所须要的全部信息；而简单的add、create 和赋值语句是作不到这一点的。因此它们不能在使用中介模型的多对多关系中使用。此时，惟一的办法就是建立中介模型的实例。

remove()方法被禁用也是出于一样的缘由。可是clear() 方法倒是可用的。它能够清空某个实例全部的多对多关系：

>>> # Beatles have broken up
>>> beatles.members.clear()
>>> # Note that this deletes the intermediate model instances
>>> Membership.objects.all()
[]

查询优化

表数据

class UserInfo(AbstractUser):
    """
    用户信息
    """
    nid = models.BigAutoField(primary_key=True)
    nickname = models.CharField(verbose_name='昵称', max_length=32)
    telephone = models.CharField(max_length=11, blank=True, null=True, unique=True, verbose_name='手机号码')
    avatar = models.FileField(verbose_name='头像',upload_to = 'avatar/',default="/avatar/default.png")
    create_time = models.DateTimeField(verbose_name='建立时间', auto_now_add=True)

    fans = models.ManyToManyField(verbose_name='粉丝们',
                                  to='UserInfo',
                                  through='UserFans',
                                  related_name='f',
                                  through_fields=('user', 'follower'))

    def __str__(self):
        return self.username

class UserFans(models.Model):
    """
    互粉关系表
    """
    nid = models.AutoField(primary_key=True)
    user = models.ForeignKey(verbose_name='博主', to='UserInfo', to_field='nid', related_name='users')
    follower = models.ForeignKey(verbose_name='粉丝', to='UserInfo', to_field='nid', related_name='followers')

class Blog(models.Model):

    """
    博客信息
    """
    nid = models.BigAutoField(primary_key=True)
    title = models.CharField(verbose_name='我的博客标题', max_length=64)
    site = models.CharField(verbose_name='我的博客后缀', max_length=32, unique=True)
    theme = models.CharField(verbose_name='博客主题', max_length=32)
    user = models.OneToOneField(to='UserInfo', to_field='nid')
    def __str__(self):
        return self.title

class Category(models.Model):
    """
    博主我的文章分类表
    """
    nid = models.AutoField(primary_key=True)
    title = models.CharField(verbose_name='分类标题', max_length=32)

    blog = models.ForeignKey(verbose_name='所属博客', to='Blog', to_field='nid')

class Article(models.Model):

    nid = models.BigAutoField(primary_key=True)
    title = models.CharField(max_length=50, verbose_name='文章标题')
    desc = models.CharField(max_length=255, verbose_name='文章描述')
    read_count = models.IntegerField(default=0)
    comment_count= models.IntegerField(default=0)
    up_count = models.IntegerField(default=0)
    down_count = models.IntegerField(default=0)
    category = models.ForeignKey(verbose_name='文章类型', to='Category', to_field='nid', null=True)
    create_time = models.DateField(verbose_name='建立时间')
    blog = models.ForeignKey(verbose_name='所属博客', to='Blog', to_field='nid')
    tags = models.ManyToManyField(
        to="Tag",
        through='Article2Tag',
        through_fields=('article', 'tag'),
)


class ArticleDetail(models.Model):
    """
    文章详细表
    """
    nid = models.AutoField(primary_key=True)
    content = models.TextField(verbose_name='文章内容', )

    article = models.OneToOneField(verbose_name='所属文章', to='Article', to_field='nid')


class Comment(models.Model):
    """
    评论表
    """
    nid = models.BigAutoField(primary_key=True)
    article = models.ForeignKey(verbose_name='评论文章', to='Article', to_field='nid')
    content = models.CharField(verbose_name='评论内容', max_length=255)
    create_time = models.DateTimeField(verbose_name='建立时间', auto_now_add=True)

    parent_comment = models.ForeignKey('self', blank=True, null=True, verbose_name='父级评论')
    user = models.ForeignKey(verbose_name='评论者', to='UserInfo', to_field='nid')

    up_count = models.IntegerField(default=0)

    def __str__(self):
        return self.content

class ArticleUpDown(models.Model):
    """
    点赞表
    """
    nid = models.AutoField(primary_key=True)
    user = models.ForeignKey('UserInfo', null=True)
    article = models.ForeignKey("Article", null=True)
    models.BooleanField(verbose_name='是否赞')

class CommentUp(models.Model):
    """
    点赞表
    """
    nid = models.AutoField(primary_key=True)
    user = models.ForeignKey('UserInfo', null=True)
    comment = models.ForeignKey("Comment", null=True)


class Tag(models.Model):
    nid = models.AutoField(primary_key=True)
    title = models.CharField(verbose_name='标签名称', max_length=32)
    blog = models.ForeignKey(verbose_name='所属博客', to='Blog', to_field='nid')



class Article2Tag(models.Model):
    nid = models.AutoField(primary_key=True)
    article = models.ForeignKey(verbose_name='文章', to="Article", to_field='nid')
    tag = models.ForeignKey(verbose_name='标签', to="Tag", to_field='nid')

select_related

简单使用

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

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

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

下面的例子解释了普通查询和select_related() 查询的区别。

查询id=2的文章的分类名称,下面是一个标准的查询：

    # Hits the database.
    article=models.Article.objects.get(nid=2)

    # Hits the database again to get the related Blog object.
    print(article.category.title)

'''

SELECT 
    "blog_article"."nid", 
    "blog_article"."title", 
    "blog_article"."desc", 
    "blog_article"."read_count", 
    "blog_article"."comment_count", 
    "blog_article"."up_count", 
    "blog_article"."down_count", 
    "blog_article"."category_id", 
    "blog_article"."create_time",
     "blog_article"."blog_id", 
     "blog_article"."article_type_id" 
             FROM "blog_article" 
             WHERE "blog_article"."nid" = 2; args=(2,)

SELECT
     "blog_category"."nid", 
     "blog_category"."title", 
     "blog_category"."blog_id"
              FROM "blog_category" 
              WHERE "blog_category"."nid" = 4; args=(4,)


'''

若是咱们使用select_related()函数：

articleList=models.Article.objects.select_related("category").all()


    for article_obj in articleList:
        #  Doesn't hit the database, because article_obj.category
        #  has been prepopulated in the previous query.
        print(article_obj.category.title)

SELECT 
	 "blog_article"."nid", 
	 "blog_article"."title", 
	 "blog_article"."desc",
	 "blog_article"."read_count", 
	 "blog_article"."comment_count", 
	 "blog_article"."up_count", 
	 "blog_article"."down_count",
	 "blog_article"."category_id", 
	 "blog_article"."create_time", 
	 "blog_article"."blog_id", 
	 "blog_article"."article_type_id", 

	 "blog_category"."nid", 
	 "blog_category"."title", 
	 "blog_category"."blog_id" 

FROM "blog_article" 
LEFT OUTER JOIN "blog_category" ON ("blog_article"."category_id" = "blog_category"."nid");

多外键查询

这是针对category的外键查询，若是是另一个外键呢？让咱们一块儿看下：

article=models.Article.objects.select_related("category").get(nid=1)
print(article.articledetail)

观察logging结果，发现依然须要查询两次，因此须要改成：

article=models.Article.objects.select_related("category","articledetail").get(nid=1)
print(article.articledetail)

或者：

article=models.Article.objects
　　　　　　　　　　　　　.select_related("category")
　　　　　　　　　　　　　.select_related("articledetail")
　　　　　　　　　　　　　.get(nid=1)  # django 1.7 支持链式操做
print(article.articledetail)

 SELECT 

	 "blog_article"."nid", 
	 "blog_article"."title", 
	 ......

	 "blog_category"."nid", 
	 "blog_category"."title",
	 "blog_category"."blog_id", 

	 "blog_articledetail"."nid",
	 "blog_articledetail"."content",
	 "blog_articledetail"."article_id" 

    FROM "blog_article" 
    LEFT OUTER JOIN "blog_category" ON ("blog_article"."category_id" = "blog_category"."nid")
    LEFT OUTER JOIN "blog_articledetail" ON ("blog_article"."nid" = "blog_articledetail"."article_id") 
    WHERE "blog_article"."nid" = 1; args=(1,)

深层查询

# 查询id=1的文章的用户姓名

    article=models.Article.objects.select_related("blog").get(nid=1)
    print(article.blog.user.username)

依然须要查询两次：

SELECT 
	"blog_article"."nid", 
	"blog_article"."title", 
	......

	 "blog_blog"."nid", 
	 "blog_blog"."title", 

   FROM "blog_article" INNER JOIN "blog_blog" ON ("blog_article"."blog_id" = "blog_blog"."nid") 
   WHERE "blog_article"."nid" = 1; 




SELECT 
	"blog_userinfo"."password", 
	"blog_userinfo"."last_login",
	......

FROM "blog_userinfo" 
WHERE "blog_userinfo"."nid" = 1;

这是由于第一次查询没有query到userInfo表，因此，修改以下：

article=models.Article.objects.select_related("blog__user").get(nid=1)
print(article.blog.user.username)

SELECT 

"blog_article"."nid", "blog_article"."title",
......

 "blog_blog"."nid", "blog_blog"."title", 
......

 "blog_userinfo"."password", "blog_userinfo"."last_login",
......

FROM "blog_article"

INNER JOIN "blog_blog" ON ("blog_article"."blog_id" = "blog_blog"."nid") 

INNER JOIN "blog_userinfo" ON ("blog_blog"."user_id" = "blog_userinfo"."nid") 
WHERE "blog_article"."nid" = 1;

总结

select_related主要针一对一和多对一关系进行优化。
select_related使用SQL的JOIN语句进行优化，经过减小SQL查询的次数来进行优化、提升性能。
能够经过可变长参数指定须要select_related的字段名。也能够经过使用双下划线“__”链接字段名来实现指定的递归查询。
没有指定的字段不会缓存，没有指定的深度不会缓存，若是要访问的话Django会再次进行SQL查询。
也能够经过depth参数指定递归的深度，Django会自动缓存指定深度内全部的字段。若是要访问指定深度外的字段，Django会再次进行SQL查询。
也接受无参数的调用，Django会尽量深的递归查询全部的字段。但注意有Django递归的限制和性能的浪费。
Django >= 1.7，链式调用的select_related至关于使用可变长参数。Django < 1.7，链式调用会致使前边的select_related失效，只保留最后一个。

prefetch_related()

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

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

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

# 查询全部文章关联的全部标签
    article_obj=models.Article.objects.all()
    for i in article_obj:

        print(i.tags.all())  #4篇文章: hits database 5

改成prefetch_related：

# 查询全部文章关联的全部标签
    article_obj=models.Article.objects.prefetch_related("tags").all()
    for i in article_obj:

        print(i.tags.all())  #4篇文章: hits database 2

SELECT "blog_article"."nid",
               "blog_article"."title", 
               ......

FROM "blog_article";



SELECT
  ("blog_article2tag"."article_id") AS "_prefetch_related_val_article_id", 
  "blog_tag"."nid", 
  "blog_tag"."title",
  "blog_tag"."blog_id"
   FROM "blog_tag"
  INNER JOIN "blog_article2tag" ON ("blog_tag"."nid" = "blog_article2tag"."tag_id") 
  WHERE "blog_article2tag"."article_id" IN (1, 2, 3, 4);

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

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

练习：

# in sqlite:
    article_obj=models.Article.objects
　　　　　　　　　　　　　　.filter(nid=1)
　　　　　　　　　　　　　　.extra(select={"standard_time":"strftime('%%Y-%%m-%%d',create_time)"})
　　　　　　　　　　　　　　.values("standard_time","nid","title")
    print(article_obj)
    # <QuerySet [{'title': 'MongoDb 入门教程', 'standard_time': '2017-09-03', 'nid': 1}]>

参数之`where` / `tables`

您可使用where定义显式SQL WHERE子句 - 也许执行非显式链接。您可使用tables手动将表添加到SQL FROM子句。

where和tables都接受字符串列表。全部where参数均为“与”任何其余搜索条件。

举例来说：

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

总体插入

建立对象时，尽量使用bulk_create()来减小SQL查询的数量。例如：

Entry.objects.bulk_create([
    Entry(headline="Python 3.0 Released"),
    Entry(headline="Python 3.1 Planned")
])

...更优于：

Entry.objects.create(headline="Python 3.0 Released")
Entry.objects.create(headline="Python 3.1 Planned")

注意该方法有不少注意事项，因此确保它适用于你的状况。

这也能够用在ManyToManyFields中，因此：

my_band.members.add(me, my_friend)

...更优于：

my_band.members.add(me)
my_band.members.add(my_friend)

...其中Bands和Artists具备多对多关联。

博客转自：http://www.cnblogs.com/yuanchenqi/articles/7629939.html

Django框架_URLconf、Views、template、ORM

目录:

1、Django-MTV

2、Django-model基础

3、Django-model进阶

MTV模型

Django基本命令

一、下载Django：

二、建立一个django project

三、在mysite目录下建立应用

四、启动django项目

五、同步更改数据库表或字段

六、清空数据库

七、建立超级管理员

八、Django 项目环境终端

九、Django 项目环境终端

十、更多命令

11 静态文件配置

视图层之路由配置系统(views)

2.1 URLconf的正则字符串参数

2.1.1 简单配置

2.1.2 有名分组(named group)

2.1.3 URLconf 在什么上查找

2.1.4 捕获的参数永远是字符串

2.1.5 指定视图参数的默认值

2.1.6 Including other URLconfs

2.2 传递额外的选项给视图函数(了解)

2.3 URL 的反向解析

2.4 命名URL 模式

2.5 CBV

d视图层之视图函数(views)

一个简单的视图

HttpRequest对象

render 函数

redirect 函数

传递一个对象

传递一个视图的名称

传递要重定向的一个硬编码的URL

跳转（重定向）应用

模板层(template)

模板语法之变量

模板之过滤器

default

length

filesizeformat

date

slice

truncatechars

safe

模板之标签

for标签

for ... empty

if 标签

with

csrf_token

自定义标签和过滤器

模板继承 (extend)

Django-model基础

ORM

建立表(创建模型)

字段选项

添加表记录

普通字段

外键字段

多对多字段

class RelatedManager

查询表记录

查询相关API

双下划线之单表查询

基于对象的跨表查询

一对多查询（Publish 与 Book）

一对一查询(Author 与 AuthorDetail)

多对多查询 (Author 与 Book)

基于双下划线的跨表查询

聚合查询与分组查询

聚合：aggregate(*args, **kwargs)

分组：annotate()

F查询与Q查询

F查询

Q查询

`default`

`filesizeformat`

模板之标签　

`聚合：aggregate`(*args, **kwargs)

分组：annotate()　

参数之`where` / `tables`