【Python全棧-後端開發】Django入門基礎

時間 2019-11-18

標籤 Python全棧-後端開發 django 入門基礎欄目 Python 简体版

原文原文鏈接

Django基礎知識

　　　　　　1、什麼是web框架？

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

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

 

 

最簡單的Web應用就是先把HTML用文件保存好，用一個現成的HTTP服務器軟件，接收用戶請求，從文件中讀取HTML，返回。

若是要動態生成HTML，就須要把上述步驟本身來實現。不過，接受HTTP請求、解析HTTP請求、發送HTTP響應都是苦力活，若是咱們本身來寫這些底層代碼，還沒開始寫動態HTML呢，就得花個把月去讀HTTP規範。

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

這個接口就是WSGI：Web Server Gateway Interface。（網絡服務網關接口）

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

step 1:
 

注意：

 

step 2
 

step 3
 

step 4

View Code

　　　　　　2、MVC和MTV模式

著名的MVC模式：所謂MVC就是把web應用分爲模型(M),控制器(C),視圖(V)三層；他們之間以一種插件似的，鬆耦合的方式鏈接在一塊兒。

模型負責業務對象與數據庫的對象(ORM) ， 視圖負責與用戶的交互(頁面)，控制器(C)接受用戶的輸入調用模型和視圖完成用戶的請求。

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

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

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

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

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

View Code

　　　　　　3、Django的流程和命令行工具

Django實現流程：

Django
    #安裝： pip3 install django
          添加環境變量

    #1  在cmd命令行中建立project
django-admin startproject [項目名]

       django-admin startproject mysite

       ---mysite

          ---settings.py
          ---url.py
          ---wsgi.py

       ---- manage.py(啓動文件)  

    #2  建立APP 
python manage.py startapp [app名字]      
       python manage.py startapp app01

    #3  settings配置
    
       TEMPLATES
　　
#配置靜態文件路徑
       STATICFILES_DIRS=(
            os.path.join(BASE_DIR,"statics"),　　　　#必定要加逗號，否則會報錯
        )

       STATIC_URL = '/static/' 　　#別名（因爲原名更改致使後續更改麻煩，之後通常使用別名，）
       #  咱們只能用 STATIC_URL，但STATIC_URL會按着你的STATICFILES_DIRS去找#4  根據需求設計代碼
           url.py
           view.py

    #5  使用模版渲染HTML界面
       render(request,"index.html")   

    #6  啓動項目（pycharm 的terminal中）
       python manage.py runserver  【127.0.0.1:8000】 #後面【】部分能夠不填，默認是127.0.0.1:8000

    #7  鏈接數據庫，操做數據
       model.py

django的cmd命令行工具：

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

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

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

manage.py ----- Django項目裏面的工具，經過它能夠調用django shell和數據庫等。
settings.py ---- 包含了項目的默認設置，包括數據庫信息，調試標誌以及其餘一些工做的變量。
urls.py ----- 負責把URL模式映射到應用程序。

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

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

<4>生成同步數據庫的腳本：python manage.py makemigrations python

同步數據庫: python manage.py migrate mysql

注意：在開發過程當中，數據庫同步誤操做以後，不免會遇到後面不能同步成功的狀況，解決這個問題的一個簡單粗暴方法是把migrations目錄下jquery

的腳本（除__init__.py以外）所有刪掉，再把數據庫刪掉以後建立一個新的數據庫，數據庫同步操做再從新作一遍。 linux

<5>當咱們訪問後臺管理員：http://127.0.0.1:8080/admin/時，會出現：nginx

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

注意：修改密碼：python manage.py changepassword [用戶名]

忘記用戶名或密碼：

在shell模式下（Python manage.py shell）
---------------------------------------------------找回用戶名

from django.contrib.auth.models import User #引入管理員密碼存放的數據庫

user=User.objects.filter()     #查找該數據庫裏有哪些用戶

print(user)    #<QuerySet [<User: root>, <User: xiong>]>

-----------------------------------------------------修改密碼（方法一）

user = User.objects.get(username='admin') #獲取名稱爲admin的用戶

user.set_password('123456') #設置密碼

user.save()  # 報錯user對象

-----------------------------------------------------修改密碼（方法二）
退出shell模式，在Terminal中

Python manage.py changepassword [用戶名]

View Code

<6>清空數據庫（慎用！！！）：python manage.py flush

<7>查詢某個命令的詳細信息： django-admin.py help startapp

admin 是Django 自帶的一個後臺數據庫管理系統。

<8>啓動Django與數據庫交互模式：python manage.py shell

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

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

實例練習1－提交數據並展現

實例練習2－提交數據並展現(數據庫)

　　　　　　4、project文件夾下(settings.py)配置

靜態文件設置:

1、概述：

     #靜態文件交由Web服務器處理，Django自己不處理靜態文件。簡單的處理邏輯以下(以nginx爲例)：

     #          URI請求-----> 按照Web服務器裏面的配置規則先處理，以nginx爲例，主要求配置在nginx.
                             #conf裏的location

                         |---------->若是是靜態文件，則由nginx直接處理

                         |---------->若是不是則交由Django處理，Django根據urls.py裏面的規則進行匹配

    # 以上是部署到Web服務器後的處理方式，爲了便於開發，Django提供了在開發環境的對靜態文件的處理機制，方法是這樣：

    #一、在INSTALLED_APPS裏面加入'django.contrib.staticfiles',

    #二、在urls.py裏面加入
       if settings.DEBUG:  
           urlpatterns += patterns('', url(r'^media/(?P<path>.*)$', 
           'django.views.static.serve', {'document_root': settings.MEDIA_ROOT }),   
            url(r'^static/(?P<path>.*)$',
          'django.views.static.serve',{'document_root':settings.STATIC_ROOT}), )  

    # 三、這樣就能夠在開發階段直接使用靜態文件了。

2、MEDIA_ROOT和MEDIA_URL

        #而靜態文件的處理又包括STATIC和MEDIA兩類，這每每容易混淆，在Django裏面是這樣定義的：

        #MEDIA:指用戶上傳的文件，好比在Model裏面的FileFIeld，ImageField上傳的文件。若是你定義

        #MEDIA_ROOT=c:\temp\media，那麼File=models.FileField(upload_to="abc/")＃，上傳的文件就會被保存到c:\temp\media\abc  
        #eg：
            class blog(models.Model):  
                   Title=models.charField(max_length=64)  
                   Photo=models.ImageField(upload_to="photo") 
        #     上傳的圖片就上傳到c:\temp\media\photo，而在模板中要顯示該文件，則在這樣寫
        #在settings裏面設置的MEDIA_ROOT必須是本地路徑的絕對路徑，通常是這樣寫:
                 BASE_DIR= os.path.abspath(os.path.dirname(__file__))  
                 MEDIA_ROOT=os.path.join(BASE_DIR,'media/').replace('\\','/') 

        #MEDIA_URL是指從瀏覽器訪問時的地址前綴，舉個例子：
            MEDIA_ROOT=c:\temp\media\photo  
            MEDIA_URL="/data/"
        #在開發階段,media的處理由django處理：

        #    訪問http://localhost/data/abc/a.png就是訪問c:\temp\media\photo\abc\a.png

        #    在模板裏面這樣寫<img src="{{MEDIA_URL}}abc/a.png">

        #    在部署階段最大的不一樣在於你必須讓web服務器來處理media文件，所以你必須在web服務器中配置，
        #  以便能讓web服務器能訪問media文件
        #    以nginx爲例，能夠在nginx.conf裏面這樣：

                 location ~/media/{
                       root/temp/
                       break;
                    }

        #    具體能夠參考如何在nginx部署django的資料。

3、STATIC_ROOT和STATIC_URL、
    STATIC主要指的是如css,js,images這樣文件，在settings裏面能夠配置STATIC_ROOT和STATIC_URL,
    配置方式與MEDIA_ROOT是同樣的，可是要注意

    #STATIC文件通常保存在如下位置：

    #一、STATIC_ROOT：在settings裏面設置，通常用來放一些公共的js,css,images等。

    #二、app的static文件夾，在每一個app所在文夾都可以創建一個static文件夾，而後當運行collectstatic時，
    #    Django會遍歷INSTALL_APPS裏面全部app的static文件夾，將裏面全部的文件複製到STATIC_ROOT。所以，
    #   若是你要創建可複用的app，那麼你要將該app所須要的靜態文件放在static文件夾中。

    # 也就是說一個項目引用了不少app，那麼這個項目所須要的css,images等靜態文件是分散在各個app的static文件的，比
    #  較典型的是admin應用。當你要發佈時，須要將這些分散的static文件收集到一個地方就是STATIC_ROOT。

    #三、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_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

配置編碼：

首先須要配置的是文字編碼格式，django默認的編碼是英語格式，咱們把它改爲中文格式，須要修改下面幾個變量的值。

LANGUAGE_CODE = 'zh-hans' # zh-hans爲中文編碼

TIME_ZONE = 'Asia/Shanghai' # 國際時區改爲中國時區

USE_I18N = True

USE_L10N = True

USE_TZ = False

View Code

配置數據庫：

而後還須要配置數據庫信息，django默認使用的是sqlite數據庫，咱們修改成mysql數據庫。找到DATABASES節點，修改成以下代碼。

其中，NAME爲數據庫名，USER爲mysql的用戶名，PASSWORD爲密碼，HOSY爲127.0.0.1，PORT爲3306

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'video',
        'USER': 'root',
        'PASSWORD': '123456',
        'HOST':'127.0.0.1',
        'PORT':'3306',
    }
}

View Code

配置好數據庫以後，還須要在 videoproject/videoproject/__init__.py 安裝mysql驅動，只須要寫入代碼：

import pymysql
pymysql.install_as_MySQLdb()

View Code

views.py操做數據庫的日誌 --->控制檯打印SQL語句

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

　　　　　　5、Django URL (路由系統)

URL配置(URLconf)就像Django 所支撐網站的目錄。它的本質是URL模式以及要爲該URL模式調用的視圖函數之間的映射表；

你就是以這種方式告訴Django，對於這個URL調用這段代碼，對於那個URL調用那段代碼。

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

參數說明：

一個正則表達式字符串
一個可調用對象，一般爲一個視圖函數或一個指定視圖函數路徑的字符串
可選的要傳遞給視圖函數的默認參數（字典形式）
一個可選的name參數
能夠兩個url對應一個views視圖函數（注意：邏輯不能亂）

5.1 下面是一些基本的URL配置:

from django.conf.urls import url
from django.contrib import admin

from blog import views

urlpatterns = [

    url(r'^articles/2003/$', views.special_case_2003),

    #url(r'^articles/[0-9]{4}/$', views.year_archive),

    url(r'^articles/([0-9]{4})/$', views.year_archive),  #no_named group

    url(r'^articles/([0-9]{4})/([0-9]{2})/$', views.month_archive),

    url(r'^articles/([0-9]{4})/([0-9]{2})/([0-9]+)/$', views.article_detail),

]

Note:

#1   There’s no need to add a leading slash, because every URL has that. For
#    example, it’s ^articles, not ^/articles.

#2   A request to /articles/2005/03/ would match the third entry in the list.
#    Django would call the function views.month_archive(request, '2005', '03').

#3   /articles/2005/3/ would not match any URL patterns

#4   /articles/2003/ would match the first pattern in the list, not the second one

#5   /articles/2003/03/03/ would match the final pattern. Django would call the
#    functionviews.article_detail(request, '2003', '03', '03').

View Code

注意問題：django---urls中導入url和path問題

初始導入的是path模塊：

urlpatterns = [
    path(r'^hello/$',views.hello),
    path(r'^admin/$', admin.site.urls),
    path(r'^time/$', current_datetime),

    path(r'^time/plus/(\d{1,2})/$',hours_ahead),

]

網站不能正常運行。正則失敗。

後來我刪掉path，導入url：

from django.conf.urls import url 

urlpatterns = [
    url(r'^hello/$',views.hello),
    url(r'^admin/$', admin.site.urls),
    url(r'^time/$', current_datetime),

    url(r'^time/plus/(\d{1,2})/$',hours_ahead),

]

網站運行成功。正則表達式成功

View Code

5.2 Named groups（命名組）

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

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

下面是用命名組重寫了上面的URL配置案例：

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

參考：

Django的路由系統|URL配置、正則表達式、分組命名、命名空間、命名URL反向解析

　　　　　　6、Django Views（視圖函數）

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

http請求：HttpRequest對象

http響應：HttpResponse對象

所在位置：django.http

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

1 HttpRequest對象的屬性和方法：

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

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

注意一個經常使用方法：request.POST.getlist('')

2 HttpResponse對象：

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

HttpResponse類在django.http.HttpResponse

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

頁面渲染：         render()（推薦）    render_to_response(),         
頁面跳轉：         redirect("路徑")
locals()：        能夠直接將函數中全部的變量傳給模板

補充：

-----------------------------------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/")
            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/,因此當刷新後
#     又得從新登陸.

區別redirect 和 render

練習：

-----------------------------------------Django/urls
url(r'blog/',include('blog.urls')),
url('login/', views.login),
-----------------------------------------blog/urls
#註冊界面
url("register",views.register,name="reg")

----------------------------------------views
def register(request):
    # print("部分路徑：",request.path)
    # print("全路徑：",request.get_full_path)
    
    # if request.method == "POST":
        # print(request.POST)
        # print(request.POST.get("userName"))
        # print(request.POST.get("age"))
        # return HttpResponse(request)
    if request.POST.get("userName") == "xiong":
        return redirect("/login/")     #輸入userName是 xiong 跳轉到login界面
    else:
        redirect("http://www.baidu.com")

# 開始進來的時候是get請求 返回html渲染界面，以後form表單是以POST提交
    return render(request,"register.html")


def login(request):
    if request.GET.get("username") == "xiong" and request.GET.get("pwd") == "123456":
        return redirect("https://www.cnblogs.com")

----------------------------------------------------template/.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    {% load staticfiles %}      {# 使用別名 須要載入靜態文件 #}
    <title>Title</title>
</head>
<body>
<h1>學生註冊界面</h1>
<hr>
{#以post方式提交,action="/register/" 是以當前頁面的ip+port放在前面一塊兒發過去即：172.0.0.1:8080/register/#}
{#<form action="/register/" method="post">#}
<form action="{% url 'reg' %}" method="post">
    <p>姓名<input type="text" name="userName"></p>
    <p>年齡<input type="text" name="age"></p>
    <p>愛好<input type="checkbox" name="hobby">籃球
            <input type="checkbox" name="hobby">足球
            <input type="checkbox" name="hobby">乒乓球
    </p>
    <p><input type="submit">提交</p>

</form>
</body>
</html>


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登陸界面</title>
</head>
<body>
<form action="">
    <p>用戶名: <input type="text" name="username" id=""></p>
    <p>密碼: <input type="text" name="pwd" id=""></p>
    <p><input type="submit"></p>
</form>
</body>
</html>

View Code

　　　　　　7、Template模板基礎（重要！！！）

模板系統的介紹

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

------------------------------------------------------------------模板語法------------------------------------------------------------------

1、模版的組成

組成：HTML代碼＋邏輯控制代碼

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(建立了3個相同的模板)
for name in ('John', 'Julie', 'Pat'):
    t = Template('Hello, {{ name }}')
    print t.render(Context({'name': name}))

# Good（推薦--建立了1個模板 用了3次）
t = Template('Hello, {{ name }}')
for name in ('John', 'Julie', 'Pat'):
    print t.render(Context({'name': name}))

View Code

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

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

在到目前爲止的例子中，咱們經過 context 傳遞的簡單參數值主要是字符串，然而，模板系統可以很是簡潔地處理更加複雜的數據結構，例如list、dictionary和自定義的對象。

在 Django 模板中遍歷複雜數據結構（字符串、列表、字典、類等）的關鍵是句點字符 (.)。

#最好是用幾個例子來講明一下。
# 首先，句點可用於訪問列表索引，例如：

>>> from django.template import Template, Context
>>> t = Template('Item 2 is {{ items.2 }}.')
>>> c = Context({'items': ['apples', 'bananas', 'carrots']})
>>> t.render(c)
'Item 2 is carrots.'

#假設你要向模板傳遞一個 Python 字典。 要經過字典鍵訪問該字典的值，可以使用一個句點：
>>> from django.template import Template, Context
>>> person = {'name': 'Sally', 'age': '43'}
>>> t = Template('{{ person.name }} is {{ person.age }} years old.')
>>> c = Context({'person': person})
>>> t.render(c)
'Sally is 43 years old.'

#一樣，也能夠經過句點來訪問對象的屬性。 比方說， Python 的 datetime.date 對象有
#year 、 month 和 day 幾個屬性，你一樣能夠在模板中使用句點來訪問這些屬性：

>>> from django.template import Template, Context
>>> import datetime
>>> d = datetime.date(1993, 5, 2)
>>> d.year
>>> d.month
>>> d.day
>>> t = Template('The month is {{ date.month }} and the year is {{ date.year }}.')
>>> c = Context({'date': d})
>>> t.render(c)
'The month is 5 and the year is 1993.'

# 這個例子使用了一個自定義的類，演示了經過實例變量加一點(dots)來訪問它的屬性，這個方法適
# 用於任意的對象。
>>> from django.template import Template, Context
>>> class Person(object):
...     def __init__(self, first_name, last_name):
...         self.first_name, self.last_name = first_name, last_name
>>> t = Template('Hello, {{ person.first_name }} {{ person.last_name }}.')
>>> c = Context({'person': Person('John', 'Smith')})
>>> t.render(c)
'Hello, John Smith.'

# 點語法也能夠用來引用對象的方法。 例如，每一個 Python 字符串都有 upper() 和 isdigit()
# 方法，你在模板中可使用一樣的句點語法來調用它們：
>>> from django.template import Template, Context
>>> t = Template('{{ var }} -- {{ var.upper }} -- {{ var.isdigit }}')
>>> t.render(Context({'var': 'hello'}))
'hello -- HELLO -- False'
>>> t.render(Context({'var': '123'}))
'123 -- 123 -- True'

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

View Code

－－－－－－變量的過濾器(filter)的使用

變量過濾器主要是處理後端視圖函數傳遞給模板HTML的字符串

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

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

#實例:

#value1="aBcDe"
{{ value1|upper }}<br>

#value2=5
{{ value2|add:3 }}<br>

#value3='he  llo wo r ld'
{{ value3|cut:' ' }}<br>

#import datetime
#value4=datetime.datetime.now()
{{ value4|date:'Y-m-d' }}<br>

#value5=[]
{{ value5|default:'空的' }}<br>

#value6='<a href="#">跳轉</a>'

{{ value6 }}

{% autoescape off %}
  {{ value6 }}
{% endautoescape %}

{{ value6|safe }}<br>

{{ value6|striptags }}

#value7='1234'
{{ value7|filesizeformat }}<br>
{{ value7|first }}<br>
{{ value7|length }}<br>
{{ value7|slice:":-1" }}<br>

#value8='http://www.baidu.com/?a=1&b=3'
{{ value8|urlencode }}<br>
    value9='hello I am yuan'

語法示例

實例演練：

--------------------------------------------------views
from django.shortcuts import render,HttpResponse
import datetime,time
# Create your views here.

class Animal():
    def __init__(self,nation,color):
        self.nation = nation
        self.color = color


def show_time(request):
    t = datetime.datetime.now()
    str1 = "hel lo wo r ld !"
    # 把變量渲染到html中(缺點：前端後端沒有分開，python雜糅到HTML中 後續維護困難)
    # return HttpResponse("<html><body>it is now %s.</body></html>"%(t))

    list1 = ['成龍','李小龍','甄子丹']
    dict1 = {'name':'李明','sex':'男','age':'25'}
    myClass = Animal("china",'yellow')
    list2 = []
    alink = "<a href='#'>click!</a>"
    str2 = "12a3bc4d"

    myurl = "https://i.cnblogs.com/PostDone.aspx?postid=10488757&actiontip=發佈草稿成功"

    return render(request,"show_time.html",locals())


------------------------------------------------------template/.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>time is: {{ t }}</h1>
    <h1>str1 is: {{ str1 }}</h1>
    <h1>list's list[0] is: {{ list1.0 }}</h1>
    <h1>list's list1[1] is: {{ list1.1 }}</h1>
    <h1>dict's name is: {{ dict1.name }}</h1>
    <h1>dict's age is: {{ dict1.age }}</h1>
    <h1>dict's sex is: {{ dict1.sex }}</h1>
    <h1>從類中取值: {{ myClass.nation }}</h1>
    <h1>從類中取值: {{ myClass.color }}</h1>

{#－－－－－－變量的過濾器(filter)的使用#}
    <h1>李明的真實年齡：{{ dict1.age|add:10}}</h1>
    <h1>字符串的首字母大寫：{{ myClass.nation|capfirst}}</h1>
    <h1>字符串中移除指定的字符--移除空格：{{ str1|cut:" "}}</h1>
    <h1>格式化日期時間：{{ t|date:"Y-m-d H:i:s"}}</h1>      {# 2019-03-08 13:35:32 #}
    <h1>若是值是False,就替換成設置的默認值，不然就是用原本的值：{{ list2|default:"[空列表]" }}</h1>
{#後端發給瀏覽器的HTML格式文本爲了安全起見，默認爲文本 不是以HTML格式渲染的，若想要HTML渲染---> obj|safe#}
    <h1>指定瀏覽器以HTML格式渲染,不加safe默認是文本：{{ alink }}</h1>
    <h1>指定瀏覽器以HTML格式渲染：{{ alink|safe }}</h1>
{#與上面的效果相同，都是保證瀏覽器以html格式渲染    #}
    {% autoescape off %}
      {{ alink }}
    {% endautoescape %}

{#對字符串進行操做#}
<h1>字符串二進制大小：{{ str2|filesizeformat }}</h1>
<h1>字符串：{{ str2|first }}</h1>
<h1>字符串長度：{{ str2|length }}</h1>
<h1>字符串切片：{{ str2|slice:":-1" }}</h1>

{# 對url進行urlencode編碼 #}
<h2>urlencode編碼：{{ myurl|urlencode }}</h2>

</body>
</html>

變量的過濾器--演練

啓用安全機制 --將字符串渲染爲html標籤

視圖函數傳遞給模板的是字符串，若是要想瀏覽器將字符串渲染爲html標籤，須要啓用安全機制：　

#方法1
{{str1|safe}}

#方法2
{% autoescape off %}
  {{ value6 }}
{% endautoescape %}

二、標籤(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 %}

View Code

－－－－－－{% for %}的使用

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

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


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

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

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

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


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

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

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

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


#{% empty %}

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

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

View Code

{% if %}和{% for %}的實例練習：

--------------------------------------------views
class Animal():
    def __init__(self,nation,color):
        self.nation = nation
        self.color = color


def show_time(request):
    t = datetime.datetime.now()
    str1 = "hel lo wo r ld !"
    # 把變量渲染到html中(缺點：前端後端沒有分開，python雜糅到HTML中 後續維護困難)
    # return HttpResponse("<html><body>it is now %s.</body></html>"%(t))

    list1 = ['成龍','愛因斯坦','李白','劉歡']
    dict1 = {'name':'李明','sex':'男','age': 25}
    myClass = Animal("china",'yellow')
    list2 = []
    list3 = ['actor','scientist','poem','singer']
    alink = "<a href='#'>click!</a>"
    str2 = "12a3bc4d"

    myurl = "https://i.cnblogs.com/PostDone.aspx?postid=10488757&actiontip=發佈草稿成功"

    return render(request,"show_time.html",locals())

---------------------------------------------template/.html
{#標籤(tag)的使用（使用大括號和百分比的組合來表示使用tag）#}
{% if dict1.age > 20 %}
    {% if dict1.age < 40  %}
        <p>{{ dict1.name }}的年齡爲20~40</p>
    {% elif dict1.age < 60 %}
        <p>李明的年齡爲40~60</p>
    {% else %}
        <p>李明的年齡大於60歲</p>
    {% endif %}
{% elif dict1.age > 10 %}
    <p>李明的年齡爲10~20</p>
{% else %}
    <p>李明的年齡爲{{ dict1.age }}</p>
{% endif %}

{#{% for %}的使用#}
{% for f1 in list1 %}
    <table><tr>{{ f1 }}
    {% for f3 in list3 %}
        <td>{{ f3 }} <span>|</span></td>
    {% endfor %}
    </tr></table>
    
{% endfor %}

{# forloop.counter表示循環的次數，它從1開始計數，第一次循環設爲1:#}
{% for item in list1 %}
    <p>{{ forloop.counter }}:{{ item }}</p>
    <p>{{ forloop.revcounter0 }}:{{ item }}</p>
    <hr/>
{% endfor %}

{#{% empty %}#}
{% for item in list2 %}
    <h2>{{ forloop.counter0 }}:{{ item }}</h2>
{% empty %}
    <h3>這個列表是空的！</h3>
{% endfor %}

View Code

－－－－－－{%csrf_token%}：csrf_token標籤

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

其實，這裏是會生成一個input標籤，和其餘表單標籤一塊兒提交給後臺的。

－－－－－－{% url %}: 引用路由配置的地址或別名

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

View Code

－－－－－－{% with %}:用更簡單的變量名替代複雜的變量名

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

－－－－－－{% verbatim %}: 禁止render，渲染出來的內容就是 {{ hello }}

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

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

三、自定義filter和simple_tag（重要！！！）

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

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

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

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


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


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


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

View Code

－－－－－－c、在使用自定義simple_tag和filter的html文件中導入以前建立的 my_tags.py ：{% load my_tags %}

－－－－－－d、使用simple_tag和filter（如何調用）

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

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

# 只能傳一個參數，注意參數能夠是列表
@register.filter
def filter_multi(v1,v2):
    return  v1 * v2

# 能夠傳多個參數，可是不能用在if for等控制語句中
@register.simple_tag
def simple_tag_multi(v1,v2,v3):
    return  v1 * v2*v3

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

View Code

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

自定義filter和自定義標籤各有優缺點：

一、自定義filter 只能傳一個參數，而自定義標籤能夠傳多個參數

二、filter能夠用在if 等控制語句後，simple_tag不能夠

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

四、extend模板繼承

－－－－－－include (將多個html中共用的部分提取出來)

主模板　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　include引入的模板

--->下圖是瀏覽器輸入url 後臺對應的執行過程:

－－－－－－extend 模板繼承

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

<1>若是在模板中使用 {% extends %} ，必須保證其爲模板中的第一個模板標記。 不然，模板繼承將不起做用。

 <2>通常來講，基礎模板中的 {% block %} 標籤越多越好。 記住，子模板沒必要定義父模板中全部的代碼塊，所以
    你能夠用合理的缺省值對一些代碼塊進行填充，而後只對子模板所需的代碼塊進行（重）定義。 俗話說，鉤子越
    多越好。

 <3>若是發覺本身在多個模板之間拷貝代碼，你應該考慮將該代碼段放置到父模板的某個 {% block %} 中。
    若是你須要訪問父模板中的塊的內容，使用 {{ block.super }}這個標籤吧，這一個魔法變量將會表現出父模
    板中的內容。 若是隻想在上級代碼塊基礎上添加內容，而不是所有重載，該變量就顯得很是有用了。

 <4>不容許在同一個模板中定義多個同名的 {% block %} 。 存在這樣的限制是由於block 標籤的工做方式是雙向的。
    也就是說，block 標籤不只挖了一個要填的坑，也定義了在父模板中這個坑所填充的內容。若是模板中出現了兩個
    相同名稱的 {% block %} 標籤，父模板將無從得知要使用哪一個塊的內容。

View Code

實例練習：

代碼：

-----------------------------------------------------urls
from django.contrib import admin
from django.conf.urls import url
from app01 import views

urlpatterns = [
    url('admin/', admin.site.urls),
    url('base/', views.backend),
    url('student/', views.student),
    url('teacher/', views.teacher),
    url('course/', views.course),
    url('classes/', views.classes),
]

------------------------------------------------------views
from django.shortcuts import render

# Create your views here.
def backend(request):
    return render(request,"base.html")

def student(request):
    student_list = ['唐僧','悟空','悟能','悟淨']

    return render(request,"student.html",locals())

def teacher(request):
    teachers_list = ['如來','觀音','彌勒','菩提']
    return render(request,"teacher.html",locals())

def course(request):
    course_list = ['語文','數學','英語','科學']
    return render(request,"course.html",locals())

def classes(request):
    classes_list = ['三年一班','四年二班','五年三班','六年一班']
    return render(request,"classes.html",locals())

--------------------------------------------------------template/.html
--------------------------------------base.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>首頁</title>
    <style>
        *{margin: 0;
        padding: 0;
        }
        a{text-decoration: none}
        .head-box{
            width: 100%;
            height: 80px;
            background-color: cadetblue;
            font-size: 26px;
            font-weight: 700;
            text-align: center;
            line-height: 80px;
        }
        .left-box{
            display: inline-block;
            float: left;
            width: 25%;
            min-height: 800px;
            background-color: darkgray;
        }
        .left-box div{
            width: 100%;
            height: 100px;
            text-align: center;
            line-height: 80px;
            font-size: 30px;
            font-weight: 500;
            {#border: 1px solid darkred;#}
        }
        .content-box{
            display: inline-block;
            float: right;
            width: 75%;
            min-height: 800px;
            font-size: 50px;
            font-weight: 700;
            color: darkred;
            text-align: center;

        }
        .footer-box{
            float: left;
            width: 100%;
            height: 120px;
            text-align: center;
            line-height: 120px;
            background-color: lightgreen;
        }
    </style>
</head>
<body>
<div class="outer">
    <div class="head-box">校務信息管理系統</div>
    <div class="left-box">
        <div class="student manage"><a href="/student/">學生信息</a></div>
        <hr>
        <div class="teacher manage"><a href="/teacher/">老師信息</a></div>
        <hr>
        <div class="course manage"><a href="/course/">課程信息</a></div>
        <hr>
        <div class="classes manage"><a href="/classes">班級信息</a></div>
    </div>
    <div class="content-box">

        {% block content %}  {# 塊隨便取個名字 但必須惟一 #}
            <h5>歡迎來到校務管理系統首頁！</h5>
        {% endblock %}

    </div>
    <div class="footer-box">底部欄</div>
</div>
</body>
</html>

------------------------------------------student.html
{% extends "base.html" %}

{% block content %}
    {% for item in student_list %}
        <h5>學生：{{ item }}</h5>
    {% endfor %}
{% endblock %}

-------------------------------------------teacher.html
{% extends "base.html" %}

{% block content %}
    {% for item in teachers_list %}
        <h5>教師：{{ item }}</h5>
    {% endfor %}
{% endblock %}

-------------------------------------------course.html
{% extends "base.html" %}

{% block content %}
    {% for item in course_list %}
        <h5>課程：{{ item }}</h5>
    {% endfor %}
{% endblock %}

------------------------------------------classes.html
{% extends "base.html" %}

{% block content %}
    {% for item in classes_list %}
        <h5>班級：{{ item }}</h5>
    {% endfor %}
{% endblock %}

View Code

　　　　　　　　8、Models -- 操做數據庫

數據庫的配置

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裏有以下設置：

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

在settings.py中修改DATABASE配置

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

Django鏈接MySQL出錯

錯誤一：No module named 'MySQLdb'

錯誤二：django.core.exceptions.ImproperlyConfigured: mysqlclient 1.3.13 or newer is required; you have 0.9.3.

Django鏈接MySQL出錯
錯誤一：No module named 'MySQLdb'

緣由：python3鏈接MySQL不能再使用mysqldb，取而代之的是pymysql。

解決方法：在python的MySQL包中，即路徑：C:\Users\adong\AppData\Local\Programs\Python\Python36\Lib\site-packages\Django-2.0.3-py3.6.egg\django\db\backends\mysql

下的__init__.py文件中加入：

import pymysql

pymysql.install_as_MySQLdb()

 
錯誤二：django.core.exceptions.ImproperlyConfigured: mysqlclient 1.3.3 or newer is required; you have 0.7.11.None

緣由：在解決了錯誤一之後出現了此錯誤。

解決方法：在python的MySQL包中，即路徑：C:\Users\Administrator\AppData\Local\Programs\Python\Python36\Lib\site-packages\Django-2.2.4-py3.6.egg\django\db\backends\mysql

下的 base.py 文件中，註釋掉一下兩行代碼：

if version < (1, 3, 3):
     raise ImproperlyConfigured("mysqlclient 1.3.3 or newer is required; you have %s" % Database.__version__)

View Code

　　　　　　8、ORM--------------Object Relation Mapping(對象關係映射)

用於實現面向對象編程語言裏不一樣類型系統的數據之間的轉換，換言之，就是用面向對象的方式去操做數據庫的建立表以及增刪改查等操做。

---對象指的就是python中的類對象

優勢：一、 ORM使得咱們的通用數據庫交互變得簡單易行，並且徹底不用考慮該死的SQL語句。快速開發，由此而來。

二、能夠避免一些新手程序猿寫sql語句帶來的性能問題。

　　　 3 、便於搬家遷移，換數據庫以後 ORM調用的語法類似換個sql接口就能夠了

好比咱們查詢User表中的全部字段:

新手可能會用select ＊ from auth_user,這樣會由於多了一個匹配動做而影響效率的。

缺點：一、性能有所犧牲，不過如今的各類ORM框架都在嘗試各類方法，好比緩存，延遲加載登來減輕這個問題。效果很顯著。

二、對於個別複雜查詢，ORM仍然力不從心，爲了解決這個問題，ORM通常也支持寫raw sql。

三、經過QuerySet的query屬性查詢對應操做的sql語句

author_obj=models.Author.objects.filter(id=2)
print(author_obj.query)

下面要開始學習Django ORM語法了，爲了更好的理解，咱們來作一個基本的書籍/做者/出版商數據庫結構。咱們這樣作是由於這是一個衆所周知的例子，不少SQL有關的書籍也經常使用這個舉例。

數據庫表的建立：

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

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

做者詳細模型：把做者的詳情放到詳情表，包含性別，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：記得在settings裏的INSTALLED_APPS中加入'app01',而後再同步數據庫。

注意2: models.ForeignKey("Publish") & models.ForeignKey(Publish)

注意3：（注意要將外鍵寫在‘多’的一方）。Django支持通用的數據關係：一對一，多對一和多對多。

分析代碼：

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

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

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

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

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

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

<4> 模型經常使用的字段類型參數

<1> CharField
        #字符串字段, 用於較短的字符串.
        #CharField 要求必須有一個參數 maxlength, 用於從數據庫層和Django校驗層限制該字段所容許的最大字符數.

<2> IntegerField
       #用於保存一個整數.

<3> FloatField
        # 一個浮點數. 必須 提供兩個參數:
        #
        # 參數    描述
        # max_digits    總位數(不包括小數點和符號)
        # decimal_places    小數位數
                # 舉例來講, 要保存最大值爲 999 (小數點後保存2位),你要這樣定義字段:
                #
                # models.FloatField(..., max_digits=5, decimal_places=2)
                # 要保存最大值一百萬(小數點後保存10位)的話,你要這樣定義:
                #
                # models.FloatField(..., max_digits=19, decimal_places=10)
                # admin 用一個文本框(<input type="text">)表示該字段保存的數據.

<4> AutoField
        # 一個 IntegerField, 添加記錄時它會自動增加. 你一般不須要直接使用這個字段; 
        # 自定義一個主鍵：my_id=models.AutoField(primary_key=True)
        # 若是你不指定主鍵的話,系統會自動添加一個主鍵字段到你的 model.

<5> BooleanField
        # A true/false field. admin 用 checkbox 來表示此類字段.

<6> TextField
        # 一個容量很大的文本字段.
        # admin 用一個 <textarea> (文本區域)表示該字段數據.(一個多行編輯框).

<7> EmailField
        # 一個帶有檢查Email合法性的 CharField,不接受 maxlength 參數.

<8> DateField
        # 一個日期字段. 共有下列額外的可選參數:
        # Argument    描述
        # auto_now    當對象被保存時,自動將該字段的值設置爲當前時間.一般用於表示 "last-modified" 時間戳.
        # auto_now_add    當對象首次被建立時,自動將該字段的值設置爲當前時間.一般用於表示對象建立時間.
        #（僅僅在admin中有意義...)

<9> DateTimeField
        #  一個日期時間字段. 相似 DateField 支持一樣的附加選項.

<10> ImageField
        # 相似 FileField, 不過要校驗上傳對象是不是一個合法圖片.#它有兩個可選參數:height_field和width_field,
        # 若是提供這兩個參數,則圖片將按提供的高度和寬度規格保存.     
<11> FileField
     # 一個文件上傳字段.
     #要求一個必須有的參數: upload_to, 一個用於保存上載文件的本地文件系統路徑. 這個路徑必須包含 strftime #formatting, 
     #該格式將被上載文件的 date/time 
     #替換(so that uploaded files don't fill up the given directory).
     # admin 用一個<input type="file">部件表示該字段保存的數據(一個文件上傳部件) .

     #注意：在一個 model 中使用 FileField 或 ImageField 須要如下步驟:
            #（1）在你的 settings 文件中, 定義一個完整路徑給 MEDIA_ROOT 以便讓 Django在此處保存上傳文件. 
            # (出於性能考慮,這些文件並不保存到數據庫.) 定義MEDIA_URL 做爲該目錄的公共 URL. 要確保該目錄對 
            #  WEB服務器用戶賬號是可寫的.
            #（2） 在你的 model 中添加 FileField 或 ImageField, 並確保定義了 upload_to 選項,以告訴 Django
            # 使用 MEDIA_ROOT 的哪一個子目錄保存上傳文件.你的數據庫中要保存的只是文件的路徑(相對於 MEDIA_ROOT). 
            # 出於習慣你必定很想使用 Django 提供的 get_<#fieldname>_url 函數.舉例來講,若是你的 ImageField 
            # 叫做 mug_shot, 你就能夠在模板中以 {{ object.#get_mug_shot_url }} 這樣的方式獲得圖像的絕對路徑.

<12> URLField
      # 用於保存 URL. 若 verify_exists 參數爲 True (默認), 給定的 URL 會預先檢查是否存在( 即URL是否被有效裝入且
      # 沒有返回404響應).
      # admin 用一個 <input type="text"> 文本框表示該字段保存的數據(一個單行編輯框)

<13> NullBooleanField
       # 相似 BooleanField, 不過容許 NULL 做爲其中一個選項. 推薦使用這個字段而不要用 BooleanField 加 null=True 選項
       # admin 用一個選擇框 <select> (三個可選擇的值: "Unknown", "Yes" 和 "No" ) 來表示這種字段數據.

<14> SlugField
       # "Slug" 是一個報紙術語. slug 是某個東西的小小標記(短籤), 只包含字母,數字,下劃線和連字符.#它們一般用於URLs
       # 若你使用 Django 開發版本,你能夠指定 maxlength. 若 maxlength 未指定, Django 會使用默認長度: 50.  #在
       # 之前的 Django 版本,沒有任何辦法改變50 這個長度.
       # 這暗示了 db_index=True.
       # 它接受一個額外的參數: prepopulate_from, which is a list of fields from which to auto-#populate 
       # the slug, via JavaScript,in the object's admin form: models.SlugField
       # (prepopulate_from=("pre_name", "name"))prepopulate_from 不接受 DateTimeFields.

<13> XMLField
        #一個校驗值是否爲合法XML的 TextField,必須提供參數: schema_path, 它是一個用來校驗文本的 RelaxNG schema #的文件系統路徑.

<14> FilePathField
        # 可選項目爲某個特定目錄下的文件名. 支持三個特殊的參數, 其中第一個是必須提供的.
        # 參數    描述
        # path    必需參數. 一個目錄的絕對文件系統路徑. FilePathField 據此獲得可選項目. 
        # Example: "/home/images".
        # match    可選參數. 一個正則表達式, 做爲一個字符串, FilePathField 將使用它過濾文件名.  
        # 注意這個正則表達式只會應用到 base filename 而不是
        # 路徑全名. Example: "foo.*\.txt^", 將匹配文件 foo23.txt 卻不匹配 bar.txt 或 foo23.gif.
        # recursive可選參數.要麼 True 要麼 False. 默認值是 False. 是否包括 path 下面的所有子目錄.
        # 這三個參數能夠同時使用.
        # match 僅應用於 base filename, 而不是路徑全名. 那麼,這個例子:
        # FilePathField(path="/home/images", match="foo.*", recursive=True)
        # ...會匹配 /home/images/foo.gif 而不匹配 /home/images/foo/bar.gif

<15> IPAddressField
        # 一個字符串形式的 IP 地址, (i.e. "24.124.1.30").
<16># CommaSeparatedIntegerField
        # 用於存放逗號分隔的整數值. 相似 CharField, 必需要有maxlength參數.

View Code

　　<5> Field重要參數

<1> null ： 數據庫中字段是否能夠爲空

    <2> blank： django的 Admin 中添加數據時是否可容許空值

    <3> default：設定缺省值

    <4> editable：若是爲假，admin模式下將不能改寫。缺省爲真

    <5> primary_key：設置主鍵，若是沒有設置django建立表時會自動加上：
        id = meta.AutoField('ID', primary_key=True)
        primary_key=True implies blank=False, null=False and unique=True. Only one
        primary key is allowed on an object.

    <6> unique：數據惟一

    <7> verbose_name　　Admin中字段的顯示名稱

    <8> validator_list：有效性檢查。非有效產生 django.core.validators.ValidationError 錯誤


    <9> db_column，db_index 若是爲真將爲此字段建立索引

    <10>choices：一個用來選擇值的2維元組。第一個值是實際存儲的值，第二個用來方便進行選擇。
                如SEX_CHOICES= (( ‘F’,'Female’),(‘M’,'Male’),)
                gender = models.CharField(max_length=2,choices = SEX_CHOICES)

View Code

注意3：在models.py中添加的類就至關於操做sql命令中建立的表，添加以後要在terminal控制檯中進行下列操做生成表

第一步：

python manage.py makemigrations

class Book(models.Model):
    name = models.CharField(max_length=30)
    price = models.IntegerField()
    pub_date = models.DateField()
    author = models.CharField(max_length=50,null=False)     #默認null=True 便可覺得空

View Code

當在models.py 中的類對象裏設置 null=False ，會出現下列問題：（須要選擇1 再設置一個

author = models.CharField(max_length=50,null=False)

爲空時的默認值便可）

D:\360Downloads\Python編程\老男孩python全棧\day49+50-Django\Django_begin_ORM>>>python manage.py makemigrations
(0.001) SELECT @@SQL_AUTO_IS_NULL; args=None
(0.001) SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED; args=None
(0.003) SHOW FULL TABLES; args=None
(0.001) SELECT `django_migrations`.`app`, `django_migrations`.`name` FROM `django_migrations`; args=()
You are trying to add a non-nullable field 'author' to book without a default; we can't do that (the database need
s something to populate existing rows).
Please select a fix:
 1) Provide a one-off default now (will be set on all existing rows with a null value for this column)
 2) Quit, and let me add a default in models.py
Select an option: 1
Please enter the default value now, as valid Python
The datetime and django.utils.timezone modules are available, so you can do e.g. timezone.now
Type 'exit' to exit this prompt
>>> "xiong"
Migrations for 'app01':
  app01\migrations\0003_book_author.py
    - Add field author to book

View Code

表的操做(增刪改查)：

-------------------------------------增(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):
    #方式一: 因爲綁定一對多的字段,好比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=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",on_delete=models.CASCADE)
    Book=  models.ForeignKey("Book",on_delete=models.CASCADE)
   
#那麼就還有一種方式:
    author_obj=models.Author.objects.filter(id=2)[0]
    book_obj  =models.Book.objects.filter(id=3)[0]

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

-----------------------------------------刪（delete） ---------------------------------------------

def delete(request):
    Book.objects.filter(author="alex").delete() return HttpResponse("刪除書籍成功！")

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

若是是多對多的關係： remove()和clear()方法：

#正向
book = models.Book.objects.filter(id=1)[0]

#刪除第三張表中和女孩1關聯的全部關聯信息
book.author.clear()            #清空與book中id=1 關聯的全部數據
book.author.remove(2)      #能夠爲id,author_id=2 被刪
book.author.remove(*[1,2,3,4])     #能夠爲列表,前面加*

#反向
author = models.Author.objects.filter(id=1)[0]
author.book_set.clear()     #清空與boy中id=1 關聯的全部數據

-----------------------------------------改（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

在這個例子裏咱們能夠看到Django的save()方法更新了不只僅是title列的值，還有更新了全部的列。若title之外的列有可能會被其餘的進程所改動的狀況下，只更改title列顯然是更加明智的。更改某一指定的列，咱們能夠調用結果集（QuerySet）對象的update()方法,與之等同的SQL語句變得更高效，而且不會引發競態條件。

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

注意：這裏由於update返回的是一個整形，因此無法用query屬性；

注意：若是是多對多的改：

obj=Book.objects.filter(id=1)[0]
    author=Author.objects.filter(id__gt=2)

    obj.author.clear()
    obj.author.add(*author)

View Code

---------------------------------------查（filter，values等) -------------------------------------重要！！！

---------->查詢API：

# 查詢相關API：

##  <1>filter(**kwargs):      它包含了與所給篩選條件相匹配的對象（返回一個可迭代對象）

##  <2>all():                 查詢全部結果（返回一個可迭代對象）

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

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

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

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

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

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

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

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

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

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

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

View Code

實例練習：

-------------------------------------models.py
# Create your models here.
class Book(models.Model):
    name = models.CharField(max_length=30)
    price = models.IntegerField(null=True)
    pub_date = models.DateField(null=True)
    author = models.CharField(max_length=50,null=False)     #默認null=False 即不能夠爲空

    # 加了默認的方法以後，打印出來的是name 而不是對象方法
    def __str__(self):
        return self.name

------------------------------------.html
<div class="bookInfo">
        {% for book in book_list %}
            <h4>書名：{{ book.name }} <span>|</span>
            做者：{{ book.author }} <span>|</span>
            價格：{{ book.price }} <span>|</span>
            </h4>
        {% endfor %}

    </div>

---------------------------------------views
def queryBook(request):
    #  <1>filter(**kwargs):      它包含了與所給篩選條件相匹配的對象(返回一個可迭代對象)
    book_list = Book.objects.filter(author='xiong')
    #  <2>all():                 查詢全部結果
    book_list = Book.objects.all()
    ## <3>get(**kwargs):         返回與所給篩選條件相匹配的對象，返回結果有且只有一個，若是符合篩選條件的對象超過一個或者沒有都會拋出錯誤。
    one_book = Book.objects.get(name='PHP')
    print("get方法返回結果：",one_book)
    first_book = Book.objects.first()
    last_book = Book.objects.last()
    print("first方法返回結果：", first_book)
    print("last方法返回結果：", last_book)

    ##  <4>values(*field):  返回一個ValueQuerySet——一個特殊的QuerySet，運行後獲得的並非一系列 model的實例化對象，而是一個可迭代的字典序列
    book_list = Book.objects.all()[:3].values("name","author")
    book_list = Book.objects.all()[::2]     #切片：梯度爲2
# < 9 > values_list(*field): 它與values() 很是類似，它返回的是一個元組序列，values返回的是一個字典序列
    book_list = Book.objects.filter(author='xiong')[:3].values_list("name","author")
    book_list = Book.objects.exclude(author='xiong')[:3].values_list("name","author")

#  <8>distinct():            從返回結果中剔除重複紀錄
    book_list = Book.objects.all().values("author").distinct()  #按照author去重,並顯示name price

#  <10>count():     返回數據庫中匹配查詢(QuerySet)的對象數量。
    book_count = Book.objects.all().values("author").distinct().count()
    print("按照做者去重以後書籍數量爲：",book_count)


    return render(request,"index.html",{"book_list":book_list})

View Code

補充：

#擴展查詢,有時候DJANGO的查詢API不能方便的設置查詢條件，提供了另外的擴展查詢方法extra:
#extra(select=None, where=None, params=None, tables=None,order_by=None, select_params=None

(1)  Entry.objects.extra(select={'is_recent': "pub_date > '2006-01-01'"})
(2)  Blog.objects.extra(
        select=SortedDict([('a', '%s'), ('b', '%s')]),
        select_params=('one', 'two'))

(3)  q = Entry.objects.extra(select={'is_recent': "pub_date > '2006-01-01'"})
     q = q.extra(order_by = ['-is_recent'])

(4)  Entry.objects.extra(where=['headline=%s'], params=['Lennon'])

View Code

---------->QuerySet對象惰性機制：

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

<QuerySet [{'name': 'php', 'price': 75.0}, {'name': 'c++', 'price': 36.0}]>

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

View Code

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

下面的一些狀況，QuerySet纔去查詢數據庫：

1.迭代操做
2.切片操做
3.repr()方法
    repr() 函數將對象轉化爲供解釋器讀取的形式。
4.len()方法
5.list()方法
6.bool(),or,and,if
如 if Book.objects.filter(id=1):

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

#--------------------對象形式的查找--------------------------
    # 正向查找
    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
    #一對多和多對多在這裏用法沒區別

View Code

單表模糊查詢之雙下劃線 __ 實例練習：

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

#    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,

模糊查詢-雙下劃線(__)

【對象查詢】多表關聯查詢--一對多實例練習：（注意：一對多的狀況下外鍵通常都建在多的一方。好比部門-->員工一個部門對應多個員工外鍵建在員工一方）

參考：https://www.cnblogs.com/aaronthon/p/9520832.html
https://www.jianshu.com/p/b0895eb45885

---------------------------------------------------------views.py
def addbook(request):
    # 添加數據庫記錄
    # 方式一
    Book.objects.create(name="linux運維",price=89,pub_date='2017-4-5',publish_id=2)
    # 方式二：
    publish_obj = Publish.objects.filter(name="圖靈出版社")[0]
    Book.objects.create(name="java開發",price=59,pub_date='2017-4-5',publish=publish_obj)

    # 多表操做：一對多查詢記錄
    # 正向查詢
    pub_obj = Publish.objects.get(name='人民出版社')
    ret = Book.objects.filter(publish=pub_obj).values('name','price')
    print(ret)

    #反向查詢
    pub_obj = Publish.objects.filter(name='人民出版社')[0]
    # pub_obj.book_set.all() 與 pub_obj關聯的book表集合 的左右對象，再取出values('name','price')
    print(pub_obj.book_set.all().values('name','price'))

    return HttpResponse("添加書籍成功！")

一對多-關聯查詢

【雙下劃線查詢】多表關聯查詢

-------------------------------------------------------views.py
    # # 【雙下劃線查詢】多表操做：一對多查詢記錄
    # 查：人民出版社出過的全部書 ---找書
    ret = Book.objects.filter(publish__name='人民出版社').values('name','price')
    # print(ret)
    # 查：出版 php入門 的出版社的信息 ---找出版社
    ret = Publish.objects.filter(book__name='php入門').values('name','city')
    # print(ret)
    # 查：city是北京的出版社出過的全部書 --->找書
    ret = Book.objects.filter(publish__city='香港').values('name')
    # print(ret)

    # 總結：找什麼就用什麼類在前面去過濾 即： ***.objects.filter()
    # 練習--查：2017年上半年（2017-01-01至2017-07-01）出版的書以及出版社信息
    ret = Book.objects.filter(pub_date__gt='2017-01-01',pub_date__lt='2017-07-01').values('name','publish__name')
    print(ret)
    return HttpResponse("添加書籍成功！")

View Code

多表操做--->多對多查詢

-------------------------------------------------------views.py
    # 多對多查詢，方式一：經過manytomany 添加第三張表
    # 查：python這本書的做者信息
    # 正向查
    # ret = Book.objects.filter(name='python').values('authors__age','authors__name')
    # print(ret)

    # 給c語言這本書(id=6) 添加Author中的全部做者
    # book_obj = Book.objects.get(name='c語言')
    # author_objs = Author.objects.all()
    # book_obj.authors.add(*author_objs)  # authors 是對象，*author_objs（author_objs是querySet集合對象要在前面加一個*）
    # 將c語言這本書(id=6) 移除掉Author中的做者
    # book_obj.authors.remove(*author_objs)   #移除掉全部做者
    # book_obj.authors.remove(2)   #移除掉author_id=2 的做者

    # 方式二：自定義一個第三方表
    # 給第三方表添加信息
    # book_author_obj = Book_Author.objects.create(book_id=1,author_id=2)
    # book_obj = Book.objects.get(id=1)
    # print(book_obj.book_author_set.all()[0])

    # 練習 - -查：xiong 出過的書 名稱和價格
    ret = Book.objects.filter(book_author__author__name='xiong').values('name','price')
    print(ret)

View Code

注意：條件查詢即與對象查詢對應，是指在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

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

注意：

Django在根據models生成數據庫表時報 init() missing 1 required positional argument: 'on_delete'

-----------------------------------------------models.py
#encoding=utf-8
from django.db import models
# Create your models here.
class BookInfo(models.Model):   #建立書本信息類，繼承models.Model
    booktitle=models.CharField(max_length=20)
    bookdata=models.DateField()
class HeroInfo(models.Model):   #建立英雄信息類
    heroname=models.CharField(max_length=10)
    herosex=models.BooleanField()
    herocontent=models.CharField(max_length=50)
    herobook=models.ForeignKey('BookInfo')   #引用外鍵，即BookInfo對象

------------------------------------------------terminal 錯誤
TypeError: __init__() missing 1 required positional argument: 'on_delete'

------------------------------------------------解決辦法
解決辦法：

將 引用外鍵 models.ForeignKey()代碼改成：

herobook=models.ForeignKey('BookInfo',on_delete=models.CASCADE,)
即在外鍵值的後面加上 on_delete=models.CASCADE

緣由：

在django2.0後，定義外鍵和一對一關係的時候須要加on_delete選項，此參數爲了不兩個表裏的數據不一致問題，否則會報錯：
TypeError: __init__() missing 1 required positional argument: 'on_delete'
舉例說明：
user=models.OneToOneField(User)
owner=models.ForeignKey(UserProfile)
須要改爲：
user=models.OneToOneField(User,on_delete=models.CASCADE) --在老版本這個參數（models.CASCADE）是默認值
owner=models.ForeignKey(UserProfile,on_delete=models.CASCADE) --在老版本這個參數（models.CASCADE）是默認值
參數說明：
on_delete有CASCADE、PROTECT、SET_NULL、SET_DEFAULT、SET()五個可選擇的值
CASCADE：此值設置，是級聯刪除。
PROTECT：此值設置，是會報完整性錯誤。
SET_NULL：此值設置，會把外鍵設置爲null，前提是容許爲null。
SET_DEFAULT：此值設置，會把設置爲外鍵的默認值。
SET()：此值設置，會調用外面的值，能夠是一個函數。
通常狀況下使用CASCADE就能夠了。

解決辦法

---------->F查詢和Q查詢

在filter() 中實現過濾條件的與或非：

# 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.get(
        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.get(
        Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),
        title__startswith='P')
    # 錯誤：
    Book.objects.get(
        question__startswith='P',
        Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))

View Code

raw SQL語句

django中models的操做, 是調用了ORM框架來實現的 pymysql 或者mysqldb。因此咱們也可使用原生的SQL語句來操做數據庫！

　　　　　　　　9、admin ---數據庫可視化管理

參考：http://www.runoob.com/django/django-admin-manage-tool.html

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

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

LANGUAGE_CODE = 'en-us'      #默認英文
#LANGUAGE_CODE = 'zh-hans'    #修改成中文

1、認識ModelAdmin

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

建立超級用戶：

能夠經過cmd命令行: python manage.py createsuperuser 來建立超級用戶，以下所示：

# python manage.py createsuperuser

Username (leave blank to use 'root'): admin
Email address: admin@runoob.com    #能夠不填
Password:    
Password (again):

Superuser created successfully.
[root@solar HelloWorld]#

View Code

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

　　<1> 使用register的方法

admin.site.register(Book,MyAdmin)

　　<2> 使用register的裝飾器

@admin.register(Book)

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

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",)    #按照price 升序排列
#ordering = ("-price","id")    #按照price 降序排列,price相同再按照id排序
    fieldsets =[
        (None,               {'fields': ['title']}),
        ('price information', {'fields': ['price',"publisher"], 'classes': ['collapse']}),
    ]

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