django
Django
MTV模型
django的MTV分别代表：
Model(模型)：负责业务对象与数据库的对象（ORM）
Template(模板)：负责如何把页面展示给用户
View(视图)：负责业务逻辑，并在适当的时候调用Model和Template
此外，django还有一个urls分发器，它的作用是将一个个URL页面请求分发给不同的view处理
view再调用相应的Model和Template
diango框架模板
Django基本命令
1.下载django
(1)在cmd命令行中输入：pip install django
2.创建一个django项目
（1）在cmd命令行中输入django-admin.py startproject mysite(项目名称)
（2）当前目录下会生成mysite的工程，目录结构如下：
（3）manage.py----django项目里的工具，通过它可以调用django shell和数据库，项目的启动文件;
settings.py----包含了项目的默认设置，包括数据库信息，调试标志以及其他一些工作的变量;
urls.py----负责把URL模式映射到应用程序
wsgi.py----socketserver
（4）在mysite目录下创建应用
在命令行中输入：python manage.py startapp blog
其目录如下：
3.启动django项目
- 在cmd命令行中输入python mange.py runserver 8000
- 访问http://127.0.0.1:8000/时就可以看到：
这样，我们就启动了django的第一个项目
4.同步更改数据库表或字段
- 在命令行中输入（按顺序输入）： python manage.py makemigrations
python manage.py migrate
- Django 1.7.1 以下的版本需用命令：python manage.py syncdb
- 可以创建表，当在models.py中新增了类时，运行它就可以自动在数据库中创建表了，不用手动创建
5.清空数据库
- 在命令行中输入：python manage.py flush 选择yes会把数据全部清空掉，只留下空表
6.创建超级管理员
- 在命令行中输入： python manage.py createsuperuser
按照提示输入用户名和对应的密码就好了邮箱可以留空，用户名和密码必填
- 修改 用户密码可以用： python manage.py changepassword username
7.django项目环境终端
（1）python manage.py shell
这个命令和 直接运行 python 进入 shell 的区别是：你可以在这个 shell 里面调用当前
项目的 models.py 中的 API，对于操作数据的测试非常方便。
（2）python manage.py dbshell
Django 会自动进入在settings.py中设置的数据库，如果是 MySQL 或 postgreSQL,
会要求输入数据库用户密码,在这个终端可以执行数据库的SQL语句
8.更多命令
python manage.py---查看所有的命令，忘记子名称的时候特别有用。9.静态文件配置
STATIC_URL = '/static/' # 别名 STATICFILES_DIRS = ( os.path.join(BASE_DIR,"static"), #实际名 ,即实际文件夹的名字 )
<script src="/static/jquery-3.1.1.js"></script>
若： STATICFILES_DIRS = ( ("app01",os.path.join(BASE_DIR, "app01/statics")), )
<script src="/static/app01/jquery.js"></script>
视图层之路由配置系统(views)
URL配置(URLconf)就像Django 所支撑网站的目录。它的本质是URL与要为该URL调用的视图函数
之间的映射表；你就是以这种方式告诉Django，对于这个URL调用这段代码，对于那个URL调用那段
代码。 ''' urlpatterns = [ url(正则表达式, views视图函数，参数，别名), ] 参数说明： 一个正则表达式字符串 一个可调用对象，通常为一个视图函数或一个指定视图函数路径的字符串 可选的要传递给视图函数的默认参数（字典形式） 一个可选的name参数 '''
1.URLconf的正则字符串参数
- 简单配置（无名分组）
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
- 有名分组
在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 在什么上查找
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等等 —— 都将路由到相同的函数。
-
捕获的参数永远是字符串
每个捕获的参数都作为一个普通的Python 字符串传递给视图，无论正则表达式使
用的是什么匹配方式。例如，下面这行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),
]
# View (in blog/views.py)
def page(request, num="1"):
...
在上面的例子中，两个URL模式指向同一个视图views.page —— 但是第一个模式不会从URL
中捕获任何值。如果第一个模式匹配，page() 函数将使用num参数的默认值"1"。
如果第二个模式匹配，page() 将使用正则表达式捕获的num值。
-
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.传递额外的选项给视图函数
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 框架中使用，来传递元数据和选项给视图。
3.URL 的反向解析
url的最后一个参数，别名，就是在改变.html文件名时，还能找着对应关系
在需要URL 的地方，对于不同层级，Django 提供不同的工具用于URL 反查：
在模板中：使用url 模板标签。
在Python 代码中：使用django.core.urlresolvers.reverse() 函数。
在更高层的与处理Django 模型实例相关的代码中：使用get_absolute_url() 方法。
例如：
from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^articles/([0-9]{4})/$', views.year_archive,
name='news-year-archive'),
]
在模板的代码中使用下面的方法：
<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 时，只有视图的名字还不够。
4.命名url模式
为了完成上面例子中的URL反查，你将需要使用命名的URL模式。URL的名称使用
的字符串可以包含任何你喜欢的字符。不只限制在合法的Python 名称。
当命名你的URL 模式时，请确保使用的名称不会与其它应用中名称冲突。
如果你的URL 模式叫做comment，而另外一个应用中也有一个同样的名称，
当你在模板中使用这个名称的时候不能保证将插入哪个URL。
在URL 名称中加上一个前缀，比如应用的名称，将减少冲突的可能。
我们建议使用myapp-comment 而不是comment。
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')
视图层之视图函数(views)
一个视图函数，简称视图，是一个简单的Python 函数，它接受Web请求并且返回Web响应。响应可以是一张网页的HTML内容，一个重定向，一个404错误，一个XML文档，或者一张图片. . . 是任何东西都可以。无论视图本身包含什么逻辑，都要返回响应。代码写在哪里也无所谓，只要它在你的Python目录下面。除此之外没有更多的要求了——可以说“没有什么神奇的地方”。为了将代码放在某处，约定是将视图放置在项目或应用程序目录中的名为views.py的文件中。
1.一个简单的视图 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对象的属性
属性： django将请求报文中的请求行、首部信息、内容主体封装成 HttpRequest 类中的属性。 除了特殊说明的之外，其他均为只读的。 (1)HttpRequest.body 一个字符串，代表请求报文的主体。在处理非 HTTP 形式的报文时非常有用，
例如：二进制图片、XML,Json等。 但是，如果要处理表单数据的时候，推荐还是使用 HttpRequest.POST。
(2)HttpRequest.path
一个字符串，表示请求的路径组件（不含域名）。
例如："/music/bands/the_beatles/"
(3)HttpRequest.method
一个字符串，表示请求使用的HTTP 方法。必须使用大写。 例如："GET"、"POST"
(4)HttpRequest.encoding
一个字符串，表示提交的数据的编码方式（如果为 None 则表示使用 DEFAULT_CHARSET 的设置，
默认为 'utf-8'）。 这个属性是可写的，你可以修改它来修改访问表单数据使用的编码。 接下来对属性的任何访问（例如从 GET 或 POST 中读取数据）将使用新的 encoding 值。 如果你知道表单数据的编码不是 DEFAULT_CHARSET ，则使用它。
(5)HttpRequest.GET
一个类似于字典的对象，包含 HTTP GET 的所有参数。
(6)HttpRequest.POST
一个类似于字典的对象，如果请求中包含表单数据，则将这些数据封装成 QueryDict 对象。
POST 请求可以带有空的 POST 字典 —— 如果通过 HTTP POST 方法发送一个表单，
但是表单中没有任何的数据，QueryDict 对象依然会被创建。
因此，不应该使用 if request.POST来检查使用的是否是POST方法；
应该使用 if request.method == "POST"
另外：如果使用 POST 上传文件的话，文件信息将包含在 FILES 属性中。
(7)HttpRequest.COOKIES 一个标准的Python 字典，包含所有的cookie。键和值都为字符串。
(8)HttpRequest.session
一个既可读又可写的类似于字典的对象，表示当前的会话。只有当Django启用会话的支持时才可用。 完整的细节参见会话的文档。
-
HttpRequest对象的方法
(1)HttpRequest.get_full_path() 返回 path，如果可以将加上查询字符串。 例如："/music/bands/the_beatles/?print=true" (2)HttpRequest.get_signed_cookie(key, default=RAISE_ERROR,
salt='', max_age=None) 返回签名过的Cookie 对应的值，如果签名不再合法则返回
django.core.signing.BadSignature。 如果提供 default 参数，将不会引发异常并返回 default 的值。 可选参数salt 可以用来对安全密钥强力攻击提供额外的保护。
max_age 参数用于检查Cookie 对应的时间戳以确保Cookie 的时间不会超过max_age 秒。 >>> request.get_signed_cookie('name') 'Tony' >>> request.get_signed_cookie('name', salt='name-salt') 'Tony' # 假设在设置cookie的时候使用的是相同的salt >>> request.get_signed_cookie('non-existing-cookie') ... KeyError: 'non-existing-cookie' # 没有相应的键时触发异常 >>> request.get_signed_cookie('non-existing-cookie', False) False >>> request.get_signed_cookie('cookie-that-was-tampered-with') ... BadSignature: ... >>> request.get_signed_cookie('name', max_age=60) ... SignatureExpired: Signature age 1677.3839159 > 60 seconds >>> request.get_signed_cookie('name', False, max_age=60) False
(3)HttpRequest.is_ajax()
如果请求是通过XMLHttpRequest发起的，则返回True，
方法是检查 HTTP_X_REQUESTED_WITH 相应的首部是否是字符串'XMLHttpRequest'；
大部分现在的JavaScript库都会发送这个头部。
如果你编写自己的 XMLHttpRequest调用（在浏览器端），
你必须手工设置这个值来让 is_ajax() 可以工作；
如果一个响应需要根据请求是否是通过AJAX发起的，
并且你正在使用某种形式的缓存例如Django的cache middleware，
你应该使用 vary_on_headers('HTTP_X_REQUESTED_WITH')
装饰你的视图以让响应能够正确地缓存
2.render函数 render(request, template_name[, context]） 结合一个给定的模板和一个给定的上下文字典，并返回一个渲染后的 HttpResponse 对象。 参数： request： 用于生成响应的请求对象。 template_name：要使用的模板的完整名称，可选的参数 context：添加到模板上下文的一个字典。默认是一个空字典。如果字典中的某个值是可调用的，
视图将在渲染模板之前调用它。 content_type：生成的文档要使用的MIME类型。默认为DEFAULT_CONTENT_TYPE 设置的值。 status：响应的状态码。默认为200。
3.redirect 函数 参数可以是： 一个模型：将调用模型的get_absolute_url() 函数 一个视图，可以带有参数：将使用urlresolvers.reverse 来反向解析名称 一个绝对的或相对的URL，将原封不动的作为重定向的位置。 默认返回一个临时的重定向；传递permanent=True 可以返回一个永久的重定向。
（1）传递一个对象
将调用get_absolute_url() 方法来获取重定向的URL：
from django.shortcuts import redirect
def my_view(request):
...
object = MyModel.objects.get(...)
return redirect(object)
（2）传递一个视图的名称
可以带有位置参数和关键字参数；将使用reverse() 方法反向解析URL：
def my_view(request):
...
return redirect('some-view-name', foo='bar')
（3）传递要重定向的一个硬编码的URL
def my_view(request):
...
return redirect('/some/url/')
也可以是一个完整的URL：
def my_view(request):
...
return redirect('http://some.com/')
默认情况下，redirect() 返回一个临时重定向。
以上所有的形式都接收一个permanent参数；
如果设置为True，将返回一个永久的重定向：
def my_view(request):
...
object = MyModel.objects.get(...)
return redirect(object, permanent=True)
（4）跳转（重定向）应用
-----------------------------------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>
redirect关键点：两次请求过程，流程。
注意：render和redirect的区别:
1、 if页面需要模板语言渲染,需要的将数据库的数据加载到html,那么render方法则不会显示这一部分。
2、 the most important: url没有跳转到/yuan_back/,而是还在/login/,
所以当刷新后又得重新登录。
模板层(template)
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]})
1.模板语法之变量
在 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})
# return render(request,"index.html",locals())
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>
2.模板之过滤器
语法：{{obj|filter__name:param}}
- default
如果一个变量是false或者为空，使用给定的默认值。否则，使用变量的值。例如：
{{obj|default:"nothing"}}
- length
返回值的长度。它对字符串和列表都起作用。例如：
{{obj|length}} 返回obj的长度
- 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" }} 会取到"llo worl"
- truncatechars/truncatewords
如果字符串字符多于指定的字符数量，那么会被截断。
截断的字符串将以可翻译的省略号序列（“...”）结尾。
参数：要截断的字符数
{{ 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}}
3.模板之标签
标签看起来像是这样的： {% 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 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 %}
4.模板继承
Django模版引擎中最强大也是最复杂的部分就是模版继承了。模版继承可以让您创建一个基本的“骨架”模版，
它包含您站点中的全部元素，并且可以定义能够被子模版覆盖的 blocks 。
语法：一个母模板是所有子模板的公共部分，在母模板中需要子模板的内容则用
{% block content %}{% endblock %}代替，在子模板中用{% extends 'base.html' %}引入
母模板
为了更好的可读性，你也可以给你的 {% endblock %} 标签一个 名字 。例如：
{% block content %} ... {% endblock content %}
浙公网安备 33010602011771号