django

Django

概述

python有许多不同的WEB框架，django是最具有代表性的一位，许多成功的网站和APP都基于django

django是一个开源的web应用框架，由python编写

django采用了MVC的软件设计模式，既模型M，视图V，和控制器C

MVC框架和MTV框架

MVC （Model View Controller）是软件工程中的一种软件架构模式；把软件分为了三个基本部分：模型（Model） 视图（View）和 控制器（controller）具有耦合度低，重用性高，生命周期成本低等优点。

Django框架的设计模式借鉴了MVC框架的思想，也是分成三部分，来降低各个部分之间的耦合性。

Django框架的不同之处在于它拆分的三部分为：Model（模型）、Template（模板）和View（视图），也就是MTV框架。

Django的MTV模式

• Model(模型)：负责业务对象与数据库的对象(ORM)
• Template(模版)：负责如何把页面展示给用户
• View(视图)：负责业务逻辑，并在适当的时候调用Model和Template

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

Django框架图示

前端状态码的返回

1xx  请求接受了需进一步处理
2xx  成功
3xx  重定向  
4xx  请求的错误
5xx  服务器错误

url

# url的组成
协议  域名(ip)  端口(http默认80  https 443 )   路径  查询参数(?k1=v1&k2=v2) 

请求的格式(request)

"请求方法 路径 HTTP/1.1

采用方式:键值对

k2:v2

web框架的功能

web框架的功能:

1. socket收发消息
2. 根据不同的路径返回不同的内容 
3. 返回动态页面(字符串的替换  模板渲染) 

django的常用命令

安装ajango

# 指定安装的版本为1.11.25  -i参数指定下载源，默认国外官方，这里改成清华源
pip install django==1.11.25 -i https://pypi.tuna.tsinghua.edu.cn/simple/

创建django项目

# 创建项目
django-admin startproject mypro

django启动

 python manage.py runserver
 python  manage.py  runserver 80  # 127.0.0.1:80
 python manage.py runserver 0.0.0.0:80   # 指定ip:port

startproject的做的事情

mysite/
    manage.py
    mysite/
        __init__.py
        settings.py
        urls.py
        wsgi.py

• 外部mysite/根目录只是您的项目的容器。它的名称与Django无关；您可以将其重命名为任何喜欢的名称

• manage.py：一个命令行实用程序，可让您以各种方式与该Django项目进行交互。您可以manage.py在django-admin和manage.py中阅读有关的所有详细信息 。

• 内部mysite/目录是项目的实际Python包。它的名称是Python包名称，您需要使用它来导入其中的任何内容（例如mysite.urls）。

• mysite/settings.py：此Django项目的设置/配置。 Django设置将告诉您所有设置的工作方式

• mysite/urls.py：此Django项目的URL声明；Django支持的网站的“目录”。您可以在URL调度程序中阅读有关URL的更多信息。

• mysite/wsgi.py：兼容WSGI的Web服务器为您的项目提供服务的入口点。有关更多详细信息，请参见如何使用WSGI进行部署。

创建app程序

项目和应用之间有什么区别？应用程序是执行某项操作的Web应用程序，例如Weblog系统，公共记录数据库或简单的民意调查应用程序。项目是特定网站的配置和应用程序的集合。一个项目可以包含多个应用程序。一个应用程序可以在多个项目中。

创建应用注意 当与manage.py处于同一层目录

python .\manage.py startapp polls

数据库迁移 注入

python manage.py  makemigrations  # 检测已经注册app下的models.py的变更记录
python manage.py migrate   # 数据库迁移(生效到数据库中) 

django的配置

• BASE_DIR 整个项目的根目录

  • INSTALLED_APPS 注册的程序APP 如果创建了新的APP这里则需要添加,不添加无法使用 默认包括了以下 Django 的自带应用：
  • django.contrib.admin -- 管理员站点， 你很快就会使用它。
    • django.contrib.auth -- 认证授权系统。
    • django.contrib.contenttypes -- 内容类型框架。
    • django.contrib.sessions -- 会话框架。
    • django.contrib.messages -- 消息框架。
    • django.contrib.staticfiles -- 管理静态文件的框架。

  这些应用被默认启用是为了给常规项目提供方便。

  'app01.apps.App01Config',  # app01 添加如下
  

• MIDDLEWARE 中间件配置

  django.middleware.csrf.CsrfViewMiddleware  # 注册掉后可以提交post请求
  

• TEMPLATES 模板目录

  'DIRS': [os.path.join(BASE_DIR, 'templates')] # 静态文件存放的目录(html)
  

• TIME_ZONE 为你自己时区

  TIME_ZONE = 'Asia/Shanghai'  # 设置时区为上海
  USE_TZ = False  # 关闭随模板时间 
  

• 定义自定义显示时间

  USE_L10N = False  # 设置为False 默认为True
  DATETIME_FORMAT = 'Y-m-d H:i:s'  # 年月日 时分秒
  DATE_FORMAT = 'Y-m-d'  # 年月日
  TIME_FORMAT = 'H:i:s'  # 时分秒
  

• DATABASES 数据库配置

  • ENGINE -- 可选值有 'django.db.backends.sqlite3'，'django.db.backends.postgresql'，'django.db.backends.mysql'，或 'django.db.backends.oracle'。其它 可用后端。
  • NAME - 数据库的名称。如果使用的是 SQLite，数据库将是你电脑上的一个文件，在这种情况下， NAME 应该是此文件的绝对路径，包括文件名。默认值 os.path.join(BASE_DIR, 'db.sqlite3') 将会把数据库文件储存在项目的根目录。

  如果你不使用 SQLite，则必须添加一些额外设置，比如 USER 、 PASSWORD 、 HOST 等等。想了解更多数据库设置方面的内容，请看文档：DATABASES 。

  注意: 配置时注意提前创建好对应库

DATABASES = {
    'default': {
    'ENGINE': 'django.db.backends.mysql', # 属于什么数据库(例如:mysql)
    'NAME': 'bookmanager',   # 数据库的名称
    'HOST': '127.0.0.1',     # 数据库地址
    'PORT': 3306,            # port
    'USER': 'user',          # 用户
    'PASSWORD': 'password'   # 密码
}
}

# 使用pymysql替换MySQLdb模块
import pymysql
pymysql.install_as_MySQLdb()

• 静态文件的配置(如CSS,js,image)

STATIC_URL = '/static/'  # 静态文件的别名
STATICFILES_DIRS = [
    os.path.join(BASE_DIR, 'static')
]

URL调度(路由)

官方文档: https://docs.djangoproject.com/zh-hans/2.2/topics/http/urls/

摘录博客:https://www.cnblogs.com/maple-shaw/articles/9282718.html

URL配置(URLconf)就像Django所支撑网站的目录.

它的本质是URL 与要 为该URL调用的试图函数之间的映射表

URLconf配置

基本格式

urlpatterns = [
	url(正则表达式,View视图, 参数, 别名),
]

示例

urlpatterns = [
    url(r'^book/$',views.book,name='book'),
    url(r'^book_add/$', views.BookAdd.as_view(), name='book_add'),
    url(r'^book_edit/(?P<pk>\d+)/$', views.BookEdit.as_view(), name='book_edit'),
    url(r'^(\w+)/del/(\d+)/$',views.delete, name='del'),
]

参数说明

• 正则表达式: 一个正则表达式字符串
• views试图: 一个可调用对象,通常为一个视图函数
• 参数: 可选的要传递给视图函数的默认参数 (字典形式)
• 别名: 一个可选的name参数

注意：

Django 2.0版本中的路由系统是下面的写法（官方文档）：

2.0版本path函数

2.0版本中re_path和1.11版本的url是一样的用法。

URLconfs中使用的函数 path（route，view，kwargs = None，name = None )

例如：

from django.urls import include, path

urlpatterns = [
    path('index/', views.index, name='main-view'),
    path('bio/<username>/', views.bio, name='bio'),
    path('articles/<slug:title>/', views.article, name='article-detail'),
    path('articles/<slug:title>/<int:section>/', views.section, name='article-section'),
    path('weblog/', include('blog.urls')),
]

route

route 是一个匹配 URL 的准则（类似正则表达式）。当 Django 响应一个请求时，它会从 urlpatterns 的第一项开始，按顺序依次匹配列表中的项，直到找到匹配的项。

这些准则不会匹配 GET 和 POST 参数或域名。例如，URLconf 在处理请求 https://www.example.com/myapp/ 时，它会尝试匹配 myapp/ 。处理请求 https://www.example.com/myapp/?page=3 时，也只会尝试匹配 myapp/。

view

当 Django 找到了一个匹配的准则，就会调用这个特定的视图函数，并传入一个 HttpRequest 对象作为第一个参数，被“捕获”的参数以关键字参数的形式传入。稍后，我们会给出一个例子。

kwargs

任意个关键字参数可以作为一个字典传递给目标视图函数。本教程中不会使用这一特性。

name

为你的 URL 取名能使你在 Django 的任意地方唯一地引用它，尤其是在模板中。这个有用的特性允许你只改一个文件就能全局地修改某个 URL 模式。

正则表达式详解

基本配置

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),
]

注意事项

1. urlpatterns中的元素按照书写顺序从上往下逐一匹配正则表达式，一旦匹配成功则不再继续。
2. 若要从URL中捕获一个值，只需要在它周围放置一对圆括号（分组匹配）。
3. 不需要添加一个前导的反斜杠，因为每个URL 都有。例如，应该是^articles 而不是 ^/articles。
4. 每个正则表达式前面的'r' 是可选的但是建议加上。

补充说明

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

Django settings.py配置文件中默认没有 APPEND_SLASH 这个参数，但 Django 默认这个参数为 APPEND_SLASH = True。 其作用就是自动在网址结尾加'/'。

其效果就是：

我们定义了urls.py：

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

urlpatterns = [
    url(r'^blog/$', views.blog),
]

访问 http://www.example.com/blog 时，默认将网址自动转换为 http://www.example/com/blog/ 。

如果在settings.py中设置了 APPEND_SLASH=False，此时我们再请求 http://www.example.com/blog 时就会提示找不到页面。

分组命名匹配

上面的示例中使用的是简单的正则表达式分组匹配(通过圆括号) 来捕获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]+)/$', views.article_detail),
]

这个实现与前面的示例完全相同,只有一个细微的差别: 捕获的值作为关键字参数而不是位置参数传递给是凸函数

例如:相当于URL /articles/2017/12/相当于以下的方式调用视图函数

views.month_archive(request, year="2017",month="12")

在实际应用中，使用分组命名匹配的方式可以让你的URLconf 更加明晰且不容易产生参数顺序问题的错误，但是有些开发人员则认为分组命名组语法太丑陋、繁琐。

至于究竟应该使用哪一种，你可以根据自己的喜好来决定。

URLconf中的配置

URLconf 在请求的url中查找,将它当作一个普通的字符串. 不包括GET和POST参数以及域名

例如:

http://www.example.com/myapp/ get请求中 , URLconf将查找myapp

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

urlconf不检查请求的方法. 换句话来讲,所有的请求方法 ---- 同一个URL的POST,GET,HEAD等等都将会路由到相同的函数下

捕获到的参数永远都是字符串

每个在URLconf中捕获的参数都作为一个普通的字符串传递给视图,无论正则表达式使用的什么匹配方式,

例如:

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

传递给视图函数views.year_archive()中的year永远是一个字符串

视图函数指定默认值

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),
]

# views.py中，可以为num指定默认值
def page(request, num="1"):
    pass

在上面的例子中，两个URL模式指向相同的view - views.page - 但是第一个模式并没有从URL中捕获任何东西。

如果第一个模式匹配上了，page()函数将使用其默认参数num=“1”,如果第二个模式匹配，page()将使用正则表达式捕获到的num值。

路由分发 (include其他的URLconfs)

该函数采用完整的Python导入路径到该位置应“包括”到另一个URLconf模块的路径。（可选）还可以指定条目将包含在其中的应用程序名称空间和实例名称空间。

通常，应用程序名称空间应由包含的模块指定。如果设置了应用程序名称空间，则该namespace参数可用于设置其他实例名称空间。

include() 还接受返回URL模式的iterable或包含该iterable的2元组以及应用程序名称空间的名称作为参数。

语法格式

include（module，namespace = None）

include（pattern_list）

include（（pattern_list，app_namespace），namespace = None

参数：

• module -URLconf模块（或模块名称）
• 名称空间（str）-包含URL条目的实例名称空间
• pattern_list-path()和/或re_path()实例的可迭代。
• app_namespace（str）-包含URL条目的应用程序名称空间

函数 include() 允许引用其它 URLconfs。每当 Django 遇到 include() 时，它会截断与此项匹配的 URL 的部分，并将剩余的字符串发送到 URLconf 以供进一步处理。

当包括其它 URL 模式时你应该总是使用 include() ， admin.site.urls 是唯一例外。

from django.conf.urls import include, url

urlpatterns = [
   url(r'^admin/', admin.site.urls),
   url(r'^blog/', include('blog.urls')),  # 可以包含其他的URLconfs文件
]

URL的命名和反向解析

在一个真实的 Django 项目中，可能会有五个，十个，二十个，甚至更多应用。Django 如何分辨重名的 URL 呢？举个例子，polls 应用有 detail 视图，可能另一个博客应用也有同名的视图。Django 如何知道 {% url %} 标签到底对应哪一个应用的 URL 呢？

不需要写死URL代码了，只需要通过名字来调用当前的URL。

答案是：在根 URLconf 中添加命名空间。在 polls/urls.py 文件中稍作修改，加上 app_name 设置命名空间：

url(r'^home', views.home, name='home'),  # 给我的url匹配模式起名为 home
url(r'^index/(\d*)', views.index, name='index'),  # 给我的url匹配模式起名为index

模板使用

{% url 'home' %}

view视图使用

from django.urls import reverse

reverse("index", args=("2018", ))

参数传递

# 模板:
{% url 'pub_del' '10' %}    _>   # '/app01/publisher/del/10/'   位置传参
{% url 'pub_del' pk='10' %}    _>  # '/app01/publisher/del/10/'   关键字传参

# py文件:
from django.urls import reverse
reverse('pub_del',args=(11,))     # '/app01/publisher/del/11/'     位置传参
reverse('pub_del',kwargs={'pk':'11'})     # '/app01/publisher/del/11/'   关键字传参

例子：

考虑下面的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.urls import reverse
from django.shortcuts import redirect

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

如果出于某种原因决定按年归档文章发布的URL应该调整一下，那么你将只需要修改URLconf 中的内容。

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

命名空间模式

namespace 避免name重名

即使不同的APP使用相同的URL名称，URL的命名空间模式也可以让你唯一反转命名的URL。

即使不同的APP使用相同的URL名称，URL的命名空间模式也可以让你唯一反转命名的URL。

举个例子：

project中的urls.py

from django.conf.urls import url, include
 
urlpatterns = [
    url(r'^app01/', include('app01.urls', namespace='app01')),
    url(r'^app02/', include('app02.urls', namespace='app02')),
]

app01中的urls.py

from django.conf.urls import url
from app01 import views
 
app_name = 'app01'
urlpatterns = [
    url(r'^(?P<pk>\d+)/$', views.detail, name='detail')
]

app02中的urls.py

from django.conf.urls import url
from app02 import views
 
app_name = 'app02'
urlpatterns = [
    url(r'^(?P<pk>\d+)/$', views.detail, name='detail')
]

现在，我的两个app中 url名称重复了，我反转URL的时候就可以通过命名空间的名称得到我当前的URL。

语法：

'命名空间名称:URL名称'

模板中使用：

{% url 'app01:detail' pk=12 pp=99 %}

views中的函数中使用

v = reverse('app01:detail', kwargs={'pk':11})

这样即使app中URL的命名相同，我也可以反转得到正确的URL了。

视图

摘录博客: https://www.cnblogs.com/maple-shaw/articles/9285269.html

一个视图函数（类），简称视图，是一个简单的Python 函数（类），它接受Web请求并且返回Web响应。

响应可以是一张网页的HTML内容，一个重定向，一个404错误，一个XML文档，或者一张图片。

无论视图本身包含什么逻辑，都要返回响应。代码写在哪里也无所谓，只要它在你当前项目目录下面。除此之外没有更多的要求了——可以说“没有什么神奇的地方”。为了将代码放在某处，大家约定成俗将视图放置在项目（project）或应用程序（app）目录中的名为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对象。

Django使用请求和响应对象来通过系统传递状态。

当浏览器向服务端请求一个页面时，Django创建一个HttpRequest对象，该对象包含关于请求的元数据。然后，Django加载相应的视图，将这个HttpRequest对象作为第一个参数传递给视图函数。

每个视图负责返回一个HttpResponse对象。

CBV和FBV

我们之前写过的都是基于函数的view，就叫FBV。还可以把view写成基于类的 就叫CBV。

FBV (function based view )

def index(request):
	# 逻辑
	return reponse

CBV (class based view )

from django.views import View
class PublisherAdd(View):
    
    def get(self,request,*args,**kwargs):
        # 处理GET请求的逻辑
        return response
    
    def post(self,request,*args,**kwargs):
        # 处理GET请求的逻辑
        return response

使用CBV时，urls.py中也做对应的修改：

url(r'^publisher/add/$', views.PublisherAdd.as_view(), name='pub_add'),

as_view()的流程:

1. self.request= request
2. 通过反射获取对应请求方式(GET)对应的方法(get)

给视图加装饰器

使用装饰器装饰FBV

FBV本身就是一个函数，所以和给普通的函数加装饰器无差：

def wrapper(func):
    def inner(*args, **kwargs):
        start_time = time.time()
        ret = func(*args, **kwargs)
        end_time = time.time()
        print("used:", end_time-start_time)
        return ret
    return inner


# FBV版添加班级
@wrapper
def add_class(request):
    if request.method == "POST":
        class_name = request.POST.get("class_name")
        models.Classes.objects.create(name=class_name)
        return redirect("/class_list/")
    return render(request, "add_class.html")

给CBV加装饰器的方法:

类中的方法与独立函数不完全相同，因此不能直接将函数装饰器应用于类中的方法 ，我们需要先将其转换为方法装饰器。

Django中提供了method_decorator装饰器用于将函数装饰器转换为方法装饰器。

from django.utils.decorators import method_decorator  # 推荐使用

1 加在方法上:

@method_decorator(timer)
def get(self, request, *args, **kwargs):

2 加在dispatch方法上

@method_decorator(timer)
def dispatch(self, request, *args, **kwargs):
    ret = super().dispatch(request, *args, **kwargs)
    return ret
    
@method_decorator(timer,name='dispatch')  # 推荐使用
class PublisherAdd(View):

3 加在类上

@method_decorator(timer,name='post')
@method_decorator(timer,name='get')
class PublisherAdd(View):

Request对象和Response对象

request对象

当一个页面被请求时，Django就会创建一个包含本次请求原信息的HttpRequest对象。
Django会将这个对象自动传递给响应的视图函数，一般视图函数约定俗成地使用 request 参数承接这个对象。

官方文档

request属性

所有的属性应该被认为是只读的，除非另有说明。

属性	含义
request.method	一个字符串，表示请求使用的HTTP 方法
request.GET	一个类似于字典的对象，包含 HTTP GET 的所有参数
request.POST	一个类似于字典的对象，如果请求中包含表单数据，编码是urlencode才有数据
request.path_info	返回用户访问url，不包含IP和端口 也不包含查询参数
request.body	请求体，byte类型 request.POST的数据就是从body里面提取到的
request.session	一个既可读又可写的类似于字典的对象，表示当前的会话。
request.COOKIES	一个标准的Python 字典，包含所有的cookie。键和值都为字符串。
request.FILES	一个类似于字典的对象，包含所有的上传文件信息。
request.META	一个标准的Python 字典，包含所有的HTTP 首部。具体的头部信息取决于客户端和服务器，

上传文件示例代码

def upload(request):
    """
    保存上传文件前，数据需要存放在某个位置。默认当上传文件小于2.5M时，django会将上传文件的全部内容读进内存。从内存读取一次，写磁盘一次。
    但当上传文件很大时，django会把上传文件写到临时文件中，然后存放到系统临时文件夹中。
    :param request: 
    :return: 
    """
    if request.method == "POST":
        # 从请求的FILES中获取上传文件的文件名，file为页面上type=files类型input的name属性值
        filename = request.FILES["file"].name
        # 在项目目录下新建一个文件
        with open(filename, "wb") as f:
            # 从上传的文件对象中一点一点读
            for chunk in request.FILES["file"].chunks():
                # 写入本地文件
                f.write(chunk)
        return HttpResponse("上传OK")

request方法

方法	含义
request.get_full_path()	返回 path，不包含IP和端口 包含查询参数
request.is_ajax()	是否ajax请求,返回布尔值

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

request.POST.getlist("hobby")

response对象

与由Django自动创建的HttpRequest对象相比，HttpResponse对象是我们的职责范围了。我们写的每个视图都需要实例化，填充和返回一个HttpResponse。

HttpResponse类位于django.http模块中。

使用

传递字符串

from django.http import HttpResponse
response = HttpResponse("Here's the text of the Web page.")
response = HttpResponse("Text only, please.", content_type="text/plain")

设置或删除响应头信息

response = HttpResponse()
response['Content-Type'] = 'text/html; charset=UTF-8'
del response['Content-Type']

属性

HttpResponse.content：响应内容

HttpResponse.charset：响应内容的编码

HttpResponse.status_code：响应的状态码

方法

HttpReponse('字符串')  # 返回字符串
render(request,'模板的路径',{})   #  返回一个HTML页面 
redirect(重定向的地址)   重定向 # 响应头  Location:地址

JsonResponse对象

JsonResponse是HttpResponse的子类，专门用来生成JSON编码的响应。

from django.http import JsonResponse

response = JsonResponse({'foo': 'bar'})
print(response.content)

b'{"foo": "bar"}'

默认只能传递字典类型，如果要传递非字典类型需要设置一下safe关键字参数。

response = JsonResponse([1, 2, 3], safe=False)

Django shortcut functions

官方文档

render()

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

参数：

• request： 用于生成响应的请求对象。
• template_name：要使用的模板的完整名称，可选的参数
• context：添加到模板上下文的一个字典。默认是一个空字典。如果字典中的某个值是可调用的，视图将在渲染模板之前调用它。
• content_type：生成的文档要使用的MIME类型。默认为 DEFAULT_CONTENT_TYPE 设置的值。默认为'text/html'
• status：响应的状态码。默认为200。
• useing: 用于加载模板的模板引擎的名称。

一个简单的例子：

from django.shortcuts import render

def my_view(request):
    # 视图的代码写在这里
    return render(request, 'myapp/index.html', {'foo': 'bar'})

上面的代码等于：

from django.http import HttpResponse
from django.template import loader

def my_view(request):
    # 视图代码写在这里
    t = loader.get_template('myapp/index.html')
    c = {'foo': 'bar'}
    return HttpResponse(t.render(c, request))

redirect()

参数可以是：

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

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

示例:[

](http://python.usyiyi.cn/documents/django_182/topics/http/shortcuts.html#examples)

你可以用多种方式使用redirect() 函数。

传递一个具体的ORM对象（了解即可）

将调用具体ORM对象的get_absolute_url() 方法来获取重定向的URL：

from django.shortcuts import redirect
 
def my_view(request):
    ...
    object = MyModel.objects.get(...)
    return redirect(object)

传递一个视图的名称

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

传递要重定向到的一个具体的网址

def my_view(request):
    ...
    return redirect('/some/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)　　

模板

• 官方文档: https://docs.djangoproject.com/en/1.11/ref/templates/language/

• 摘录博客: https://www.cnblogs.com/maple-shaw/articles/9333821.html

常用语法

{{ 变量 }}  # 表示变量，在模板渲染的时候替换成值
{%  %}   # 表示逻辑相关的代码

点（.）在模板语言中有特殊的含义，用来获取对象的相应属性值。

模板中支持的写法：

{{  变量 }}   没有 []  ()  写法

{{ 变量.   }}    .索引  .key   .属性 .方法

注：当模板系统遇到一个（.）时，会按照如下的顺序去查询：

1. 在字典中查询
2. 属性或者方法
3. 数字索引

Filters 过滤器

翻译为过滤器，用来修改变量的显示结果。

语法： {{ value|filter_name:参数 }}

':'左右没有空格没有空格没有空格

内置的过滤器

default 默认值

{{ xxx|default:"没有这个变量" }}  # 变量不存在或者为空时候使用默认值
# 注：TEMPLATES的OPTIONS可以增加一个选项：string_if_invalid：'找不到'，可以替代default的的作用。

filesizeformat 格式化文件大小

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

{{ value|filesizeformat }}

如果 value 是 123456789，输出将会是 117.7 MB。

add 计算 拼接

{{ a|add:b }}  # 数字的加减法  字符串的拼接  列表的拼接

{{ value|add:"2" }}
# value是数字4，则输出结果为6。

{{ first|add:second }}
# 如果first是 [1,.2,3] ，second是 [4,5,6] ，那输出结果是 [1,2,3,4,5,6] 。

length 统计长度

{{ [1,32,]|length }}   # 2 
# 返回value的长度，如 value=['a', 'b', 'c', 'd']的话，就显示4.

slice 切片

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

first 取第一个元素

{{ value|first }}

last 取最后一个元素

{{ value|last }}

join 字符串拼接

使用字符串拼接列表。同python的str.join(list)。

{{ value|join:" // " }}

truncatechars truncatewords

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

参数：截断的字符数

{{ "如果字符串字符多于指定的字符数量，那么会被截断。截断的字符串将以可翻译的省略号"|truncatechars:'10' }}

{{ "如果 字符串 字符 多于 指定的字符数量，那么会被截断。截断的字符串将以可翻译的省略号"|truncatewords:'4' }}

date

日期格式化

{{ now|date:'Y-m-d H:i:s' }}

safe

# 告诉django,当前的内容是安全的,不需要做转义
value = "<a href='#'>点我</a>"
{{ value|safe}}

自定义filter

自定义过滤器只是带有一个或两个参数的Python函数:

• 变量（输入）的值 - -不一定是一个字符串
• 参数的值 - 这可以有一个默认值，或完全省略

例如，在过滤器{{var | foo：“bar”}}中，过滤器foo将传递变量var和参数“bar”。

自定义filter代码文件摆放位置：

app01/
    __init__.py
    models.py
    templatetags/  # 在app01下面新建一个package package
        __init__.py
        app01_filters.py  # 建一个存放自定义filter的py文件
    views.py

编写自定义filter

from django import template
register = template.Library()


@register.filter
def fill(value, arg):
    return value.replace(" ", arg)


@register.filter(name="addSB")
def add_sb(value):
    return "{} SB".format(value)

使用自定义filter

{# 先导入我们自定义filter那个文件 #}
{% load app01_filters %}

{# 使用我们自定义的filter #}
{{ somevariable|fill:"__" }}
{{ d.name|addSB }}

Tags

for

<ul>
{% for user in user_list %}
    <li>{{ user.name }}</li>
{% endfor %}
</ul>

for循环可用的一些参数：

变量	描述
forloop.counter	循环的当前迭代（1索引）
forloop.counter0	循环的当前迭代（0索引）
forloop.revcounter	从循环末尾开始的迭代次数（1索引）
forloop.revcounter0	从循环末尾开始的迭代次数（0索引）
forloop.first	如果这是第一次循环，则为真
forloop.last	如果这是最后一次循环，则为true
forloop.parentloop	对于嵌套循环，这是围绕当前循环的循环

for ... empty

<ul>
{% for user in user_list %}
    <li>{{ user.name }}</li>
{% empty %}
    <li>空空如也</li>
{% endfor %}
</ul>

if,elif和else

{% if user_list %}
  用户人数：{{ user_list|length }}
{% elif black_list %}
  黑名单数：{{ black_list|length }}
{% else %}
  没有用户
{% endif %}

当然也可以只有if和else

{% if user_list|length > 5 %}
  七座豪华SUV
{% else %}
    黄包车
{% endif %}

if语句支持 and 、or、==、>、<、!=、<=、>=、in、not in、is、is not判断。

if 判断不支持算数运算 不支持连续判断

with

定义一个中间变量

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

csrf_token

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

在form标签中使用{% csrf_token %}标签,就可以提交POST请求.

在页面的form表单里面写上{% csrf_token %}

注释

{# ... #}

注意事项

1. Django的模板语言不支持连续判断，即不支持以下写法：

{% if a > b > c %}
...
{% endif %}

\2. Django的模板语言中属性的优先级大于方法

def xx(request):
    d = {"a": 1, "b": 2, "c": 3, "items": "100"}
    return render(request, "xx.html", {"data": d})

如上，我们在使用render方法渲染一个页面的时候，传的字典d有一个key是items并且还有默认的 d.items() 方法，此时在模板语言中:

{{ data.items }}

默认会取d的items key的值。

母版

注意：我们通常会在母板中定义页面专用的CSS块和JS块，方便子页面替换。

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="x-ua-compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Title</title>
  {% block page-css %}
  
  {% endblock %}
</head>
<body>

<h1>这是母板的标题</h1>

{% block page-main %}

{% endblock %}
<h1>母板底部内容</h1>
{% block page-js %}

{% endblock %}
</body>
</html>

继承母板

在子页面中在页面最上方使用下面的语法来继承母板。

{% extends 'layouts.html' %}

块 block

通过在母板中使用{% block xxx %}来定义"块"。

在子页面中通过定义母板中的block名来对应替换母板中相应的内容。

{% block page-main %}
  <p>世情薄</p>
  <p>人情恶</p>
  <p>雨送黄昏花易落</p>
{% endblock %}

组件

可以将常用的页面内容如导航条，页尾信息等组件保存在单独的文件中，然后在需要使用的地方按如下语法导入即可。

{% include 'navbar.html' %}

静态文件相关

{% load static %}
<img src="{% static "images/hi.jpg" %}" alt="Hi!" />

引用JS文件时使用：

{% load static %}
<script src="{% static "mytest.js" %}"></script>

某个文件多处被用到可以存为一个变量

{% load static %}
{% static "images/hi.jpg" as myphoto %}
<img src="{{ myphoto }}"></img>

使用get_static_prefix

{% load static %}
<img src="{% get_static_prefix %}images/hi.jpg" alt="Hi!" />

或者

{% load static %}
{% get_static_prefix as STATIC_PREFIX %}

<img src="{{ STATIC_PREFIX }}images/hi.jpg" alt="Hi!" />
<img src="{{ STATIC_PREFIX }}images/hi2.jpg" alt="Hello!" />