Django框架學習筆記

django框架

MVC框架

簡介

MVC的產生理念：分工。讓專門的人去做專門的事。
MVC的核心思想：解耦
M：model模型，和數據庫進行交互
V：view視圖，產生HTML頁面
C：controller控制器，接收請求，進行處理，與M，V進行交互，返回應答

Django的MVT框架

本質上還是MVC的思想
M：model模型，和MVC中M功能相同，和數據庫進行交互
V：View視圖，和MVC中C功能相同，接收請求，進行處理，與M和T進行交互，返回應答
T：template模板，和MVC中V功能相同，產生HTML頁面

虛擬環境

pip install virtualenv  #安裝虛擬環境
pip install virtualenvwrapper #安裝虛擬環境擴展包
vim .bashrc  #添加以下兩行
export WORKON_HOME=$HOME/.vitualenvs
source /usr/bin/virtualenvwrapper.sh
使用source .bashrc使其生效
創建python3虛擬環境
mkvirtualenv -p python3 虛擬環境名
workon 虛擬環境名   #進入虛擬環境
deactivate #退出虛擬環境

項目創建

命令：django-admin startproject myobj

項目下各文件說明

init:說明myobj是一個python包
settings.py:項目的配置文件
urls.py:進行url路由的配置
wsgi.py:web服務器和Django交互的入口
manage.py:項目的管理文件

應用創建

命令：python manage.py startapp appname

應用下生成的文件說明

init .py:說明目錄是一個Python模塊
models.py:寫和數據庫項目的內容
views.py:接收請求，進行處理，與M和T進行交互，返回應答。定義處理函數，視圖函數
test.py:寫測試代碼文件
admin.py:網站后臺管理相關的文件

建立應用和項目之間的聯系，需要對應用進行注冊

修改settings.py的INSTALLED_APPS的內容，添加應用名字

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'test1',
]

運行一個應用

python manage.py runserver
訪問127.0.0.1:8000可以查看創建的應用

后臺管理

本地化

語言和時區的本地化

修改settings.py文件

LANGUAGE_CODE = 'zh-hans'  #使用中文
TIME_ZONE = 'Asia/Shanghai' #中國時區

創建管理員

命令：python manage.py createsuperuser
登錄后臺
瀏覽器輸入"127.0.0.1/admin"進入后臺管理頁面

注冊模型類

在應用下的admin.py下注冊模型類
告訴Django框架根據注冊的模型來生成對應表管理頁面
b=Bookinfo()
str(b)

列表頁選項

頁大小

• 每頁中顯示多少條數據，默認為每頁顯示100條數據，屬性如下：
  list_per_page=100
  打開booktest/admin.py文件，修改AreaAdmin類如下：

  class AreaInfoAdmin(admin.ModelAdmin):
  '''地區模型管理類'''
  list_per_page=10 #指定每頁顯示10條數據

  操作選項的位置

  頂部顯示的屬性，設置為True在頂部顯示，設置為False不在頂部顯示，默認為True
  actions_on_top=True
  底部顯示的屬性，設置為True在底部顯示，設置為False不在底部顯示，默認為False
  actions_on_bottom=False

  列表中的列

  屬性如下：
  list_display=[模型字段1,模型字段2,...]
  方法列是不能排序的，如果需要排序需要為方法指定排序依據
  admin_order_field=模型類字段
  打開booktest/models.py文件，修改AreaInfo類如下：

  class AreaInfo(models.Model):
  ...
  def title(self):
      return self.atitle
  title.admin_order_field='atitle'

  列標題

  列標題默認為屬性或方法的名稱，可以通過屬性設置。需要先將模型字段封裝成方法，再對方法使用這個屬性，模型字段不能直接使用這個屬性
  short_description='列標題'
  vim booktest/models.py文件，修改AreaInfo類如下：

  class AreaInfo(models.Model):
  ...
  title.short_description='區域名稱'

  右側欄過濾器

  屬性如下，只能接收字段，會將對應字段的值列出來，用于快速過濾。一般用于有重復值的字段。
  list_filter=[]

  搜索框

  屬性如下，用于對指定字段的值進行搜索，支持模糊查詢。列表類型，表示在這些字段上進行搜索。
  search_fields=[]

  編輯頁選項

  顯示字段順序

  屬性如下：
  fields=[]
  vim booktest/admin.py

  class AreaAdmin(admin.ModelAdmin):
  ...
  fields=['aprent','atitle']

  分組顯示

  屬性如下：

  fieldset=(
  ('組1標題',{'fields':('字段1'，'字段2')}),
  ('組2標題',{'fields':('字段3','字段4')}),
  )

  vim booktest/admin.py文件，修改AreaAdmin類如下：

  class AreaAdmin(admin.ModelAdmin):
  ...
  #fields=['aparent','atitle']
  fieldsets=(
      ('基本',{'fields':['atitle']}),
      ('高級',{'fields':['aparent']})
  )

  關聯對象

  在一對多的關系中，可以在一端的編輯頁面中編輯多端的對象，嵌入多端對象的方式包括表格、塊兩種。類型InlineModelAdmin:表示在模型的編輯頁面嵌入關聯模型的編輯。子類Tabularlnline：以表格的形式嵌入。子類StackedInline：以塊的形式嵌入。
  打開booktest/admin.py文件，創建AreaStackedInline類。

  class AreaStackedInline(admin.StackedInline):
  model=AreaInfo #關聯子對象
  extra=2 #額外編輯2個子對象

  打開booktest/admin.py文件，修改AreaAdmin類如下：

  class AreaAdmin(admin.ModelAdmin):
  ...
  inlines=[AreaStackedInline]

orm框架

Object:對象-類
Mapping:映射，建立類與表的對應關系
Relation:關系，關系數據庫中的表
Django中內嵌了orm框架，orm框架可以通過類和對象操作對應的數據表，不需要寫sql語句

django orm框架的功能

1. 建立模型和表之間的對應關系，允許我們通過面向對象的方式來操作數據庫
2. 根據設計的模型類生成數據庫中的表格。
3. 通過方便的配置就可以進行數據庫的切換

設計類：模型類

創建模型類

#圖書類
class BookInfo(models.Model):
    '''圖書模型類'''
    #圖書名稱，Charfield說明是一個字符串，max_length指定字符串的最大長度
    btitle=models.CharField(max_length=20)
    #出版日期，DateField說明是一個日期類型
    bpub_date=models.DateField()

orm另外一個作用：根據設計的類生成數據庫中的表

模型類生成表

1. 生成遷移文件
   命令：python manage.py makemigrations
   遷移文件是根據模型類生成的
2. 執行遷移生成表
   命令：python manage.py migrate

通過模型類操作數據表

往表中添加數據
python manage.py shell

>>> from test1.models import BookInfo
>>> b=BookInfo()
>>> b.btitle='天龍八部'
>>> from datetime import date
>>> b.bpub_date=date(1990,1,1)
>>> b.save()
>>> BookInfo.objects.get(id=1)
<BookInfo: BookInfo object (1)>
>>> b2=BookInfo.objects.get(id=1)
>>> b2.btitle
'天龍八部'
>>> b2.bpub_date
datetime.date(1990, 1, 1)
>>> b2.id
1
>>> b2.bpub_date=date(2019,1,1)
>>> b2.save()
>>> b3=BookInfo.objects.get(id=1)
>>> b3.bpub_date
datetime.date(2019, 1, 1)
>>> b2.delete()
(1, {'test1.BookInfo': 1})

模型類關系和模型查詢

vim models.py

class HeroInfo(models.Model):
     hname =models.CharField(max_length=20)  #英雄名稱
     #性別，Booleanfield說明是bool類型，default指定默認值，False代表男
     hgender=models.BooleanField(default=False)
     #備注
     hcomment=models.CharField(max_length=128)
     #關系屬性 hbook，建立圖書類和英雄人物類之間的一對多關系
     #關系屬性對應的表的字段名格式：關系屬性名_id
     hbook=models.ForeignKey('BookInfo',on_delete=models.CASCADE,)

生成遷移文件
python3 manage.py makemigrations
執行遷移文件生成表
python3 manage.py migrate
往表中操作數據
python manage.py shell

from test1.models import BookInfo,HeroInfo
b=BookInfo()
b.btitle='天龍八部'
from datetime import date
b.bpub_date=date(1990,1,1)
b.save()
h=HeroInfo()
h.hname='段譽'
h.hgender=False
h.hcomment='六脈神劍'
h.hbook=b
h.save()
h3=HeroInfo()
h3.hname='喬峰'
h3.hcomment='降龍十八掌'
h3.hbook=b
h3.save()
h4=HeroInfo.objects.get(id=2)
h4.hname
'喬峰'
h4.hgender
False
h4.hcomment
'降龍十八掌'
h4.hbook_id
3
h4.hbook.btitle
'天龍八部'

模型類屬性命名限制

1. 不能是python保留的關鍵字
2. 不允許使用連續的下劃線，這是由Django的查詢方式決定的
3. 定義屬性時需要指定字段類型，通過字段類型的參數指定選項，語法如下：
   屬性名=models.字段類型(選項)

   字段類型

   使用時需要引入django.db.models包，字段類型如下：

選項

通過選項實現對字段的約束，選項如下：

MVT綜合案例

vim test1/urls.py

urlpatterns =[
    #通過url函數設置url路由配置項
    url(r'^index$',views.index), # 建立index和視圖之間的關系
    url(r'^index2$',views.index2),
    url(r'^books$',views.show_books), #顯示圖書信息
    url(r'^books/(\d+)$',views.detail), #顯示英雄信息
]

vim views.py

def show_books(request):
    '''顯示圖書的信息'''
    #1.通過M查找圖書表中的數據
    books=BookInfo.objects.all()
    #2.使用模板
    return render(request,'test1/show_books.html',{'books':books})
def detail(request,bid):
    '''查詢圖書關聯英雄信息'''
    #1.根據bid查詢圖書信息
    book=BookInfo.objects.get(id=bid)
    #2.查詢和book關聯的英雄信息
    heros=book.heroinfo_set.all()
    #3.使用模板
    return render(request,'test1/detail.html',{'book':book,'heros':heros})

vim templates/test1/show_books.html

<!DOCTYPE>
<html lang="en">
<head>
        <meta charset="UTF-8">
        <title>顯示圖書信息</title>
</head>
<body>
圖書信息如下：
<ul>
        {% for book in books %}
                <li><a href="/books/{{ book.id }}">{{ book.btitle }}</a></li>
        {% endfor %}
</ul>
</body>
</html>

vim detail.html

<!DOCTYPE html>
<html lang="en">
<head>
        <meta charset="UTF-8">
        <title>顯示圖書關聯的英雄信息</title>
</head>
<body>
<h2>{{ book.btitle }}</h2>
英雄信息如下:<br/>
<ul>
        {% for hero in heros  %}
                <li>{{ hero.hname }}--{{ hero.hcomment }}</li>
        {% empty %}
                <li>沒有英雄信息</li>
        {% endfor %}
</ul>
</body>
</html>

配置使用mysql數據庫

vim settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'booktest',   #注冊應用
]
DATABASES = {
    'default': {
        #'ENGINE': 'django.db.backends.sqlite3',
        #'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'booktest', #使用的數據庫名字
        'USER': 'root',  #mysql用戶名
        'PASSWORD': 'root', #mysql密碼
        'HOST': 'localhost', #mysql主機
        'PORT': 3306,
    }
}

創建數據庫

create database booktest charset=utf8;

安裝pymysql

pip install pymysql

vim __init__.py

ALLOWED_HOSTS = ['60.205.177.168']

后臺管理

1. 本地化
   • 語言和時區的本地化，修改settings.py文件
2. 創建管理員
   • 命令：Python manage.py createsuperuser
3. 注冊模型類
   • 在應用下的admin.py中注冊模型類
   • 告訴Django框架根據注冊的模型類來生成對應表管理頁面

     from test1.models import BookInfo
     # Register your models here.
     #注冊模型類
     admin.site.register(BookInfo)

     vim models.py

     class BookInfo(models.Model):
     '''圖書模型類'''
     btitle=models.CharField(max_length=20)
     #出版日期，DateField說明是一個日期類型
     bpub_date=models.DateField()
     def __str__(self):
     #返回書名
     return self.btitle

4. 自定義管理頁面
   自定義模型管理類。模型管理類就是告訴Django在生成的管理頁面上顯示哪些內容

class BookInfoAdmin(admin.ModelAdmin):
    '''圖書模型管理類'''
    list_display=['id','btitle','bpub_date']

class HeroInfoAdmin(admin.ModelAdmin):
    '''英雄模型人物類'''
    list_display=['id','hname','hcomment']

#注冊模型類
admin.site.register(BookInfo,BookInfoAdmin)
admin.site.register(HeroInfo,HeroInfoAdmin)

視圖

在Django中，通過瀏覽器去請求一個頁面時，使用視圖函數來處理這個請求的，視圖函數處理之后，要給瀏覽器返回頁面內容
返回HTML內容httpresponse，也可能重定向redirect

視圖函數的使用

定義視圖函數

視圖函數定義在views.py中
視圖函數必須有一個參數request，是一個httprequest類型的對象，參數名可以變化，進行處理之后，需要返回一個HttpResponse的類對象，hello,python就是返回給瀏覽器顯示的內容
例：

from django.shortcuts import render
from django.http import HttpResponse
# Create your views here.
#1.定義視圖函數,HttpRequest
#2.進行url配置，建立url地址和視圖的對應關系
#http://127.0.0.1:8000/index
def index(request):
    #進行處理，和M,T進行交互
    return HttpResponse('老鐵沒毛病')
def index2(request):
    return HttpResponse('hello python')

進行url配置

• 所有的url配置項都定義在一個叫做urlpatterns的列表中，每一個元素都是一個配置項
• 每一個配置項都會調用url函數，第一個參數是正則表達式，第二個參數是對應的處理動作，可以寫一個視圖函數的名字
• 和url字符串進行正則匹配，匹配成功則執行其后對應的處理動作
• 對應的動作可以是一個視圖函數的名字，也可以是包含一個應用的urls.py文件

url配置的目的是建立url和視圖函數的對應關系。url配置項定義在urlpatterns的列表中，每一個配置項都調用url函數。
url函數有兩個參數，第一個參數是一個正則表達式，第二個是對應的處理動作。
配置url時，有兩種語法格式：

• url(正則表達式，視圖函數名)
• url(正則表達式，include(應用中的urls文件))
  工作中在配置url時，首先在項目的urls.py文件中添加配置項時，并不寫具體的url和視圖函數之間的對應關系，而是包含具體應用的urls.py文件，在應用的urls.py文件中寫url和視圖函數的對應關系。

  url匹配的過程

  在項目的urls.py文件中包含具體應用的urls.py文件，應用的urls.py文件中寫url和視圖函數的對應關系
  當用戶輸入如127.0.0.1:8000/index時，去除域名和最前面的/,剩下index，拿index字符串到項目的urls文件中進行匹配，配置成功之后，繼續到項目中的urls文件中進行正則匹配，匹配成功之后執行視圖函數index，index視圖函數返回內容hello python 給瀏覽器來顯示
  vim /myobj/urls.py

  from django.contrib import admin
  #from django.urls import path
  from django.conf.urls import include,url
  urlpatterns = [
  url(r'^admin/',admin.site.urls),#配置項
  url(r'^',include('test1.urls')) #包含test1應用中的urls文件
  ]

  vim test1/urls.py

  from django.conf.urls import url
  from test1 import views
  # /index
  #在應用的urls文件中進行url配置的時候：
  #1.嚴格匹配開頭和結尾
  urlpatterns =[
  #通過url函數設置url路由配置項
  url(r'^index$',views.index), # 建立index和視圖之間的關系
  url(r'^index2$',views.index2),
  ]

  錯誤視圖

  404：找不到頁面，關閉調試模式之后，默認會顯示一個標準的錯誤頁面，如果要顯示自定義的頁面，則需要templates目錄下面自定義一個404.html文件

  • url沒有配置
  • url配置錯誤
    500：服務器端的錯誤
  • 視圖出錯
    網站開發完成需要關閉調試模式，在settings.py文件中：
  • DEBUG=False
  • ALLOWED_HOST=['*']

捕獲url參數

進行url匹配時，把所需要的捕獲的部分設置成一個正則表達式組，這樣Django框架就會自動把匹配成功后相應組的內容作為參數傳遞給視圖函數。

1. 位置參數
   • 位置參數，參數名可以隨意指定
     vim booktest/urls.py

     from django.conf.urls import url
     from booktest import views
     urlpatterns = [
     url(r'^index$',views.index), #首頁,
     url(r'^showarg(\d+)$',views.show_arg), #捕獲url參數
     ]

     vim test3/urls.py

     urlpatterns = [
     path('admin/', admin.site.urls),
     url(r'^',include('booktest.urls')),
     ]

     vim booktest/views.py

     from django.shortcuts import render
     from django.http import HttpResponse
     # Create your views here.
     def index(request):
     '''首頁'''
     return render(request,'booktest/index.html')
     def show_arg(request,num):
     return HttpResponse(num)

2. 關鍵字參數：在位置參數的基礎上給正則表達式組命名即可
   • ？P<組名>
   • 關鍵字參數，視圖中參數名必須和正則表達式組名一致
     vim booktest.urls

     from django.conf.urls import url
     from booktest import views
     urlpatterns = [
     url(r'^index$',views.index), #首頁,
     url(r'^showarg(\d+)$',views.show_arg), #捕獲url參數：位置參數
     url(r'^showarg(?P<num>\d+)$',views.show_arg), #捕獲關鍵字參數
     ]

登錄案例

1. 顯示出登錄頁面
   • 設計url，通過瀏覽器訪問http://127.0.0.1:8000/login時顯示登錄頁面
   • 設計url對應的視圖函數login
   • 編寫模板文件login.htnl
     vim booktest/urls.py

     from django.conf.urls import url
     from booktest import views
     urlpatterns = [
     url(r'^index$',views.index), #首頁,
     url(r'^showarg(\d+)$',views.show_arg), #捕獲url參數：位置參數
     url(r'^showarg(?P<num>\d+)$',views.show_arg), #捕獲關鍵字參數
     url(r'^login$',views.login), #顯示登錄頁面
     url(r'^login_check$',views.login_check),
     ]

     vim login.html

     <!DOCTYPE html>
     <html lang="en">
     <head>
     <meta charset="UTF-8">
     <title>登錄頁面</title>
     </head>
     <body>
     <form method="post" action="/login_check">
     用戶名:<input type="text" name="username"><br/>
     密碼:<input type="password" name="password"><br/>
     <input type="submit" value="登錄">
     </form>
     </body>
     </html>

2. 登錄校驗功能
   • 設計url，點擊登錄頁的登錄按鈕發起請求http://127.0.0.1:8000/login_check
   • 設計url對應的視圖函數login_check。接收表單提交過來的數據

注釋掉settings.py文件的47行

vim booktest/views.py

from django.shortcuts import render,redirect
from django.http import HttpResponse
# Create your views here.
def index(request):
    '''首頁'''
    return render(request,'booktest/index.html')
def show_arg(request,num):
    return HttpResponse(num)

def login(request):
    '''顯示登錄頁面'''
    return render(request,'booktest/login.html')

def login_check(request):
    '''登錄校驗視圖'''
    #request.POST保存的是post方式提交的參數 QueryDict
    # request.GET保存的是get方式提交的參數
    #1. 獲取提交的用戶名和密碼
    username=request.POST.get('username')
    password=request.POST.get('password')
    #2. 進行登錄的校驗
    #實際開發：根據用戶和密碼查找數據庫
    #模擬：smart 123
    if username=='smart' and password=='123':
        #用戶名密碼正確，跳轉到首頁
        return redirect('/index')
    else:
        #用戶名或密碼錯誤，跳轉到登錄頁面
        return redirect('/login')

HttpRequest對象的屬性

• path：一個字符串，表示請求的頁面的完整路徑，不包含域名和參數部分
• method：一個字符串，表示請求使用的HTTP方法，常用值包括：'GET'、'POST'
  • 在瀏覽器中給出地址發出請求采用get方式，如超鏈接
  • 在瀏覽器中點擊表單的提交按鈕發起請求，如果表單的method設置為post則為post請求
• encoding：一個字符串，表示提交的數據的編碼方式
  • 如果為none則表示使用瀏覽器的默認設置，一般為utf-8
  • 這個屬性是可寫的，可以通過修改他來修改訪問表單數據使用的編碼，接下來對屬性的任何訪問將使用新的encoding值
• GET：QueryDict類型對象，類似于字典，包含get請求方式的所有參數
• POST：QueryDict類型對象，類似于字典，包含post請求方式的所有參數
• FILES：一個類似于字典的對象，包含所有的上傳文件
• COOKIES：一個標準的python字典，包含所有的cookie，鍵和值都為字符串
• session：一個既可讀又可寫的類似于字典的對象，表示當前的對話，只有當Django啟用會話的支持時才可用，詳細內容見“狀態保持”
• 運行服務器，在瀏覽器中瀏覽首頁，可以在瀏覽器“開發者工具”中看到請求信息如下圖

Ajax登錄案例

• 首先分析出請求地址時需要攜帶的參數
• 視圖函數處理完成之后，所返回的json格式
  1. 顯示出登錄頁面
     • 設計url，通過瀏覽器訪問http://127.0.0.1:8000/login_ajax時顯示登錄頁面
     • 設計url對應的視圖函數login_ajax
     • 編寫模板文件login_ajax.html。在里面寫jQuery代碼發起ajax請求
  2. 登錄校驗功能
     • 設計url，點擊登錄頁的登錄按鈕發起請求，http://127.0.0.1:8000/login_ajax_check時進行登陸校驗
     • 設計url對應的視圖函數login_ajax_check，接收一個提交過來的數據

狀態保持

cookie

cookie是由服務器生成，存儲在瀏覽器端的一小段文本信息

cookie的特點

1. 以鍵值對方式進行存儲
2. 通過瀏覽器訪問同一個網站時，會將瀏覽器存儲的跟網站相關的所有cookie信息發送給該網站的服務器。request.COOKIES
3. cookie是基于域名安全的
4. cookie是有過期時間的，如果不指定，默認關閉瀏覽器之后cookie就會過期

cookie請求的步驟

1. 服務端接收瀏覽器發送來的請求并進行處理
2. 設置cookie，需要一個HTTPresponse類的對象，或者是它子類的對象，將cookie發送給瀏覽器保存
3. 瀏覽器將cookie發送給服務器，保存request對象的COOKIES

vim booktest/urls.py

from django.shortcuts import render,redirect
from django.http import HttpResponse
from datetime import datetime,timedelta
# /set_cookie
def set_cookie(request):
    '''設置一個cookie信息'''
    response=HttpResponse('設置cookie')
    # 設置一個cookie信息，名字為num，值為1
    response.set_cookie('num',1,max_age=14*24*3600)
    #response.set_cookie('num', 1, expires=datetime.now()+timedelta(days=14))
    #返回response
    return response

# /get_cookie
def get_cookie(request):
    '''獲取cookie的信息'''
    #取出cookie num的值
    num=request.COOKIES['num']
    return HttpResponse(num)

vim booktest/urls.py

urlpatterns = [
    url(r'^index$',views.index), #首頁,
    url(r'^showarg(\d+)$',views.show_arg), #捕獲url參數：位置參數
    url(r'^showarg(?P<num>\d+)$',views.show_arg), #捕獲關鍵字參數
    url(r'^login$',views.login), #顯示登錄頁面
    url(r'^login_check$',views.login_check),
    url(r'^set_cookie$',views.set_cookie), #設置cookie
    url(r'^get_cookie$',views.get_cookie),  #獲取cookie
]

記住用戶名的案例

vim login.html

<form method="post" action="/login_check">
    用戶名:<input type="text" name="username" value="{{ username }}"><br/>
    密碼:<input type="password" name="password"><br/>
    <input type="checkbox" name="remember">記住用戶名<br/>
    <input type="submit" value="登錄">
</form>

vim booktest/views.py

def login(request):
    '''顯示登錄頁面'''
    #獲取cookie username
    if 'username' in request.COOKIES:
        #獲取記住的用戶名
        username = request.COOKIES['username']
    else:
        username=''
    return render(request,'booktest/login.html',{'username':username})

def login_check(request):
    '''登錄校驗視圖'''
    #request.POST保存的是post方式提交的參數 QueryDict
    # request.GET保存的是get方式提交的參數
    #1. 獲取提交的用戶名和密碼
    username=request.POST.get('username')
    password=request.POST.get('password')
    remember=request.POST.get('remember')
    #2. 進行登錄的校驗
    #實際開發：根據用戶和密碼查找數據庫
    #模擬：smart 123
    if username=='smart' and password=='123':
        #用戶名密碼正確，跳轉到首頁
        response=redirect('/index')
        #判斷是否需要記住用戶名
        if remember == 'on':
            #設置cookie username，過期時間為一周
            response.set_cookie('username',username,max_age=7*24*3600)
        return response
    else:
        #用戶名或密碼錯誤，跳轉到登錄頁面
        return redirect('/login')

session

session存儲在服務器端

session的特點

1. session是以鍵值對進行存儲的
2. session依賴于cookie。唯一的標識碼保存在sessionid cookie中
3. session也是有過期時間，如果不指定，默認兩周就會過期

設置session

vim booktest/views.py

#/set_session
def set_session(request):
    '''設置session'''
    request.session['username']='smart'
    request.session['age']=18
    return HttpResponse('設置session')

#/get_session
def get_session(request):
    '''獲取session'''
    username=request.session['username']
    age=request.session['age']
    return HttpResponse(username+':'+str(age))
#/clear_session
def clear_session(request):
    '''清除session信息'''
    #request.session.clear()
    request.session.flush()
    #del request.session['age']
    return HttpResponse('清除成功')    

vim booktest/urls.py

url(r'^set_session$',views.set_session), #設置session
url(r'^get_session$',views.get_session), #獲取session
url(r'^clear_session$',views.clear_session), #清除session

設置會話的超時時間

如果沒有指定過期時間則兩個星期后過期
request.sesion.set_expiry(value)

• 如果value是一個整數，會話的session_id cookie將在value秒沒有活動后過期
• 如果value為0，那么用戶會話的session_id cookie將在用戶的瀏覽器關閉時過期
• 如果value為None，那么會話的session_id cookie兩周之后過期

記住用戶登錄狀態案例

vim views.py

def login(request):
    '''顯示登錄頁面'''
    #判斷用戶是否登錄
    if request.session.has_key('islogin'):
        return redirect('/index')
    else:
        #用戶未登錄
        #獲取cookie username
        if 'username' in request.COOKIES:
            #獲取記住的用戶名
            username = request.COOKIES['username']
        else:
            username=''
        return render(request,'booktest/login.html',{'username':username})

def login_check(request):
    '''登錄校驗視圖'''
    #request.POST保存的是post方式提交的參數 QueryDict
    # request.GET保存的是get方式提交的參數
    #1. 獲取提交的用戶名和密碼
    username=request.POST.get('username')
    password=request.POST.get('password')
    remember=request.POST.get('remember')
    #2. 進行登錄的校驗
    #實際開發：根據用戶和密碼查找數據庫
    #模擬：smart 123
    if username=='smart' and password=='123':
        #用戶名密碼正確，跳轉到首頁
        response=redirect('/index')
        #判斷是否需要記住用戶名
        if remember == 'on':
            #設置cookie username，過期時間為一周
            response.set_cookie('username',username,max_age=7*24*3600)
        #記住用戶登錄狀態
        #只有session中有islogin，就認為用戶已登錄
        request.session['islogin']=True
        return response
    else:
        #用戶名或密碼錯誤，跳轉到登錄頁面
        return redirect('/login')

cookie和session的應用場景

• cookie：記住用戶名，安全性要求不高
• session：涉及到安全性要求比較高的數據

模板

模板的功能

• 產生html，控制頁面上展示的內容。模板文件不僅僅是一個html文件。模板文件包含兩部分內容：
  1. 靜態內容：css，js，html
  2. 動態內容：用于動態去產生一些網頁內容。通過模板語言來產生

模板文件的使用

通常是在視圖函數中使用模板產生html內容返回給客戶端

1. 創建模板文件夾
   在項目目錄下創建一個文件夾
2. 配置模板目錄
   vim settings.py

   'DIRS': [os.path.join(BASE_DIR,'templates')],

3. 使用模板文件
   • 加載模板文件loader.get_template
     去模板目錄下面獲取HTML文件的內容，得到一個模板對象
   • 定義模板上下文RequeseContext
     向模板文件傳遞數據
   • 模板渲染產生html頁面內容render
     用傳遞的數據替換相應的變量，得到一個替換后的標準的HTML內容

模板文件加載順序

django.template.loaders.filesystem.Loader：/root/wanger/test4/templates/booktest/index2.html（來源不存在）
django.template.loaders.app_directories.Loader：/root/.virtualenvs/wanger/lib/python3.5/site-packages/django/contrib/admin/templates/booktest/index2.html（來源不存在）
django.template.loaders.app_directories.Loader：/root/.virtualenvs/wanger/lib/python3.5/site-packages/django/contrib/auth/templates/booktest/index2.html（來源不存在）

• 首先去配置的模板目錄下面去找模板文件
• 去INSYALL_APPS下面的每個應用的去找模板文件，前提是應用中必須有templates文件夾

模板語言

模板語言簡稱為DTL（Django template language）

模板變量

模板變量名是由數字，字母，下劃線和點組成的，不能以下劃線開頭
模板變量使用：{{ 模板變量名 }}
模板變量的解析順序:
例如：{{ book.btitle }}

1. 首先把book當成一個字典，把btitle當成鍵名，進行取值book['btitle']
2. 把book當成一個對象，把btitle當成屬性，進行取值book.btitle

3. 把book當成一個對象，把btitle當成對象的方法，進行取值book.btitle
   例如：{{book.0}}

4. 首先把book當成一個字典，把0當成鍵名，進行取值book[0]
5. 把book當成一個列表，把0當成下標，進行取值book[0]
   如果解析失敗，則產生內容時用空字符串填充模板變量
   使用模板變量時，前面的可能是一個字典，可能是一個對象，還可能是一個列表
   vim models.py

from django.db import models

# Create your models here.
class BookInfo(models.Model):
    '''圖書模型類'''
    #圖書名稱
    btitle=models.CharField(max_length=20,db_column='btitle')
    #出版日期
    bpub_date=models.DateField()
    #閱讀量
    bread=models.IntegerField(default=0)
    #評論量
    bcomment=models.IntegerField(default=0)
    #刪除標記
    isdelete=models.BooleanField(default=False)

vim views.py

from booktest.models import BookInfo
# /temp_var
def temp_var(request):
    '''模板變量'''
    my_dict={'title':'字典鍵值'}
    my_list=[1,2,3]
    book=BookInfo.objects.get(id=1)
    #定義模板上下文
    context={'my_dict':my_dict,'my_list':my_list,'book':book}
    return  render(request,'booktest/temp_var.html',context)

vim urls.py

from django.conf.urls import url
from booktest import views
urlpatterns = [
   url(r'^temp_var$',views.temp_var),#模板變量
]

vim temp_var.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>模板變量</title>
</head>
<body>
使用字典屬性:{{ my_dict.title }}<br/>
使用列表元素:{{ my_list.1 }}<br/>
使用對象屬性:{{ book.btitle }}<br/>
</body>
</html>

模板標簽

模板代碼段：{% 代碼段 %}
for循環：

{% for i in list %}

列表不為空時執行

{% empty %}

列表為空時執行

{% endfor %}

可以通過{{ forloop.counter }}得到for循環遍歷到了第幾次

vim urls.py

from django.conf.urls import url
from booktest import views
urlpatterns = [
    url(r'^temp_tags$',views.temp_tags),
]

vim views.py

# /temp_tags
def temp_tags(request):
    '''模板標簽'''
    #1. 查找所有圖書的信息
    books=BookInfo.objects.all()
    return render(request,'booktest/temp_tags.html',{'books':books})

vim temp_tags.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>模板標簽</title>
</head>
<body>
<ul>
    {% for book in books %}
        <li>{{ forlop.counter }}--{{ book.btitle }}</li>
    {% endfor %}
</ul>
</body>
</html>

{% if 條件 %}
{% elif 條件 %}
{% else %}
{% endif %}

關系比較操作符：< > <= >= !=

注意:進行比較時，比較操作符兩邊必須有空格

邏輯運算：not and or
vim temp_tags.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>模板標簽</title>
    <style>
        .red {
            background-color: red;
        }
        .yellow {
            background-color: yellow;
        }
        .green {
            background-color: green;
        }
    </style>
</head>
<body>
<ul>
    {% for book in books %}
        {% if book.id <= 2 %}
            <li class="red">{{ forloop.counter }}--{{ book.btitle }}</li>
        {% elif book.id <= 4 %}
            <li class="yellow">{{ forloop.counter }}--{{ book.btitle }}</li>
        {% else %}
            <li class="green">{{ forloop.counter }}--{{ book.btitle }}</li>
        {% endif %}
    {% endfor %}
</ul>
</body>
</html>

模板過濾器

過濾器用于對模板變量進行操作
date:改變日期的顯示格式
length：求長度。字符串，列表長度
default:設置模板變量的默認值
格式：模板變量|過濾器：參數
自定義過濾器。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>模板過濾器</title>
    <style>
        .red {
            background-color: red;
        }
        .green {
            background-color: green;
        }
    </style>
</head>
<body>
<ul>
    {% for book in books %}
        {% if book.id <= 2 %}
            <li class="red">{{ book.btitle }}--{{ book.bpub_date|date:'Y年-m月-d日' }}</li>
        {% else %}
            <li class="green">{{ book.btitle }}--{{ book.bpub_date }}</li>
        {% endif %}
    {% endfor %}
</ul>
default過濾器：<br/>
{{ content|default:'hello' }}
</body>
</html>

自定義模板過濾器

在應用下創建一個包templatetags，包的名字固定，在包下創建一個過濾器文件
vim filters.py

#自定義過濾器
#過濾器其實就是python函數
from django.template import Library

#創建一個library類的對象
register=Library()
#自定義的過濾器函數，最少有一個參數，最多有兩個
@register.filter
def mod(num):
    '''判斷num是否為偶數'''
    return num%2 == 0

@register.filter
def mod_val(num,val):
    '''判斷num是否能被val整除'''
    return num%val ==0

vim temp_filters.html

<!DOCTYPE html>
<html lang="en">
{% load filters %}
<head>
    <meta charset="UTF-8">
    <title>模板過濾器</title>
    <style>
        .red {
            background-color: red;
        }
        .green {
            background-color: green;
        }
    </style>
</head>
<body>
<ul>
    {% for book in books %}
        {# {% if book.id <= 2 %} #}
        {# {% if book.id|mod %} #}
        {% if book.id|mod_val:3 %}
            <li class="red">{{ book.id }}--{{ book.btitle }}--{{ book.bpub_date|date:'Y年-m月-d日' }}</li>
        {% else %}
            <li class="green">{{ book.btitle }}--{{ book.bpub_date }}</li>
        {% endif %}
    {% endfor %}
</ul>
default過濾器：<br/>
{{ content|default:'hello' }}
</body>
</html>

模板注釋

單行注釋：{# 注釋內容 #}
多行注釋：{% comment %}
注釋內容
{% endcomment %}

模板繼承

把所有頁面相同的內容放到父模板文件中，不需要放在塊中，有些位置頁面內容不同，需要在父模板中預留塊。
在父模板里可以定義塊，使用標簽：
{% block 塊名 %}
塊中間可以寫內容，也可以不寫
{% endblock 塊名 %}
字模板去繼承父模板之后，可以重寫父模板中的某一塊內容
繼承格式：

{% extends 父模板文件路徑 %}
{% block 塊名 %}
{{ block.super }} #獲取父模板中塊的默認內容
重寫的內容
{% endblock 塊名 %}

vim views.py

#/temp_inherit
def temp_inherit(request):
    '''模板繼承'''
    return render(request,'booktest/child.html')

vim base.html

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>父模板文件</title>
</head>
<body>
<h2>導航條</h2>
{% block b1 %}
    <h2>這是父模板b1塊中</h2>
{% endblock b1 %}
<h2>版權信息</h2>
</body>
</html>

vim child.html

{% extends 'booktest/base.html' %}
{% block b1 %}
    {{ block.super }}
    <b1>這是子模板b1塊中的內容</b1>
{% endblock b1 %}

vim urls.py

url(r'^temp_inherit$',views.temp_inherit), ##模板繼承

html轉義

編輯商品詳情信息，數據表中保存的是html內容
在模板上下文中的html標記默認是會被轉義的

< 轉化為& lt;
> 轉換為& gt;
' 轉換為& #39;
" 轉換為& quot;
& 轉換為& amp;

要關閉模板上下文字符串的轉義：可以使用{{ 模板變量|safe }}
也可以使用
{% autoescape off %}
模板語言代碼
{% endautoescape %}

模板硬編碼中的字符串默認不會經過轉義，如果需要轉義，那需要手動進行轉義

vim views.py

def html_escape(request):
    '''HTML轉義'''
    return render(request,'booktest/html_escape.html',{'content':'<h2>hello</h2>'})

vim urls.py

 url(r'^html_escape$',views.html_escape), #HTML轉義

vim html_escap[e.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>html轉義</title>
</head>
<body>
{{ content }}
使用safe過濾器關閉轉義：<br/>
{{ content|safe }}
</br>
模板硬編碼中的字符串不會經過轉義<br/>
{{ test|default:'<h2>hello</h2>' }}<br/>
手動進行轉義：<br/>
{{ test|default:'<h2>hello</h2>' }}
</body>
</html>

csrf***

首先做一個登錄頁，讓用戶輸入用戶名和密碼進行登錄，登陸成功之后跳轉的修改密碼頁面。在修改密碼頁面輸入新密碼，點擊確認按鈕完成密碼修改
登錄頁需要一個模板文件login.html，修改密碼頁面也需要一個模板文件
change_pwd.html
顯示登錄頁的視圖login，驗證登錄的視圖login_check，顯示發帖頁的視圖change_pwd，處理修改密碼的視圖change_pwd_action
加功能：

1. 只有用戶登錄之后才可以進行發帖操作
   登錄裝飾器函數

vim views.py

def login_required(view_func):
    '''登錄判斷裝飾器'''
    def wrapper(request,*views_args,**view_kwargs):
        #判斷用戶是否登錄
        if request.session.has_key('islogin'):
            #用戶已登錄，調用對應的視圖
            return view_func(request,*views_args,**view_kwargs)
        else:
            #用戶未登錄，跳轉到登錄頁
            return redirect('/login')
    return wrapper
def login(request):
    '''顯示登錄頁面'''
    #判斷用戶是否登錄
    if request.session.has_key('islogin'):
        return redirect('/index')
    else:
        #用戶未登錄
        #獲取cookie username
        if 'username' in request.COOKIES:
            #獲取記住的用戶名
            username = request.COOKIES['username']
        else:
            username=''
        return render(request,'booktest/login.html',{'username':username})

def login_check(request):
    '''登錄校驗視圖'''

    username=request.POST.get('username')
    password=request.POST.get('password')
    remember=request.POST.get('remember')
    #2. 進行登錄的校驗
    #實際開發：根據用戶和密碼查找數據庫
    #模擬：smart 123
    if username=='smart' and password=='123':
        #用戶名密碼正確，跳轉到首頁
        response=redirect('/index')
        #判斷是否需要記住用戶名
        if remember == 'on':
            #設置cookie username，過期時間為一周
            response.set_cookie('username',username,max_age=7*24*3600)
        #記住用戶登錄狀態
        #只有session中有islogin，就認為用戶已登錄
        request.session['islogin']=True
        #記住登錄的用戶名
        request.session['username']=username

        return response
    else:
        #用戶名或密碼錯誤，跳轉到登錄頁面
        request.session['username']=username
        return redirect('/change_pwd')

# /change_pwd
@login_required
def change_pwd(request):
    '''顯示修改密碼頁面'''
    return render(request,'booktest/change_pwd.html')

# /change_pwd_action
@login_required
def change_pwd_action(request):
    '''模擬修改密碼處理'''
    # 1.獲取新密碼
    pwd=request.POST.get('pwd')
    #獲取用戶名
    username=request.session.get('username')
    #2.實際開發的時候:修改對應數據庫的內容
    #3.返回一個應答
    return HttpResponse('%s修改密碼為:%s' %(username,pwd))

vim urls.py

url(r'^login$',views.login), #顯示登錄頁面
    url(r'^login_check$',views.login_check), #進行登錄校驗
    url(r'^change_pwd$',views.change_pwd), #修改密碼頁面顯示
    url(r'^change_pwd_action$',views.change_pwd_action), #修改密碼處理

vim login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登錄頁面</title>
</head>
<body>
<form method="post" action="/login_check">
    用戶名:<input type="text" name="username" value="{{ username }}"><br/>
    密碼:<input type="password" name="password"><br/>
    <input type="checkbox" name="remember">記住用戶名<br/>
    <input type="submit" value="登錄">
</form>
</body>
</html>

vim change_pwd.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>修改密碼界面</title>
</head>
<body>
<form method="post" action="/change_pwd_action">
    新密碼:<input type="password" name="pwd">
    <input type="submit" value="確認修改">
</form>
</body>
</html>

django防止csrf的方式:

1. 默認打開CSRF中間件
2. 表單post提交數據時加上{% csrf_token %}標簽

防御原理：

1. 渲染模板文件時在頁面生成一個名字叫做csrfmiddlewaretoken的隱藏域
2. 服務器交給瀏覽器保存一個名字為csrftoken的cookie信息
3. 提交表單時，兩個值都會發給服務器，服務器進行比對，如果一樣，則csrf驗證通過，否則失敗

驗證碼

vim views.py

def login_check(request):
    '''登錄校驗視圖'''

    username=request.POST.get('username')
    password=request.POST.get('password')
    remember=request.POST.get('remember')
    #獲取用戶輸入驗證碼
    vcode1=request.POST.get('vcode')
    #獲取session中保存的驗證碼
    vcode2=request.session.get('verifycode')
    #進行驗證碼校驗
    if vcode1 != vcode2:
        #驗證碼錯誤
        return redirect('/login')
    #2. 進行登錄的校驗
    #實際開發：根據用戶和密碼查找數據庫
    #模擬：smart 123
    if username=='smart' and password=='123':
        #用戶名密碼正確，跳轉到首頁
        response=redirect('/index')
        #判斷是否需要記住用戶名
        ...
#/驗證碼
from PIL import Image,ImageDraw,ImageFont
from django.utils.six import BytesIO
def verify_code(request):
    #引入隨機函數模塊
    import random
    #定義變量，用于畫面的背景色、寬、高
    bgcolor=(random.randrange(20,100),random.randrange(20,100),255)
    width=100
    height=25
    #構建畫面圖像
    im=Image.new('RGB',(width,height),bgcolor)
    #創建畫筆對象
    draw=ImageDraw.Draw(im)
    #調用畫筆的point()函數繪制噪點
    for i in range(0,100):
        xy=(random.randrange(0,width),random.randrange(0,height))
        fill=(random.randrange(0,255),255,random.randrange(0,255))
        draw.point(xy,fill=fill)
    #定義驗證碼的備選值
    str1='ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890'
    #隨機選取4個值作為驗證碼
    rand_str=''
    for i in range(0,4):
        rand_str+=str1[random.randrange(0,len(str1))]

    #構造字體對象
    font=ImageFont.truetype('/usr/share/fonts/gnu-free/FreeMonoBold.ttf',23)
    #構造字體的顏色
    fontcolor=(255,random.randrange(0,255),random.randrange(0,255))
    #繪制四個字
    draw.text((5,2),rand_str[0],font=font,fill=fontcolor)
    draw.text((25,2),rand_str[1],font=font,fill=fontcolor)
    draw.text((50, 2), rand_str[2], font=font, fill=fontcolor)
    draw.text((75, 2), rand_str[3], font=font, fill=fontcolor)
    #釋放畫筆
    del draw
    #存入session，用于做進一步驗證
    request.session['verifycode']=rand_str
    #內存文件操作
    buf=BytesIO()
    #將圖片保存在內存中，文件類型是png
    im.save(buf,'png')
    #將內存中的圖片數據返回給客戶端，mime類型為圖片png
    return HttpResponse(buf.getvalue(),'image/png')

vim login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登錄頁面</title>
</head>
<body>
<form method="post" action="/login_check">
    {% csrf_token %}
    用戶名:<input type="text" name="username" value="{{ username }}"><br/>
    密碼:<input type="password" name="password"><br/>
    <input type="checkbox" name="remember">記住用戶名<br/>

    <img src="/verify_code"><input type="text" name="vcode"><br/>
    <input type="submit" value="登錄">
</form>
</body>
</html>

反向解析

當某一個url配置的地址發生變化時，頁面上使用反向解析生成地址的位置不需要發生變化
根據url正則表達式的配置動態的生成url

vim booktest/views.py

url(r'^url_reverse$',viewa.url_reverse), #反向解析頁面

模型

創建模型類

vim models.py

from django.db import models

# Create your models here.
class BookInfo(models.Model):
    '''圖書模型類'''
    #圖書名稱
    btitle=models.CharField(max_length=20)
    #出版日期
    bpub_date=models.DateField()
    #閱讀量
    bread=models.IntegerField(default=0)
    #評論量
    bcomment=models.IntegerField(default=0)
    #刪除標記
    isdelete=models.BooleanField(default=False)

class HeroInfo(models.Model):
    '''英雄人物模型類'''
    #英雄名
    hname=models.CharField(max_length=20)
    #性別
    hgender=models.BooleanField(default=False)
    #備注
    hcomment=models.CharField(max_length=200)
    #關系屬性
    hbook=models.ForeignKey('BookInfo',on_delete=models.CASCADE,)
    # 刪除標記
    isdelete=models.BooleanField(default=False)

執行遷移文件生成表

python manage.py makemigrations
python manage.py migrate

往數據表里插入數據

insert into booktest_bookinfo(btitle,bpub_date,bread,bcomment,isdelete) values
    -> ('射雕英雄傳','1980-5-1',12,34,0),
    -> ('天龍八部','1986-7-24',36,40,0),
    -> ('笑傲江湖','1995-12-24',20,80,0),
    -> ('雪山飛狐','1987-11-11',58,24,0);
insert into booktest_heroinfo(hname,hgender,hbook_id,hcomment,isdelete) valu s 掌0) ('郭靖',1,1,'降龍十八掌',0), ('黃蓉',0,1,'打狗棍法',0), ('黃藥師',1,1,'彈指神  姐姐 ('歐陽鋒',1,1,'蛤蟆功',0), ('梅超風',0,1,'九陰白骨爪',0) ,('喬峰',1,2,'降龍十  劍法',0), ('段譽',1,2,'六脈神劍',0), ('虛竹',1,2,'天山折梅手',0), ('王語嫣',0,2,'神 黃衣',,0), ('令狐沖',1,3,'獨孤九劍',0), ('任盈盈',0,3,'彈琴',0), ('岳不群',1,3,'華.劍Query OK, 17 rows affected (0.00 sec)), ('胡斐',1,4,'胡家刀法',0), ('苗春蘭',0,4,'黃衣Records: 17  Duplicates: 0  Warnings: 00,4,'六合拳',0);

設計url，通過url瀏覽器訪問url/index時顯示圖書信息頁面

vim index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>圖書信息</title>
</head>
<body>
<a href="/create">新增</a>
<ul>
    {% for book in books %}
        <li>{{ book.btitle }}--<a href="/delete{{ book.id }}">刪除</a></li>
    {% endfor %}
</ul>

</body>
</html>

vim booktest/views.py

from django.shortcuts import render,redirect 
from booktest.models import BookInfo  
from datetime import date
from django.http import HttpResponse,HttpResponseRedirect
# Create your views here.
def index(request):
    '''顯示圖書信息'''
    #1. 查詢出所有圖書的信息
    books=BookInfo.objects.all()
    #2.使用模板
    return render(request,'booktest/index.html',{'books':books})
def create(request):
    '''新增一本圖書'''
    #1.創建BookInfo對象
    b=BookInfo()
    b.btitle='流星蝴蝶劍'
    b.bpub_date=date(1990,1,1)
    #2.保存進數據庫
    b.save()
    #3.返回應答，讓瀏覽器再訪問/index
    return HttpResponse('ok')
    #return HttpResponseRedirect('/index')
def delete(request,bid):
    '''刪除點擊的圖書'''
    #1.通過bid獲取圖書對象
    book=BookInfo.objects.get(id=bid)
    #2.刪除
    book.delete()
    #3.重定向，讓瀏覽器訪問/index
    #return HttpResponseRedirect('/index')
    return redirect('/index')

vim test2/urls.py

from django.contrib import admin
#from django.urls import path
from django.conf.urls import include,url
urlpatterns = [
    url(r'^admin/',admin.site.urls),#配置項
    url(r'^',include('booktest.urls')) #包含test1應用中的urls文件
]

vim booktest/urls.py

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

urlpatterns=[
    url(r'^index$',views.index), #圖書信息頁面
    url(r'^create$',views.create), #添加圖書信息
    url(r'^delete(\d+)$',views.delete), #刪除點擊的圖書
]

查詢

修改mysql的日志文件：
讓其產生mysql.log，即是mysql的日志文件，里面記錄的對mysql數據庫的操作記錄

1. 使用下面的命令打開mysql的配置文件，編輯general_log=1 general_log_file= /usr/local/mysql/data/mysql.log，然后保存vi /etc/my.cnf
2. 重啟mysql服務，就會產生mysql日志文件mysql.server start
3. 打開mysql的日志文件
   tail /usr/local/mysql/data/mysql.log

查詢函數

通過模型類.objects屬性可以調用如下函數，實現對模型類對應的數據表的查詢

filter方法示例：

• 條件格式：模型類屬性名__條件名=值
  • 判等 條件名:exact
    • 查詢編號為1的圖書
    • BookInfo.objects.get(id__exact=1)
  • 模糊查詢
    • 查詢書名包含傳的圖書
    • BookInfo.objects.filter(btitle__contains='傳')
    • 查詢書名以'部'結尾的圖書endswith開頭：startswith
    • BookInfo.objects.filter(btitle__endswith='部')
  • 空查詢isnull
    • 查詢書名不為空的圖書
    • BookInfo.objects.filter(btitle__isnull=False)
  • 范圍查詢
    • 查詢id為1或3或5的圖書
    • BookInfo.objects.filter(id__in=[1,3,5])
  • 比較查詢gt、lt、gte、lte
    • 查詢編號大于3的圖書
    • BookInfo.objects.filter(id__gt=3)
  • 日期查詢
    • 查詢1980年發表的圖書
    • BookInfo.objects.filter(bpub_date__year=1980)
    • 查詢1980年1月1日后發表的書
    • from datetime importdate
    • BookInfo.objects.filter(bpub_date__gt=date(1980,1,1))

order by方法示例

• 作用:進行查詢結果的排序
  • 查詢所有圖書信息，按照id從小到大進行排序
  • BookInfo.objects.all().order_by('id')
  • 查詢所有圖書的信息，按照id從大到小進行排序
  • BookInfo.objects.all().order_by('-id')
  • 把id大于3的圖書信息按閱讀量從大到小進行排序
  • BookInfo.objects.filter(id__gt=3).order_by('-bread')

Q對象

作用：用于查詢時條件之間的邏輯關系。mot and or，可以對Q對象進行&|~操作
使用之前需要先導入：
from Django.db.models import Q
例：查詢id大于3且閱讀量大于30的圖書的信息
BookInfo.objects.filter(id__gt=3,bread__gt=30)
BookInfo.objects.filter(Q(id__gt=3)&Q(bread__gt=30))
例：查詢id大于3或者閱讀量大于30的圖書的信息
BookInfo.objects.filter(Q(id__gt=3)|Q(bread__gt=30))
例：查詢id不等于3圖書的信息
BookInfo.objects.filter(~Q(id=3))

F對象

作用：用于類屬性之間的比較
使用之前需要先導入：
from django.db.models import F
例：查詢圖書閱讀量大于評論量圖書的信息
BookInfo.objects.filter(bread__gt=F('bcomment'))
例：查詢圖書閱讀量大于2倍評論量圖書信息
BookInfo.objects.filter(bread__gt=F('bcomment')*2)

聚合函數

作用：對查詢結果進行聚合操作
sum count avg max min
aggregate：調用這個函數來使用聚合。返回值是一個字典。
使用前需先導入聚合類：
from django.db.models import Sum,Count,Max,Min,Avg
例：查詢所有圖書的數目

select count(*) from booktest_bookinfo;
BookInfo.objects.all().aggregate(Count('id'))
BookInfo.objects.aggregate(Count('id'))

例：查詢所有圖書閱讀量的總和
BookInfo.objects.aggregate(Sum('bread'))

查詢集

all,filter,exclude,order_by調用這些函數會產生一個查詢集
QuerySet類對象可以繼續調用上面的所有函數

查詢集特性：

1. 惰性查詢：只有在實際使用查詢集中的數據的時候才會發生對數據庫的真正查詢
2. 緩存：當使用的是同一個查詢集時，第一次的時候會發生實際數據庫的查詢，然后把結果緩存起來，之后再使用這個查詢集時，使用的是緩存中的結果。

限制查詢集

可以對一個查詢集進行取下標或者切片操作來限制查詢集的結果
對一個查詢集進行切片操作會產生一個新的查詢集，下標不允許為負數。
取出查詢集第一條數據的兩種方式：

• exists：判斷一個查詢集中是否有數據。True False

模型類關系

1. 一對多關系
   例：圖書類-英雄類
   models.ForeignKey()定義多的類中
   2. 多對多關系
      例：新聞類-新聞類型類 體育新聞 國際新聞
      models.ManyToManyField()定義在哪個類中都可以
   3. 一對一關系
      例：員工基本信息表-員工詳細信息類
      models.OneToOneField定義在哪個類中都可以

關聯查詢(一對多)

在一對多關系中，一對應的類我們把他叫做一類，多對應的類我們把它叫做多類，我們把多類中定義的建立關聯的類屬性叫做關聯屬性。
例：查詢id為1的圖書關聯的英雄的信息。

b=BookInfo.objects.get(id=1)
b.heroinfo_set.all()

通過模型類查詢：
HeroInfo.objects.filter(hbook__id=1)
例：查詢id為1的英雄關聯的圖書信息

h=HeroInfo.objects.get(id=1)
h.hbook()

通過模型類查詢：
BookInfo.objects.filter(heroinfo__id=1)

通過模型類查詢

• 由一類的對象查詢多類的時候
  • 一類的對象.多類名小寫_set.all() #查詢所用數據
• 由多類的對象查詢一類的時候
  • 多類的對象.關聯屬性 #查詢多類的對象對應的一類的對象
• 由多類的對象查詢一類的對象的id的時候
  • 多類的對象.關聯屬性_id

插入、更新和刪除

• 調用一個模型類對象的save方法的時候就可以實現對模型類對應數據表的插入和更新
• 調用一個模型類對象的delete方法的時候就可以實現對模型類對應數據表數據的刪除

自關聯

自關聯是一種特殊的一對多的關系

管理器

BookInfo.objects.all()->ojects是一個什么東西呢？
答：

• objects是Django幫我自動生成的管理器對象，通過這個管理器可以實現對數據的查詢
• objects是models.Manger類的一個對象。自定義管理器之后Django不再幫我們生成默認的objects管理器
  1. 自定義一個管理器類，這個類繼承models.Manger類
  2. 再在具體的模型類里定義一個自定義管理器類的對象

     class BookInfoManager(models.Manager):
     '''圖書模型管理器類'''
     # 1.改變查詢的結果集
     def all(self):
     #1.調用父類的all，獲取所有數據
     books=super().all() #QuerySet
     #2. 對數據進行過濾
     books=books.filter(isDelete=False)
     #3.返回books
     return books
     #2.封裝函數：操作模型類對應的數據表(增刪改查)
     def create_book(self,btitle,bpub_date):
     #1.創建一個圖書對象
     model_class=self.model
     book=model_class()
     #book=BookInfo()
     book.btitle=btitle
     book.bpub_date=bpub_date
     #2.保存進數據庫
     book.save()
     #3.返回book
     return book 

     自定義管理器類的應用場景

  3. 改變查詢的結果集
     • 比如調用BookInfo.boks.all()返回的是沒有刪除的圖書的數據
  4. 添加額外的方法
     • 管理器類中定義一個方法幫我們操作模型類對應的數據表
     • 使用self.model()就可以創建一個跟自定義管理器對應的模型 類對象

元選項

• Django默認生成的表名：
  • 應用名小寫_模型類名小寫
• 元選項：
  • 需要在模型類中定義一個Meta，在里面定義一個類屬性db_table就可以指定表名
• 以BookInfo模型類為例，在BookInfo中定義一個元類

  class BookInfo(models.Model):
  class Meta:
      db_table='bookinfo'

其他

靜態文件

使用

在網頁使用的css文件，js文件和圖片叫做靜態文件

新建靜態文件夾

• static
  • images
  • css
  • js

配置靜態文件所在的物理目錄。

vim settings.py

#設置訪問靜態文件對應的url地址
STATIC_URL = '/static/'
#設置靜態文件存放的物理目錄
STATICFILES_DIRS=[os.path.join(BASE_DIR,'static')]

vim static_test.html

<!DOCTYPE html>
{% load staticfiles %}
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>靜態文件</title>
</head>
<body>
<img src="/static/images/mm.jpg"><br/>
動態獲取STATIC_URL，拼接靜態文件路徑:<br/>
<img src="{% static 'images/mm.jpg' %}">
</body>
</html>

vim views.py

from django.shortcuts import render
from django.conf import settings
# Create your views here.
# /static_test
def static_test(request):
    '''靜態文件'''
    print(settings.STATICFILES_FINDERS)
    return render(request,'booktest/static_test.html')

vim urls.py

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

urlpatterns = [
    url(r'^static_test$',views.static_test), #靜態文件
]

加載目錄

STATICFILES_FINDERS=('django.contrib.staticfiles.finders.FileSystemFinder','django.contrib.staticfiles.finders.AppDirectoriesFinder')

中間件

中間件函數是Django框架給我們預留的函數接口，讓我們可以干預請求和應答的過程

獲取瀏覽器端的ip地址

使用request對象的meta屬性：request.META['REMOTE_ADDR']

使用中間件

新建middleware.py文件

vim booktest/middleware.py

定義中間件類

• 在類中定義中間件預留函數
  • __init__:服務器響應第一個請求的時候調用
  • process_request:是在產生request對象，進行url匹配之前調用
  • process_view:是url匹配之后，調用視圖函數之前
  • process_response:視圖函數調用之后，內容返回給瀏覽器之前
  • process_exception:視圖函數出現異常，會調用這個函數

如果注冊的多個中間件類中包含process_exception函數的時候，調用的順序跟注冊的順序是相反的

vim booktest/middleware.py

from django.http import HttpResponse
from django.utils.deprecation import MiddlewareMixin
class BlockedIPSMiddleware(object):
    EXCLUDE_IPS=['223.71.207.106']
    def process_view(self,request,view_func,*view_arg,**view_kwargs):
        '''視圖函數調用之前會調用'''
        user_ip=request.META['REMOTE_ADDR']
        if user_ip in BlockedIPSMiddleware.EXCLUDE_IPS:
            return HttpResponse('<h2>Forbidden</h2>')

注冊中間件類

vim settings.py

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'booktest.middleware.BlockedIPSMiddleware', #注冊中間件類
]

上傳圖片

配置上傳文件保存目錄

1. 新建上傳文件保存目錄
   在static下創建目錄media/booktest
2. 配置上傳文件保存目錄
   vim settings.py

   #設置上傳文件的保存目錄
   MEDIA_ROOT=os.path.join(BASE_DIR,'static/media')

后臺管理頁面上傳圖片

設計模型類

vim models.py

from django.db import models

# Create your models here.
class PicTest(models.Model):
    '''上傳圖片'''   goods_pic=models.ImageField(upload_to='booktest')

遷移生成表格

python manage.py makimigrations
python manage.py migrate

注冊模型類

vim admin.py

from django.contrib import admin
from booktest.models import PicTest
admin.site.register(PicTest)

自定義頁面上傳

1. 定義用戶上傳圖片的頁面并顯示，是一個自定義的表單

vim upload_pic.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>上傳圖片</title>
</head>
<body>
<form method="post" enctype="multipart/form-data" action="upload_handle">
    {% csrf_token %}
    <input type="file" name="pic"><br/>
    <input type="submit" value="上傳">
</form>
</body>
</html>

2. 定義接收上傳文件的視圖函數
   request對象有一個FILES的屬性，類似于字典，通過request.FILES可以獲取上傳文件的處理對象

vim views.py

from booktest.models import PicTest
def show_upload(request):
    '''顯示上傳圖片頁面'''
    return render(request,'booktest/upload_pic.html')

def upload_handle(request):
    '''上傳圖片處理'''
    # 1.獲取上傳的圖片
    pic =request.FILES['pic']
    #print (pic.name)
    #2.創建一個文件
    save_path= '%s/booktest/%s' %(settings.MEDIA_ROOT,pic.name)
    with open(save_path,'wb') as f:
        #3.獲取上傳文件的內容并寫到創建的文件中
        for content in pic.chunks():
            f.write(content)
    #4. 在數據庫中保存上傳記錄
    PicTest.objects.create(goods_pic='booktest/%s' %pic.name)
    #5.返回
    return HttpResponse('ok')

上傳文件不大于2.5M，文件放在內存中
上傳文件大于2.5M，文件內容寫到一個臨時文件中

分頁

查詢出所有省級地區的信息，顯示在頁面上。
AreaInfo.objects.filter(aparent_isnull)

1. 查詢出所有省級地區的信息
2. 按每頁顯示10條信息進行分頁，默認顯示第一頁的信息，下面并顯示出頁碼
3. 點擊i頁鏈接的時候，就顯示第i頁的省級地區信息。

from django.core.paginator import Paginator
paginator=Paginator(areas,10) #按每頁10條數據進行分頁

Paginator類對象的屬性

Paginator

Page類對象的屬性

Page類對象的方法