Django基礎（一）

時間 2019-11-30

標籤 django 基礎欄目 Python 简体版

原文原文鏈接

知識預覽php

ORM性能相關
        user_list = models.UserInfo.objects.all()
            for row in user_list:
                # 只去取當前表數據 若是增長了外鍵，沒查一次外鍵，就會查詢一次數據庫
    
        select_related,主動連表查詢【FK】
            
            user_list = models.UserInfo.objects.all().select_related('FK字段')
            for row in user_list:
                # 只去取當前表數據和FK表關聯字段 查詢其餘字段，查詢一次訪問一次數據庫
        
        
            user_list = models.UserInfo.objects.values(...)
            for row in user_list:
                # 只去取當前表數據和FK表關聯字段
        
            ==》 連表下降性能
    
        prefetch_related
            user_list = models.UserInfo.objects.all().prefetch_related('FK字段')
    
            # [obj,obj,obj]
            # 查詢用戶表models.UserInfo.objects.all() 1000
            # 把用戶表中全部的ut_id拿到, 用戶類型ID [1,2,3]
            # 把用戶表中全部的ut_id拿到, 用戶類型ID [21,21,31]
            # select * from UsetType where id in [1,2,3]
            # select * from xx where id in [21,21,31]
            user_list = models.UserInfo.objects.all().prefetch_related('ut','xx')
            for row in user_list:
                print(row.name, row.pwd, row.ut.caption)
        補充：
            # [obj,obj,obj]
            # user_list = models.UserInfo.objects.all().only('name')   # 只取某個字段 select name from userinfo 
            # user_list = models.UserInfo.objects.all().defer('name')  # 排除當前字段    
            # for row in user_list:
            #     print(row.pwd)

Django： 大而全

Flask ： 小而精

Django基本命令html

1  django-admin  startproject project_name     建立項目
2  python manage.py startapp  appName          建立應用
3  python manage.py runserver IP PORT          啓動項目

4 python manage.py makemigrations 建立數據庫 5 python manage.py migrate 建立數據庫前端

6 python manage.py flush 清空數據庫python



MTV  C

M：model
T：template
V: views
C: Controller(路由分配系統)


一 路由分配系統

    功能：客戶端訪問的url的路徑（path）與視圖函數一一映射關係
    語法格式：
  
    urlpatterns = [
          url(正則表達式, views視圖函數，參數，別名),
    ]
            
    key:    經過路徑分組傳參數給視圖函數
    
    無名分組：url(r'^(\d{4})/$', year_query),           #    year_query(request,2007)
            
    有名分組：url(r'^(?P<year>\d{4})/(?P<month>\d{2})$', year_query),          #    year_query(request,year=2010,month=12)

    name參數：    url(r'^regq/', reg,name="register"),  #<form action="{% url 'INDEX' %}" method="post"> 等同於 <form action="/index/" method="post"> 

　　 路由分流：
    urlpatterns = [

       url(r'^admin/', admin.site.urls),

　　　　url(r'^blog/', include('[App名].urls')),

　　　　url(r'^blog/', include('blog.urls')),
    ]

二 視圖函數（views）

    請求對象： request
    響應對象： httpresponse("")
    
    request.method   : 請求方式
    request.GET    : 存放 get請求數據
    request.POST   : 存放 post數據
    #用原數據 queryset 後面處理多選列表的時候 get 只能取到列表最後一個值,getlist 獲得全部值

    
    Httpresponse("[HTML 字符串]")             ------>實例字符創對象
    render(request,"[HTML 文件]",local())     ------>模板的渲染
    redirect("[HTML 連接 （/book/index/）]")   ------>跳轉（最前面沒有 / 好像默認從當前 app 補充前段的連接，如 index/ 至關於 /book/index/）


三 模板語言

    模板語言： 渲染變量 {{}}         渲染標籤 {% %}
    
    目的： 將變量嵌入到html中
    
           注意：
               1 只要帶有模板語法的html都成爲模板    

               2 render方法渲染時 把後端變量嵌入到模板中               
    
    
             關於redirect與render的區別：
                redirect走的是路徑
                render返回的是模板

    萬能的句點號（.）：

　　　　　　　　列表索引 、
　　　　　　　　字典key|value 或者 某一key 、
　　　　　　　　對象屬性 、
　　　　　　　　對象的方法（如 .upper .isdigit 只能調用不傳參的方法）

　　 顯示處理（filter）    {{ obj | filter:param }}

　　 {% if %} {% for %} forloop ……

　　 自定義 filter  simple_tag

　　　　　　　　{{ num|filter:[參]}} mysql

　　　　　　　能夠用在 for 、 if 中可是隻能有一個參數，可是這個參數能夠經過列表、元組等方式存放多個參數的。jquery

　　　　　　　　{% simple_tag [參] [參] [參] %} 參數不限,但不能放在if for語句中linux

　　　　 extend模板繼承git

　　　　　　　　模板：{% load staticfiles %} {% block [block 名字] %}{% endblock %}程序員

　　　　　　　　繼承：{% extends "[模板 HTML 文件]" %} {% block [block 名字] %}{% endblock %}web

四 ORM

四 ORM

0 配置數據庫（MySQL）：settings 、 __init__ 、 migrate

1 添加方法

   表.objects.create()
   
   obj=類(title="")
   obj.save()
   
   
   外鍵字段添加方式（一對多）
   
   Book.objects.create(title="",price="",publish_id=)  # publish_id對應的Publish表中的主鍵id
   Book.objects.create(title="",price="",publish=pub_obj)  # publish_id對應的Publish表中的主鍵id
   
   book_obj.publish  :  與這本書相關聯的出版社對象（一個）
   
   
   外鍵字段添加方式（多對多）
   
       authors=models.ManyToManyFields("Author")
       book_obj.authors : 與這本書相關的全部的做者集合（querySet）
       
       book_obj.authors.add(obj1,obj2)
       book_obj.authors.add(*[])
       
       book_obj.authors.remove(obj)
       book_obj.authors.clear()
   
   
2 查詢方法


      表.objects.all()                     -----------QuerySet    [obj,obj] 
      表.objects.filter(id__gt=3,id__lt=6) -----------QuerySet    [obj,obj] 
      表.objects.get()                     -----------model對象
      
      QuerSet.first()    -----------model對象
      QuerSet.last()     -----------model對象  eg: 表.objects.all().first()
      
      
      表.objects.values(字段)   --------- 存放字典的集合對象，也能夠當作sql語句中的 group by 分組使用
      
      <QuerySet [{'price': Decimal('45.00'), 'title': 'linux'}, {'price': Decimal('100.00'), 'title': '老男孩歷險記'}, {'price': Decimal('12.00'), 'title': '老男孩感情史'}]>
          


 QuerySet的高效使用:

              1 可切片
              2 可迭代
              3 惰性機制 

                  iterator   ----------閱後即焚
                  exits      ----------是否存在   

          
          
  連表查詢 （了不得的下劃線）
                class Book_authors():
                      book_id=...
                      author_id=....
                
                class Author():
                      name=.....
                      
                      #books=models.ManyToManyFields("Book")
                 
                class Publish():
                      name=....                
        
                class BOOK():
                
                     title=...
                     publish=...
                     
                     authors=.....
        
        
               1  基於對象
                   
                  正向查詢：（多對多的時候，ManyToManyField 在哪一個表那個表是正向查詢）
                  
                     # 查詢某本書的出版社或者做者信息
                     
                     book_obj=BOOK.objects.get(id=4)
                     book_obj.publish  # 與這本書相關聯的出版社                     
                     book_obj.authors  #  與這本書關聯的做者對象集合
                   
                  反向查詢： 
                      # 查詢某個出版社出版過的書                  
                      # 查詢某個做者出版社過的書    
 
                      author_obj=Author.objects.get(id=2)
                      author_obj.關聯表名__set  
                      author_obj.book__set      # 與這個做者關聯的全部書籍對象的集合

               2  基於 filter values __
                              
                     表.objects.filter().values()
                     # 查詢python這本書的出版社名字
                     BOOK.objects.filter(title="python").values(publish__name)
                     Publish.objects.filter(book__title="python").values("name")
                   
               
 聚合與分組

                在sql：                  
                select max()    group by 字段 having             
                select Avg(score) from stu 
                
                
                aggreagte:
                       Book.objects.all().aggregate(AvgPrice=Avg("price"))
                annotate:
                
                       # 每個做者出版過的書中的最高價 ： 按做者名字分組
                        ret4=Book.objects.values("authors__name").annotate(Max("price"))
                        print(ret4)
                
                
        F Q 
            F:
               Book.objects.all().update(price=F("price")+20)            
                
            Q:
               Book.objects.filter(Q(price__gt=200) | Q(id__gt=5) ,title__startswith="老")

                    
3 修改方法

  Book.objects.filter(id=5).update(price=1000)
  
4 刪除 
  Book.objects.filter(id=5).delete() #  級聯刪除  
  
  
  
  
Ajax(******):



   json對象  就是js對象子集 （number string（「」） bool array  null  {「」：「」}）
   
   json字符串

from django.shortcuts import render,HttpResponse


from app01.models import *
# Create your views here.


def add(request):

    # 添加記錄兩種方式：
    # create 方式

    # Publish.objects.create(
    #     name="老衲出版社",
    #     addr="沙河"
    #
    # )
    #
    # # save方式
    #
    # p=Publish(name="瞎驢出版社",addr="昌平區")
    # p.save()

 #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


    # 一對多 添加一個book記錄 方法1 ：

    # Book.objects.create(
    #     title="python",
    #     price=100.00,
    #     publish_id=2
    # )



    # book_obj=Book.objects.get(id=1)
    # print(book_obj.title)
    # print(book_obj.price)
    # print(book_obj.publish)


    # 一對多 create 方法 添加一個book記錄 方法2：
    #publish_obj=Publish.objects.get(id=1)    #  一個北京出版社對象

    # 建立一個Book對象
    #
    # Book.objects.create(
    #     title="Linux",
    #     price=29.00,
    #     publish=publish_obj
    # )

    # 一對多 save 方法

    # b=Book(title="",price="",publish=pub_obj)
    # b.save()
    #
    # b = Book(title="", price="", publish_id=1)
    # b.save()

#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

# 添加多對多關係

# +++++++++++++++++++經過對象綁定關係

    #book_obj=Book.objects.get(id=3)

    #print("authors:  ",book_obj.authors.all()) # id=3的這本書全部關聯的做者對象集合 [author1,author2,]

    # author_obj1=Author.objects.get(id=1)
    # author_obj2=Author.objects.get(id=2)

    #author_list=Author.objects.all()

    # 綁定關係
    # 正向綁定

    # book_obj.authors.add(author_obj1,author_obj2)
    #book_obj.authors.add(*author_list)

    author_obj=Author.objects.get(name="Yuan")

    author_obj.book_set.add(*Book.objects.all())



    # 解除綁定

    #book_obj.authors.clear()

    #author=Author.objects.get(name='alex')

    #book_obj.authors.remove(author)
    #book_obj.delete()



    # 向手動建立的第三張表中添加記錄

    # b2a=Book2Author(book_id=4,author_id=3)
    # b2a.save()


    return HttpResponse("OK")



def query(request):

    # 雙下劃線 __

    # publish_list=Publish.objects.filter(id__gt=1)
    #
    # print(publish_list)


    book_list=Book.objects.filter(title__contains="老男孩")
    print(book_list)


    return HttpResponse("OK")

def query2(request):

    #++++++++++++++++++++++++++++ values 顯示方法
    #ret=Book.objects.all().values("price","title")
    #print(ret)
# <QuerySet [{'title': 'linux'"}, {'title': '老男孩歷險記'}, {'title': '老男孩感情史'}]>

    # 全部id大於1 的書籍的title
    # ret=Book.objects.filter(id__gt=1).values("title")
    # ret=Book.objects.filter(id__gt=1).values_list("title")
    # print(ret)# <QuerySet [('linux',), ('老男孩歷險記',), ('老男孩感情史',)]>


 #+++++++++++++++++++++++++++++++++++

    #  按條件排除

    # ret=Book.objects.exclude(id__gt=4)
    # ret=Book.objects.exclude(title__contains="li")
    # print(ret)  # <QuerySet [<Book: linux>]>


    # 反轉 reverse order by

    ret=Book.objects.filter(id__gt=2).order_by("price").reverse()
    print(ret)


    return HttpResponse("OK")



def queryset(request):

    #  Queryset集合支持切片操做
    #ret=Book.objects.all()[2]
    #ret=Book.objects.all()[0:2]
    #ret=Book.objects.all()[::2]
    #print(ret)


    #book_list=Book.objects.all().iterator()
    book_list=Book.objects.all()

    if book_list.exists():
        print("PK")


    # if book_list:
    #     print("Ok")

    # for obj  in book_list:
    #     print(obj.title,obj.price)
    #
    # #Book.objects.filter(title="linux").update(price=145)
    #
    # for obj  in book_list:
    #     print(obj.title,obj.price)

    return HttpResponse("OK")

def  relationQuery(request):

    ######################################藉助對象以及屬性publish，authors

    # # 查詢linux這本書的出版社的地址
    #
    # book_obj=Book.objects.filter(title="linux").first()
    #
    # print(book_obj.publish.addr) # 北京
    # # sql: 子查詢：select  * from publish where id=（select publish_id from Book where title='linux'）
    # #join: select publish.addr from book left join publish on book.publish_id=publish.id where title="linux"
    #
    # # 查詢 老男孩感情史這本書的全部做者
    #
    # book_obj=Book.objects.filter(title="老男孩感情史").first()
    # authors_list=book_obj.authors.all()
    # for obj in authors_list:
    #     print(obj.name)
    #
    #
    #
    # # 反向 ： 查詢人民出版社出版過哪些書
    #
    # # 方式1
    # pub=Publish.objects.get(name="人民出版社")
    # book_list=pub.book_set.all()
    # print(book_list)
    #
    # # <QuerySet [<Book: linux>, <Book: 水滸傳>]>
    #
    # # 方式2
    # pid=Publish.objects.get(name="人民出版社").id
    #
    # book_list=Book.objects.filter(publish_id=pid)
    #
    # print(book_list)  # <QuerySet [<Book: linux>, <Book: 水滸傳>]>




    ##########################value filter : 雙下劃線__#############

    # ret=Book.objects.filter(title="linux").values("price")
    # print(ret) #<QuerySet [{'price': Decimal('145.00')}]>
    #
    # # 查詢linux這本書的出版社的地址
    #
    # ret=Book.objects.filter(title="linux").values("publish__name")
    # print(ret)
    #
    #
    # ret=Publish.objects.filter(book__title="linux").values("name")
    # print(ret)
    #
    # #查詢 老男孩感情史這本書的全部做者
    # # ret=Book.objects.filter(title="老男孩感情史").values("authors__name")
    # # print(ret)

    # 查詢價格大於100的書籍的做者姓名

    # ret=Book.objects.filter(price__gt=100).values("authors__name")
    # print(ret)

    # ret=Author.objects.filter(book__price__gt=100).values("name")
    # print(ret)
    #<QuerySet [{'name': 'oldmen'}, {'name': 'Yuan'}]>



    return HttpResponse("OK")


def aggreAnno(request):

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

    # 求全部書籍的平均價格

    ret=Book.objects.all().aggregate(AvgPrice=Avg("price"))

    print(ret) # {'AvgPrice': 73.8}

    #求全部書籍的最高價格

    ret2 = Book.objects.all().aggregate(MaxPrice=Max("price"))
    print(ret2) # {'MaxPrice': Decimal('145.00')}

    # 老男孩出版過的過的書中的最高價

    ret3=Book.objects.filter(authors__name="oldmen").aggregate(Max("price"))
    print(ret3)

    # 每個做者出版過的書中的最高價 ： 按做者名字分組

    ret4=Book.objects.values("authors__name").annotate(Max("price"))
    print(ret4)

    #<QuerySet [{'authors__name': 'egon', 'price__max': Decimal('45.00')}, {'authors__name': 'alex', 'price__max': Decimal('12.00')}, {'authors__name': 'wupeiqi', 'price__max': Decimal('67.00')}, {'authors__name': 'oldmen', 'price__max': Decimal('145.00')}, {'authors__name': 'Yuan', 'price__max': Decimal('145.00')}]>

    #  每個出版社出版過的書中最低價格

    Book.objects.values("publish__name").annotate(Min("price"))

    return HttpResponse("OK")


def FAndQ(request):
    from django.db.models import F,Q

    #Book.objects.all().update(price=F("price")+20)

    # 查詢

    # ret=Book.objects.filter(title__startswith="老",price__gt=100)
    # print(ret) # <QuerySet [<Book: 老男孩歷險記>]>


    # Q查詢支持的邏輯運算符：  & | ~

    # ret2 = Book.objects.filter(Q(title__startswith="老") | Q(price__gt=200),)
    # print(ret2)  #<QuerySet [<Book: linux>, <Book: 老男孩歷險記>, <Book: 老男孩感情史>]>

    ret3 = Book.objects.filter(Q(price__gt=200) | Q(id__gt=5) ,title__startswith="老")
    print(ret3) #<QuerySet [<Book: 老男孩歷險記>, <Book: 老男孩感情史>]>


    return HttpResponse("OK")



def edit(req):

    #修改方式1 （推薦）
    #Book.objects.filter(id=5).update(price=1000)  #  update是QuertySet集合對象的方法

    #修改方式2  (效率低)   對象信息更改後，能夠用save（）來保存更改，可是會更新全部信息，效率低於update

    book=Book.objects.get(id=5)

    # book.price=400
    # book.save()

    return HttpResponse("OK")

講課記錄，一點補充

一什麼是web框架？

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

#對於全部的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, yuan</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。

View Code

-----------------------------Do a web framework ourselves---------------------------

#--templates-------

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

<form action="/auth">
<!--<form>-->
    <p>用戶名<input type="text" name="user"></p>
    <p>密碼<input type="password" name="pwd"></p>
    <p><input type="submit" value="提交"></p>
</form>

</body>
</html>

#--templates-------


from wsgiref.simple_server import make_server

#--view-----
def login(requests):
    with open("login.html",'rb')as f :
        data=f.read()
    return [data]

def auth(request):
    user,pwd=request.get("QUERY_STRING").split("&")
    user=user.split('=')[1]
    pwd=pwd.split('=')[1]
    if user=='jzh'and pwd=='123':            #----model---數據庫提取數據
        return [b'login success']
    else:
        return [b'login failed']
#--view----

#----控制器control------
def pages(page):
    d={
        "/login":login,
        "/auth":auth,
    }
    if d.get(page):
        return d[page]
    else:
        return False
#----控制器control------

#----監聽請求-----
def application(environ,start_response):
    path=environ.get("PATH_INFO")
    start_response('200 OK',[('Content-Type','text/html')])
    print(path)
    func=False
    func=pages(path)
    if func:
        return func(environ)
    else:
        return [b'<h1>404</h1>']

httpd=make_server('',8800,application)

print('Serving HTTP on port 8000...')
# 開始監聽HTTP請求:
httpd.serve_forever()

View Code

夥計們，不知不覺咱們本身已經寫出一個web框架啦！

二 MVC和MTV模式

Django的MTV模式本質是各組件之間爲了保持鬆耦合關係,Django的MTV分別表明：

       Model(模型)：負責業務對象與數據庫的對象(ORM)

       Template(模版)：負責如何把頁面展現給用戶

       View(視圖)：負責業務邏輯，並在適當的時候調用Model和Template

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

View Code

回到頂部

Django基本命令

一、建立一個django project

cmd：
python3 django-admin.py startproject mysite
or
django-admin.exe startproject mysite

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

manage.py ----- Django項目裏面的工具，經過它能夠調用django shell和數據庫等。
settings.py ---- 包含了項目的默認設置，包括數據庫信息，調試標誌以及其餘一些工做的變量。（例如，某些post模式的訪問會觸發Django的防攻擊程序，測試的時候若是不想讓其啓動，能夠註釋掉這個文件中的——「 'django.middleware.csrf.CsrfViewMiddleware',」）
urls.py ----- 負責把URL模式映射到應用程序。

二、在mysite目錄下建立應用，好比blog:

```
python manage.py startapp blog
```

三、啓動django項目

```
python manage.py runserver 8080
```

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

四、同步更改數據庫表或字段

'''
    python manage.py syncdb
     
    注意：Django 1.7.1 及以上的版本須要用如下命令
    python manage.py makemigrations      建立數據庫
    python manage.py migrate             建立數據庫
    
'''

View Code

這種方法能夠建立表，當你在models.py中新增了類時，運行它就能夠自動在數據庫中建立表了，不用手動建立。

五、清空數據庫

```
python manage.py flush
```

此命令會詢問是 yes 仍是 no, 選擇 yes 會把數據所有清空掉，只留下空表。

六、建立超級管理員

'''
    python manage.py createsuperuser
     
    # 按照提示輸入用戶名和對應的密碼就行了郵箱能夠留空，用戶名和密碼必填
     
    # 修改 用戶密碼能夠用：
    python manage.py changepassword username
    
'''

createsuperuser

七、Django 項目環境終端

```
python manage.py shell
```

這個命令和直接運行 python 進入 shell 的區別是：你能夠在這個 shell 裏面調用當前項目的 models.py 中的 API，對於操做數據的測試很是方便。

八、Django 項目環境終端

```
ython manage.py dbshell
```

Django 會自動進入在settings.py中設置的數據庫，若是是 MySQL 或 postgreSQL,會要求輸入數據庫用戶密碼。

在這個終端能夠執行數據庫的SQL語句。若是您對SQL比較熟悉，可能喜歡這種方式。

九、更多命令

```
python manage.py
```

查看全部的命令，忘記子名稱的時候特別有用。

10 、靜態文件static配置

#三、STATIC文件還能夠配置STATICFILES_DIRS，指定額外的靜態文件存儲位置。
    #  STATIC_URL的含義與MEDIA_URL相似。

    # ----------------------------------------------------------------------------
    #注意1:
        #爲了後端的更改不會影響前端的引入，避免形成前端大量修改

        STATIC_URL = '/static/'               #引用名
        STATICFILES_DIRS = (
            os.path.join(BASE_DIR,"statics")  #實際名 ,即實際文件夾的名字
        )

        #django對引用名和實際名進行映射,引用時,只能按照引用名來,不能按實際名去找
        #<script src="/statics/jquery-3.1.1.js"></script>
        #------error－－－－－不能直接用，必須用STATIC_URL = '/static/':
        #<script src="/static/jquery-3.1.1.js"></script>

    #注意2(statics文件夾寫在不一樣的app下,靜態文件的調用)（這裏STATIC_DIR 能夠用 STATIC_ROOT 可是DIR 可以調用到任何層級的靜態文件，可是ROOT只能調用到當前 APP 的靜態文件）:

        STATIC_URL = '/static/'

        STATICFILES_DIRS=(
            ('hello',os.path.join(BASE_DIR,"app01","statics")) ,
        )

        #<script src="/static/hello/jquery-1.8.2.min.js"></script>

    #注意3:
        STATIC_URL = '/static/'
        {% load staticfiles %}
       # <script src={% static "jquery-1.8.2.min.js" %}></script>

View Code

回到頂部

二路由配置系統（URLconf）

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

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

    參數說明：

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

2.1 URLconf的正則字符串參數

2.1.1 簡單配置

from django.conf.urls import url

from . 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})/([0-9]{2})/$', views.month_archive),
    url(r'^articles/([0-9]{4})/([0-9]{2})/([0-9]+)/$', views.article_detail),
]

    '''
    NOTE:
    1 一旦匹配成功則再也不繼續
    2 若要從URL 中捕獲一個值，只須要在它周圍放置一對圓括號。
    3 不須要添加一個前導的反斜槓，由於每一個URL 都有。例如，應該是^articles 而不是 ^/articles。
    4 每一個正則表達式前面的'r' 是可選的可是建議加上。

一些請求的例子：

    /articles/2005/3/ 不匹配任何URL 模式，由於列表中的第三個模式要求月份應該是兩個數字。
    /articles/2003/ 將匹配列表中的第一個模式不是第二個，由於模式按順序匹配，第一個會首先測試是否匹配。
    /articles/2005/03/ 請求將匹配列表中的第三個模式。Django 將調用函數
                       views.month_archive(request, '2005', '03')。
    '''


#設置項是否開啓URL訪問地址後面不爲/跳轉至帶有/的路徑
APPEND_SLASH=True

View Code

2.1.2 有名分組(named group)

上面的示例使用簡單的、沒有命名的正則表達式組（經過圓括號）來捕獲URL 中的值並以位置參數傳遞給視圖。在更高級的用法中，可使用命名的正則表達式組來捕獲URL 中的值並以關鍵字參數傳遞給視圖。

在Python 正則表達式中，命名正則表達式組的語法是(?P<name>pattern)，其中name 是組的名稱，pattern 是要匹配的模式。

下面是以上URLconf 使用命名組的重寫：

from django.conf.urls import url

from . import views

urlpatterns = [
    url(r'^articles/2003/$', views.special_case_2003),
    url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),
    url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$', views.month_archive),
    url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/(?P<day>[0-9]{2})/$', views.article_detail),
]

這個實現與前面的示例徹底相同，只有一個細微的差異：捕獲的值做爲關鍵字參數而不是位置參數傳遞給視圖函數。例如：

    /articles/2005/03/    
    請求將調用views.month_archive(request, year='2005', month='03')函數
    /articles/2003/03/03/ 
    請求將調用函數views.article_detail(request, year='2003', month='03', day='03')。

View Code

在實際應用中，這意味你的URLconf 會更加明晰且不容易產生參數順序問題的錯誤 —— 你能夠在你的視圖函數定義中從新安排參數的順序。固然，這些好處是以簡潔爲代價；有些開發人員認爲命名組語法醜陋而繁瑣。

2.1.3 URLconf 在什麼上查找

URLconf 在請求的URL 上查找，將它當作一個普通的Python 字符串。不包括GET和POST參數以及域名。

例如，http://www.example.com/myapp/ 請求中，URLconf 將查找myapp/。

在http://www.example.com/myapp/?page=3 請求中，URLconf 仍將查找myapp/。

URLconf 不檢查請求的方法。換句話講，全部的請求方法 —— 同一個URL的POST、GET、HEAD等等 —— 都將路由到相同的函數。

2.1.4 捕獲的參數永遠是字符串

每一個捕獲的參數都做爲一個普通的Python 字符串傳遞給視圖，不管正則表達式使用的是什麼匹配方式。例如，下面這行URLconf 中：

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

views.year_archive() 的year 參數將是一個字符串

2.1.5 指定視圖參數的默認值

有一個方便的小技巧是指定視圖參數的默認值。下面是一個URLconf 和視圖的示例：

# URLconf
from django.conf.urls import url

from . import views

urlpatterns = [
    url(r'^blog/$', views.page),
    url(r'^blog/page(?P<num>[0-9]+)/$', views.page),
]

# View (in blog/views.py)
def page(request, num="1"):

    ...

View Code

在上面的例子中，兩個URL模式指向同一個視圖views.page —— 可是第一個模式不會從URL 中捕獲任何值。若是第一個模式匹配，page() 函數將使用num參數的默認值"1"。若是第二個模式匹配，page() 將使用正則表達式捕獲的num 值。

2.1.6 Including other URLconfs（路由分流）

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

2.2 傳遞額外的選項給視圖函數(瞭解)

URLconfs 具備一個鉤子，讓你傳遞一個Python 字典做爲額外的參數傳遞給視圖函數。

django.conf.urls.url() 函數能夠接收一個可選的第三個參數，它是一個字典，表示想要傳遞給視圖函數的額外關鍵字參數。

例如：

from django.conf.urls import url
from . import views

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

在這個例子中，對於/blog/2005/請求，Django 將調用views.year_archive(request, year='2005', foo='bar')。

這個技術在Syndication 框架中使用，來傳遞元數據和選項給視圖。

2.3 name參數（前端別名）

'''

urlpatterns = [
    url(r'^index',views.index,name='INDEX'),

]
###################

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


#######################

'''

View Code

使用了別名也會被截胡。使用別名就至關於找這個別名對應的路徑，和通常的路徑的查詢順序是同樣的，若是被前面的幾條截胡了，一樣到不了這一條。

回到頂部

三編寫視圖

一個視圖函數，或者簡短來講叫作視圖，是一個簡單的Python函數，它接受web請求，而且返回web響應。響應能夠是一張網頁的HTML內容，一個重定向，一個404錯誤，一個XML文檔，或者一張圖片. . . 是任何東西均可以。不管視圖自己包含什麼邏輯，都要返回響應。代碼寫在哪裏也無所謂，只要它在你的Python目錄下面。除此以外沒有更多的要求了——能夠說「沒有什麼神奇的地方」。爲了可以把代碼放在某個地方，慣例是把視圖放在叫作views.py的文件中，而後把它放到你的項目或者應用目錄裏。

3.1 一個簡單的視圖

下面是一個返回當前日期和時間做爲HTML文檔的視圖：

from django.http import HttpResponse
import datetime

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

讓咱們逐行閱讀上面的代碼：

首先，咱們從 django.http模塊導入了HttpResponse類，以及Python的datetime庫。
接着，咱們定義了current_datetime函數。它是一個視圖函數。每一個視圖函數都應接收HttpRequest對象做爲第一個參數，通常叫作request。
注意視圖函數的名稱並不重要；不須要用一個統一的命名方式來命名，以便讓Django識別它。咱們將其命名爲current_datetime，是由於這個名稱可以精確地反映出它的功能。
這個視圖會返回一個HttpResponse對象，其中包含生成的響應。每一個視圖函數都要返回HttpResponse對象

'''
http請求－響應過程當中有兩個核心對象：
        http請求對象：HttpRequest
        http響應響應：HttpResponse
所在位置：django.http
'''

3.2 快捷函數

3.2.1 render函數

－－－－－－－－－－－－－－－render(request, template_name[, context]）

結合一個給定的模板和一個給定的上下文字典，並返回一個渲染後的 HttpResponse 對象。

參數：
     request： 用於生成響應的請求對象。

     template_name：要使用的模板的完整名稱，可選的參數

     context：添加到模板上下文的一個字典。默認是一個空字典。若是字典中的某個值是可調用的，視圖將在渲染模板以前調用它。

     content_type：生成的文檔要使用的MIME類型。默認爲DEFAULT_CONTENT_TYPE 設置的值。

     status：響應的狀態碼。默認爲200。

3.2.2 redirect函數

-----------------------------------url.py

 url(r"login",   views.login),
 url(r"yuan_back",   views.yuan_back),

-----------------------------------views.py
def login(req):
    if req.method=="POST":
        if 1:
            # return redirect("/yuan_back/")     #local()是將本地變量所有傳過去，用當前變量名調用
            name="yuanhao"

            return render(req,"my backend.html",locals())

    return render(req,"login.html",locals())


def yuan_back(req):

    name="苑昊"

    return render(req,"my backend.html",locals())

-----------------------------------login.html

<form action="/login/" 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>
-----------------------------------my backend.html
<h1>用戶{{ name }}你好</h1>

#總結: render和redirect的區別:
#   1 if render的頁面須要模板語言渲染,須要的將數據庫的數據加載到html,那麼全部的這一部分
#     除了寫在yuan_back的視圖函數中,必須還要寫在login中,代碼重複,沒有解耦.

#   2 the most important: url沒有跳轉到/yuan_back/,而是還在/login/,因此當刷新後
#     又得從新登陸.

回到頂部

四 Template

4.1 模板系統的介紹

你可能已經注意到咱們在例子視圖中返回文本的方式有點特別。也就是說，HTML被直接硬編碼在 Python代碼之中。

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

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

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

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

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

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

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

4.2 模板支持的語法

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

```
語法格式：       {{var_name}}
```

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－Template和Context對象 
>>> python manange.py shell  (進入該django項目的環境)
>>> from django.template import Context, Template
>>> t = Template('My name is {{ name }}.')
>>> c = Context({'name': 'Stephane'})
>>> t.render(c)
'My name is Stephane.'


# *********************************
# 同一模板，多個上下文，一旦有了模板對象，你就能夠經過它渲染多個context，不管什麼時候咱們均可以
# 像這樣使用同一模板源渲染多個context，只進行 一次模板建立而後屢次調用render()方法渲染會
# 更爲高效：
# Low
for name in ('John', 'Julie', 'Pat'):
    t = Template('Hello, {{ name }}')
    print t.render(Context({'name': name}))

# Good
t = Template('Hello, {{ name }}')
for name in ('John', 'Julie', 'Pat'):
    print t.render(Context({'name': name}))

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

View Code

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

在到目前爲止的例子中，咱們經過 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 字典。 要經過字典鍵訪問該字典的值，可以使用一個句點：（若是用for遍歷字典，遍歷獲得的是key，可是能夠選擇 person.keys,仍是 person.values 選擇遍歷鍵仍是值 ）
>>> 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
1993
>>> d.month
5
>>> d.day
2
>>> 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'

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

4.2.3 變量的展現處理（filter）

語法格式：      {{obj|filter:param}}

   # 1  add          ：   給變量加上相應的值
   #
   # 2  addslashes   :    給變量中的引號前加上斜線
   #
   # 3  capfirst     :    首字母大寫
   #
   # 4  cut          ：   從字符串中移除指定的字符
   #
   # 5  date         ：   格式化日期字符串
   #
   # 6  default      ：   若是值是False,就替換成設置的默認值，不然就是用原本的值
   #
   # 7  default_if_none:  若是值是None，就替換成設置的默認值，不然就使用原本的值
   #
   #  upper safe truncatewords truncatechars

　　# striptags 刪除value中的全部HTML標籤

#實例:

#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 }}（可以直接後臺寫一個html標籤傳過去，否則做爲字符串傳）<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'

#更多:

4.2.4 標籤(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 %}的使用以及 forloop

{% for %}標籤容許你按順序遍歷一個序列中的各個元素,每次循環模板系統都會渲染{% for %}和{% endfor %}之間的全部內容

<ul>
{% for obj in list %}
    <li>{{ obj.name }}</li>
{% endfor %}
</ul>

#在標籤裏添加reversed來反序循環列表：

    {% for obj in list reversed %}
    ...
    {% endfor %}

#{% for %}標籤能夠嵌套：

    {% for country in countries %}
        <h1>{{ country.name }}</h1>
        <ul>
         {% for city in country.city_list %}
            <li>{{ city }}</li>
         {% endfor %}
        </ul>
    {% endfor %}


#系統不支持中斷循環，系統也不支持continue語句，{% for %}標籤內置了一個forloop模板變量，
#這個變量含有一些屬性能夠提供給你一些關於循環的信息

1，forloop.counter表示循環的次數，它從1開始計數，第一次循環設爲1:

    {% for item in todo_list %}
        <p>{{ forloop.counter }}: {{ item }}</p>
    {% endfor %}
2，forloop.counter0 相似於forloop.counter，但它是從0開始計數，第一次循環設爲0
3，forloop.revcounter
4，forloop.revcounter0
5，forloop.first當第一次循環時值爲True，在特別狀況下頗有用：

    
    {% for object in objects %}   
         {% if forloop.first %}<li class="first">{% else %}<li>{% endif %}   
         {{ object }}   
        </li>  
    {% endfor %}  
    
# 富有魔力的forloop變量只能在循環中獲得，當模板解析器到達{% endfor %}時forloop就消失了
# 若是你的模板context已經包含一個叫forloop的變量，Django會用{% for %}標籤替代它
# Django會在for標籤的塊中覆蓋你定義的forloop變量的值
# 在其餘非循環的地方，你的forloop變量仍然可用


#{% empty %}

{{li }}
      {%  for i in li %}
          <li>{{ forloop.counter0 }}----{{ i }}</li>
      {% empty %}
          <li>this is empty!</li>
      {% endfor %}

#         [11, 22, 33, 44, 55]
#            0----11
#            1----22
#            2----33
#            3----44
#            4----55

補充：

csrf_token標籤

用於生成csrf_token的標籤，用於防治跨站攻擊驗證。其實，這裏是會生成一個input標籤，和其餘表單標籤一塊兒提交給後臺的。

{% url %}

引用路由配置的地址

<form action="{% url "bieming"%}" >
          <input type="text">
          <input type="submit"value="提交">
          {%csrf_token%}
</form>

{% with %}

用更簡單的變量名替代複雜的變量名

{% with total=fhjsaldfhjsdfhlasdfhljsdal %} {{ total }} {% endwith %}

{% verbatim %}

禁止render

{% verbatim %}
         {{ hello }}
{% endverbatim %}

{% load %}

略

4.2.五、加載標籤庫:自定義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實例化 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)

View Code

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

View Code

e、在settings中的INSTALLED_APPS配置當前app，否則django沒法找到自定義的simple_tag.

注意：

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

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

4.3 extend模板繼承

到目前爲止，咱們的模板範例都只是些零星的 HTML 片斷，但在實際應用中，你將用 Django 模板系統來建立整個 HTML 頁面。這就帶來一個常見的 Web 開發問題：在整個網站中，如何減小共用頁面區域（好比站點導航）所引發的重複和冗餘代碼？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>

View Code

這看起來很棒，但若是咱們要爲 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>

View Code

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

View Code

回到頂部

五數據庫與ORM

配置數據庫：

1、settings 更改數據庫：

DATABASES = {

    'default': {

        'ENGINE': 'django.db.backends.mysql', 

        'NAME': 'books',    #你的數據庫名稱

        'USER': 'root',   #你的數據庫用戶名

        'PASSWORD': '', #你的數據庫密碼

        'HOST': '', #你的數據庫主機，留空默認爲localhost

        'PORT': '3306', #你的數據庫端口

    }

}

2、更改MySQLdb 爲 pyMySQL

  項目名文件下的__init__,在裏面寫入：

  import pymysql
  pymysql.install_as_MySQLdb()

3、

    python manage.py makemigrations      建立數據庫
    python manage.py migrate             建立數據庫

5.1 數據庫的配置

1 django默認支持sqlite，mysql, oracle,postgresql數據庫。

<1> sqlite

django默認使用sqlite的數據庫，默認自帶sqlite的數據庫驅動 , 引擎名稱：django.db.backends.sqlite3

<2> mysql

引擎名稱：django.db.backends.mysql

2 mysql驅動程序

- MySQLdb(mysql python)
- mysqlclient
- MySQL
- PyMySQL(純python的mysql驅動程序)

3 在django的項目中會默認使用sqlite數據庫，在settings裏有以下設置：

若是咱們想要更改數據庫，須要修改以下：

DATABASES = {

    'default': {

        'ENGINE': 'django.db.backends.mysql', 

        'NAME': 'books',    #你的數據庫名稱

        'USER': 'root',   #你的數據庫用戶名

        'PASSWORD': '', #你的數據庫密碼

        'HOST': '', #你的數據庫主機，留空默認爲localhost

        'PORT': '3306', #你的數據庫端口

    }

}

View Code

注意：

NAME即數據庫的名字，在mysql鏈接前該數據庫必須已經建立，而上面的sqlite數據庫下的db.sqlite3則是項目自動建立

USER和PASSWORD分別是數據庫的用戶名和密碼。

設置完後，再啓動咱們的Django項目前，咱們須要激活咱們的mysql。

而後，啓動項目，會報錯：no module named MySQLdb

這是由於django默認你導入的驅動是MySQLdb，但是MySQLdb對於py3有很大問題，因此咱們須要的驅動是PyMySQL

因此，咱們只須要找到項目名文件下的__init__,在裏面寫入：

import pymysql
pymysql.install_as_MySQLdb()

問題解決！

View Code

5.2 ORM表模型

表(模型)的建立：

實例：咱們來假定下面這些概念，字段和關係

做者模型：一個做者有姓名。

做者詳細模型：把做者的詳情放到詳情表，包含性別，email地址和出生日期，做者詳情模型和做者模型之間是一對一的關係（one－to－one）（相似於每一個人和他的身份證之間的關係），在大多數狀況下咱們沒有必要將他們拆分紅兩張表，這裏只是引出一對一的概念。

出版商模型：出版商有名稱，地址，所在城市，省，國家和網站。

書籍模型：書籍有書名和出版日期，一本書可能會有多個做者，一個做者也能夠寫多本書，因此做者和書籍的關係就是多對多的關聯關係（many－to－many），一本書只應該由一個出版商出版，因此出版商和書籍是一對多關聯關係（one－to－many），也被稱做外鍵。

from django.db import models<br>
class Publisher(models.Model):
    name = models.CharField(max_length=30, verbose_name="名稱")
    address = models.CharField("地址", max_length=50)
    city = models.CharField('城市',max_length=60)
    state_province = models.CharField(max_length=30)
    country = models.CharField(max_length=50)
    website = models.URLField()
 
    class Meta:
        verbose_name = '出版商'
        verbose_name_plural = verbose_name
 
    def __str__(self):
        return self.name
 
class Author(models.Model):
    name = models.CharField(max_length=30)
    def __str__(self):
        return self.name
 
class AuthorDetail(models.Model):
    sex = models.BooleanField(max_length=1, choices=((0, '男'),(1, '女'),))
    email = models.EmailField()
    address = models.CharField(max_length=50)
    birthday = models.DateField()
    author = models.OneToOneField(Author)
 
class Book(models.Model):
    title = models.CharField(max_length=100)
    authors = models.ManyToManyField(Author)
    publisher = models.ForeignKey(Publisher)
    publication_date = models.DateField()
    price=models.DecimalField(max_digits=5,decimal_places=2,default=10)
    def __str__(self):
        return self.title

View Code

分析代碼：

<1> 每一個數據模型都是django.db.models.Model的子類，它的父類Model包含了全部必要的和數據庫交互的方法。並提供了一個簡介漂亮的定義數據庫字段的語法。

<2> 每一個模型至關於單個數據庫表（多對多關係例外，會多生成一張關係表），每一個屬性也是這個表中的字段。屬性名就是字段名，它的類型（例如CharField）至關於數據庫的字段類型（例如varchar）。你們能夠留意下其它的類型都和數據庫裏的什麼字段對應。

<3> 模型之間的三種關係：一對一，一對多，多對多。

一對一：實質就是在主外鍵（author_id就是foreign key）的關係基礎上，給外鍵加了一個UNIQUE＝True的屬性；

一對多：就是主外鍵關係；（foreign key）

多對多：(ManyToManyField) 自動建立第三張表(固然咱們也能夠本身建立第三張表：兩個foreign key)

ORM之增(create,save)

from app01.models import *

    #create方式一:   Author.objects.create(name='Alvin')

    #create方式二:   Author.objects.create(**{"name":"alex"})

    #save方式一:     author=Author(name="alvin")
                            author.save()

    #save方式二:     author=Author()
                            author.name="alvin"
                            author.save()

重點來了－－－－－－－>那麼如何建立存在一對多或多對多關係的一本書的信息呢？(如何處理外鍵關係的字段如一對多的publisher和多對多的authors)

#  一對多(ForeignKey):
#  多對多(ManyToManyField()):

#一對多(ForeignKey):

    #方式一: 因爲綁定一對多的字段,好比publish,存到數據庫中的字段名叫publish_id,因此咱們能夠直接給這個
    #       字段設定對應值:
           Book.objects.create(title='php',
                               publisher_id=2,   #這裏的2是指爲該book對象綁定了Publisher表中id=2的行對象
                               publication_date='2017-7-7',
                               price=99)


    #方式二:
    #       <1> 先獲取要綁定的Publisher對象:
        pub_obj=Publisher(name='河大出版社',address='保定',city='保定',
                state_province='河北',country='China',website='http://www.hbu.com')
    OR  pub_obj=Publisher.objects.get(id=1)

    #       <2>將 publisher_id=2 改成  publisher=pub_obj

#多對多(ManyToManyField()):

    author1=Author.objects.get(id=1)
    author2=Author.objects.filter(name='alvin')[0]
    book=Book.objects.get(id=1)
    book.authors.add(author1,author2)
    #等同於:
    book.authors.add(*[author1,author2])
    book.authors.remove(*[author1,author2])
    book.authors.clear() #清除全部author信息
    #-------------------
    book=models.Book.objects.filter(id__gt=1)
    authors=models.Author.objects.filter(id=1)[0]
    authors.book_set.add(*book)
    authors.book_set.remove(*book)
    #-------------------
    book.authors.add(1)
    book.authors.remove(1)
    authors.book_set.add(1)
    authors.book_set.remove(1)

#注意: 若是第三張表是經過models.ManyToManyField()自動建立的,那麼綁定關係只有上面一種方式
#     若是第三張表是本身建立的:
     class Book2Author(models.Model):
            author=models.ForeignKey("Author")
            Book=  models.ForeignKey("Book")
#     那麼就還有一種方式:
            author_obj=models.Author.objects.filter(id=2)[0]
            book_obj  =models.Book.objects.filter(id=3)[0]

            s=models.Book2Author.objects.create(author_id=1,Book_id=2)
            s.save()
            s=models.Book2Author(author=author_obj,Book_id=1)
            s.save()

View Code

ORM之刪（delete）

>>> Book.objects.filter(id=1).delete()
(3, {'app01.Book_authors': 2, 'app01.Book': 1})

咱們表面上刪除了一條信息，實際卻刪除了三條，由於咱們刪除的這本書在Book_authors表中有兩條相關信息，這種刪除方式就是django默認的級聯刪除。

ORM之改（update和save）

實例：

注意：

<1> 第二種方式修改不能用get的緣由是：update是QuerySet對象的方法，get返回的是一個model對象，它沒有update方法，而filter返回的是一個QuerySet對象(filter裏面的條件可能有多個條件符合，好比name＝'alvin',可能有兩個name＝'alvin'的行數據)。

<2>在「插入和更新數據」小節中，咱們有提到模型的save()方法，這個方法會更新一行裏的全部列。而某些狀況下，咱們只須要更新行裏的某幾列。

#---------------- update方法直接設定對應屬性----------------
    models.Book.objects.filter(id=3).update(title="PHP")
    ##sql:
    ##UPDATE "app01_book" SET "title" = 'PHP' WHERE "app01_book"."id" = 3; args=('PHP', 3)


#--------------- save方法會將全部屬性從新設定一遍,效率低-----------
    obj=models.Book.objects.filter(id=3)[0]
    obj.title="Python"
    obj.save()
# SELECT "app01_book"."id", "app01_book"."title", "app01_book"."price", 
# "app01_book"."color", "app01_book"."page_num", 
# "app01_book"."publisher_id" FROM "app01_book" WHERE "app01_book"."id" = 3 LIMIT 1; 
# 
# UPDATE "app01_book" SET "title" = 'Python', "price" = 3333, "color" = 'red', "page_num" = 556,
# "publisher_id" = 1 WHERE "app01_book"."id" = 3;

View Code

此外，update()方法對於任何結果集（QuerySet）均有效，這意味着你能夠同時更新多條記錄update()方法會返回一個整型數值，表示受影響的記錄條數。

注意，這裏由於update返回的是一個整形，因此無法用query屬性；對於每次建立一個對象，想顯示對應的raw sql，須要在settings加上日誌記錄部分：

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console':{
            'level':'DEBUG',
            'class':'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
    }
}

View Code

ORM之查（filter,value)

查詢API：

#------------- 查詢相關API：--------------------------------------------------

#  <1>filter(**kwargs):      它包含了與所給篩選條件相匹配的對象 獲得的是集合對象，包含符合條件的對象[obj1,]

#  <2>all():                 查詢全部結果

#  <3>get(**kwargs):         返回與所給篩選條件相匹配的對象，返回結果有且只有一個，若是符合篩選條件的對象超過一個或者沒有都會拋出錯誤。

#-----------下面的方法都是對查詢的結果再進行處理:好比 objects.filter.values()--------

#  <4>values(*field):        返回一個ValueQuerySet——一個特殊的QuerySet，運行後獲得的並非一系列 model的實例化對象，而是一個可迭代的字典序列
                                     
#  <5>exclude(**kwargs):     排除，它包含了與所給篩選條件不匹配的對象

#  <6>order_by(*field):      對查詢結果排序

#  <7>reverse():             order_by以後，對查詢結果反向排序

#  <8>distinct():            從返回結果中剔除重複紀錄

#  <9>values_list(*field):   它與values()很是類似，它返回的是一個元組序列，values返回的是一個字典序列

#  <10>count():              返回數據庫中匹配查詢(QuerySet)的對象數量。

#  <11>first():               返回第一條記錄

#  <12>last():                返回最後一條記錄

#  <13>exists():             若是QuerySet包含數據，就返回True，不然返回False

條件查詢：

---------------了不得的雙下劃線(__)之單表條件查詢----------------

#    models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 獲取id大於1 且 小於10的值
#
#    models.Tb1.objects.filter(id__in=[11, 22, 33])   # 獲取id等於十一、2二、33的數據
#    models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
#
#    models.Tb1.objects.filter(name__contains="ven")
#    models.Tb1.objects.filter(name__icontains="ven") # icontains大小寫不敏感
#
#    models.Tb1.objects.filter(id__range=[1, 2])   # 範圍bettwen and
#
#    startswith，istartswith, endswith, iendswith,

QuerySet與惰性機制

所謂惰性機制：Publisher.objects.all()或者.filter()等都只是返回了一個QuerySet（查詢結果集對象），它並不會立刻執行sql，而是當調用QuerySet的時候才執行。

QuerySet特色：

<1> 可迭代的

<2> 可切片

    #objs=models.Book.objects.all()#[obj1,obj2,ob3...]

    #QuerySet:   可迭代

    # for obj in objs:#每一obj就是一個行對象
    #     print("obj:",obj)
    # QuerySet:  可切片

    # print(objs[1])
    # print(objs[1:4])
    # print(objs[::-1])

QuerySet的高效使用：

<1>Django的queryset是惰性的

     Django的queryset對應於數據庫的若干記錄（row），經過可選的查詢來過濾。例如，下面的代碼會得
     到數據庫中名字爲‘Dave’的全部的人:person_set = Person.objects.filter(first_name="Dave")
     上面的代碼並無運行任何的數據庫查詢。你可使用person_set，給它加上一些過濾條件，或者將它傳給某個函數，
     這些操做都不會發送給數據庫。這是對的，由於數據庫查詢是顯著影響web應用性能的因素之一。

<2>要真正從數據庫得到數據，你能夠遍歷queryset或者使用if queryset,總之你用到數據時就會執行sql.
   爲了驗證這些,須要在settings里加入 LOGGING(驗證方式)
        obj=models.Book.objects.filter(id=3)
        # for i in obj:
        #     print(i)

        # if obj:
        #     print("ok")

<3>queryset是具備cache的
     當你遍歷queryset時，全部匹配的記錄會從數據庫獲取，而後轉換成Django的model。這被稱爲執行
    （evaluation）.這些model會保存在queryset內置的cache中，這樣若是你再次遍歷這個queryset，
     你不須要重複運行通用的查詢。
        obj=models.Book.objects.filter(id=3)

        # for i in obj:
        #     print(i)
                          ## models.Book.objects.filter(id=3).update(title="GO")
                          ## obj_new=models.Book.objects.filter(id=3)
        # for i in obj:
        #     print(i)   #LOGGING只會打印一次

<4>
     簡單的使用if語句進行判斷也會徹底執行整個queryset而且把數據放入cache，雖然你並不須要這些
     數據！爲了不這個，能夠用exists()方法來檢查是否有數據：

            obj = Book.objects.filter(id=4)
            #  exists()的檢查能夠避免數據放入queryset的cache。
            if obj.exists():
                print("hello world!")

<5>當queryset很是巨大時，cache會成爲問題

     處理成千上萬的記錄時，將它們一次裝入內存是很浪費的。更糟糕的是，巨大的queryset可能會鎖住系統
     進程，讓你的程序瀕臨崩潰。要避免在遍歷數據的同時產生queryset cache，可使用iterator()方法
     來獲取數據，處理完數據就將其丟棄。
        objs = Book.objects.all().iterator()
        # iterator()能夠一次只從數據庫獲取少許數據，這樣能夠節省內存
        for obj in objs:
            print(obj.name)
        #BUT,再次遍歷沒有打印,由於迭代器已經在上一次遍歷(next)到最後一次了,沒得遍歷了
        for obj in objs:
            print(obj.name)

     #固然，使用iterator()方法來防止生成cache，意味着遍歷同一個queryset時會重複執行查詢。因此使
     #用iterator()的時候要小心，確保你的代碼在操做一個大的queryset時沒有重複執行查詢

總結:
    queryset的cache是用於減小程序對數據庫的查詢，在一般的使用下會保證只有在須要的時候纔會查詢數據庫。
使用exists()和iterator()方法能夠優化程序對內存的使用。不過，因爲它們並不會生成queryset cache，可能
會形成額外的數據庫查詢。

View Code

對象查詢，單表條件查詢，多表條件關聯查詢

#--------------------對象形式的查找--------------------------
    # 正向查找
    ret1=models.Book.objects.first()
    print(ret1.title)
    print(ret1.price)
    print(ret1.publisher)
    print(ret1.publisher.name)  #由於一對多的關係因此ret1.publisher是一個對象,而不是一個queryset集合

    # 反向查找
    ret2=models.Publish.objects.last()
    print(ret2.name)
    print(ret2.city)
    #如何拿到與它綁定的Book對象呢?
    print(ret2.book_set.all()) #ret2.book_set是一個queryset集合

#---------------了不得的雙下劃線(__)之單表條件查詢----------------

#    models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 獲取id大於1 且 小於10的值
#
#    models.Tb1.objects.filter(id__in=[11, 22, 33])   # 獲取id等於十一、2二、33的數據
#    models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
#
#    models.Tb1.objects.filter(name__contains="ven")
#    models.Tb1.objects.filter(name__icontains="ven") # icontains大小寫不敏感
#
#    models.Tb1.objects.filter(id__range=[1, 2])   # 範圍bettwen and
#
#    startswith，istartswith, endswith, iendswith,

#----------------了不得的雙下劃線(__)之多表條件關聯查詢---------------

# 正向查找(條件)

#     ret3=models.Book.objects.filter(title='Python').values('id')
#     print(ret3)#[{'id': 1}]

      #正向查找(條件)之一對多

      ret4=models.Book.objects.filter(title='Python').values('publisher__city')
      print(ret4)  #[{'publisher__city': '北京'}]

      #正向查找(條件)之多對多
      ret5=models.Book.objects.filter(title='Python').values('author__name')
      print(ret5)
      ret6=models.Book.objects.filter(author__name="alex").values('title')
      print(ret6)

      #注意
      #正向查找的publisher__city或者author__name中的publisher,author是book表中綁定的字段
      #一對多和多對多在這裏用法沒區別

# 反向查找(條件)

    #反向查找之一對多:
    ret8=models.Publisher.objects.filter(book__title='Python').values('name')
    print(ret8)#[{'name': '人大出版社'}]  注意,book__title中的book就是Publisher的關聯表名

    ret9=models.Publisher.objects.filter(book__title='Python').values('book__authors')
    print(ret9)#[{'book__authors': 1}, {'book__authors': 2}]

    #反向查找之多對多:
    ret10=models.Author.objects.filter(book__title='Python').values('name')
    print(ret10)#[{'name': 'alex'}, {'name': 'alvin'}]

    #注意
    #正向查找的book__title中的book是表名Book
    #一對多和多對多在這裏用法沒區別

注意：條件查詢即與對象查詢對應，是指在filter，values等方法中的經過__來明確查詢條件。

聚合查詢和分組查詢

<1> aggregate(*args,**kwargs):

經過對QuerySet進行計算，返回一個聚合值的字典。aggregate()中每個參數都指定一個包含在字典中的返回值。即在查詢集上生成聚合。

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

從整個查詢集生成統計值。好比，你想要計算全部在售書的平均價錢。Django的查詢語法提供了一種方式描述全部
圖書的集合。

>>> Book.objects.all().aggregate(Avg('price'))
{'price__avg': 34.35}

aggregate()子句的參數描述了咱們想要計算的聚合值，在這個例子中，是Book模型中price字段的平均值

aggregate()是QuerySet 的一個終止子句，意思是說，它返回一個包含一些鍵值對的字典。鍵的名稱是聚合值的
標識符，值是計算出來的聚合值。鍵的名稱是按照字段和聚合函數的名稱自動生成出來的。若是你想要爲聚合值指定
一個名稱，能夠向聚合子句提供它:
>>> Book.objects.aggregate(average_price=Avg('price'))
{'average_price': 34.35}


若是你也想知道全部圖書價格的最大值和最小值，能夠這樣查詢：
>>> Book.objects.aggregate(Avg('price'), Max('price'), Min('price'))
{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}
複製代碼

View Code

<2> annotate(*args,**kwargs):

能夠經過計算查詢結果中每個對象所關聯的對象集合，從而得出總計值(也能夠是平均值或總和)，即爲查詢集的每一項生成聚合。

查詢alex出的書總價格

查詢各個做者出的書的總價格,這裏就涉及到分組了，分組條件是authors__name

查詢各個出版社最便宜的書價是多少

F查詢和Q查詢

僅僅靠單一的關鍵字參數查詢已經很難知足查詢要求。此時Django爲咱們提供了F和Q查詢：

# F 使用查詢條件的值,專門取對象中某列值的操做

    # from django.db.models import F
    # models.Tb1.objects.update(num=F('num')+1)


# Q 構建搜索條件
    from django.db.models import Q

    #1 Q對象(django.db.models.Q)能夠對關鍵字參數進行封裝，從而更好地應用多個查詢
    q1=models.Book.objects.filter(Q(title__startswith='P')).all()
    print(q1)#[<Book: Python>, <Book: Perl>]

    # 二、能夠組合使用&,|操做符，當一個操做符是用於兩個Q的對象,它產生一個新的Q對象。
    Q(title__startswith='P') | Q(title__startswith='J')

    # 三、Q對象能夠用~操做符放在前面表示否認，也可容許否認與不否認形式的組合
    Q(title__startswith='P') | ~Q(pub_date__year=2005)

    # 四、應用範圍：

    # Each lookup function that takes keyword-arguments (e.g. filter(),
    #  exclude(), get()) can also be passed one or more Q objects as
    # positional (not-named) arguments. If you provide multiple Q object
    # arguments to a lookup function, the arguments will be 「AND」ed
    # together. For example:

    Book.objects.filter(
        Q(title__startswith='P'),
        Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6))
    )

    #sql:
    # SELECT * from polls WHERE question LIKE 'P%'
    #     AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06')

    # import datetime
    # e=datetime.date(2005,5,6)  #2005-05-06

    # 五、Q對象能夠與關鍵字參數查詢一塊兒使用，不過必定要把Q對象放在關鍵字參數查詢的前面。
    # 正確：
    Book.objects.filter(
        Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),
        title__startswith='P')
    # 錯誤：
    Book.objects.filter(
        question__startswith='P',
        Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))

View Code

回到頂部

admin的配置

admin是django強大功能之一，它能共從數據庫中讀取數據，呈如今頁面中，進行管理。默認狀況下，它的功能已經很是強大，若是你不須要複雜的功能，它已經夠用，可是有時候，一些特殊的功能還須要定製，好比搜索功能，下面這一系列文章就逐步深刻介紹如何定製適合本身的admin應用。

若是你以爲英文界面很差用，能夠在setting.py 文件中修改如下選項

LANGUAGE_CODE = 'en-us'  #LANGUAGE_CODE = 'zh-hans'

一認識ModelAdmin

管理界面的定製類，如需擴展特定的model界面需從該類繼承。

二註冊medel類到admin的兩種方式：

<1> 使用register的方法

admin.site.register(Book,MyAdmin)

<2> 使用register的裝飾器

@admin.register(Book)

三掌握一些經常使用的設置技巧

list_display: 指定要顯示的字段
search_fields: 指定搜索的字段
list_filter: 指定列表過濾器
ordering：指定排序字段

from django.contrib import admin
from app01.models import *
# Register your models here.

# @admin.register(Book)#----->單給某個表加一個定製
class MyAdmin(admin.ModelAdmin):
    list_display = ("title","price","publisher")
    search_fields = ("title","publisher")
    list_filter = ("publisher",)
    ordering = ("price",)
    fieldsets =[
        (None,               {'fields': ['title']}),
        ('price information', {'fields': ['price',"publisher"], 'classes': ['collapse']}),
    ]

admin.site.register(Book,MyAdmin)
admin.site.register(Publish)
admin.site.register(Author)

python manage.py makemigrations      建立數據庫
    python manage.py migrate             建立數據庫

相關標籤/搜索

每日一句

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

Django基礎（一）

一 什麼是web框架？

二 MVC和MTV模式

Django基本命令

二 路由配置系統（URLconf）

2.1 URLconf的正則字符串參數

2.1.1 簡單配置

2.1.2 有名分組(named group)

2.1.3 URLconf 在什麼上查找

2.1.4 捕獲的參數永遠是字符串

2.1.5 指定視圖參數的默認值

2.1.6 Including other URLconfs（路由分流）

2.2 傳遞額外的選項給視圖函數(瞭解)

2.3 name參數（前端別名）

三 編寫視圖

3.1 一個簡單的視圖

3.2 快捷函數

3.2.1 render函數

3.2.2 redirect函數

四 Template

4.1 模板系統的介紹

4.2 模板支持的語法

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

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

4.2.3 變量的展現處理（filter）

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

{% if %} 的使用

{% for %}的使用以及 forloop

csrf_token標籤

{% url %}

{% with %}

{% verbatim %}

{% load %}

4.2.五、加載標籤庫:自定義filter和simple_tag

4.3 extend模板繼承

五 數據庫與ORM

5.1 數據庫的配置

1 django默認支持sqlite，mysql, oracle,postgresql數據庫。

2 mysql驅動程序

3 在django的項目中會默認使用sqlite數據庫，在settings裏有以下設置：

5.2 ORM表模型

表(模型)的建立：

ORM之增(create,save)

ORM之刪（delete）

ORM之改（update和save）

ORM之查（filter,value)

查詢API：

QuerySet與惰性機制

對象查詢，單表條件查詢，多表條件關聯查詢

聚合查詢和分組查詢

F查詢和Q查詢

admin的配置

一 認識ModelAdmin

二 註冊medel類到admin的兩種方式：

三 掌握一些經常使用的設置技巧

一什麼是web框架？

二路由配置系統（URLconf）

三編寫視圖

五數據庫與ORM

一認識ModelAdmin

二註冊medel類到admin的兩種方式：

三掌握一些經常使用的設置技巧