第十篇：web以前端之django一些feature

時間 2019-11-19

標籤第十 web 前端 django 一些 feature 欄目 HTML 简体版

原文原文鏈接

前端之django一些feature

本節內容

cookie
session
跨站請求保護
分頁
序列化
model模塊
CBV和FBV
模板渲染對象

cookie 是一種發送到客戶瀏覽器的文本串句柄，並保存在客戶機硬盤上，能夠用來在某個WEB站點會話間持久的保持數據。
cookie特性：javascript

一組一組鍵值對保存在用戶瀏覽器
能夠主動清除
也能夠被「僞造」
跨域名cookie不共享
瀏覽器能夠設置不接受cookie

cookie在瀏覽器中將會被放在一個一個源下，能夠把瀏覽器中保存cookie的地方想象成一棵樹，若是沒有設置cookie的Domain和Path,則，該cookie將會被瀏覽器使用在該域名的頂級域名及它的全部子域名下。html

django設置cookie經過接受的req對象來設置：前端

req.set_cookie(key, value='', max_age=None, expires=None, path='/', domain=None, secure=None, httponly=None) expires屬性： 指定了coolie的生存期，默認狀況下coolie是暫時存在的，他們存儲的值只在瀏覽器會話期間存在，當用戶退出瀏覽器後這些值也會丟失。 若是想讓cookie存在一段時間，就要爲expires屬性設置爲將來的一個過時日期。 如今已經被max-age屬性所取代，max-age用秒來設置cookie的生存期。 max_age設置的值是數字，單位是秒，例如：max_age=10表明超時時間爲10秒鐘。 expires對應的值是datetime對象，能夠設置成expires=datetime.datetime.now()+datetime.timedelta(seconds=10)也是將超時時間延長10s path屬性: 它指定與cookie關聯在一塊兒的網頁。 在默認的狀況下cookie會與建立它的網頁，與該網頁處於同一目錄下的網頁以及與這個網頁所在目錄下的子目錄下的網頁關聯。 domain屬性： domain屬性可使多個web服務器共享cookie。domain屬性的默認值是建立cookie的網頁所在服務器的主機名。 不能將一個cookie的域設置成服務器所在的域以外的域。 例如讓位於order.example.com的服務器可以讀取catalog.example.com設置的cookie值。 若是catalog.example.com的頁面建立的cookie把本身的path屬性設置爲「/」，把domain屬性設置成「.example.com」，那麼全部位於catalog.example.com的網頁和全部位於orlders.example.com的網頁，以及位於example.com域的其餘服務器上的網頁均可以訪問這個coolie。 secure屬性： 它是一個布爾值，指定在網絡上如何傳輸cookie，默認是不安全的，經過一個普通的http鏈接傳輸。 httponly屬性： 只容許這個cookie使用在http協議裏面，也就是說不容許客戶端js什麼的修改這個cookie的值，可是這個cookie是可以總體被替換的，因此這個安全性並無什麼卵用。。。。。。

django設置簽名cookie方式：java

rep.set_signed_cookie(key,value,salt='加密鹽',**kwrgs) 參數： key, 鍵 value='', 值 salt 加密鹽

django獲取cookiepython

request.COOKIES['key'] request.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None) 參數： default: 默認值 salt: 加密鹽 //注意這裏的salt要和簽名cookie時候的salt設置同樣才能拿到解密的cookie max_age: 後臺控制過時時間

2. session

session機制：
session機制是一種服務器端的機制，服務器使用一種相似於散列表的結構（也可能就是使用散列表）來保存信息。jquery

當程序須要爲某個客戶端的請求建立一個session時，服務器首先檢查這個客戶端的請求裏是否已包含了一個session標識（稱爲session id），若是已包含則說明之前已經爲此客戶端建立過session，服務器就按照session id把這個session檢索出來使用（檢索不到，會新建一個），若是客戶端請求不包含session id，則爲此客戶端建立一個session而且生成一個與此session相關聯的session id，session id的值應該是一個既不會重複，又不容易被找到規律以仿造的字符串，這個session id將被在本次響應中返回給客戶端保存。保存這個session id的方式能夠採用cookie，這樣在交互過程當中瀏覽器能夠自動的按照規則把這個標識發送給服務器。通常這個cookie的名字都是相似於SEEESIONID。但cookie能夠被人爲的禁止，則必須有其餘機制以便在cookie被禁止時仍然可以把session id傳遞迴服務器。git

生成隨機字符串，並在服務端保存特定信息；web

Django中默認支持Session，其內部提供了5種類型的Session供開發者使用：ajax

使用如下的類型只須要在引擎修改下配置換成相應的類型就能夠了。數據庫

數據庫（默認）
緩存
文件
緩存+數據庫
加密cookie

1. 數據庫

配置 settings.py

    SESSION_ENGINE = 'django.contrib.sessions.backends.db' # 引擎（默認） SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在瀏覽器上時的key，即：sessionid＝隨機字符串（默認） SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路徑（默認） SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名（默認） SESSION_COOKIE_SECURE = False # 是否Https傳輸cookie（默認） SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http傳輸（默認） SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周）（默認） SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否關閉瀏覽器使得Session過時（默認） SESSION_SAVE_EVERY_REQUEST = False # 是否每次請求都保存Session，默認修改以後才保存（默認） 使用 def index(request): # 獲取、設置、刪除Session中數據 request.session['k1'] # 獲取 request.session.get('k1',None) request.session['k1'] = 123 # 設置 request.session.setdefault('k1',123) # 設置，存在則不設置 del request.session['k1'] # 獲取全部 鍵、值、鍵值對 request.session.keys() request.session.values() request.session.items() request.session.iterkeys() request.session.itervalues() request.session.iteritems() # 用戶session的隨機字符串（存在客戶端瀏覽器中，也存在服務端的數據庫中） request.session.session_key # 將全部Session失效日期小於當前日期的數據刪除 request.session.clear_expired() # 檢查 用戶session的隨機字符串 在數據庫中是否 request.session.exists("session_key") # 刪除當前用戶的全部Session數據 request.session.delete("session_key") 示例： def session(request): # request.session request.session['k1'] = 123 # 設置session # request.session['k1'] print(request.session.session_key) # 得到用戶session的隨機字符串（存在客戶端瀏覽器中，也存在服務端的數據庫中） return HttpResponse('session') def index(request): # 得到session return HttpResponse(request.session['k1']) # 這裏能夠直接讀取到session

2. 緩存

配置 settings.py

    SESSION_ENGINE = 'django.contrib.sessions.backends.cache' # 引擎 SESSION_CACHE_ALIAS = 'default' # 使用的緩存別名（默認內存緩存，也能夠是memcache），此處別名依賴緩存的設置 SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在瀏覽器上時的key，即：sessionid＝隨機字符串 SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路徑 SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名 SESSION_COOKIE_SECURE = False # 是否Https傳輸cookie SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http傳輸 SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周） SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否關閉瀏覽器使得Session過時 SESSION_SAVE_EVERY_REQUEST = False # 是否每次請求都保存Session，默認修改以後才保存 使用和數據庫Session使用同樣，只須要修改下配置就能夠。

3. 文件

配置 settings.py

    SESSION_ENGINE = 'django.contrib.sessions.backends.file' # 引擎 SESSION_FILE_PATH = None # 緩存文件路徑，若是爲None，則使用tempfile模塊獲取一個臨時地址tempfile.gettempdir() #如：/var/folders/d3/j9tj0gz93dg06bmwxmhh6_xm0000gn/T SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在瀏覽器上時的key，即：sessionid＝隨機字符串 SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路徑 SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名 SESSION_COOKIE_SECURE = False # 是否Https傳輸cookie SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http傳輸 SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周） SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否關閉瀏覽器使得Session過時 SESSION_SAVE_EVERY_REQUEST = False # 是否每次請求都保存Session，默認修改以後才保存 使用和數據庫Session使用同樣，只須要修改下配置就能夠。

4. 緩存+數據庫

數據庫用於作持久化，緩存用於提升效率
a. 配置 settings.py
    SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db' # 引擎 b. 使用 同上

5. 加密cookie

a. 配置 settings.py
    SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies' # 引擎 b. 使用 同上

登陸認證示例

<form class="common_form" id="Form" method="post" action="/app01/login/">
    <div><h1 class="login_title">登陸</h1></div>
    <div style="width: 600px">
        <div class="form_group"><input name="username" class="form-control" label='用戶名' type="text" placeholder="用戶名" require='true'></div>
    </div>
    <div style="width: 600px">
        <div class="form_group"><input name="password" class="form-control" label='密碼' type="password" placeholder="密碼" require='true'></div>
    </div>
    <div class="form_group"><input class="btn btn-info form_btn" type="submit" value="登陸"></div>
</form>

def login(request): if request.method == "POST": username = request.POST.get("username") password = request.POST.get("password") if username == "zhangsan" and password == "123456": request.session["IS_LOGIN"] = True #建立session return redirect("/app01/home/") return render(request,"app01/login.html") def home(request): islogin = request.session.get("IS_LOGIN",False) if islogin:#若是用戶已登陸 return render(request,"app01/menus.html") else: return redirect("/app01/login/") def logout(request):#退出 try: del request.session['IS_LOGIN'] except KeyError: pass return redirect("/app01/login/")

3. 跨站請求保護

1、簡介

django爲用戶實現防止跨站請求僞造的功能，經過中間件 django.middleware.csrf.CsrfViewMiddleware 來完成。而對於django中設置防跨站請求僞造功能有分爲全局和局部。

全局：
　　中間件 django.middleware.csrf.CsrfViewMiddleware

局部：

@csrf_protect，爲當前函數強制設置防跨站請求僞造功能，即使settings中沒有設置全局中間件。
@csrf_exempt，取消當前函數防跨站請求僞造功能，即使settings中設置了全局中間件。
注：from django.views.decorators.csrf import csrf_exempt,csrf_protect

2、應用

一、普通表單

veiw中設置返回值：
　　return render_to_response('Account/Login.html',data,context_instance=RequestContext(request)) 或者 return render(request, 'xxx.html', data) html中設置Token: 　　{% csrf_token %}

二、Ajax

對於傳統的form，能夠經過表單的方式將token再次發送到服務端，而對於ajax的話，使用以下方式。

view.py

from django.template.context import RequestContext # Create your views here. def test(request): if request.method == 'POST': print request.POST return HttpResponse('ok') return render_to_response('app01/test.html',context_instance=RequestContext(request))

text.html

<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
    {% csrf_token %}
    <input type="button" onclick="Do();"  value="Do it"/>
    <script src="/static/plugin/jquery/jquery-1.8.0.js"></script>
    <script src="/static/plugin/jquery/jquery.cookie.js"></script>
    <script type="text/javascript">
        var csrftoken = $.cookie('csrftoken');

        function csrfSafeMethod(method) {
            // these HTTP methods do not require CSRF protection
            return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
        }
        $.ajaxSetup({  //設置ajax發送以前作的操做，在data裏面加上一個鍵值對
            beforeSend: function(xhr, settings) {
                if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
                    xhr.setRequestHeader("X-CSRFToken", csrftoken);
                }
            }
        });
        function Do(){

            $.ajax({
                url:"/app01/test/",
                data:{id:1},
                type:'POST',
                success:function(data){
                    console.log(data);
                }
            });

        }
    </script>
</body>
</html>

4. 分頁

在django中內置了分頁功能：Paginator
可是其餘web框架中沒有該功能，因此本身實現一個分頁功能之後能夠拿到其餘框架中直接使用。

自定義分頁

分頁功能在每一個網站都是必要的，對於分頁來講，其實就是根據用戶的輸入計算出應該在數據庫表中的起始位置。

設定每頁顯示數據條數
用戶輸入頁碼（第一頁、第二頁…）
根據設定的每頁顯示條數和當前頁碼，計算出須要取數據表的起始位置
在數據表中根據起始位置取值，頁面上輸出數據

需求又來了，須要在頁面上顯示分頁的頁面。如：［上一頁］［1］［2］［3］［4］［5］［下一頁］

設定每頁顯示數據條數
用戶輸入頁碼（第一頁、第二頁…）
設定顯示多少頁號
獲取當前數據總條數
根據設定顯示多少頁號和數據總條數計算出，總頁數
根據設定的每頁顯示條數和當前頁碼，計算出須要取數據表的起始位置
在數據表中根據起始位置取值，頁面上輸出數據
輸出分頁html，如：［上一頁］［1］［2］［3］［4］［5］［下一頁］

分頁示例:

def paging(p,num,count_data): btn_num=11 #定義的按鈕個數 num_list=[5,10,15,20,30,50,100] # 定義每頁顯示的行數 page_num=(count_data//num) if count_data%num==0 else (count_data//num+1) #拿到全部數據分頁的頁數 if p==0: #爲了防止上一頁和下一頁在邊界越界狀況 p+=1 elif p==page_num+1: p-=1 page_list=None if btn_num>=page_num: #當總數小於最小圖標數時 page_list=range(1,page_num+1) else: if p<=btn_num//2: #當選中圖標小於圖標數的一半時 page_list=range(1,btn_num+1) elif page_num-p<=btn_num//2: #當選中圖標以後剩下圖標少於圖標數一半時 page_list=range(page_num-btn_num+1,page_num+1) else: if btn_num%2==0: #若是是偶數 page_list=range(p-btn_num//2+1,p+btn_num//2+1) else: #若是是奇數 page_list=range(p-btn_num//2,p+btn_num//2+1) p_dict={"first":1,"last":page_num,"current":p,"up":p-1,"down":p+1} return page_list,p_dict,num_list def show_teacher(req): if req.method=="GET": p=int(req.GET.get("p",1)) #第n頁 num=int(req.GET.get("num",10)) #每頁展現的數據條數 count_data=models.Teacher.objects.all().count() page_list,p_dict,num_list=utils.paging(p,num,count_data) # page_list頁面顯示的數字按鈕，p_dict字典，存放首頁尾頁，上頁下頁及當前頁的值，num_list返回一個列表，設置每頁顯示多少行數據 data = models.Teacher.objects.all()[(p_dict["current"]-1)*num:p_dict["current"]*num] return render(req, "teacher.html", {"data": data,"page_list":page_list,"p":p_dict,"num_list":num_list,"num":num})

{% if data %}
        <table class=" table table-striped table-bordered table-hover table-condensed">
        <thead>
            <tr class="info">
                <th>ID</th>
                <th>教師姓名</th>
                <th>所教班級</th>
                <th>選項</th>
            </tr>
        </thead>
        <tbody>
            {% for i in data %}
            <tr>
                <td>{{ i.id }}</td>
                <td>{{ i.name }}</td>
                <td>{% for j in i.cls.all %}{{ j.caption }} {% endfor %}</td>
                <td style="width: 200px">
                    <button id="modify" choice_id={{ i.id }} type="button" class="btn btn-primary" data-toggle="modal" data-target="#Mymodal">
                        編輯
                    </button>
                    <button id="del" choice_id={{ i.id }} type="button" class="btn btn-danger" data-toggle="modal" data-target="#Mymodal">
                        {% csrf_token %}
                        刪除
                    </button>
                </td>
            </tr>
            {% endfor %}
        </tbody>
        </table>
        <div>
            <button id={{ p.first }} paging="paging" class="btn btn-primary">首頁</button>
            <button id={{  p.up }} paging="paging" class="btn btn-primary">上一頁</button>
            {% for i in page_list %}
                <button id={{ i }} paging="paging" class="btn {% if i == p.current %}btn-primary{% endif %}">{{ i }}</button>
            {% endfor %}
            <button id={{  p.down }} paging="paging" class="btn btn-primary">下一頁</button>
            <button id={{ p.last }} paging="paging" class="btn btn-primary">尾頁</button>
            <select class="form-control" style="display:inline-block;width: 120px;">
                {% for i in num_list %}
                <option value="{{ i }}" {% if i == num %}selected="selected"{% endif %}>每頁{{ i }}條</option>
                {% endfor %}
            </select>
        </div>
    {% endif %}

//點擊分頁按鈕獲取相關數據併發送ajax向服務器請求數據 function paging_action(ev){ var p=$(ev.target).attr("id"); var num=$($(ev.target).nextAll("select")).val(); var tbl_name=$(".body_left .check").attr("id"); ajax_paging({p:p,num:num},tbl_name) } //用來發送ajax請求獲取分頁數據並放到相應位置 function ajax_paging(data,tbl_name){ if (!(data && tbl_name)){ var p=$("#content button[paging=paging]") } if(tbl_name=="classes"){ $.ajax("/show_classes/",{ type:"GET", data:data, dataType:"html", success:ajax_body }) }else if(tbl_name=="teacher"){ $.ajax("/show_teacher/",{ type:"GET", data:data, dataType:"html", success:ajax_body }) }else if(tbl_name=="student"){ $.ajax("/show_student/",{ type:"GET", data:data, dataType:"html", success:ajax_body }) } } //點擊分頁按鈕獲取相關數據併發送ajax向服務器請求數據 function paging_action(ev){ var p=$(ev.target).attr("id"); var num=$($(ev.target).nextAll("select")).val(); var tbl_name=$(".body_left .check").attr("id"); ajax_paging({p:p,num:num},tbl_name) } //添加按鈕的點擊事件，經過button的id值判斷去執行不一樣的函數 $(".body_right").click(".btn",function (ev){ var btn=$(ev.target); if(btn.attr("paging")=="paging"){paging_action(ev);} });

總結，分頁時須要作三件事：

建立處理分頁數據的函數或類
根據分頁數據獲取數據
輸出分頁HTML，即：［首頁］［上一頁］［1］［2］［3］［4］［5］［下一頁］［尾頁］［每頁顯示條數］

5. 序列化

關於Django中的序列化主要應用在將數據庫中檢索的數據返回給客戶端用戶，特別的Ajax請求通常返回的爲Json格式。

serializers

from django.core import serializers #django內部提供的一個序列化對象的方法 ret = models.BookType.objects.all() #經過all或者filter這種方式拿到的queryset對象能夠經過serializers進行序列化 data = serializers.serialize("json", ret)

json.dumps

import json #ret = models.BookType.objects.all().values('caption') #經過values或者values_list方式拿到的數據，能夠直接被list強轉以後再經過json.dumps進行序列化 ret = models.BookType.objects.all().values_list('caption') ret=list(ret) result = json.dumps(ret)

因爲json.dumps時沒法處理datetime日期，因此能夠經過自定義處理器來作擴展，如：

import json from datetime import date from datetime import datetime class JsonCustomEncoder(json.JSONEncoder): def default(self, field): if isinstance(field, datetime): return field.strftime('%Y-%m-%d %H:%M:%S') elif isinstance(field, date): return field.strftime('%Y-%m-%d') else: return json.JSONEncoder.default(self, field) print(json.dumps(datetime.now(),cls=JsonCustomEncoder))

6. model模塊

6.1 model字段

6.1.1 全部字段

AutoField(Field)
    - int自增列，必須填入參數 primary_key=True BigAutoField(AutoField) - bigint自增列，必須填入參數 primary_key=True 注：當model中若是沒有自增列，則自動會建立一個列名爲id的列 from django.db import models class UserInfo(models.Model): # 自動建立一個列名爲id的且爲自增的整數列 username = models.CharField(max_length=32) class Group(models.Model): # 自定義自增列 nid = models.AutoField(primary_key=True) name = models.CharField(max_length=32) SmallIntegerField(IntegerField): - 小整數 -32768 ～ 32767 PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField) - 正小整數 0 ～ 32767 IntegerField(Field) - 整數列(有符號的) -2147483648 ～ 2147483647 PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField) - 正整數 0 ～ 2147483647 BigIntegerField(IntegerField): - 長整型(有符號的) -9223372036854775808 ～ 9223372036854775807 自定義無符號整數字段 class UnsignedIntegerField(models.IntegerField): def db_type(self, connection): return 'integer UNSIGNED' PS: 返回值爲字段在數據庫中的屬性，Django字段默認的值爲： 'AutoField': 'integer AUTO_INCREMENT', 'BigAutoField': 'bigint AUTO_INCREMENT', 'BinaryField': 'longblob', 'BooleanField': 'bool', 'CharField': 'varchar(%(max_length)s)', 'CommaSeparatedIntegerField': 'varchar(%(max_length)s)', 'DateField': 'date', 'DateTimeField': 'datetime', 'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)', 'DurationField': 'bigint', 'FileField': 'varchar(%(max_length)s)', 'FilePathField': 'varchar(%(max_length)s)', 'FloatField': 'double precision', 'IntegerField': 'integer', 'BigIntegerField': 'bigint', 'IPAddressField': 'char(15)', 'GenericIPAddressField': 'char(39)', 'NullBooleanField': 'bool', 'OneToOneField': 'integer', 'PositiveIntegerField': 'integer UNSIGNED', 'PositiveSmallIntegerField': 'smallint UNSIGNED', 'SlugField': 'varchar(%(max_length)s)', 'SmallIntegerField': 'smallint', 'TextField': 'longtext', 'TimeField': 'time', 'UUIDField': 'char(32)', BooleanField(Field) - 布爾值類型 NullBooleanField(Field): - 能夠爲空的布爾值 CharField(Field) - 字符類型 - 必須提供max_length參數， max_length表示字符長度 TextField(Field) - 文本類型 EmailField(CharField)： - 字符串類型，Django Admin以及ModelForm中提供驗證機制 IPAddressField(Field) - 字符串類型，Django Admin以及ModelForm中提供驗證 IPV4 機制 GenericIPAddressField(Field) - 字符串類型，Django Admin以及ModelForm中提供驗證 Ipv4和Ipv6 - 參數： protocol，用於指定Ipv4或Ipv6， 'both',"ipv4","ipv6" unpack_ipv4， 若是指定爲True，則輸入::ffff:192.0.2.1時候，可解析爲192.0.2.1，開啓刺功能，須要protocol="both" URLField(CharField) - 字符串類型，Django Admin以及ModelForm中提供驗證 URL SlugField(CharField) - 字符串類型，Django Admin以及ModelForm中提供驗證支持 字母、數字、下劃線、鏈接符（減號） CommaSeparatedIntegerField(CharField) - 字符串類型，格式必須爲逗號分割的數字 UUIDField(Field) - 字符串類型，Django Admin以及ModelForm中提供對UUID格式的驗證 FilePathField(Field) - 字符串，Django Admin以及ModelForm中提供讀取文件夾下文件的功能 - 參數： path, 文件夾路徑 match=None, 正則匹配 recursive=False, 遞歸下面的文件夾 allow_files=True, 容許文件 allow_folders=False, 容許文件夾 FileField(Field) - 字符串，路徑保存在數據庫，文件上傳到指定目錄 - 參數： upload_to = "" 上傳文件的保存路徑 storage = None 存儲組件，默認django.core.files.storage.FileSystemStorage ImageField(FileField) - 字符串，路徑保存在數據庫，文件上傳到指定目錄 - 參數： upload_to = "" 上傳文件的保存路徑 storage = None 存儲組件，默認django.core.files.storage.FileSystemStorage width_field=None, 上傳圖片的高度保存的數據庫字段名（字符串） height_field=None 上傳圖片的寬度保存的數據庫字段名（字符串） DateTimeField(DateField) - 日期+時間格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] DateField(DateTimeCheckMixin, Field) - 日期格式 YYYY-MM-DD TimeField(DateTimeCheckMixin, Field) - 時間格式 HH:MM[:ss[.uuuuuu]] DurationField(Field) - 長整數，時間間隔，數據庫中按照bigint存儲，ORM中獲取的值爲datetime.timedelta類型 FloatField(Field) - 浮點型 DecimalField(Field) - 10進制小數 - 參數： max_digits，小數總長度 decimal_places，小數位長度 BinaryField(Field) - 二進制類型

6.1.2 參數

null                數據庫中字段是否能夠爲空
db_column           數據庫中字段的列名
db_tablespace
default             數據庫中字段的默認值
primary_key         數據庫中字段是否爲主鍵
db_index            數據庫中字段是否能夠創建索引
unique              數據庫中字段是否能夠創建惟一索引
unique_for_date     數據庫中字段【日期】部分是否能夠創建惟一索引
unique_for_month    數據庫中字段【月】部分是否能夠創建惟一索引
unique_for_year     數據庫中字段【年】部分是否能夠創建惟一索引

verbose_name        Admin中顯示的字段名稱
blank               Admin中是否容許用戶輸入爲空
editable            Admin中是否能夠編輯
help_text           Admin中該字段的提示信息
choices             Admin中顯示選擇框的內容，用不變更的數據放在內存中從而避免跨表操做
                    如：gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1) error_messages 自定義錯誤信息（字典類型），從而定製想要顯示的錯誤信息； 字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date 如：{'null': "不能爲空.", 'invalid': '格式錯誤'} validators 自定義錯誤驗證（列表類型），從而定製想要的驗證規則 from django.core.validators import RegexValidator from django.core.validators import EmailValidator,URLValidator,DecimalValidator,\ MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator 如： test = models.CharField( max_length=32, error_messages={ 'c1': '優先錯信息1', 'c2': '優先錯信息2', 'c3': '優先錯信息3', }, validators=[ RegexValidator(regex='root_\d+', message='錯誤了', code='c1'), RegexValidator(regex='root_112233\d+', message='又錯誤了', code='c2'), EmailValidator(message='又錯誤了', code='c3'), ] )

6.1.3 元信息

class UserInfo(models.Model): nid = models.AutoField(primary_key=True) username = models.CharField(max_length=32) class Meta: # 數據庫中生成的表名稱 默認 app名稱 + 下劃線 + 類名 db_table = "table_name" # 聯合索引 index_together = [ ("pub_date", "deadline"), ] # 聯合惟一索引 unique_together = (("driver", "restaurant"),) # admin中顯示的表名稱 verbose_name # verbose_name加s verbose_name_plural ''' 更多：https://docs.djangoproject.com/en/1.10/ref/models/options/ 注: 1.觸發Model中的驗證和錯誤提示有兩種方式： a. Django Admin中的錯誤信息會優先根據Admiin內部的ModelForm錯誤信息提示，若是都成功，纔來檢查Model的字段並顯示指定錯誤信息 b. 調用Model對象的 clean_fields 方法，如： # models.py class UserInfo(models.Model): nid = models.AutoField(primary_key=True) username = models.CharField(max_length=32) email = models.EmailField(error_messages={'invalid': '格式錯了.'}) # views.py def index(request): obj = models.UserInfo(username='11234', email='uu') try: print(obj.clean_fields()) except Exception as e: print(e) return HttpResponse('ok') # Model的clean方法是一個鉤子，可用於定製操做，如：上述的異常處理。 2.Admin中修改錯誤提示 ''' # admin.py from django.contrib import admin from model_club import models from django import forms class UserInfoForm(forms.ModelForm): username = forms.CharField(error_messages={'required': '用戶名不能爲空.'}) email = forms.EmailField(error_messages={'invalid': '郵箱格式錯誤.'}) age = forms.IntegerField(initial=1, error_messages={'required': '請輸入數值.', 'invalid': '年齡必須爲數值.'}) class Meta: model = models.UserInfo # fields = ('username',) fields = "__all__" class UserInfoAdmin(admin.ModelAdmin): form = UserInfoForm admin.site.register(models.UserInfo, UserInfoAdmin)

6.1.4 多表關係

ForeignKey(ForeignObject) # ForeignObject(RelatedField) to, # 要進行關聯的表名 to_field=None, # 要關聯的表中的字段名稱 on_delete=None, # 當刪除關聯表中的數據時，當前表與其關聯的行的行爲 - models.CASCADE，刪除關聯數據，與之關聯也刪除 - models.DO_NOTHING，刪除關聯數據，引起錯誤IntegrityError - models.PROTECT，刪除關聯數據，引起錯誤ProtectedError - models.SET_NULL，刪除關聯數據，與之關聯的值設置爲null（前提FK字段須要設置爲可空） - models.SET_DEFAULT，刪除關聯數據，與之關聯的值設置爲默認值（前提FK字段須要設置默認值） - models.SET，刪除關聯數據， a. 與之關聯的值設置爲指定值，設置：models.SET(值) b. 與之關聯的值設置爲可執行對象的返回值，設置：models.SET(可執行對象) def func(): return 10 class MyModel(models.Model): user = models.ForeignKey( to="User", to_field="id" on_delete=models.SET(func),) related_name=None, # 反向操做時，使用的字段名，用於代替 【表名_set】 如： obj.表名_set.all() related_query_name=None, # 反向操做時，使用的鏈接前綴，用於替換【表名】 如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名') limit_choices_to=None, # 在Admin或ModelForm中顯示關聯數據時，提供的條件： # 如： - limit_choices_to={'nid__gt': 5} - limit_choices_to=lambda : {'nid__gt': 5} from django.db.models import Q - limit_choices_to=Q(nid__gt=10) - limit_choices_to=Q(nid=8) | Q(nid__gt=10) - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root') db_constraint=True # 是否在數據庫中建立外鍵約束 parent_link=False # 在Admin中是否顯示關聯數據 OneToOneField(ForeignKey) to, # 要進行關聯的表名 to_field=None # 要關聯的表中的字段名稱 on_delete=None, # 當刪除關聯表中的數據時，當前表與其關聯的行的行爲 ###### 對於一對一 ###### # 1. 一對一其實就是 一對多 + 惟一索引 # 2.當兩個類之間有繼承關係時，默認會建立一個一對一字段 # 以下會在A表中額外增長一個c_ptr_id列且惟一： class C(models.Model): nid = models.AutoField(primary_key=True) part = models.CharField(max_length=12) class A(C): id = models.AutoField(primary_key=True) code = models.CharField(max_length=1) ManyToManyField(RelatedField) to, # 要進行關聯的表名 related_name=None, # 反向操做時，使用的字段名，用於代替 【表名_set】 如： obj.表名_set.all() related_query_name=None, # 反向操做時，使用的鏈接前綴，用於替換【表名】 如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名') limit_choices_to=None, # 在Admin或ModelForm中顯示關聯數據時，提供的條件： # 如： - limit_choices_to={'nid__gt': 5} - limit_choices_to=lambda : {'nid__gt': 5} from django.db.models import Q - limit_choices_to=Q(nid__gt=10) - limit_choices_to=Q(nid=8) | Q(nid__gt=10) - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root') symmetrical=None, # 僅用於多對多自關聯時，symmetrical用於指定內部是否建立反向操做的字段 # 作以下操做時，不一樣的symmetrical會有不一樣的可選字段 models.BB.objects.filter(...) # 可選字段有：code, id, m1 class BB(models.Model): code = models.CharField(max_length=12) m1 = models.ManyToManyField('self',symmetrical=True) # 可選字段有: bb, code, id, m1 class BB(models.Model): code = models.CharField(max_length=12) m1 = models.ManyToManyField('self',symmetrical=False) through=None, # 自定義第三張表時，使用字段用於指定關係表 through_fields=None, # 自定義第三張表時，使用字段用於指定關係表中那些字段作多對多關係表 from django.db import models class Person(models.Model): name = models.CharField(max_length=50) class Group(models.Model): name = models.CharField(max_length=128) members = models.ManyToManyField( Person, through='Membership', through_fields=('group', 'person'), ) class Membership(models.Model): group = models.ForeignKey(Group, on_delete=models.CASCADE) person = models.ForeignKey(Person, on_delete=models.CASCADE) inviter = models.ForeignKey( Person, on_delete=models.CASCADE, related_name="membership_invites", ) invite_reason = models.CharField(max_length=64) db_constraint=True, # 是否在數據庫中建立外鍵約束 db_table=None, # 默認建立第三張表時，數據庫中表的名稱 練習：使用ForeignKey 、ManyToManyField、OneToOneField建立表

6.1.5 操做

基本操做：
    # 增 # # models.Tb1.objects.create(c1='xx', c2='oo') 增長一條數據，能夠接受字典類型數據 **kwargs # obj = models.Tb1(c1='xx', c2='oo') # obj.save() # 查 # # models.Tb1.objects.get(id=123) # 獲取單條數據，不存在則報錯（不建議） # models.Tb1.objects.all() # 獲取所有 # models.Tb1.objects.filter(name='seven') # 獲取指定條件的數據 # models.Tb1.objects.exclude(name='seven') # 獲取指定條件的數據 # 刪 # # models.Tb1.objects.filter(name='seven').delete() # 刪除指定條件的數據 # 改 # models.Tb1.objects.filter(name='seven').update(gender='0') # 將指定條件的數據更新，均支持 **kwargs # obj = models.Tb1.objects.get(id=1) # obj.c1 = '111' # obj.save() # 修改單條數據 進階操做： # 獲取個數 # # models.Tb1.objects.filter(name='seven').count() # 大於，小於 # # models.Tb1.objects.filter(id__gt=1) # 獲取id大於1的值 # models.Tb1.objects.filter(id__gte=1) # 獲取id大於等於1的值 # models.Tb1.objects.filter(id__lt=10) # 獲取id小於10的值 # models.Tb1.objects.filter(id__lte=10) # 獲取id小於10的值 # models.Tb1.objects.filter(id__lt=10, id__gt=1) # 獲取id大於1 且 小於10的值 # in # # models.Tb1.objects.filter(id__in=[11, 22, 33]) # 獲取id等於十一、2二、33的數據 # models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in # isnull # Entry.objects.filter(pub_date__isnull=True) # contains # # models.Tb1.objects.filter(name__contains="ven") # models.Tb1.objects.filter(name__icontains="ven") # icontains大小寫不敏感 # models.Tb1.objects.exclude(name__icontains="ven") # range # # models.Tb1.objects.filter(id__range=[1, 2]) # 範圍bettwen and # 其餘相似 # # startswith，istartswith, endswith, iendswith, # order by # # models.Tb1.objects.filter(name='seven').order_by('id') # asc # models.Tb1.objects.filter(name='seven').order_by('-id') # desc # group by # # from django.db.models import Count, Min, Max, Sum # models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num')) # SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id" # limit 、offset # # models.Tb1.objects.all()[10:20] # regex正則匹配，iregex 不區分大小寫 # # Entry.objects.get(title__regex=r'^(An?|The) +') # Entry.objects.get(title__iregex=r'^(an?|the) +') # date # # Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1)) # Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1)) # year # # Entry.objects.filter(pub_date__year=2005) # Entry.objects.filter(pub_date__year__gte=2005) # month # # Entry.objects.filter(pub_date__month=12) # Entry.objects.filter(pub_date__month__gte=6) # day # # Entry.objects.filter(pub_date__day=3) # Entry.objects.filter(pub_date__day__gte=3) # week_day # # Entry.objects.filter(pub_date__week_day=2) # Entry.objects.filter(pub_date__week_day__gte=2) # hour # # Event.objects.filter(timestamp__hour=23) # Event.objects.filter(time__hour=5) # Event.objects.filter(timestamp__hour__gte=12) # minute # # Event.objects.filter(timestamp__minute=29) # Event.objects.filter(time__minute=46) # Event.objects.filter(timestamp__minute__gte=29) # second # # Event.objects.filter(timestamp__second=31) # Event.objects.filter(time__second=2) # Event.objects.filter(timestamp__second__gte=31) 其餘操做： # extra # # extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None) # Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,)) # Entry.objects.extra(where=['headline=%s'], params=['Lennon']) # Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"]) # Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid']) # F # # from django.db.models import F # models.Tb1.objects.update(num=F('num')+1) # Q # # 方式一： # Q(nid__gt=10) # Q(nid=8) | Q(nid__gt=10) # Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root') # 方式二： # con = Q() # q1 = Q() # q1.connector = 'OR' # q1.children.append(('id', 1)) # q1.children.append(('id', 10)) # q1.children.append(('id', 9)) # q2 = Q() # q2.connector = 'OR' # q2.children.append(('c1', 1)) # q2.children.append(('c1', 10)) # q2.children.append(('c1', 9)) # con.add(q1, 'AND') # con.add(q2, 'AND') # # models.Tb1.objects.filter(con) # 執行原生SQL # # from django.db import connection, connections # cursor = connection.cursor() # cursor = connections['default'].cursor() # cursor.execute("""SELECT * from auth_user where id = %s""", [1]) # row = cursor.fetchone()

6.2 ORM基本操做

##################################################################
# PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET #
##################################################################

def all(self)
    # 獲取全部的數據對象

def filter(self, *args, **kwargs)
    # 條件查詢
    # 條件能夠是：參數，字典，Q

def exclude(self, *args, **kwargs)
    # 條件查詢
    # 條件能夠是：參數，字典，Q

def select_related(self, *fields)
     性能相關：表之間進行join連表操做，一次性獲取關聯的數據。
     model.tb.objects.all().select_related()
     model.tb.objects.all().select_related('外鍵字段')
     model.tb.objects.all().select_related('外鍵字段__外鍵字段')

def prefetch_related(self, *lookups)
    性能相關：多表連表操做時速度會慢，使用其執行屢次SQL查詢在Python代碼中實現連表操做。
            # 獲取全部用戶表
            # 獲取用戶類型表where id in (用戶表中的查到的全部用戶ID)
            models.UserInfo.objects.prefetch_related('外鍵字段')



            from django.db.models import Count, Case, When, IntegerField
            Article.objects.annotate(
                numviews=Count(Case(
                    When(readership__what_time__lt=treshold, then=1),
                    output_field=CharField(),
                ))
            )

            students = Student.objects.all().annotate(num_excused_absences=models.Sum(
                models.Case(
                    models.When(absence__type='Excused', then=1),
                default=0,
                output_field=models.IntegerField()
            )))

def annotate(self, *args, **kwargs)
    # 用於實現聚合group by查詢

    from django.db.models import Count, Avg, Max, Min, Sum

    v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id'))
    # SELECT u_id, COUNT(ui) AS `uid` FROM UserInfo GROUP BY u_id

    v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')).filter(uid__gt=1)
    # SELECT u_id, COUNT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1

    v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id',distinct=True)).filter(uid__gt=1)
    # SELECT u_id, COUNT( DISTINCT ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1

def distinct(self, *field_names)
    # 用於distinct去重
    models.UserInfo.objects.values('nid').distinct()
    # select distinct nid from userinfo

    注：只有在PostgreSQL中才能使用distinct進行去重

def order_by(self, *field_names)
    # 用於排序
    models.UserInfo.objects.all().order_by('-id','age')

def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
    # 構造額外的查詢條件或者映射，如：子查詢

    Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
    Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
    Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
    Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])

 def reverse(self):
    # 倒序
    models.UserInfo.objects.all().order_by('-nid').reverse()
    # 注：若是存在order_by，reverse則是倒序，若是多個排序則一一倒序


 def defer(self, *fields):
    models.UserInfo.objects.defer('username','id')
    或
    models.UserInfo.objects.filter(...).defer('username','id')
    #映射中排除某列數據

 def only(self, *fields):
    #僅取某個表中的數據
     models.UserInfo.objects.only('username','id')
     或
     models.UserInfo.objects.filter(...).only('username','id')

 def using(self, alias):
     指定使用的數據庫，參數爲別名（setting中的設置）


##################################################
# PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS #
##################################################

def raw(self, raw_query, params=None, translations=None, using=None):
    # 執行原生SQL
    models.UserInfo.objects.raw('select * from userinfo')

    # 若是SQL是其餘表時，必須將名字設置爲當前UserInfo對象的主鍵列名
    models.UserInfo.objects.raw('select id as nid from 其餘表')

    # 爲原生SQL設置參數
    models.UserInfo.objects.raw('select id as nid from userinfo where nid>%s', params=[12,])

    # 將獲取的到列名轉換爲指定列名
    name_map = {'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'}
    Person.objects.raw('SELECT * FROM some_other_table', translations=name_map)

    # 指定數據庫
    models.UserInfo.objects.raw('select * from userinfo', using="default")

    ################### 原生SQL ###################
    from django.db import connection, connections
    cursor = connection.cursor()  # cursor = connections['default'].cursor()
    cursor.execute("""SELECT * from auth_user where id = %s""", [1])
    row = cursor.fetchone() # fetchall()/fetchmany(..)


def values(self, *fields):
    # 獲取每行數據爲字典格式

def values_list(self, *fields, **kwargs):
    # 獲取每行數據爲元祖

def dates(self, field_name, kind, order='ASC'):
    # 根據時間進行某一部分進行去重查找並截取指定內容
    # kind只能是："year"（年）, "month"（年-月）, "day"（年-月-日）
    # order只能是："ASC"  "DESC"
    # 並獲取轉換後的時間
        - year : 年-01-01
        - month: 年-月-01
        - day  : 年-月-日

    models.DatePlus.objects.dates('ctime','day','DESC')

def datetimes(self, field_name, kind, order='ASC', tzinfo=None):
    # 根據時間進行某一部分進行去重查找並截取指定內容，將時間轉換爲指定時區時間
    # kind只能是 "year", "month", "day", "hour", "minute", "second"
    # order只能是："ASC"  "DESC"
    # tzinfo時區對象
    models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.UTC)
    models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai'))

    """
    pip3 install pytz
    import pytz
    pytz.all_timezones
    pytz.timezone(‘Asia/Shanghai’)
    """

def none(self):
    # 空QuerySet對象


####################################
# METHODS THAT DO DATABASE QUERIES #
####################################

def aggregate(self, *args, **kwargs):
   # 聚合函數，獲取字典類型聚合結果
   from django.db.models import Count, Avg, Max, Min, Sum
   result = models.UserInfo.objects.aggregate(k=Count('u_id', distinct=True), n=Count('nid'))
   ===> {'k': 3, 'n': 4}

def count(self):
   # 獲取個數

def get(self, *args, **kwargs):
   # 獲取單個對象

def create(self, **kwargs):
   # 建立對象

def bulk_create(self, objs, batch_size=None):
    # 批量插入
    # batch_size表示一次插入的個數
    objs = [
        models.DDD(name='r11'),
        models.DDD(name='r22')
    ]
    models.DDD.objects.bulk_create(objs, 10)

def get_or_create(self, defaults=None, **kwargs):
    # 若是存在，則獲取，不然，建立
    # defaults 指定建立時，其餘字段的值
    obj, created = models.UserInfo.objects.get_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 2})

def update_or_create(self, defaults=None, **kwargs):
    # 若是存在，則更新，不然，建立
    # defaults 指定建立時或更新時的其餘字段
    obj, created = models.UserInfo.objects.update_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 1})

def first(self):
   # 獲取第一個

def last(self):
   # 獲取最後一個

def in_bulk(self, id_list=None):
   # 根據主鍵ID進行查找
   id_list = [11,21,31]
   models.DDD.objects.in_bulk(id_list)

def delete(self):
   # 刪除

def update(self, **kwargs):
    # 更新

def exists(self):
   # 是否有結果

7. CBV和FBV

django裏面的views裏面支持兩種處理請求的方式：

CBV—->views裏面處理請求使用類
FBV—->views裏面處理請求使用函數

使用視圖函數處理請求的方式就不贅述了，以前一直是這種方式。
下面介紹使用類處理請求的方式。

首先在urls裏面定義方式須要改變：

urlpatterns = [
    url(r'^admin/', admin.site.urls), url(r'^login/', views.Login.as_view()), ]

要將以前的函數名稱改爲類名.as_view()方式，以後在views裏面導入views模塊：

from django import views from django.utils.decorators import method_decorator #用來在類裏面的函數視圖函數中加上裝飾器時使用

以後定義類繼承自views.View:

def outer(func): def wrapper(req,*args,**kwargs): print("xxxxxxx") return func(req,*args,*kwargs) return wrapper class Login(views.View): def dispatch(self, request, *args, **kwargs): if request.method=="GET": # return HttpResponse("xxx") pass ret=super(Login, self).dispatch(request, *args, **kwargs) print(111) return ret @method_decorator(outer) def get(self,req,*args,**kwargs): return render(req,"login.html") @method_decorator(outer) def post(self,req,*args,**kwargs): return render(req,"login.html",{"msg":"hello post"})

至於Login繼承自views.View，而其父類中有一個方法dispatch，這個方法用來分發請求到不一樣的處理視圖函數中，繼承下這個類的子類中重寫這個方法能夠在視圖函數處理請求以前和處理請求以後作一些操做。（甚至能夠把裝飾器裝飾在這上面）

導入的method_decorator方法用來在類中的視圖函數前面加上裝飾器，把裝飾器當作參數傳遞給method_decorator函數中。

8. 模板渲染對象

在django的模板語言中，可使用.來獲取對象的屬性和方法，那麼，當這個對象有同名的屬性和方法時，模板語言調用對象的屬性，而當對象中沒有這個屬性時，則調用該對象的方法。

class testobj: def __init__(self,name): self.name=name def name(self): return "xiaoming2" def test(req): obj=testobj("xiaoming") return render(req,"test.html",{"obj":obj})

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>test template</h1>
    <h1>{{ obj.name }}</h1>
</body>
</html>

頁面拿到的值是xiaoming，而當把self.name改爲self.aname時則頁面拿到的是xiaoming2