python ==> Django框架

時間 2019-11-19

標籤 python django 框架欄目 Python 简体版

原文原文鏈接

python 之 Django 框架html

本節內容前端

1.web 框架python

2.mvc和mtv模式jquery

3.django流程和命令git

4.django URL程序員

5.django viewsweb

6.django temple正則表達式

7.django modelsshell

8.django admin數據庫

1.web框架

框架，即framework，特指爲解決一個開放性問題而設計的具備必定約束性的支撐結構，使用框架能夠幫你快速開發特定的系統，簡單地說，就是你用別人搭建好的舞臺來作表演。

Web應用的流程：

//瀏覽器發送一個HTTP請求；
//服務器收到請求，生成一個HTML文檔；
//服務器把HTML文檔做爲HTTP響應的Body發送給瀏覽器；
//瀏覽器收到HTTP響應，從HTTP Body取出HTML文檔並顯示。

對於全部的Web應用，本質上其實就是一個socket服務端，用戶的瀏覽器其實就是一個socket客戶端。　　

import socket

def handle_request(client):

    buf = client.recv(1024)
    client.send("HTTP/1.1 200 OK\r\n\r\n".encode("utf8"))
    client.send("<h1 style='color:red'>Hello, world</h1>".encode("utf8"))

def main():

    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.bind(('localhost',8001))
    sock.listen(5)

    while True:
        connection, address = sock.accept()
        handle_request(connection)
        connection.close()

if __name__ == '__main__':

    main()

最簡單的Web應用就是先把HTML用文件保存好，用一個現成的HTTP服務器軟件，接收用戶請求，從文件中讀取HTML，返回。
若是要動態生成HTML，就須要把上述步驟本身來實現。不過，接受HTTP請求、解析HTTP請求、發送HTTP響應都是苦力活，若是咱們本身來寫這些底層代碼，還沒開始寫動態HTML呢，就得花個把月去讀HTTP規範。

正確的作法是底層代碼由專門的服務器軟件實現，咱們用Python專一於生成HTML文檔。由於咱們不但願接觸到TCP鏈接、HTTP原始請求和響應格式，因此，須要一個統一的接口，讓咱們專心用Python編寫Web業務。

這個接口就是WSGI：Web Server Gateway Interface。

實現一個簡單的web框架　　

one：

from wsgiref.simple_server import make_server
 
 
def application(environ, start_response):
    start_response('200 OK', [('Content-Type', 'text/html')])
    return [b'<h1>Hello, web!</h1>']
 
 
httpd = make_server('', 8080, application)
 
print('Serving HTTP on port 8000...')
# 開始監聽HTTP請求:
httpd.serve_forever()

注意：

整個application()函數自己沒有涉及到任何解析HTTP的部分，也就是說，底層代碼不須要咱們本身編寫，
咱們只負責在更高層次上考慮如何響應請求就能夠了。

application()函數必須由WSGI服務器來調用。有不少符合WSGI規範的服務器，咱們能夠挑選一個來用。

Python內置了一個WSGI服務器，這個模塊叫wsgiref

application()函數就是符合WSGI標準的一個HTTP處理函數，它接收兩個參數：

        //environ：一個包含全部HTTP請求信息的dict對象；

        //start_response：一個發送HTTP響應的函數。

在application()函數中，調用：

start_response('200 OK', [('Content-Type', 'text/html')])

就發送了HTTP響應的Header，注意Header只能發送一次，也就是隻能調用一次start_response()函數。
start_response()函數接收兩個參數，一個是HTTP響應碼，一個是一組list表示的HTTP Header，每一個Header用一個包含兩個str的tuple表示。

一般狀況下，都應該把Content-Type頭髮送給瀏覽器。其餘不少經常使用的HTTP Header也應該發送。

而後，函數的返回值b'<h1>Hello, web!</h1>'將做爲HTTP響應的Body發送給瀏覽器。

有了WSGI，咱們關心的就是如何從environ這個dict對象拿到HTTP請求信息，而後構造HTML，
經過start_response()發送Header，最後返回Body。

two：　　

print(environ['PATH_INFO'])
    path=environ['PATH_INFO']
    start_response('200 OK', [('Content-Type', 'text/html')])
    f1=open("index1.html","rb")
    data1=f1.read()
    f2=open("index2.html","rb")
    data2=f2.read()
 
    if path=="/yuan":
        return [data1]
    elif path=="/alex":
        return [data2]
    else:
        return ["<h1>404</h1>".encode('utf8')]

Three：　　

from wsgiref.simple_server import make_server
 
def f1():
    f1=open("index1.html","rb")
    data1=f1.read()
    return [data1]
 
def f2():
    f2=open("index2.html","rb")
    data2=f2.read()
    return [data2]
 
def application(environ, start_response):
 
    print(environ['PATH_INFO'])
    path=environ['PATH_INFO']
    start_response('200 OK', [('Content-Type', 'text/html')])
 
 
    if path=="/yuan":
        return f1()
 
    elif path=="/alex":
        return f2()
 
    else:
        return ["<h1>404</h1>".encode("utf8")]
 
 
httpd = make_server('', 8502, application)
 
print('Serving HTTP on port 8084...')
 
# 開始監聽HTTP請求:
httpd.serve_forever()

Four：　　

from wsgiref.simple_server import make_server
 
 
def f1(req):
    print(req)
    print(req["QUERY_STRING"])
 
    f1=open("index1.html","rb")
    data1=f1.read()
    return [data1]
 
def f2(req):
 
    f2=open("index2.html","rb")
    data2=f2.read()
    return [data2]
 
import time
 
def f3(req):        #模版以及數據庫
 
    f3=open("index3.html","rb")
    data3=f3.read()
    times=time.strftime("%Y-%m-%d %X", time.localtime())
    data3=str(data3,"utf8").replace("!time!",str(times))
 
 
    return [data3.encode("utf8")]
 
 
def routers():
 
    urlpatterns = (
        ('/yuan',f1),
        ('/alex',f2),
        ("/cur_time",f3)
    )
    return urlpatterns
 
 
def application(environ, start_response):
 
    print(environ['PATH_INFO'])
    path=environ['PATH_INFO']
    start_response('200 OK', [('Content-Type', 'text/html')])
 
 
    urlpatterns = routers()
    func = None
    for item in urlpatterns:
        if item[0] == path:
            func = item[1]
            break
    if func:
        return func(environ)
    else:
        return ["<h1>404</h1>".encode("utf8")]
 
httpd = make_server('', 8518, application)
 
print('Serving HTTP on port 8084...')
 
# 開始監聽HTTP請求:
 
httpd.serve_forever()

2.mvc和mtv模式　　

著名的MVC模式：所謂MVC就是把web應用分爲模型(M),控制器(C),視圖(V)三層；他們之間以一種插件似的，鬆耦合的方式鏈接在一塊兒。
模型負責業務對象與數據庫的對象(ORM),視圖負責與用戶的交互(頁面)，控制器(C)接受用戶的輸入調用模型和視圖完成用戶的請求。

Django的MTV模式本質上與MVC模式沒有什麼差異，也是各組件之間爲了保持鬆耦合關係，只是定義上有些許不一樣，Django的MTV分別表明：

Model(模型)：負責業務對象與數據庫的對象(ORM)
Template(模版)：負責如何把頁面展現給用戶
View(視圖)：負責業務邏輯，並在適當的時候調用Model和Template

此外，Django還有一個url分發器，它的做用是將一個個URL的頁面請求分發給不一樣的view處理，view再調用相應的Model和Template

3.django流程和命令　　

1. django流程

django
#安裝： pip3 install django
      添加環境變量
#1  建立project
   django-admin startproject mysite
   ---mysite
      ---settings.py
      ---url.py
      ---wsgi.py
   ---- manage.py(啓動文件)
#2  建立APP
   python mannage.py startapp  app01
#3  settings配置
   TEMPLATES
   STATICFILES_DIRS=(
        os.path.join(BASE_DIR,"statics"),
    )
   STATIC_URL = '/static/'
   #  咱們只能用 STATIC_URL，但STATIC_URL會按着你的STATICFILES_DIRS去找
  <script src="/statics/jquery-3.1.1.js"></script> ------error－－－－－不能直接用，必須用STATIC_URL = '/static/'
  <script src="/static/jquery-3.1.1.js"></script>
  採用第二種方式 ，後端的更改不會影響前端的引入，避免形成前端大量修改
#4  根據需求設計代碼
       url.py
       view.py
#5  使用模版
   render(req,"index.html")
#6  啓動項目
   python manage.py runserver  127.0.0.1:8090
#7  鏈接數據庫，操做數據
   model.py

2.django命令行工具　

django-admin.py 是Django的一個用於管理任務的命令行工具，manage.py是對django－admin.py的簡單包裝,每個Django Project裏都會有一個mannage.py。

<1> 建立一個django工程 : django-admin.py startproject mysite

當前目錄下會生成mysite的工程，目錄結構以下：

.
└── mysite
    ├── manage.py
    └── mysite
        ├── __init__.py
        ├── settings.py
        ├── urls.py
        └── wsgi.py

manage.py ——- Django項目裏面的工具，經過它能夠調用django shell和數據庫等。

settings.py —— 包含了項目的默認設置，包括數據庫信息，調試標誌以及其餘一些工做的變量。
urls.py ——- 負責把URL模式映射到應用程序。

<2>在mysite目錄下建立blog應用: python manage.py startapp blog

.
├── blog
│   ├── admin.py
│   ├── apps.py
│   ├── __init__.py
│   ├── migrations
│   │   └── __init__.py
│   ├── models.py
│   ├── tests.py
│   └── views.py
├── manage.py
└── mysite
    ├── __init__.py
    ├── __pycache__
    │   ├── __init__.cpython-35.pyc
    │   └── settings.cpython-35.pyc
    ├── settings.py
    ├── urls.py
    └── wsgi.py

<3>啓動django項目：python manage.py runserver 8080

這樣咱們的django就啓動起來了！當咱們訪問：http://127.0.0.1:8080/ 時就能夠看到」It worked!」

<4>生成數據庫
生成同步數據庫的腳本：python manage.py makemigrations
同步數據庫：python manage.py migrate
注意：在開發過程當中，數據庫同步誤操做以後，不免會遇到後面不能同步成功的狀況，解決這個問題的一個簡單粗暴方法是把migrations目錄下的腳本（除init.py以外）所有刪掉，再把數據庫刪掉以後建立一個新的數據庫，數據庫同步操做再從新作一遍。

<5>admin後臺
當咱們訪問http://127.0.0.1:8080/admin/ 時，會出現admin後臺的登陸頁面

因此咱們須要爲進入這個項目的後臺建立超級管理員：python manage.py createsuperuser，設置好用戶名和密碼後即可登陸啦！

<6>清空數據庫： python manage.py flush

<7>查詢某個命令的詳細信息： django-admin.py help startapp
admin 是Django 自帶的一個後臺數據庫管理系統。

<8>啓動交互界面：python manage.py shell
這個命令和直接運行 python 進入 shell 的區別是：你能夠在這個 shell 裏面調用當前項目的 models.py 中的 API，對於操做數據，還有一些小測試很是方便。

<9> 終端上輸入 python manage.py 能夠看到詳細的列表，在忘記子名稱的時候特別有用。

demo1提交數據並展現

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>建立我的信息</h1>
 
<form action="/userInfor/" 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>
 
<hr>
 
<h1>信息展現</h1>
 
<table border="1">
 
    <tr>
        <td>姓名</td>
        <td>性別</td>
        <td>郵箱</td>
    </tr>
    {% for i in info_list %}
 
        <tr>
            <td>{{ i.username }}</td>
            <td>{{ i.sex }}</td>
            <td>{{ i.email }}</td>
        </tr>
 
    {% endfor %}
 
</table>
 
</body>
</html>

-----------------------url.py---------------------------------------
url(r'^userInfor/', views.userInfor) -----------------------views.py-------------------------------------- info_list=[] def userInfor(req): if req.method=="POST": username=req.POST.get("username",None) sex=req.POST.get("sex",None) email=req.POST.get("email",None) info={"username":username,"sex":sex,"email":email} info_list.append(info) return render(req,"userInfor.html",{"info_list":info_list})

demo2提交數據並展現（數據庫）

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>建立我的信息</h1>
 
<form action="/userInfor/" 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>
 
<hr>
 
<h1>信息展現</h1>
 
<table border="1">
 
    <tr>
        <td>姓名</td>
        <td>性別</td>
        <td>郵箱</td>
    </tr>
    {% for i in info_list %}
 
        <tr>
            <td>{{ i.username }}</td>
            <td>{{ i.sex }}</td>
            <td>{{ i.email }}</td>
        </tr>
 
    {% endfor %}
 
</table>
 
</body>
</html>

----------------------------------------------models.py
from django.db import models # Create your models here. class UserInfor(models.Model): username=models.CharField(max_length=64) sex=models.CharField(max_length=64) email=models.CharField(max_length=64) ----------------------------------------------views.py from django.shortcuts import render from app01 import models # Create your views here. def userInfor(req): if req.method=="POST": u=req.POST.get("username",None) s=req.POST.get("sex",None) e=req.POST.get("email",None) #---------表中插入數據方式一 # info={"username":u,"sex":e,"email":e} # models.UserInfor.objects.create(**info) #---------表中插入數據方式二 models.UserInfor.objects.create( username=u, sex=s, email=e ) info_list=models.UserInfor.objects.all() return render(req,"userInfor.html",{"info_list":info_list}) return render(req,"userInfor.html")

4.django URL　　

URL配置(URLconf)就像Django 所支撐網站的目錄。它的本質是URL模式以及要爲該URL模式調用的視圖函數之間的映射表；你就是以這種方式告訴Django，對於這個URL調用這段代碼，對於那個URL調用那段代碼。　　

urlpatterns = [
    url(正則表達式, views視圖函數，參數，別名),
]

參數說明：

一個正則表達式字符串
一個可調用對象，一般爲一個視圖函數或一個指定視圖函數路徑的字符串
可選的要傳遞給視圖函數的默認參數（字典形式）
一個可選的name參數

簡單url配置

from django.conf.urls import url
from django.contrib import admin
from blog 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})/$', views.year_archive),  #no_named group
    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),

上面用括號括住的內容將被當作參數傳遞給視圖函數，()在正則中表示分組，這些分組是無名分組，將做爲普通參數傳遞進入視圖函數。

命名分組url配置

from django.conf.urls import url
from blog 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),
]

上面形似(?P正則表達式)的形式在正則表達式中叫作命名分組，就是給該分組取了個名字，在這裏，有名分組將做爲key:value對的方式以關鍵字參數傳遞進視圖函數。

擴展參數配置

from django.conf.urls import url
from blog import views
urlpatterns = [
    url(r'^blog/(?P<year>[0-9]{4})/$', views.year_archive, {'foo': 'bar'}),
]

第三個參數是一個字典，這個字典的鍵值對將做爲關鍵字參數傳遞進視圖函數，若是url中的命名分組和字典中的鍵相同，則字典中的鍵對應的值將會覆蓋url中的命名分組的值傳遞進視圖函數中。

別名配置

-------------------------------------urls-------------------------------------
urlpatterns = [
    url(r'^index',views.index,name='bieming'),
    url(r'^admin/', admin.site.urls),
    # 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),

]
------------------------------------views-------------------------------------

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 'bieming' %}" method="post">
         用戶名:<input type="text" name="username">
         密碼:<input type="password" name="password">
         <input type="submit" value="submit">
     </form>
</body>
</html>

第四個參數name=bieming做用就是給url取了個別名，以後在html中若是有form表單要提交到該url，則能夠經過{% url 「bieming」 %}轉換成相應的url。

添加子url

#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')),
]
--------------------------blog.urls----------------------------------
from django.conf.urls import url
from blog import views

urlpatterns = [
    url(r'login/', views.login),
    url(r'home/', views.home)
    ]

在主項目的urls文件中先導入include,以後在url中的blog中設置include(「blog.urls」)將會將blog子項目中的urls文件中的全部Url添加到django的url路由中。注意，在新版的django中建議include中的url blog後面和blog裏面的url的前面都不須要加/，由於django會給咱們加好。　　

5.django views　　

http請求中產生兩個核心對象：

http請求：HttpRequest對象
http響應：HttpResponse對象

所在位置：django.http

以前咱們用到的參數request就是HttpRequest 檢測方法：isinstance(request,HttpRequest)

1. HttpRequest方法

# path：       請求頁面的全路徑，不包括域名
#
# method：     請求中使用的HTTP方法的字符串表示。全大寫表示。例如
#
#                    if  req.method=="GET":
#
#                              do_something()
#
#                    elseif req.method=="POST":
#
#                              do_something_else()
#
# GET:         包含全部HTTP GET參數的類字典對象
#
# POST：       包含全部HTTP POST參數的類字典對象
#
#              服務器收到空的POST請求的狀況也是可能發生的，也就是說，表單form經過
#              HTTP POST方法提交請求，可是表單中可能沒有數據，所以不能使用
#              if req.POST來判斷是否使用了HTTP POST 方法；應該使用  if req.method=="POST"
#
#
#
# COOKIES:     包含全部cookies的標準Python字典對象；keys和values都是字符串。
#
# FILES：      包含全部上傳文件的類字典對象；FILES中的每個Key都是<input type="file" name="" />標籤中                     name屬性的值，FILES中的每個value同時也是一個標準的python字典對象，包含下面三個Keys：
#
#             filename：      上傳文件名，用字符串表示
#             content_type:   上傳文件的Content Type
#             content：       上傳文件的原始內容
#
#
# user：       是一個django.contrib.auth.models.User對象，表明當前登錄的用戶。若是訪問用戶當前
#              沒有登錄，user將被初始化爲django.contrib.auth.models.AnonymousUser的實例。你
#              能夠經過user的is_authenticated()方法來辨別用戶是否登錄：
#              if req.user.is_authenticated();只有激活Django中的AuthenticationMiddleware
#              時該屬性纔可用
#
# session：    惟一可讀寫的屬性，表明當前會話的字典對象；本身有激活Django中的session支持時該屬性纔可用。

#方法
get_full_path(),   好比：http://127.0.0.1:8000/index33/?name=123 ,req.get_full_path()獲得的結果就是/index33/?name=123
req.path:/index33

2. HttpResponse對象

對於HttpRequest對象來講，是由django自動建立的，可是，HttpResponse對象就必須咱們本身建立。每一個view請求處理方法必須返回一個HttpResponse對象。

HttpResponse類在django.http.HttpResponse

在HttpResponse對象上擴展的經常使用方法：

頁面渲染： render()（推薦)
新版中不推薦： render_to_response(),
頁面跳轉： redirect(「路徑」)
locals()：能夠直接將函數中全部的變量傳給模板（雖然能夠將全部變量都傳遞給模板，可是效率低下，看需求使用）

總結: render和redirect的區別:
render瀏覽器只是作了一次url請求，的到了一次返回頁面，而redirect瀏覽器第一次請求時服務器給瀏覽器發了個302跳轉，瀏覽器拿到新的url後又進行了一次請求，獲取到了新的頁面。

6. django temple

模板系統的介紹

你可能已經注意到咱們在例子視圖中返回文本的方式有點特別。也就是說，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>

2.標籤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
c、在使用自定義simple_tag和filter的html文件中導入以前建立的 my_tags.py ：{% load my_tags %}
d、使用simple_tag和filter（如何調用）
e、在settings中的INSTALLED_APPS配置當前app，否則django沒法找到自定義的simple_tag.

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

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

　　注意：
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 視圖建立另外一個模板會發生什麼事情呢？1

<!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 %} 標籤中的內容老是被看成一條退路。

繼承並不會影響到模板的上下文。換句話說，任何處在繼承樹上的模板均可以訪問到你傳到模板中的每個模板變量。

你能夠根據須要使用任意多的繼承次數。使用繼承的一種常見方式是下面的三層法：

建立 base.html 模板，在其中定義站點的主要外觀感覺。這些都是不常修改甚至從不修改的部分。
爲網站的每一個區域建立 base_SECTION.html 模板(例如, base_photos.html 和 base_forum.html )。這些模板對base.html 進行拓展，幷包含區域特定的風格與設計。
爲每種類型的頁面建立獨立的模板，例如論壇頁面或者圖片庫。這些模板拓展相應的區域模板。

這個方法可最大限度地重用代碼，並使得向公共區域（如區域級的導航）添加內容成爲一件輕鬆的工做。

如下是使用模板繼承的一些訣竅：

若是在模板中使用 {% extends %} ，必須保證其爲模板中的第一個模板標記。不然，模板繼承將不起做用。
通常來講，基礎模板中的 {% block %} 標籤越多越好。記住，子模板沒必要定義父模板中全部的代碼塊，所以你能夠用合理的缺省值對一些代碼塊進行填充，而後只對子模板所需的代碼塊進行（重）定義。俗話說，鉤子越多越好。
若是發覺本身在多個模板之間拷貝代碼，你應該考慮將該代碼段放置到父模板的某個 {% block %} 中。
若是你須要訪問父模板中的塊的內容，使用 {{ block.super }}這個標籤吧，這一個魔法變量將會表現出父模板中的內容。若是隻想在上級代碼塊基礎上添加內容，而不是所有重載，該變量就顯得很是有用了。
不容許在同一個模板中定義多個同名的 {% block %} 。存在這樣的限制是由於block 標籤的工做方式是雙向的。也就是說，block 標籤不只挖了一個要填的坑，也定義了在父模板中這個坑所填充的內容。若是模板中出現了兩個相同名稱的 {% block %} 標籤，父模板將無從得知要使用哪一個塊的內容。

相關標籤/搜索

每日一句

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