Django——模板層(template)（模板語法、自定義模板過濾器及標籤、模板繼承）

時間 2019-12-05

標籤 django 模板 template 語法自定義過濾器標籤繼承欄目 Python 简体版

原文原文鏈接

前言:當咱們想在頁面上給客戶端返回一個當前時間，一些初學者可能會很天然的想到用佔位符，字符串拼接來達到咱們想要的效果，可是這樣作會有一個問題，HTML被直接硬編碼在 Python代碼之中。javascript

 
         def 
         current_datetime(request): 
        
         now  
         = 
         datetime.datetime.now() 
        
         html  
         = 
         "<html><body>It is now %s.</body></html>" 
         % 
         now 
        
         return 
         HttpResponse(html)

儘管這種技術便於解釋視圖是如何工做的，但直接將HTML硬編碼到你的視圖裏卻並非一個好主意。讓咱們來看一下爲何：css

對頁面設計進行的任何改變都必須對 Python 代碼進行相應的修改。站點設計的修改每每比底層 Python 代碼的修改要頻繁得多，所以若是能夠在不進行 Python 代碼修改的狀況下變動設計，那將會方便得多。html

Python 代碼編寫和 HTML 設計是兩項不一樣的工做，大多數專業的網站開發環境都將他們分配給不一樣的人員（甚至不一樣部門）來完成。設計者和HTML/CSS的編碼人員不該該被要求去編輯Python的代碼來完成他們的工做。java

程序員編寫 Python代碼和設計人員製做模板兩項工做同時進行的效率是最高的，遠勝於讓一我的等待另外一我的完成對某個既包含 Python又包含 HTML 的文件的編輯工做。python

基於這些緣由，將頁面的設計和Python的代碼分離開會更乾淨簡潔更容易維護。咱們可使用 Django的 模板系統 (Template System)來實現這種模式，這就是本章要具體討論的問題。程序員

python的模板：HTML代碼＋模板語法web

模版包括在使用時會被值替換掉的變量，和控制模版邏輯的標籤。數據庫

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

回到頂部(go to top)

模板語法之變量

在 Django 模板中遍歷複雜數據結構的關鍵是句點字符 .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>

模板之過濾器

語法：

 
         {{obj|filter__name:param}}

`default`

若是一個變量是false或者爲空，使用給定的默認值。不然，使用變量的值。例如：

 
         {{ value|default: 
         "nothing" 
         }}

length

返回值的長度。它對字符串和列表都起做用。例如：

 
         {{ value|length }}

若是 value 是 ['a', 'b', 'c', 'd']，那麼輸出是 4。

`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"，則結果爲ello worl （也是顧頭不顧尾）

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

truncatechars

若是字符串字符多於指定的字符數量，那麼會被截斷。截斷的字符串將以可翻譯的省略號序列（「...」）結尾。（truncatewords則是按單詞數目截斷（單詞與單詞間按空格算），用法相同）

參數：要截斷的字符數

例如：

 
           {{ value|truncatechars: 
           3 
           }}

若是value是「Joel是a，輸出將爲「Joe...」。

safe

Django的模板中會對HTML標籤和JS等語法標籤進行自動轉義，緣由顯而易見，這樣是爲了安全。可是有的時候咱們可能不但願這些HTML元素被轉義，好比咱們作一個內容管理系統，後臺添加的文章中是通過修飾的，這些修飾多是經過一個相似於FCKeditor編輯加註了HTML修飾符的文本，若是自動轉義的話顯示的就是保護HTML標籤的源文件。爲了在Django中關閉HTML的自動轉義有兩種方式，若是是一個單獨的變量咱們能夠經過過濾器「|safe」的方式告訴Django這段代碼是安全的沒必要轉義。好比：

 
         value 
         = 
         "<a href=" 
         ">點擊</a>"

 
         {{ value|safe}}

這裏簡單介紹一些經常使用的模板的過濾器，更多詳見

回到頂部(go to top)

模板之標籤　

標籤看起來像是這樣的： {% 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         #默認第一個循環的序號爲1，升序
forloop.counter0       # 默認第一個循環的序號爲0，升序
forloop.revcounter    #循環序號爲降序，最後一個爲1 
forloop.revcounter0   #循環序號爲降序，最後一個爲0
forloop.first              #第一個爲True，其他爲False
forloop.last               #最後一個爲True，其他爲False

View Code

for ... empty

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

==, !=, >=, <=, >, < 這些比較均可以在模板中使用

（注意：比較符號先後必須有至少一個空格！）

and, or, not, in, not in 也能夠在模板中使用

with

使用一個簡單地名字緩存一個複雜的變量，當你須要使用一個「昂貴的」方法（好比訪問數據庫）不少次的時候是很是有用的

例如：

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

csrf_token

這個標籤用於跨站請求僞造保護

<form action="/login/" method="post">
    {% csrf_token %}  #加上這個才能正常POST請求 <p><input type="text" name="user"></p>
    <input type="submit">
</form>

一些有趣的用法：

.獲取當前用戶：

{{ request.user }}

若是登錄就顯示內容，不登錄就不顯示內容：

{% if request.user.is_authenticated %}
    {{ request.user.username }}，您好！
{% else %}
    請登錄，這裏放登錄連接
{% endif %}

自定義標籤和過濾器

一、在settings中的INSTALLED_APPS配置當前app（即加上當前app的名字，如‘app01’），否則django沒法找到自定義的simple_tag.

二、在app中建立templatetags模塊(模塊名只能是templatetags)

三、建立任意 .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

######################定義標籤##################### <br>
@register.simple_tag
def simple_tag_multi(v1,v2):
    return  v1 * v2
<br>
@register.simple_tag
def my_input(id,arg):
    result = "<input type='text' id='%s' class='%s' />" %(id,arg,)
    return mark_safe(result)

四、在使用自定義simple_tag和filter的html文件中導入以前建立的 my_tags.py

 
         { 
         % 
         load my_tags  
         % 
         }

五、使用simple_tag和filter（如何調用）

-------------模板頁面.html--------------------

過濾器： {{var|filter_name:參數}} # 參數只能是一個

標籤： {% simple_tag 參數1 參數2 ... %} #參數不限


{% load my_tags %}  
      
# 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 %}

注意：filter能夠用在if等語句後，simple_tag不能夠

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

對比過濾器與自定義標籤的使用：
　　過濾器函數的參數只能有兩個，自定義標籤無參數限制
　　過濾器能夠與邏輯標籤共同使用，好比if標籤。自定義標籤不能夠。

模板繼承 (extend)

Django模版引擎中最強大也是最複雜的部分就是模版繼承了。模版繼承可讓您建立一個基本的「骨架」模版，它包含您站點中的所有元素，而且能夠定義可以被子模版覆蓋的 blocks 。

經過從下面這個例子開始，能夠容易的理解模版繼承，首先咱們寫一個模板：

<!DOCTYPE html>
<html lang="en">
<head>
    <link rel="stylesheet" href="style.css" />
    <title>{% block title %}My amazing site{% endblock %}</title>
</head>

<body>
    <div id="sidebar">
        {% block sidebar %}
        <ul>
            <li><a href="/">Home</a></li>
            <li><a href="/blog/">Blog</a></li>
        </ul>
        {% endblock %}
    </div>

    <div id="content">
        {% block content %}{% endblock %}
    </div>
</body>
</html>

這個模版，咱們把它叫做 base.html， 它定義了一個能夠用於兩列排版頁面的簡單HTML骨架。「子模版」的工做是用它們的內容填充空的blocks。

在這個例子中， block 標籤訂義了三個能夠被子模版內容填充的block。 block 告訴模版引擎：子模版可能會覆蓋掉模版中的這些位置。

接下來，咱們再寫一個子模板：

{% extends "base.html" %}
 
{% block title %}My amazing blog{% endblock %}
 
{% block content %}
{% for entry in blog_entries %}
    <h2>{{ entry.title }}</h2>
    <p>{{ entry.body }}</p>
{% endfor %}
{% endblock %}

extends 標籤是這裏的關鍵。它告訴模版引擎，這個模版「繼承」了另外一個模版。當模版系統處理這個模版時，首先，它將定位父模版——在此例中，就是「base.html」。

那時，模版引擎將注意到 base.html 中的三個 block 標籤，並用子模版中的內容來替換這些block。根據 blog_entries 的值，子模板輸出的內容會是下面的內容：

<!DOCTYPE html>
<html lang="en">
<head>
    <link rel="stylesheet" href="style.css" />
    <title>My amazing blog</title>
</head>
 
<body>
    <div id="sidebar">
        <ul>
            <li><a href="/">Home</a></li>
            <li><a href="/blog/">Blog</a></li>
        </ul>
    </div>
 
    <div id="content">
        <h2>Entry one</h2>
        <p>This is my first entry.</p>
 
        <h2>Entry two</h2>
        <p>This is my second entry.</p>
    </div>
</body>
</html>

請注意，子模版並無定義 sidebar block，因此係統使用了父模版中的值。父模版的 {% block %} 標籤中的內容老是被用做備選內容（fallback）。

這種方式使代碼獲得最大程度的複用，而且使得添加內容到共享的內容區域更加簡單，例如，部分範圍內的導航。

這裏是使用繼承的一些提示：

若是你在模版中使用 {% extends %} 標籤，它必須是模版中的第一個標籤。其餘的任何狀況下，模版繼承都將沒法工做。
在base模版中設置越多的 {% block %} 標籤越好。請記住，子模版沒必要定義所有父模版中的blocks，因此，你能夠在大多數blocks中填充合理的默認內容，而後，只定義你須要的那一個。多一點鉤子總比少一點好。
若是你發現你本身在大量的模版中複製內容，那可能意味着你應該把內容移動到父模版中的一個 {% block %} 中。
有時候，想在父模板的基礎上再添加點其餘的，而不是徹底覆蓋父模板的內容，那麼你只須要在想要填充的塊裏，再加上一句 {{ block.super }}，咱們就能夠把父模板裏的東西給留下來，如：
```
父模板中的
{% block title %}My amazing site{% endblock %}，
若是咱們只想子模板的結果是在後面加一個！,
則只須要在子模板中寫成
{% block title %}
    {{ block.super }}！
{% endblock %}
便可。
```

爲了更好的可讀性，你也能夠給你的 {% endblock %} 標籤一個名字。例如：

 
           { 
           %  
           block content  
           % 
           } 
          
           ... 
          
           { 
           %  
           endblock content  
           % 
           }

在大型模版中，這個方法幫你清楚的看到哪個　 {% block %} 標籤被關閉了。

最後，請注意您並不能在一個模版中定義多個相同名字的 block 標籤。這個限制的存在是由於block標籤的做用是「雙向」的。這個意思是，block標籤不只提供了一個坑去填，它還在 _父模版_中定義了填坑的內容。若是在一個模版中有兩個名字同樣的 block 標籤，模版的父模版將不知道使用哪一個block的內容。

注意：模板通常放在app下的templates中，Django會自動去這個文件夾中找。但假如咱們每一個app的templates中都有一個 index.html，當咱們在views.py中使用的時候，直接寫一個 render(request, 'index.html')，Django 能不能找到當前 app 的 templates 文件夾中的 index.html 文件夾呢?（答案是不必定能，有可能找錯）

Django 模板查找機制： Django 查找模板的過程是在每一個 app 的 templates 文件夾中找（而不僅是當前 app 中的代碼只在當前的 app 的 templates 文件夾中找）。各個 app 的 templates 造成一個文件夾列表，Django 遍歷這個列表，一個個文件夾進行查找，當在某一個文件夾找到的時候就中止，全部的都遍歷完了還找不到指定的模板的時候就是 Template Not Found （過程相似於Python找包）。這樣設計有利固然也有弊，有利是的地方是一個app能夠用另外一個app的模板文件，弊是有可能會找錯了。因此咱們使用的時候在 templates 中創建一個 app 同名的文件夾，這樣就行了。

這就須要把每一個app中的 templates 文件夾中再建一個 app 的名稱，僅和該app相關的模板放在 app/templates/app/ 目錄下面，

例如：項目 zqxt 有兩個 app，分別爲 tutorial 和 tryit

 
      zqxt 
     
      ├── tutorial 
     
      │   ├── __init__.py 
     
      │   ├── admin.py 
     
      │   ├── models.py 
     
      │   ├── templates 
     
      │   │   └── tutorial 
     
      │   │       ├── index.html 
     
      │   │       └── search.html 
     
      │   ├── tests.py 
     
      │   └── views.py 
     
      ├── tryit 
     
      │   ├── __init__.py 
     
      │   ├── admin.py 
     
      │   ├── models.py 
     
      │   ├── templates 
     
      │   │   └── tryit 
     
      │   │       ├── index.html 
     
      │   │       └── poll.html 
     
      │   ├── tests.py 
     
      │   └── views.py 
     
      ├── manage.py 
     
      └── zqxt 
     
      ├── __init__.py 
     
      ├── settings.py 
     
      ├── urls.py 
     
      └── wsgi.py

這樣，使用的時候，模板就是 "tutorial/index.html" 和 "tryit/index.html" 這樣有app做爲名稱的一部分，就不會混淆。

假如咱們有如下模板index.html，代碼爲：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<div>網頁公共頭部部分</div>

<h2> 網頁body部分 </h2>

<div>網頁公共底部部分</div>

</body>
</html>

作過web開發的童鞋知道大部分網頁的公共頭部，公共底部部分代碼每一個頁面都同樣，那麼就應該將其單獨拿出作爲一個html，這樣修改這部分代碼時候，不須要每一個頁面都修改，因此在django中咱們能夠這麼作：

top.html

<div>網頁公共頭部部分</div>

bottom.html

<div>網頁公共底部部分</div>

index.html

<!DOCTYPE html>  
<html lang="en">  
<head>  
    <meta charset="UTF-8">  
    <title>Title</title>  
</head>  
<body>  
  
{% include 'top.html' %}  
  
<h2> 網頁body部分 </h2>  
  
{% include 'bottom.html' %}  
  
</body>  
</html>

咱們可使用django模板引擎的Include語法，來將單獨的頁面包含到當前模板頁面中。有同窗有疑問，那咱們經過視圖傳遞給模板的上下文，在被包含的模板中可使用嗎？能夠直接使用。

假如咱們有以下視圖：

def index(request):  
    return render(request, 'index.html', {'a': 100, 'b': 200})

該django的視圖函數，傳遞給模板並渲染模板。

top.html修改以下：

<div>網頁公共頭部部分：{{ a }}</div>

這麼使用是沒有問題的。

我這裏有這樣的一個問題，假如全部的頁面都使用共同的頭部top.html，可能針對1.html 2.html 3.html所使用的頭部有些樣式不同,所需top.html:

<div classs='acss'>網頁公共頭部部分</div>

可是對於5.html， 6.html使用的頭部樣式爲：

<div class='bcss'>網頁公共頭部部分</div>

很顯然，若是直接經過include方式包含公共頭部，會致使一些頁面顯示問題。既然部分參數不同，include容許咱們傳遞參數給被include的模板，咱們可使用with語法，那麼問題解決以下：

{{ % include 'top.html' with mycss='acss' % }}

top.html可修改以下：

<div class='{{mycss}}'>網頁公共頭部部分</div>

被包含模板中部分參數，由咱們include的時候動態指定，那麼top.html就不會由於細微差異而編寫多份代碼了。

轉自：http://www.cnblogs.com/huchong/p/7723525.html

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。