Python之Django基础

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python之Django基础相关的知识,希望对你有一定的参考价值。

MVC和MTV模式

Django的MTV模式本质是各组件之间为了保持松耦合关系,Django的MTV分别代表:

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

       Template(模版):负责如何把页面展示给用户

       View(视图):负责业务逻辑,并在适当的时候调用Model和Template

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

技术分享

Django基本结构:

│  db.sqlite3 ----------sqlie3数据库
│  manage.py        
│      
├─Bookcase
│  │  admin.py          后台,可以用很少量的代码就拥有一个强大的后台。
│  │  apps.py
│  │  models.py         与数据库操作相关,存入或读取数据时用到这个
│  │  tests.py
│  │  urls.py
│  │  views.py  
│  │  处理用户发出的请求,从urls.py中对应过来, 通过渲染templates中的网页可以将显示
│  │      内容比如登陆后的用户名,用户请求的数据,输出到网页。
│  │  __init__.py
│  │  
│  ├─migrations
│     │  0001_initial.py
│     │  __init__.py
│    
│  
│  
│  
├─Bookstore
│  │  settings.py  Django 的设置,配置文件,比如 DEBUG 的开关,静态文件的位置等
│  │  urls.py    urls.py
│  │             网址入口,关联到对应的views.py中的一个函数(或者generic类),
│  │             访问网址就对应一个函数。
│  │  wsgi.py    wsgi有多重一种uwsgi和wsgi,你用那种wsgi来运行Django,
                 一般不用改只有你用到的时候在改
│  │  __init__.py
│   
│          
├─static			
└─templates         templates中的Html模板,
        index.html
        login.html
        regist.html

一.Django基本命令

1.创建一个django project

django-admin.py startproject mysite
  • manage.py ----- Django项目里面的工具,通过它可以调用django shell和数据库等。
  • settings.py ---- 包含了项目的默认设置,包括数据库信息,调试标志以及其他一些工作的变量。
  • urls.py ----- 负责把URL模式映射到应用程序。

2.在mysite目录下创建应用,比如blog:

python manage.py startapp blog

3.启动Django项目

python manage.py runserver 8080

 这样我们的django就启动起来了!在浏览器上访问:http://127.0.0.1:8080/

4.同步更改数据库或者字段

python manage.py syncdb

这种方法可以创建表,当你在models.py中新增了类时,运行它就可以自动在数据库中创建表了,不用手动创建。 

5.清空数据库

python manage.py flush

 6.创建超级管理员

python manage.py createsuperuser
# 按照提示输入用户名和对应的密码就好了邮箱可以留空,用户名和密码必填

# 修改 用户密码可以用:
python manage.py changepassword username

 7.Django项目环境终端1

python manage.py shell

这个命令和 直接运行 python 进入 shell 的区别是:你可以在这个 shell 里面调用当前项目的 models.py 中的 API,对于操作数据的测试非常方便。

 8.Django项目终端环境2

python manage.py dbshell

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

在这个终端可以执行数据库的SQL语句。如果您对SQL比较熟悉,可能喜欢这种方式。

 9.查看更多命令

python manage.py

 10.static配置

为了后端的更改不会影响前端的引入,避免造成前端大量修改

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

 在html文件中导入JavaScript,css,JavaQuery时应如下所示导入:

<link rel="stylesheet" href="{% static "bootstrap-3.3.7/dist/css/bootstrap.css" %}">
<link rel="stylesheet" href="{% static "css_menu/my_css.css" %}">
<script src="{% static "bootstrap-3.3.7/dist/js/jquery-3.1.1.js" %}"></script>
<script src="{% static "dist/js/bootstrap.js" %}"></script>

 二.路由配置系统(URLconf)

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

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


参数说明:

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

2.1 URLconf的正则字符串参数

2.1.1 简单配置

urlpatterns = [
    url(r‘^admin/‘, admin.site.urls),
    url(r‘^index/‘, views.index),
    url(r‘^login_in/‘, views.login_in),
    url(r‘^back/‘, views.back)
    # 当路径符合多个url的时候,走第一个
    # url(r‘^articles/\\d{4}$‘, views.year1), #   year_2004(request)
    # url(r‘^articles/2004$‘, views.year_2004), #   year_2004(request)
    # 无名参数
    # url(r‘^articles/(\\d{4})‘, views.year), #    year(request,2010)
    # url(r‘^articles/(\\d{4})/(\\d{2})‘, views.year_month), #    year(request,2010,12)

]

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

 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的POSTGETHEAD等等 —— 都将路由到相同的函数。

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

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

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

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

三.编写视图

一个视图函数,或者简短来说叫做视图,是一个简单的Python函数,它接受web请求,并且返回web响应。响应可以是一张网页的HTML内容,一个重定向,一个404错误,一个XML文档,或者一张图片. . . 是任何东西都可以。无论视图本身包含什么逻辑,都要返回响应。代码写在哪里也无所谓,只要它在你的Python目录下面。除此之外没有更多的要求了——可以说“没有什么神奇的地方”。为了能够把代码放在某个地方,惯例是把视图放在叫做views.py的文件中,然后把它放到你的项目或者应用目录里。

3.1 一个简单的视图

下面是一个返回当前日期和时间作为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对象

‘‘‘
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函数

技术分享
 1 -----------------------------------url.py
 2 
 3  url(r"login",   views.login),
 4  url(r"index",   views.index),
 5 
 6 -----------------------------------views.py
 7 def login(req):
 8     if req.method=="POST":
 9         if 1:
10             # return redirect("/index/")
11             name="json"
12 
13             return render(req,"index.html",locals())
14 
15     return render(req,"login.html",locals())
16 
17 
18 def index(req):
19 
20     name="json"
21 
22     return render(req,"index.html",locals())
23 
24 -----------------------------------login.html
25 
26 <form action="/login/" method="post">
27     <p>姓名<input type="text" name="username"></p>
28     <p>性别<input type="text" name="sex"></p>
29     <p>邮箱<input type="text" name="email"></p>
30     <p><input type="submit" value="submit"></p>
31 </form>
32 -----------------------------------index.html
33 <h1>用户{{ name }}你好</h1>
34 
35 #总结: render和redirect的区别:
36 #   1 if render的页面需要模板语言渲染,需要的将数据库的数据加载到html,那么所有的这一部分
37 #     除了写在index的视图函数中,必须还要写在login中,代码重复,没有解耦.
38 
39 #   2 the most important: url没有跳转到/index/,而是还在/login/,所以当刷新后
40 #     又得重新登录.
View Code

四.Template

4.1 模板系统的介绍

你可能已经注意到我们在例子视图中返回文本的方式有点特别。 也就是说,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)来实现这种模式,这就是本章要具体讨论的问题。

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

 4.2.2 深度变量的查找(万能的句点号)

在到目前为止的例子中,我们通过 context 传递的简单参数值主要是字符串,然而,模板系统能够非常简洁地处理更加复杂的数据结构,例如list、dictionary和自定义的对象。在 Django 模板中遍历复杂数据结构的关键是句点字符 (.)。
技术分享
 1 #最好是用几个例子来说明一下。
 2 # 首先,句点可用于访问列表索引,例如:
 3 
 4 >>> from django.template import Template, Context
 5 >>> t = Template(Item 2 is {{ items.2 }}.)
 6 >>> c = Context({items: [apples, bananas, carrots]})
 7 >>> t.render(c)
 8 Item 2 is carrots.
 9 
10 #假设你要向模板传递一个 Python 字典。 要通过字典键访问该字典的值,可使用一个句点:
11 >>> from django.template import Template, Context
12 >>> person = {name: Sally, age: 43}
13 >>> t = Template({{ person.name }} is {{ person.age }} years old.)
14 >>> c = Context({person: person})
15 >>> t.render(c)
16 Sally is 43 years old.
17 
18 #同样,也可以通过句点来访问对象的属性。 比方说, Python 的 datetime.date 对象有
19 #year 、 month 和 day 几个属性,你同样可以在模板中使用句点来访问这些属性:
20 
21 >>> from django.template import Template, Context
22 >>> import datetime
23 >>> d = datetime.date(1993, 5, 2)
24 >>> d.year
25 >>> d.month
26 >>> d.day
27 >>> t = Template(The month is {{ date.month }} and the year is {{ date.year }}.)
28 >>> c = Context({date: d})
29 >>> t.render(c)
30 The month is 5 and the year is 1993.
31 
32 # 这个例子使用了一个自定义的类,演示了通过实例变量加一点(dots)来访问它的属性,这个方法适
33 # 用于任意的对象。
34 >>> from django.template import Template, Context
35 >>> class Person(object):
36 ...     def __init__(self, first_name, last_name):
37 ...         self.first_name, self.last_name = first_name, last_name
38 >>> t = Template(Hello, {{ person.first_name }} {{ person.last_name }}.)
39 >>> c = Context({person: Person(John, Smith)})
40 >>> t.render(c)
41 Hello, John Smith.
42 
43 # 点语法也可以用来引用对象的方法。 例如,每个 Python 字符串都有 upper() 和 isdigit()
44 # 方法,你在模板中可以使用同样的句点语法来调用它们:
45 >>> from django.template import Template, Context
46 >>> t = Template({{ var }} -- {{ var.upper }} -- {{ var.isdigit }})
47 >>> t.render(Context({var: hello}))
48 hello -- HELLO -- False
49 >>> t.render(Context({var: 123}))
50 123 -- 123 -- True
51 
52 # 注意这里调用方法时并* 没有* 使用圆括号 而且也无法给该方法传递参数;你只能调用不需参数的
53 # 方法。
View Code

 

4.2.3 变量的过滤器(filter)的使用

语法格式:      {{obj|filter:param}}
技术分享
 1 # 1  add          :   给变量加上相应的值
 2    #
 3    # 2  addslashes   :    给变量中的引号前加上斜线
 4    #
 5    # 3  capfirst     :    首字母大写
 6    #
 7    # 4  cut          :   从字符串中移除指定的字符
 8    #
 9    # 5  date         :   格式化日期字符串
10    #
11    # 6  default      :   如果值是False,就替换成设置的默认值,否则就是用本来的值
12    #
13    # 7  default_if_none:  如果值是None,就替换成设置的默认值,否则就使用本来的值
14 
15 
16 #实例:
17 
18 #value1="aBcDe"
19 {{ value1|upper }}<br>
20 
21 #value2=5
22 {{ value2|add:3 }}<br>
23 
24 #value3=‘he  llo wo r ld‘
25 {{ value3|cut:  }}<br>
26 
27 #import datetime
28 #value4=datetime.datetime.now()
29 {{ value4|date:Y-m-d }}<br>
30 
31 #value5=[]
32 {{ value5|default:空的 }}<br>
33 
34 #value6=‘<a href="#">跳转</a>‘
35 
36 {{ value6 }}
37 
38 {% autoescape off %}
39   {{ value6 }}
40 {% endautoescape %}
41 
42 {{ value6|safe }}<br>
43 
44 {{ value6|striptags }}
45 
46 #value7=‘1234‘
47 {{ value7|filesizeformat }}<br>
48 {{ value7|first }}<br>
49 {{ value7|length }}<br>
50 {{ value7|slice:":-1" }}<br>
51 
52 #value8=‘http://www.baidu.com/?a=1&b=3‘
53 {{ value8|urlencode }}<br>
54     value9=hello I am yuan
View Code

 

4.2.4 标签(tag)的使用(使用大括号和百分比的组合来表示使用tag)

{% 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 %}

 {% 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
 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

 

技术分享
 1 from django import template
 2 from django.utils.safestring import mark_safe
 3 
 4 register = template.Library()   #register的名字是固定的,不可改变
 5 
 6 
 7 @register.filter
 8 def filter_multi(v1,v2):
 9     return  v1 * v2
10 
11 
12 @register.simple_tag
13 def simple_tag_multi(v1,v2):
14     return  v1 * v2
15 
16 
17 @register.simple_tag
18 def my_input(id,arg):
19     result = "<input type=‘text‘ id=‘%s‘ class=‘%s‘ />" %(id,arg,)
20     return mark_safe(result)
View Code

 

 

 

c、在使用自定义simple_tag和filter的html文件中导入之前创建的 my_tags.py :{% load my_tags %}

d、使用simple_tag和filter(如何调用)

技术分享
 1 -------------------------------.html
 2 {% load xxx %}   #首行
 3     
 4     
 5     
 6     
 7  # num=12
 8 {{ num|filter_multi:2 }} #24
 9 
10 {{ num|filter_multi:"[22,333,4444]" }}
11 
12 
13 {% simple_tag_multi 2 5 %}  参数不限,但不能放在if for语句中
14 {% 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 创建一个更加完整的模板来体会一下这种做法:

技术分享
 1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
 2 <html lang="en">
 3 <head>
 4     <title>The current time</title>
 5 </head>
 6 <body>
 7     <h1>My helpful timestamp site</h1>
 8     <p>It is now {{ current_date }}.</p>
 9  
10     <hr>
11     <p>Thanks for visiting my site.</p>
12 </body>
13 </html>
View Code

这看起来很棒,但如果我们要为 hours_ahead 视图创建另一个模板会发生什么事情呢?

技术分享
 1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
 2 <html lang="en">
 3 <head>
 4     <title>Future time</title>
 5 </head>
 6 <body>
 7     <h1>My helpful timestamp site</h1>
 8     <p>In {{ hour_offset }} hour(s), it will be {{ next_time }}.</p>
 9  
10     <hr>
11     <p>Thanks for visiting my site.</p>
12 </body>
13 </html>
View Code

Django 的模板继承系统解决了这些问题。 你可以将其视为服务器端 include 的逆向思维版本。 你可以对那些不同 的代码段进行定义,而不是 共同 代码段。

第一步是定义 基础模板,该框架之后将由子模板所继承。 以下是我们目前所讲述范例的基础模板:

技术分享
 1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
 2 <html lang="en">
 3 <head>
 4     <title>{% block title %}{% endblock %}</title>
 5 </head>
 6 <body>
 7     <h1>My helpful timestamp site</h1>
 8     {% block content %}{% endblock %}
 9     {% block footer %}
10     <hr>
11     <p>Thanks for visiting my site.</p>
12     {% endblock %}
13 </body>
14 </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 %}

 再为 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 %} 标签中的内容总是被当作一条退路。继承并不会影响到模板的上下文。 换句话说,任何处在继承树上的模板都可以访问到你传到模板中的每一个模板变量。你可以根据需要使用任意多的继承次数。 使用继承的一种常见方式是下面的三层法:

  • 创建 base.html 模板,在其中定义站点的主要外观感受。 这些都是不常修改甚至从不修改的部分。
  • 为网站的每个区域创建 base_SECTION.html 模板(例如, base_photos.html 和 base_forum.html )。这些模板对base.html 进行拓展,并包含区域特定的风格与设计。
  • 为每种类型的页面创建独立的模板,例如论坛页面或者图片库。 这些模板拓展相应的区域模板。

 

这个方法可最大限度地重用代码,并使得向公共区域(如区域级的导航)添加内容成为一件轻松的工作。

 

以下是使用模板继承的一些诀窍:

技术分享
 1 <1>如果在模板中使用 {% extends %} ,必须保证其为模板中的第一个模板标记。 否则,模板继承将不起作用。
 2 
 3  <2>一般来说,基础模板中的 {% block %} 标签越多越好。 记住,子模板不必定义父模板中所有的代码块,因此
 4     你可以用合理的缺省值对一些代码块进行填充,然后只对子模板所需的代码块进行(重)定义。 俗话说,钩子越
 5     多越好。
 6 
 7  <3>如果发觉自己在多个模板之间拷贝代码,你应该考虑将该代码段放置到父模板的某个 {% block %} 中。
 8     如果你需要访问父模板中的块的内容,使用 {{ block.super }}这个标签吧,这一个魔法变量将会表现出父模
 9     板中的内容。 如果只想在上级代码块基础上添加内容,而不是全部重载,该变量就显得非常有用了。
10 
11  <4>不允许在同一个模板中定义多个同名的 {% block %} 。 存在这样的限制是因为block 标签的工作方式是双向的。
12     也就是说,block 标签不仅挖了一个要填的坑,也定义了在父模板中这个坑所填充的内容。如果模板中出现了两个
13     相同名称的 {% block %} 标签,父模板将无从得知要使用哪个块的内容。
View Code

五.数据库与ORM

 

以上是关于Python之Django基础的主要内容,如果未能解决你的问题,请参考以下文章

Python云端系统开发入门——云端系统之框架基础

web框架之--Django基础入门

Python基础之 Django模型

Python基础之 Django模板

Python之Django基础

Python基础之 Django安装和配置