day16- django
MVC和MTV模式
Django的MTV模式本质是各组件之间为了保持松耦合关系,Django的MTV分别代表:
Model(模型):负责业务对象与数据库的对象(ORM)
Template(模版):负责如何把页面展示给用户
View(视图):负责业务逻辑,并在适当的时候调用Model和Template
此外,Django还有一个url分发器,它的作用是将一个个URL的页面请求分发给不同的view处理,view再调用相应的Model和Template
Django基本命令
1、创建一个django project
django
-
admin.py startproject mysite
2、在mysite目录下创建应用,比如blog:
python manage.py startapp blog
3、启动django项目
python manage.py runserver
8080
4、同步更改数据库表或字段
python manage.py syncdb注意:Django 1.7.1 及以上的版本需要用以下命令python manage.py makemigrationspython manage.py migrate 这种方法可以创建表,当你在models.py中新增了类时,运行它就可以自动在数据库中创建表了,不用手动创建。
5、清空数据库
python manage.py flush
此命令会询问是 yes 还是 no, 选择 yes 会把数据全部清空掉,只留下空表。
6、创建超级管理员
'''python manage.py createsuperuser# 按照提示输入用户名和对应的密码就好了邮箱可以留空,用户名和密码必填# 修改 用户密码可以用:python manage.py changepassword username'''
7、Django 项目环境终端
python manage.py shell
8、Django 项目环境终端
python manage.py dbshell
9、更多命令
python manage.py
10 static配置
#3、STATIC文件还可以配置STATICFILES_DIRS,指定额外的静态文件存储位置。# STATIC_URL的含义与MEDIA_URL类似。# ----------------------------------------------------------------------------#注意1:#为了后端的更改不会影响前端的引入,避免造成前端大量修改 STATIC_URL = '/static/' #引用名STATICFILES_DIRS = (os.path.join(BASE_DIR,"statics") #实际名 ,即实际文件夹的名字 )#django对引用名和实际名进行映射,引用时,只能按照引用名来,不能按实际名去找#<script src="/statics/jquery-3.1.1.js"></script>#------error-----不能直接用,必须用STATIC_URL = '/static/':#<script src="/static/jquery-3.1.1.js"></script>#注意2(statics文件夹写在不同的app下,静态文件的调用): STATIC_URL = '/static/'STATICFILES_DIRS=(('hello',os.path.join(BASE_DIR,"app01","statics")) ,)#<script src="/static/hello/jquery-1.8.2.min.js"></script>#注意3:STATIC_URL = '/static/'{% load staticfiles %}# <script src={% static "jquery-1.8.2.min.js" %}></script>
View Code
=====================
二 路由配置系统(URLconf)(urls)
URL配置(URLconf)就像Django 所支撑网站的目录。它的本质是URL与要为该URL调用的视图函数之间的映射表;你就是以这种方式告诉Django,对于这个URL调用这段代码,对于那个URL调用那段代码。
''' urlpatterns = [ url(正则表达式, views视图函数,参数,别名),] 参数说明: 一个正则表达式字符串 一个可调用对象,通常为一个视图函数或一个指定视图函数路径的字符串 可选的要传递给视图函数的默认参数(字典形式) 一个可选的name参数 '''
2.1 URLconf的正则字符串参数
2.1.1 简单配置
from django.conf.urls import urlfrom . import viewsurlpatterns = [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: 一旦匹配成功则不再继续 若要从URL 中捕获一个值,只需要在它周围放置一对圆括号。 不需要添加一个前导的反斜杠,因为每个URL 都有。例如,应该是^articles 而不是 ^/articles。 每个正则表达式前面的'r' 是可选的但是建议加上。一些请求的例子:/articles/2005/3/ 不匹配任何URL 模式,因为列表中的第三个模式要求月份应该是两个数字。/articles/2003/ 将匹配列表中的第一个模式不是第二个,因为模式按顺序匹配,第一个会首先测试是否匹配。/articles/2005/03/ 请求将匹配列表中的第三个模式。Django 将调用函数views.month_archive(request, '2005', '03')。'''
#设置项是否开启URL访问地址后面不为/跳转至带有/的路径 APPEND_SLASH=True
2.1.2 有名分组(named group)
上面的示例使用简单的、没有命名的正则表达式组(通过圆括号)来捕获URL 中的值并以位置 参数传递给视图。在更高级的用法中,可以使用命名的正则表达式组来捕获URL 中的值并以关键字 参数传递给视图。
在Python 正则表达式中,命名正则表达式组的语法是(?P<name>pattern)
,其中name
是组的名称,pattern
是要匹配的模式。
下面是以上URLconf 使用命名组的重写:
from django.conf.urls import urlfrom . import viewsurlpatterns = [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 捕获的参数永远是字符串
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 urlfrom . import viewsurlpatterns = [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, urlurlpatterns = [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 viewsurlpatterns = [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 name参数
'''urlpatterns = [url(r'^index',views.index,name='INDEX'),] ###################def index(req):if req.method=='POST':username=req.POST.get('username')password=req.POST.get('password')if username=='alex' and password=='123':return HttpResponse("登陆成功")return render(req,'index.html')#####################<!DOCTYPE html> <html lang="en"> <head><meta charset="UTF-8"><title>Title</title> </head> <body> {# <form action="/index/" method="post">#}<form action="{% url 'INDEX' %}" method="post">用户名:<input type="text" name="username">密码:<input type="password" name="password"><input type="submit" value="submit"></form> </body> </html>#######################'''
View Code
======================================
三 编写视图(views)
一个视图函数,或者简短来说叫做视图,是一个简单的Python函数,它接受web请求,并且返回web响应。响应可以是一张网页的HTML内容,一个重定向,一个404错误,一个XML文档,或者一张图片. . . 是任何东西都可以。无论视图本身包含什么逻辑,都要返回响应。代码写在哪里也无所谓,只要它在你的Python目录下面。除此之外没有更多的要求了——可以说“没有什么神奇的地方”。为了能够把代码放在某个地方,惯例是把视图放在叫做views.py的文件中,然后把它放到你的项目或者应用目录里。
3.1 一个简单的视图
下面是一个返回当前日期和时间作为HTML文档的视图:
from django.http import HttpResponse import datetimedef current_datetime(request):now = datetime.datetime.now()html = "<html><body>It is now %s.</body></html>" % nowreturn HttpResponse(html)
让我们逐行阅读上面的代码:
- 首先,我们从 django.http模块导入了HttpResponse类,以及Python的datetime库。
- 接着,我们定义了current_datetime函数。它是一个视图函数。每个视图函数都应接收HttpRequest对象作为第一个参数,一般叫做request。
- 注意视图函数的名称并不重要;不需要用一个统一的命名方式来命名,以便让Django识别它。我们将其命名为current_datetime,是因为这个名称能够精确地反映出它的功能。
- 这个视图会返回一个HttpResponse对象,其中包含生成的响应。每个视图函数都要返回HttpResponse对象
'''http请求-响应过程中有两个核心对象: http请求对象:HttpRequest http响应响应:HttpResponse 所在位置:django.http '''
3.2 快捷函数
3.2.1 render函数
---------------render(request, template_name[, context])结合一个给定的模板和一个给定的上下文字典,并返回一个渲染后的 HttpResponse 对象。参数:request: 用于生成响应的请求对象。template_name:要使用的模板的完整名称,可选的参数context:添加到模板上下文的一个字典。默认是一个空字典。如果字典中的某个值是可调用的,视图将在渲染模板之前调用它。content_type:生成的文档要使用的MIME类型。默认为DEFAULT_CONTENT_TYPE 设置的值。status:响应的状态码。默认为200。
3.2.2 redirect函数
-----------------------------------url.pyurl(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>#总结: render和redirect的区别: # 1 if render的页面需要模板语言渲染,需要的将数据库的数据加载到html,那么所有的这一部分 # 除了写在yuan_back的视图函数中,必须还要写在login中,代码重复,没有解耦.# 2 the most important: url没有跳转到/yuan_back/,而是还在/login/,所以当刷新后 # 又得重新登录.
View Code
===========================================
四 Template(html)
4.1 模板系统的介绍
你可能已经注意到我们在例子视图中返回文本的方式有点特别。 也就是说,HTML被直接硬编码在 Python代码之中。
def current_datetime(request):now = datetime.datetime.now()html = "<html><body>It is now %s.</body></html>" % nowreturn HttpResponse(html)
html
尽管这种技术便于解释视图是如何工作的,但直接将HTML硬编码到你的视图里却并不是一个好主意。 让我们来看一下为什么:
对页面设计进行的任何改变都必须对 Python 代码进行相应的修改。 站点设计的修改往往比底层 Python 代码的修改要频繁得多,因此如果可以在不进行 Python 代码修改的情况下变更设计,那将会方便得多。
Python 代码编写和 HTML 设计是两项不同的工作,大多数专业的网站开发环境都将他们分配给不同的人员(甚至不同部门)来完成。 设计者和HTML/CSS的编码人员不应该被要求去编辑Python的代码来完成他们的工作。
程序员编写 Python代码和设计人员制作模板两项工作同时进行的效率是最高的,远胜于让一个人等待另一个人完成对某个既包含 Python又包含 HTML 的文件的编辑工作。
基于这些原因,将页面的设计和Python的代码分离开会更干净简洁更容易维护。 我们可以使用 Django的 模板系统 (Template System)来实现这种模式,这就是本章要具体讨论的问题。
python的模板:HTML代码+逻辑控制代码
4.2 模板支持的语法
4.2.1 变量(使用双大括号来引用变量)
语法格式: {{var_name}}
----------------------------------Template和Context对象 >>> python manange.py shell (进入该django项目的环境) >>> from django.template import Context, Template >>> t = Template('My name is {{ name }}.') >>> c = Context({'name': 'Stephane'}) >>> t.render(c) 'My name is Stephane.'# 同一模板,多个上下文,一旦有了模板对象,你就可以通过它渲染多个context,无论何时我们都可以 # 像这样使用同一模板源渲染多个context,只进行 一次模板创建然后多次调用render()方法渲染会 # 更为高效: # Low for name in ('John', 'Julie', 'Pat'):t = Template('Hello, {{ name }}')print t.render(Context({'name': name}))# Good t = Template('Hello, {{ name }}') for name in ('John', 'Julie', 'Pat'):print t.render(Context({'name': name}))
Django 模板解析非常快捷。 大部分的解析工作都是在后台通过对简短正则表达式一次性调用来完成。 这和基于 XML 的模板引擎形成鲜明对比,那些引擎承担了 XML 解析器的开销,且往往比 Django 模板渲染引擎要慢上几个数量级。
from django.shortcuts import render,HttpResponse from django.template.loader import get_template #记得导入 # Create your views here.import datetime from django.template import Template,Context# def current_time(req):#原始的视图函数# now=datetime.datetime.now()# html="<html><body>现在时刻:<h1>%s.</h1></body></html>" %now# return HttpResponse(html)# def current_time(req):#django模板修改的视图函数 # now=datetime.datetime.now() # t=Template('<html><body>现在时刻是:<h1 style="color:red">{{current_date}}</h1></body></html>')#t=get_template('current_datetime.html') # c=Context({'current_date':now}) # html=t.render(c) # return HttpResponse(html)#另一种写法(推荐)def current_time(req):now=datetime.datetime.now()return render(req, 'current_datetime.html', {'current_date':now})
View Code
4.2.2 深度变量的查找(万能的句点号)
在到目前为止的例子中,我们通过 context 传递的简单参数值主要是字符串,然而,模板系统能够非常简洁地处理更加复杂的数据结构,例如list、dictionary和自定义的对象。在 Django 模板中遍历复杂数据结构的关键是句点字符 (.)。
#最好是用几个例子来说明一下。 # 首先,句点可用于访问列表索引,例如:>>> from django.template import Template, Context >>> t = Template('Item 2 is {{ items.2 }}.') >>> c = Context({'items': ['apples', 'bananas', 'carrots']}) >>> t.render(c) 'Item 2 is carrots.'#假设你要向模板传递一个 Python 字典。 要通过字典键访问该字典的值,可使用一个句点: >>> from django.template import Template, Context >>> person = {'name': 'Sally', 'age': '43'} >>> t = Template('{{ person.name }} is {{ person.age }} years old.') >>> c = Context({'person': person}) >>> t.render(c) 'Sally is 43 years old.'#同样,也可以通过句点来访问对象的属性。 比方说, Python 的 datetime.date 对象有 #year 、 month 和 day 几个属性,你同样可以在模板中使用句点来访问这些属性:>>> from django.template import Template, Context >>> import datetime >>> d = datetime.date(1993, 5, 2) >>> d.year >>> d.month >>> d.day >>> t = Template('The month is {{ date.month }} and the year is {{ date.year }}.') >>> c = Context({'date': d}) >>> t.render(c) 'The month is 5 and the year is 1993.'# 这个例子使用了一个自定义的类,演示了通过实例变量加一点(dots)来访问它的属性,这个方法适 # 用于任意的对象。 >>> from django.template import Template, Context >>> class Person(object): ... def __init__(self, first_name, last_name): ... self.first_name, self.last_name = first_name, last_name >>> t = Template('Hello, {{ person.first_name }} {{ person.last_name }}.') >>> c = Context({'person': Person('John', 'Smith')}) >>> t.render(c) 'Hello, John Smith.'# 点语法也可以用来引用对象的方法。 例如,每个 Python 字符串都有 upper() 和 isdigit() # 方法,你在模板中可以使用同样的句点语法来调用它们: >>> from django.template import Template, Context >>> t = Template('{{ var }} -- {{ var.upper }} -- {{ var.isdigit }}') >>> t.render(Context({'var': 'hello'})) 'hello -- HELLO -- False' >>> t.render(Context({'var': '123'})) '123 -- 123 -- True'# 注意这里调用方法时并* 没有* 使用圆括号 而且也无法给该方法传递参数;你只能调用不需参数的 # 方法。
View Code
4.2.3 变量的过滤器(filter)的使用
语法格式: {{obj|filter:param}}
# 1 add : 给变量加上相应的值# # 2 addslashes : 给变量中的引号前加上斜线# # 3 capfirst : 首字母大写# # 4 cut : 从字符串中移除指定的字符# # 5 date : 格式化日期字符串# # 6 default : 如果值是False,就替换成设置的默认值,否则就是用本来的值# # 7 default_if_none: 如果值是None,就替换成设置的默认值,否则就使用本来的值#实例:#value1="aBcDe" {{ value1|upper }}<br>#value2=5 {{ value2|add:3 }}<br>#value3='he llo wo r ld' {{ value3|cut:' ' }}<br>#import datetime #value4=datetime.datetime.now() {{ value4|date:'Y-m-d' }}<br>#value5=[] {{ value5|default:'空的' }}<br>#value6='<a href="#">跳转</a>' {{ value6 }}{% autoescape off %}{{ value6 }} {% endautoescape %}{{ value6|safe }}<br>{{ value6|striptags }}#value7='1234' {{ value7|filesizeformat }}<br> {{ value7|first }}<br> {{ value7|length }}<br> {{ value7|slice:":-1" }}<br>#value8='http://www.baidu.com/?a=1&b=3' {{ value8|urlencode }}<br>value9='hello I am yuan'
View Code
4.2.4 标签(tag)的使用(使用大括号和百分比的组合来表示使用tag)
语法格式: {% tags %}
{% if %} 的使用
{% if %}标签计算一个变量值,如果是“true”,即它存在、不为空并且不是false的boolean值,系统则会显示{% if %}和{% endif %}间的所有内容
{% if num >= 100 and 8 %}{% if num > 200 %}<p>num大于200</p>{% else %}<p>num大于100小于200</p>{% endif %}{% elif num < 100%}<p>num小于100</p>{% else %}<p>num等于100</p>{% endif %}{% if %} 标签接受and,or或者not来测试多个变量值或者否定一个给定的变量 {% if %} 标签不允许同一标签里同时出现and和or,否则逻辑容易产生歧义,例如下面的标签是不合法的:{% if obj1 and obj2 or obj3 %}
View Code
{% for %}的使用
{% for %}标签允许你按顺序遍历一个序列中的各个元素,每次循环模板系统都会渲染{% for %}和{% endfor %}之间的所有内容
<ul> {% for obj in list %}<li>{{ obj.name }}</li> {% endfor %} </ul>#在标签里添加reversed来反序循环列表: {% for obj in list reversed %}...{% endfor %}#{% for %}标签可以嵌套: {% for country in countries %}<h1>{{ country.name }}</h1><ul>{% for city in country.city_list %}<li>{{ city }}</li>{% endfor %}</ul>{% endfor %}#系统不支持中断循环,系统也不支持continue语句,{% for %}标签内置了一个forloop模板变量, #这个变量含有一些属性可以提供给你一些关于循环的信息1,forloop.counter表示循环的次数,它从1开始计数,第一次循环设为1:{% for item in todo_list %}<p>{{ forloop.counter }}: {{ item }}</p>{% endfor %} 2,forloop.counter0 类似于forloop.counter,但它是从0开始计数,第一次循环设为0 3,forloop.revcounter 4,forloop.revcounter0 5,forloop.first当第一次循环时值为True,在特别情况下很有用:{% for object in objects %} {% if forloop.first %}<li class="first">{% else %}<li>{% endif %} {{ object }} </li> {% endfor %} # 富有魔力的forloop变量只能在循环中得到,当模板解析器到达{% endfor %}时forloop就消失了 # 如果你的模板context已经包含一个叫forloop的变量,Django会用{% for %}标签替代它 # Django会在for标签的块中覆盖你定义的forloop变量的值 # 在其他非循环的地方,你的forloop变量仍然可用#{% empty %} {{li }}{% for i in li %}<li>{{ forloop.counter0 }}----{{ i }}</li>{% empty %}<li>this is empty!</li>{% endfor %}# [11, 22, 33, 44, 55] # 0----11 # 1----22 # 2----33 # 3----44 # 4----55
View Code
csrf_token标签
用于生成csrf_token的标签,用于防治跨站攻击验证。 其实,这里是会生成一个input标签,和其他表单标签一起提交给后台的。
{% url %}
引用路由配置的地址
<form action="{% url "bieming"%}" ><input type="text"><input type="submit"value="提交">{%csrf_token%} </form>
{% with %}
用更简单的变量名替代复杂的变量名
{% with total=fhjsaldfhjsdfhlasdfhljsdal %} {{ total }} {% endwith %}
{% verbatim %}
禁止render
{% verbatim %}{{ hello }} {% endverbatim %}
加载标签库:自定义filter和simple_tag
a、在app中创建templatetags模块(必须的)
b、创建任意 .py 文件,如:my_tags.py
from django import template from django.utils.safestring import mark_saferegister = 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)
View Code
c、在使用自定义simple_tag和filter的html文件中导入之前创建的 my_tags.py :{% load my_tags %}
d、使用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 %}
View Code
e、在settings中的INSTALLED_APPS配置当前app,不然django无法找到自定义的simple_tag.
注意:
filter可以用在if等语句后,simple_tag不可以
{% if num|filter_multi:30 > 100 %}{{ num|filter_multi:30 }} {% endif %}
extend模板继承
到目前为止,我们的模板范例都只是些零星的 HTML 片段,但在实际应用中,你将用 Django 模板系统来创建整个 HTML 页面。 这就带来一个常见的 Web 开发问题: 在整个网站中,如何减少共用页面区域(比如站点导航)所引起的重复和冗余代码?Django 解决此类问题的首选方法是使用一种优雅的策略—— 模板继承 。
本质上来说,模板继承就是先构造一个基础框架模板,而后在其子模板中对它所包含站点公用部分和定义块进行重载。
让我们通过修改 current_datetime.html 文件,为 current_datetime 创建一个更加完整的模板来体会一下这种做法:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html lang="en"> <head><title>The current time</title> </head> <body><h1>My helpful timestamp site</h1><p>It is now {{ current_date }}.</p><hr><p>Thanks for visiting my site.</p> </body> </html>
View Code
这看起来很棒,但如果我们要为 hours_ahead 视图创建另一个模板会发生什么事情呢?
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html lang="en"> <head><title>Future time</title> </head> <body><h1>My helpful timestamp site</h1><p>In {{ hour_offset }} hour(s), it will be {{ next_time }}.</p><hr><p>Thanks for visiting my site.</p> </body> </html>
View Code
Django 的模板继承系统解决了这些问题。 你可以将其视为服务器端 include 的逆向思维版本。 你可以对那些不同 的代码段进行定义,而不是 共同 代码段。
第一步是定义 基础模板,该框架之后将由子模板所继承。 以下是我们目前所讲述范例的基础模板:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html lang="en"> <head><title>{% block title %}{% endblock %}</title> </head> <body><h1>My helpful timestamp site</h1>{% block content %}{% endblock %}{% block footer %}<hr><p>Thanks for visiting my site.</p>{% endblock %} </body> </html>
View Code
这个叫做 base.html 的模板定义了一个简单的 HTML 框架文档,我们将在本站点的所有页面中使用。 子模板的作用就是重载、添加或保留那些块的内容。 (如果你一直按顺序学习到这里,保存这个文件到你的template目录下,命名为 base.html .)
我们使用模板标签: {% block %} 。 所有的 {% block %} 标签告诉模板引擎,子模板可以重载这些部分。 每个{% block %}标签所要做的是告诉模板引擎,该模板下的这一块内容将有可能被子模板覆盖。
现在我们已经有了一个基本模板,我们可以修改 current_datetime.html 模板来 使用它:
{% extends "base.html" %}{% block title %}The current time{% endblock %}{% block content %} <p>It is now {{ current_date }}.</p> {% endblock %}
View Code
再为 hours_ahead 视图创建一个模板,看起来是这样的:
{% extends "base.html" %}{% block title %}Future time{% endblock %}{% block content %} <p>In {{ hour_offset }} hour(s), it will be {{ next_time }}.</p> {% endblock %}
看起来很漂亮是不是? 每个模板只包含对自己而言 独一无二 的代码。 无需多余的部分。 如果想进行站点级的设计修改,仅需修改 base.html ,所有其它模板会立即反映出所作修改。
以下是其工作方式:
在加载 current_datetime.html 模板时,模板引擎发现了 {% extends %} 标签, 注意到该模板是一个子模板。 模板引擎立即装载其父模板,即本例中的 base.html 。此时,模板引擎注意到 base.html 中的三个 {% block %} 标签,并用子模板的内容替换这些 block 。因此,引擎将会使用我们在 { block title %} 中定义的标题,对 {% block content %} 也是如此。 所以,网页标题一块将由{% block title %}替换,同样地,网页的内容一块将由 {% block content %}替换。
注意由于子模板并没有定义 footer 块,模板系统将使用在父模板中定义的值。 父模板 {% block %} 标签中的内容总是被当作一条退路。继承并不会影响到模板的上下文。 换句话说,任何处在继承树上的模板都可以访问到你传到模板中的每一个模板变量。你可以根据需要使用任意多的继承次数。 使用继承的一种常见方式是下面的三层法:
<1> 创建 base.html 模板,在其中定义站点的主要外观感受。 这些都是不常修改甚至从不修改的部分。<2> 为网站的每个区域创建 base_SECTION.html 模板(例如, base_photos.html 和 base_forum.html )。这些模板对base.html 进行拓展,并包含区域特定的风格与设计。<3> 为每种类型的页面创建独立的模板,例如论坛页面或者图片库。 这些模板拓展相应的区域模板。
这个方法可最大限度地重用代码,并使得向公共区域(如区域级的导航)添加内容成为一件轻松的工作。
以下是使用模板继承的一些诀窍:
<1>如果在模板中使用 {% extends %} ,必须保证其为模板中的第一个模板标记。 否则,模板继承将不起作用。<2>一般来说,基础模板中的 {% block %} 标签越多越好。 记住,子模板不必定义父模板中所有的代码块,因此你可以用合理的缺省值对一些代码块进行填充,然后只对子模板所需的代码块进行(重)定义。 俗话说,钩子越多越好。<3>如果发觉自己在多个模板之间拷贝代码,你应该考虑将该代码段放置到父模板的某个 {% block %} 中。如果你需要访问父模板中的块的内容,使用 {{ block.super }}这个标签吧,这一个魔法变量将会表现出父模板中的内容。 如果只想在上级代码块基础上添加内容,而不是全部重载,该变量就显得非常有用了。<4>不允许在同一个模板中定义多个同名的 {% block %} 。 存在这样的限制是因为block 标签的工作方式是双向的。也就是说,block 标签不仅挖了一个要填的坑,也定义了在父模板中这个坑所填充的内容。如果模板中出现了两个相同名称的 {% block %} 标签,父模板将无从得知要使用哪个块的内容。
View Code
====================================================
五 数据库与ORM
5.1 数据库的配置
1 django默认支持sqlite,mysql, oracle,postgresql数据库。
<1> sqlite
django默认使用sqlite的数据库,默认自带sqlite的数据库驱动 , 引擎名称:django.db.backends.sqlite3
<2> mysql
引擎名称:django.db.backends.mysql
2 mysql驱动程序
- MySQLdb(mysql python)
- mysqlclient
- MySQL
- PyMySQL(纯python的mysql驱动程序)
3 在django的项目中会默认使用sqlite数据库,在settings里有如下设置:
如果我们想要更改数据库,需要修改如下:
DATABASES = {'default': {'ENGINE': 'django.db.backends.mysql', 'NAME': 'books', #你的数据库名称'USER': 'root', #你的数据库用户名'PASSWORD': '', #你的数据库密码'HOST': '', #你的数据库主机,留空默认为localhost'PORT': '3306', #你的数据库端口 }}
View Code
NAME即数据库的名字,在mysql连接前该数据库必须已经创建,而上面的sqlite数据库下的db.sqlite3则是项目自动创建USER和PASSWORD分别是数据库的用户名和密码。设置完后,再启动我们的Django项目前,我们需要激活我们的mysql。然后,启动项目,会报错:no module named MySQLdb这是因为django默认你导入的驱动是MySQLdb,可是MySQLdb对于py3有很大问题,所以我们需要的驱动是PyMySQL所以,我们只需要找到项目名文件下的__init__,在里面写入:import pymysql pymysql.install_as_MySQLdb()问题解决!
View Code
5.2 ORM表模型
表(模型)的创建:
实例:我们来假定下面这些概念,字段和关系
作者模型:一个作者有姓名。
作者详细模型:把作者的详情放到详情表,包含性别,email地址和出生日期,作者详情模型和作者模型之间是一对一的关系(one-to-one)(类似于每个人和他的身份证之间的关系),在大多数情况下我们没有必要将他们拆分成两张表,这里只是引出一对一的概念。
出版商模型:出版商有名称,地址,所在城市,省,国家和网站。
书籍模型:书籍有书名和出版日期,一本书可能会有多个作者,一个作者也可以写多本书,所以作者和书籍的关系就是多对多的关联关系(many-to-many),一本书只应该由一个出版商出版,所以出版商和书籍是一对多关联关系(one-to-many),也被称作外键。
from django.db import models<br> class Publisher(models.Model):name = models.CharField(max_length=30, verbose_name="名称")address = models.CharField("地址", max_length=50)city = models.CharField('城市',max_length=60)state_province = models.CharField(max_length=30)country = models.CharField(max_length=50)website = models.URLField()class Meta:verbose_name = '出版商'verbose_name_plural = verbose_namedef __str__(self):return self.nameclass Author(models.Model):name = models.CharField(max_length=30)def __str__(self):return self.nameclass AuthorDetail(models.Model):sex = models.BooleanField(max_length=1, choices=((0, '男'),(1, '女'),))email = models.EmailField()address = models.CharField(max_length=50)birthday = models.DateField()author = models.OneToOneField(Author)class Book(models.Model):title = models.CharField(max_length=100)authors = models.ManyToManyField(Author)publisher = models.ForeignKey(Publisher)publication_date = models.DateField()price=models.DecimalField(max_digits=5,decimal_places=2,default=10)def __str__(self):return self.title
View Code
分析代码:
<1> 每个数据模型都是django.db.models.Model的子类,它的父类Model包含了所有必要的和数据库交互的方法。并提供了一个简介漂亮的定义数据库字段的语法。
<2> 每个模型相当于单个数据库表(多对多关系例外,会多生成一张关系表),每个属性也是这个表中的字段。属性名就是字段名,它的类型(例如CharField)相当于数据库的字段类型(例如varchar)。大家可以留意下其它的类型都和数据库里的什么字段对应。
<3> 模型之间的三种关系:一对一,一对多,多对多。
一对一:实质就是在主外键(author_id就是foreign key)的关系基础上,给外键加了一个UNIQUE=True的属性;
一对多:就是主外键关系;(foreign key)
多对多:(ManyToManyField) 自动创建第三张表(当然我们也可以自己创建第三张表:两个foreign key)
ORM之增(create,save)
from app01.models import *#create方式一: Author.objects.create(name='Alvin')#create方式二: Author.objects.create(**{"name":"alex"})#save方式一: author=Author(name="alvin") author.save()#save方式二: author=Author()author.name="alvin"author.save()
View Code
重点来了------->那么如何创建存在一对多或多对多关系的一本书的信息呢?(如何处理外键关系的字段如一对多的publisher和
多对多的authors)
#一对多(ForeignKey):#方式一: 由于绑定一对多的字段,比如publish,存到数据库中的字段名叫publish_id,所以我们可以直接给这个# 字段设定对应值:Book.objects.create(title='php',publisher_id=2, #这里的2是指为该book对象绑定了Publisher表中id=2的行对象publication_date='2017-7-7',price=99)#方式二:# <1> 先获取要绑定的Publisher对象:pub_obj=Publisher(name='河大出版社',address='保定',city='保定',state_province='河北',country='China',website='http://www.hbu.com')OR pub_obj=Publisher.objects.get(id=1)# <2>将 publisher_id=2 改为 publisher=pub_obj#多对多(ManyToManyField()): author1=Author.objects.get(id=1)author2=Author.objects.filter(name='alvin')[0]book=Book.objects.get(id=1)book.authors.add(author1,author2)#等同于:book.authors.add(*[author1,author2])book.authors.remove(*[author1,author2])#-------------------book=models.Book.objects.filter(id__gt=1)authors=models.Author.objects.filter(id=1)[0]authors.book_set.add(*book)authors.book_set.remove(*book)#-------------------book.authors.add(1)book.authors.remove(1)authors.book_set.add(1)authors.book_set.remove(1)#注意: 如果第三张表是通过models.ManyToManyField()自动创建的,那么绑定关系只有上面一种方式 # 如果第三张表是自己创建的:class Book2Author(models.Model):author=models.ForeignKey("Author")Book= models.ForeignKey("Book") # 那么就还有一种方式:author_obj=models.Author.objects.filter(id=2)[0]book_obj =models.Book.objects.filter(id=3)[0]s=models.Book2Author.objects.create(author_id=1,Book_id=2)s.save()s=models.Book2Author(author=author_obj,Book_id=1)s.save()
View Code
ORM之删(delete)
>>> Book.objects.filter(id=1).delete() (3, {'app01.Book_authors': 2, 'app01.Book': 1})
我们表面上删除了一条信息,实际却删除了三条,因为我们删除的这本书在Book_authors表中有两条相关信息,这种删除方式就是django默认的级联删除。
ORM之改(update和save)
注意:
<1> 第二种方式修改不能用get的原因是:update是QuerySet对象的方法,get返回的是一个model对象,它没有update方法,而filter返回的是一个QuerySet对象(filter里面的条件可能有多个条件符合,比如name='alvin',可能有两个name='alvin'的行数据)。
<2>在“插入和更新数据”小节中,我们有提到模型的save()方法,这个方法会更新一行里的所有列。 而某些情况下,我们只需要更新行里的某几列。
#---------------- update方法直接设定对应属性----------------models.Book.objects.filter(id=3).update(title="PHP")##sql:##UPDATE "app01_book" SET "title" = 'PHP' WHERE "app01_book"."id" = 3; args=('PHP', 3)#--------------- save方法会将所有属性重新设定一遍,效率低-----------obj=models.Book.objects.filter(id=3)[0]obj.title="Python"obj.save() # SELECT "app01_book"."id", "app01_book"."title", "app01_book"."price", # "app01_book"."color", "app01_book"."page_num", # "app01_book"."publisher_id" FROM "app01_book" WHERE "app01_book"."id" = 3 LIMIT 1; # # UPDATE "app01_book" SET "title" = 'Python', "price" = 3333, "color" = 'red', "page_num" = 556, # "publisher_id" = 1 WHERE "app01_book"."id" = 3;
View Code
此外,update()方法对于任何结果集(QuerySet)均有效,这意味着你可以同时更新多条记录update()方法会返回一个整型数值,表示受影响的记录条数。
注意,这里因为update返回的是一个整形,所以没法用query属性;对于每次创建一个对象,想显示对应的raw sql,需要在settings加上日志记录部分:
LOGGING = {'version': 1,'disable_existing_loggers': False,'handlers': {'console':{'level':'DEBUG','class':'logging.StreamHandler',},},'loggers': {'django.db.backends': {'handlers': ['console'],'propagate': True,'level':'DEBUG',},} }
View Code
ORM之查(filter,value)
查询API:
# 查询相关API:# <1>filter(**kwargs): 它包含了与所给筛选条件相匹配的对象# <2>all(): 查询所有结果# <3>get(**kwargs): 返回与所给筛选条件相匹配的对象,返回结果有且只有一个,如果符合筛选条件的对象超过一个或者没有都会抛出错误。#-----------下面的方法都是对查询的结果再进行处理:比如 objects.filter.values()--------# <4>values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet,运行后得到的并不是一系列 model的实例化对象,而是一个可迭代的字典序列 ;-->拿到库内 固定列内的 值作为 一对 key value ;如果条件是多个,那就拿到多对,整体是一个列表# <5>exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象# <6>order_by(*field): 对查询结果排序# <7>reverse(): 对查询结果反向排序# <8>distinct(): 从返回结果中剔除重复纪录# <9>values_list(*field): 它与values()非常相似,它返回的是一个元组序列,values返回的是一个字典序列;相比于 values 左后是一个 元祖,不是字典# <10>count(): 返回数据库中匹配查询(QuerySet)的对象数量。# <11>first(): 返回第一条记录# <12>last(): 返回最后一条记录# <13>exists(): 如果QuerySet包含数据,就返回True,否则返回False
---------------了不起的双下划线(__)之单表条件查询----------------# models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值 # # models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据 # models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in # # models.Tb1.objects.filter(name__contains="ven") # models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感 # # models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and # # startswith,istartswith, endswith, iendswith,
双下划线
QuerySet与惰性机制
所谓惰性机制:Publisher.objects.all()或者.filter()等都只是返回了一个QuerySet(查询结果集对象),它并不会马上执行sql,而是当调用QuerySet的时候才执行。
QuerySet特点:
<1> 可迭代的
<2> 可切片
#objs=models.Book.objects.all()#[obj1,obj2,ob3...]#QuerySet: 可迭代# for obj in objs:#每一obj就是一个行对象# print("obj:",obj)# QuerySet: 可切片# print(objs[1])# print(objs[1:4])# print(objs[::-1])
QuerySet的高效使用:
<1>Django的queryset是惰性的Django的queryset对应于数据库的若干记录(row),通过可选的查询来过滤。例如,下面的代码会得到数据库中名字为‘Dave’的所有的人:person_set = Person.objects.filter(first_name="Dave")上面的代码并没有运行任何的数据库查询。你可以使用person_set,给它加上一些过滤条件,或者将它传给某个函数,这些操作都不会发送给数据库。这是对的,因为数据库查询是显著影响web应用性能的因素之一。<2>要真正从数据库获得数据,你可以遍历queryset或者使用if queryset,总之你用到数据时就会执行sql.为了验证这些,需要在settings里加入 LOGGING(验证方式)obj=models.Book.objects.filter(id=3)# for i in obj:# print(i)# if obj:# print("ok")<3>queryset是具有cache的当你遍历queryset时,所有匹配的记录会从数据库获取,然后转换成Django的model。这被称为执行(evaluation).这些model会保存在queryset内置的cache中,这样如果你再次遍历这个queryset,你不需要重复运行通用的查询。obj=models.Book.objects.filter(id=3)# for i in obj:# print(i)## models.Book.objects.filter(id=3).update(title="GO")## obj_new=models.Book.objects.filter(id=3)# for i in obj:# print(i) #LOGGING只会打印一次<4>简单的使用if语句进行判断也会完全执行整个queryset并且把数据放入cache,虽然你并不需要这些数据!为了避免这个,可以用exists()方法来检查是否有数据:obj = Book.objects.filter(id=4)# exists()的检查可以避免数据放入queryset的cache。if obj.exists():print("hello world!")<5>当queryset非常巨大时,cache会成为问题处理成千上万的记录时,将它们一次装入内存是很浪费的。更糟糕的是,巨大的queryset可能会锁住系统进程,让你的程序濒临崩溃。要避免在遍历数据的同时产生queryset cache,可以使用iterator()方法来获取数据,处理完数据就将其丢弃。objs = Book.objects.all().iterator()# iterator()可以一次只从数据库获取少量数据,这样可以节省内存for obj in objs:print(obj.name)#BUT,再次遍历没有打印,因为迭代器已经在上一次遍历(next)到最后一次了,没得遍历了for obj in objs:print(obj.name)#当然,使用iterator()方法来防止生成cache,意味着遍历同一个queryset时会重复执行查询。所以使#用iterator()的时候要当心,确保你的代码在操作一个大的queryset时没有重复执行查询 总结:queryset的cache是用于减少程序对数据库的查询,在通常的使用下会保证只有在需要的时候才会查询数据库。 使用exists()和iterator()方法可以优化程序对内存的使用。不过,由于它们并不会生成queryset cache,可能 会造成额外的数据库查询。
View Code
对象查询,单表条件查询,多表条件关联查询
#--------------------对象形式的查找--------------------------# 正向查找ret1=models.Book.objects.first()print(ret1.title)print(ret1.price)print(ret1.publisher)print(ret1.publisher.name) #因为一对多的关系所以ret1.publisher是一个对象,而不是一个queryset集合# 反向查找ret2=models.Publish.objects.last()print(ret2.name)print(ret2.city)#如何拿到与它绑定的Book对象呢?print(ret2.book_set.all()) #ret2.book_set是一个queryset集合#---------------了不起的双下划线(__)之单表条件查询----------------# models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值 # # models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据 # models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in # # models.Tb1.objects.filter(name__contains="ven") # models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感 # # models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and # # startswith,istartswith, endswith, iendswith,#----------------了不起的双下划线(__)之多表条件关联查询---------------# 正向查找(条件)# ret3=models.Book.objects.filter(title='Python').values('id') # print(ret3)#[{'id': 1}]#正向查找(条件)之一对多 ret4=models.Book.objects.filter(title='Python').values('publisher__city')print(ret4) #[{'publisher__city': '北京'}]#正向查找(条件)之多对多ret5=models.Book.objects.filter(title='Python').values('author__name')print(ret5)ret6=models.Book.objects.filter(author__name="alex").values('title')print(ret6)#注意#正向查找的publisher__city或者author__name中的publisher,author是book表中绑定的字段#一对多和多对多在这里用法没区别# 反向查找(条件)#反向查找之一对多:ret8=models.Publisher.objects.filter(book__title='Python').values('name')print(ret8)#[{'name': '人大出版社'}] 注意,book__title中的book就是Publisher的关联表名 ret9=models.Publisher.objects.filter(book__title='Python').values('book__authors')print(ret9)#[{'book__authors': 1}, {'book__authors': 2}]#反向查找之多对多:ret10=models.Author.objects.filter(book__title='Python').values('name')print(ret10)#[{'name': 'alex'}, {'name': 'alvin'}]#注意#正向查找的book__title中的book是表名Book#一对多和多对多在这里用法没区别
View Code
注意:条件查询即与对象查询对应,是指在filter,values等方法中的通过__来明确查询条件。
聚合查询和分组查询
<1> aggregate(*args,**kwargs):
通过对QuerySet进行计算,返回一个聚合值的字典。aggregate()中每一个参数都指定一个包含在字典中的返回值。即在查询集上生成聚合。
from django.db.models import Avg,Min,Sum,Max从整个查询集生成统计值。比如,你想要计算所有在售书的平均价钱。Django的查询语法提供了一种方式描述所有 图书的集合。>>> Book.objects.all().aggregate(Avg('price')) {'price__avg': 34.35}aggregate()子句的参数描述了我们想要计算的聚合值,在这个例子中,是Book模型中price字段的平均值aggregate()是QuerySet 的一个终止子句,意思是说,它返回一个包含一些键值对的字典。键的名称是聚合值的 标识符,值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。如果你想要为聚合值指定 一个名称,可以向聚合子句提供它: >>> Book.objects.aggregate(average_price=Avg('price')) {'average_price': 34.35}如果你也想知道所有图书价格的最大值和最小值,可以这样查询: >>> Book.objects.aggregate(Avg('price'), Max('price'), Min('price')) {'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}
View Code
<2> annotate(*args,**kwargs):
可以通过计算查询结果中每一个对象所关联的对象集合,从而得出总计值(也可以是平均值或总和),即为查询集的每一项生成聚合。
查询alex出的书总价格
查询各个作者出的书的总价格,这里就涉及到分组了,分组条件是authors__name
查询各个出版社最便宜的书价是多少
F查询和Q查询
仅仅靠单一的关键字参数查询已经很难满足查询要求。此时Django为我们提供了F和Q查询:
# F 使用查询条件的值,专门取对象中某列值的操作# from django.db.models import F# models.Tb1.objects.update(num=F('num')+1)# Q 构建搜索条件from django.db.models import Q#1 Q对象(django.db.models.Q)可以对关键字参数进行封装,从而更好地应用多个查询q1=models.Book.objects.filter(Q(title__startswith='P')).all()print(q1)#[<Book: Python>, <Book: Perl>]# 2、可以组合使用&,|操作符,当一个操作符是用于两个Q的对象,它产生一个新的Q对象。Q(title__startswith='P') | Q(title__startswith='J')# 3、Q对象可以用~操作符放在前面表示否定,也可允许否定与不否定形式的组合Q(title__startswith='P') | ~Q(pub_date__year=2005)# 4、应用范围:# Each lookup function that takes keyword-arguments (e.g. filter(),# exclude(), get()) can also be passed one or more Q objects as# positional (not-named) arguments. If you provide multiple Q object# arguments to a lookup function, the arguments will be “AND”ed# together. For example: Book.objects.get(Q(title__startswith='P'),Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))#sql:# SELECT * from polls WHERE question LIKE 'P%'# AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06')# import datetime# e=datetime.date(2005,5,6) #2005-05-06# 5、Q对象可以与关键字参数查询一起使用,不过一定要把Q对象放在关键字参数查询的前面。# 正确: Book.objects.get(Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),title__startswith='P')# 错误: Book.objects.get(question__startswith='P',Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))
View Code
=============================
admin的配置
admin是django强大功能之一,它能共从数据库中读取数据,呈现在页面中,进行管理。默认情况下,它的功能已经非常强大,如果你不需要复杂的功能,它已经够用,但是有时候,一些特殊的功能还需要定制,比如搜索功能,下面这一系列文章就逐步深入介绍如何定制适合自己的admin应用。
如果你觉得英文界面不好用,可以在setting.py 文件中修改以下选项
LANGUAGE_CODE = 'en-us' #LANGUAGE_CODE = 'zh-hans'
一 认识ModelAdmin
管理界面的定制类,如需扩展特定的model界面需从该类继承。
二 注册medel类到admin的两种方式:
<1> 使用register的方法
admin.site.register(Book,MyAdmin)
<2> 使用register的装饰器
@admin.register(Book)
三 掌握一些常用的设置技巧
- list_display: 指定要显示的字段
- search_fields: 指定搜索的字段
- list_filter: 指定列表过滤器
- ordering: 指定排序字段
from django.contrib import admin from app01.models import * # Register your models here.# @admin.register(Book)#----->单给某个表加一个定制 class MyAdmin(admin.ModelAdmin):list_display = ("title","price","publisher")search_fields = ("title","publisher")list_filter = ("publisher",)ordering = ("price",)fieldsets =[(None, {'fields': ['title']}),('price information', {'fields': ['price',"publisher"], 'classes': ['collapse']}),]admin.site.register(Book,MyAdmin) admin.site.register(Publish) admin.site.register(Author)
转载于:https://www.cnblogs.com/onda/p/7380850.html
day16- django相关推荐
- 老男孩python第六期
01 python s6 day7 上节回顾 02 python s6 day7 SNMP使用 03 python s6 day7 大型监控架构讲解 04 python s6 day7 Redis使用 ...
- python django项目实例_最新Django项目实战-从零开发NB的任务平台python视频学习教程...
saas导学视频 .mp4 │ 模态框.zip │ ├─day01 │ │ 01 day01 sass项目介绍 .mp4 │ │ 02 day01 sass项目演示 .mp4 │ │ 04 day01 ...
- 【django小练习之主机管理界面】
需求: 利用django,js,bootstrap等实现登录,主机管理等操作. 实现截图 登录界面 主机界面,添加及编辑 部门管理界面 代码实现 目录层级 settings.py "&quo ...
- 【前端开发学习】7.Django
文章目录 1 初识Django 1.1 django的安装 1.2 创建django项目 1.3 两种创建方式的对比 1.4 默认文件介绍 1.5 APP的创建和说明 1.6 启动运行django 1 ...
- Django学习之路(一)--初识django
1.先创建虚拟环境 为什么要创建虚拟环境呢? 你有两个项目同时进行,一个需要pytnon3.9和Django3.x版本的,一个需要python3.7和Django2.x版本的,不进行环境隔离的话,运行 ...
- django自带的分页功能
django自带的分页功能 django中自带的分页功能有缺陷,但是也是一种思路,所以在下做一个整理,方便以后使用,还有服务各位小伙伴. django视图部分的代码.(注释才是重点) from dja ...
- django正反向查询
django正反向查询 当我们的表存在外键想要从一找多的时候该怎么查找,当我们从多找一的时候又应该怎么查找. 一找多 首先我们要创建一个项目,在项目的model.py中创建两个模型. from dja ...
- Django 布署6.5
布署 从uwsgi.nginx.静态文件三个方面处理 服务器介绍 服务器:私有服务器.公有服务器 私有服务器:公司自己购买.自己维护,只布署自己的应用,可供公司内部或外网访问 公有服务器:集成好运营环 ...
- Django 全文检索6.3
全文检索 全文检索不同于特定字段的模糊查询,使用全文检索的效率更高,并且能够对于中文进行分词处理 haystack:django的一个包,可以方便地对model里面的内容进行索引.搜索,设计为支持wh ...
- Django 缓存6.2
缓存 对于中等流量的网站来说,尽可能地减少开销是必要的.缓存数据就是为了保存那些需要很多计算资源的结果,这样的话就不必在下次重复消耗计算资源 Django自带了一个健壮的缓存系统来保存动态页面,避免对 ...
最新文章
- cout 和 printf 性能比较
- .Net core下的配置设置(一)——Configuration
- import librosa出错解决方案
- AndroidUI的基本结构
- 03day输入及转义符的使用
- 线性代数中一些有关秩的不等式
- 计算机应用技术辅助设计方向课程,AutoCAD计算机辅助设计课程标准.doc
- 用python预测小孩的身高体重标准表格_儿童身高体重标准表2019
- SpringBoot + uni-app开发企业级图书商城系统
- 去面试却被问的哑口无言,是不是踏入了机器学习误区
- 制作美观GIS地图,掌握这些技巧就够了
- SQL Sever:关于外键引用无效表的问题
- 介绍一个产品的思维导图_产品运营怎么使用思维导图?四个方面阐释思维导图的运用...
- 如何使用JWT进行身份验证与授权
- 使用Python+selenium实例化Microsoft Edge或Chrome浏览器对象和常见的报错
- springboot2.x整合tkmapper
- 【LINUX】系统安全
- 什么是语义化标签,常见的语义化标签介绍
- 【Designing ML Systems】第 11 章 :机器学习的人性方面
- 解决windows 2000无法安装vmtool的问题