django之Template(模板)

阿新 • • 發佈：2018-10-04

驗證易維優雅 pytho time footer light 容易 counter

模板

　　從名字上來說，模板是什麽，是供我們使用的一些規範，你可以在這上面添加一些東西，是基於這個物體的，而不是憑空創造的。

　　至於我們為什麽需要模板，在這裏利用別人的一些文字做一些介紹，如下：

你可能已經註意到我們在例子視圖中返回文本的方式有點特別。也就是說，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)來實現這種模式，這就是本章要具體討論的問題。

模板語法

模板的組成：HTML代碼＋邏輯控制代碼

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

推薦方式

－－－－－－深度變量的查找（萬能的句點號）

在到目前為止的例子中，我們通過 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‘

# 註意這裏調用方法時並* 沒有* 使用圓括號 而且也無法給該方法傳遞參數；你只能調用不需參數的
# 方法。

－－－－－－變量的過濾器(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‘

2 標簽(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 %}

－－－－－－{% 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標簽

用於生成csrf_token的標簽，用於防治跨站攻擊驗證。註意如果你在view的index裏用的是render_to_response方法，不會生效

其實，這裏是會生成一個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 %}

－－－－－－{% load %}: 加載標簽庫

3 自定義filter和simple_tag

－－－－－－a、在app中創建templatetags模塊(必須的)

－－－－－－b、創建任意 .py 文件，如：my_tags.py

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

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


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


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


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

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

－－－－－－e、在settings中的INSTALLED_APPS配置當前app，不然django無法找到自定義的simple_tag.（一般會自動添加）

註意：

filter可以用在if等語句後，simple_tag不可以

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

4 extend模板繼承

－－－－－－include 模板標簽

在講解了模板加載機制之後，我們再介紹一個利用該機制的內建模板標簽： {% include %} 。該標簽允許在（模板中）包含其它的模板的內容。標簽的參數是所要包含的模板名稱，可以是一個變量，也可以是用單/雙引號硬編碼的字符串。每當在多個模板中出現相同的代碼時，就應該考慮是否要使用 {% include %} 來減少重復。

－－－－－－extend(繼承)模板標簽

到目前為止，我們的模板範例都只是些零星的 HTML 片段，但在實際應用中，你將用 Django 模板系統來創建整個 HTML 頁面。這就帶來一個常見的 Web 開發問題：在整個網站中，如何減少共用頁面區域（比如站點導航）所引起的重復和冗余代碼？

解決該問題的傳統做法是使用 服務器端的 includes ，你可以在 HTML 頁面中使用該指令將一個網頁嵌入到另一個中。事實上， Django 通過剛才講述的 {% include %} 支持了這種方法。但是用 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>

這看起來很棒，但如果我們要為 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>

很明顯，我們剛才重復了大量的 HTML 代碼。想象一下，如果有一個更典型的網站，它有導航條、樣式表，可能還有一些 JavaScript 代碼，事情必將以向每個模板填充各種冗余的 HTML 而告終。

解決這個問題的服務器端 include 方案是找出兩個模板中的共同部分，將其保存為不同的模板片段，然後在每個模板中進行 include。也許你會把模板頭部的一些代碼保存為 header.html 文件：

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
<html lang="en">
<head>

你可能會把底部保存到文件 footer.html :

<hr>
    <p>Thanks for visiting my site.</p>
</body>
</html>

對基於 include 的策略，頭部和底部的包含很簡單。麻煩的是中間部分。在此範例中，每個頁面都有一個<h1>My helpful timestamp site</h1> 標題，但是這個標題不能放在 header.html 中，因為每個頁面的 <title> 是不同的。如果我們將 <h1> 包含在頭部，我們就不得不包含 <title> ，但這樣又不允許在每個頁面對它進行定制。何去何從呢？

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>

這個叫做 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 %} 標簽中的內容總是被當作一條退路。繼承並不會影響到模板的上下文。換句話說，任何處在繼承樹上的模板都可以訪問到你傳到模板中的每一個模板變量。你可以根據需要使用任意多的繼承次數。使用繼承的一種常見方式是下面的三層法：

   <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 %} 標簽，父模板將無從得知要使用哪個塊的內容。

django之Template(模板)

驗證易維優雅 pytho time footer light 容易 counter 模板　　從名字上來說，模板是什麽，是供我們使用的一些規範，你可以在這上面添加一些東西，是基於這個物體的，而不是憑空創造的。　　至於我們為什麽需要模板，在這裏利用別人的一些文字做一些介

django之Template(模板)

模板

模板語法

模板的組成：HTML代碼＋邏輯控制代碼

1 變量（使用雙大括號來引用變量）：

2 標簽(tag)的使用（使用大括號和百分比的組合來表示使用tag）

3 自定義filter和simple_tag

4 extend模板繼承

django之Template(模板)

Python Django 之 Template 模板的使用

Django框架之template(模板)中的安全機制

django之Template

Django之html-模板繼承

六、Django之Template

Django之mako模板使用

微信小程式之template模板

微信小程式學習之template模板的使用

RobotFrameWork（七）資料驅動之Template模板

django中template模板、static靜態檔案

python--Django之模板層（template）

Django之模板(Template)

django模板語言之Template

Django之模板渲染

Django學習之 - 基礎模板語言

Python自動化運維：Django之View視圖和Template

Django之模板

C#設計模式之十三模板方法模式（Template Method Pattern）【行為型】

微信小程序開發之--"template模板“的應用

django之Template(模板)

模板

模板語法

模板的組成：HTML代碼＋邏輯控制代碼

1 變量（使用雙大括號來引用變量）：

2 標簽(tag)的使用（使用大括號和百分比的組合來表示使用tag）

3 自定義filter和simple_tag

4 extend模板繼承

相關推薦