Django(一)
Django
1、什麼是web框架
框架，即framework，特指爲解決一個開放性問題而設計的具備必定約束性的支撐結構，使用框架能夠幫你快速開發特定的系統，簡單地說，就是你用別人搭建好的舞臺來作表演。
對於全部的Web應用，本質上其實就是一個socket服務端，用戶的瀏覽器其實就是一個socket客戶端。css
最簡單的Web應用就是先把HTML用文件保存好，用一個現成的HTTP服務器軟件，接收用戶請求，從文件中讀取HTML，返回。html
若是要動態生成HTML，就須要把上述步驟本身來實現。不過，接受HTTP請求、解析HTTP請求、發送HTTP響應都是苦力活，若是咱們本身來寫這些底層代碼，還沒開始寫動態HTML呢，就得花個把月去讀HTTP規範。前端
正確的作法是底層代碼由專門的服務器軟件實現，咱們用Python專一於生成HTML文檔。由於咱們不但願接觸到TCP鏈接、HTTP原始請求和響應格式，因此，須要一個統一的接口，讓咱們專心用Python編寫Web業務。python
這個接口就是WSGI：Web Server Gateway Interface。mysql
2、Django的底層原理（靜態頁面）：
對於Django的設計原理這裏會用Python的Socket來演示：jquery
import socket
+++++++++++C過程++++++++++++++++++++++++++
def f1(request):
"""
處理用戶請求，並返回相應的內容
:param request: 用戶請求的全部信息
:return:
"""
f = open('index.fsw','rb')
data = f.read()
f.close()
return data
def f2(request):
f = open('aricle.tpl','rb')
data = f.read()
f.close()
return data
+++++++++++C過程++++++++++++++++++++++++++
+++++++++++D過程++++++++++++++++++++++++++
routers = [
('/xxx', f1),
('/ooo', f2),
]
+++++++++++D過程++++++++++++++++++++++++++
++++++++++++A過程++++++++++++++++++++++++++
def run():
sock = socket.socket()
sock.bind(('127.0.0.1',8080))
sock.listen(5)
while True:
conn,addr = sock.accept() # hang住
# 有人來鏈接了
# 獲取用戶發送的數據
data = conn.recv(8096)
data = str(data,encoding='utf-8')
headers,bodys = data.split('\r\n\r\n')
temp_list = headers.split('\r\n')
method,url,protocal = temp_list[0].split(' ')
conn.send(b"HTTP/1.1 200 OK\r\n\r\n")
+++++++++++++++A過程+++++++++++++++++++++++
+++++++++++++++B過程+++++++++++++++++++++++
func_name = None
for item in routers:
if item[0] == url:
func_name = item[1]
break
if func_name:
response = func_name(data)
else:
response = b"404"
conn.send(response)
conn.close()
+++++++++++++++B過程+++++++++++++++++++++++
if __name__ == '__main__':
run()
分析：git
上述是一個簡單socket加載的靜態頁面，也是最基礎的一個Django的一個框架雛形web
A過程---循環的接收客戶端的請求，並拆分客戶的請求信息（message_header）這個過程是繁雜的。ajax
B過程---對A過程的拆分好的客戶端信息進行解析，並根據請求信息返回調用對應的頁面反饋給客戶端正則表達式
C過程--至關於Django的視圖函數，經路由分配後B過程調用的執行代碼
D過程--就是Django的路由分配系統。
Django的底層原理（動態頁面）
import socket
def f1(request):
"""
處理用戶請求，並返回相應的內容
:param request: 用戶請求的全部信息
:return:
"""
f = open('index.fsw','rb')
data = f.read()
f.close()
return data
def f2(request):
f = open('aricle.tpl','r',encoding='utf-8')
data = f.read()
f.close()
import time
ctime = time.time()
data = data.replace('@@sw@@',str(ctime))
return bytes(data,encoding='utf-8')
def f3(request):
import pymysql
# 建立鏈接
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='db666')
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
cursor.execute("select id,username,password from userinfo")
user_list = cursor.fetchall()
cursor.close()
conn.close()
content_list = []
for row in user_list:
tp = "<tr><td>%s</td><td>%s</td><td>%s</td></tr>" %(row['id'],row['username'],row['password'])
content_list.append(tp)
content = "".join(content_list)
f = open('userlist.html','r',encoding='utf-8')
template = f.read()
f.close()
# 模板渲染（模板+數據）
data = template.replace('@@sdfsdffd@@',content)
return bytes(data,encoding='utf-8')
def f4(request):
import pymysql
# 建立鏈接
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='db666')
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
cursor.execute("select id,username,password from userinfo")
user_list = cursor.fetchall()
cursor.close()
conn.close()
f = open('hostlist.html','r',encoding='utf-8')
data = f.read()
f.close()
# 基於第三方工具實現的模板渲染
from jinja2 import Template
template = Template(data)
data = template.render(xxxxx=user_list,user='sdfsdfsdf')
return data.encode('utf-8')
routers = [
('/xxx', f1),
('/ooo', f2),
('/userlist.htm', f3),
('/host.html', f4),
]
def run():
sock = socket.socket()
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(('127.0.0.1',8080))
sock.listen(5)
while True:
conn,addr = sock.accept() # hang住
# 有人來鏈接了
# 獲取用戶發送的數據
data = conn.recv(8096)
data = str(data,encoding='utf-8')
headers,bodys = data.split('\r\n\r\n')
temp_list = headers.split('\r\n')
method,url,protocal = temp_list[0].split(' ')
conn.send(b"HTTP/1.1 200 OK\r\n\r\n")
func_name = None
for item in routers:
if item[0] == url:
func_name = item[1]
break
if func_name:
response = func_name(data)
else:
response = b"404"
conn.send(response)
conn.close()
if __name__ == '__main__':
run()
動態的頁面與靜態的頁面的原理相同只是增長一個模板的導入和渲染。因此對於瞭解Django的底層的運行機制這兩個實例是很好案例。
提醒：對於咱們在Django中添加css的渲染文件或者其餘文件在導入到過程當中的路徑問題這裏須要瞭解Django的別名配置：
static配置
#三、STATIC文件還能夠配置STATICFILES_DIRS，指定額外的靜態文件存儲位置。
# STATIC_URL的含義與MEDIA_URL相似。
# ----------------------------------------------------------------------------
#注意1:
#爲了後端的更改不會影響前端的引入，避免形成前端大量修改
STATIC_URL = '/static/' #引用名
STATICFILES_DIRS = (
os.path.join(BASE_DIR,"statics") #實際名 ,即實際文件夾的名字
)
#django對引用名和實際名進行映射,引用時,只能按照引用名來,不能按實際名去找
#<script src="/statics/jquery-3.1.1.js"></script>
#------error－－－－－不能直接用，必須用STATIC_URL = '/static/':
#<script src="/static/jquery-3.1.1.js"></script>
#注意2(statics文件夾寫在不一樣的app下,靜態文件的調用):
STATIC_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>
經常使用命令
終端執行的命令：
# 查看django版本
$ python -m django --version
# 建立項目,名爲mysite
$ django-admin startproject mysite
# Django項目環境終端
$ python manage.py shell
# 建立應用程序，確保和 manage.py 是同一目錄
$ python manage.py startapp polls
# 啓動django
$ python manage.py runserver
$ python manage.py runserver 8080
$ python manage.py runserver 0.0.0.0:8000
# 運行創造模型變化遷移
$ python manage.py makemigrations
# 運行應用模型變化到數據庫
$ python manage.py migrate
# 同步數據庫
$ python manage.py syncdb
# 清空數據庫（保留空表）
$ python manage.py flush
# admin建立管理員用戶
$ python manage.py createsuperuser
# 修改用戶密碼
$ python manage.py changepassword username
注：自動從新加載 runserver，根據須要開發服務器自動從新加載Python代碼爲每一個請求。您不須要從新啓動服務器代碼更改生效。然而，像添加文件某些操做不觸發從新啓動，因此你必須從新啓動在這些狀況下的服務器。
下面是基本的目錄結構及做用
mysite/ # 項目的容器,名稱自定義
manage.py # 命令行實用工具,以各類方式與該Django項目進行交互
mysite/ # 實際的Python項目
__init__.py # 空文件,導入不出錯
settings.py # 這個Django項目配置
urls.py # 這個Django項目的URL聲明; 一個Django驅動網站的「目錄」
wsgi.py # 一個入口點爲WSGI兼容的Web服務器，以知足您的項目
配置文件
1.靜態文件
# 在settings裏修改添加，放css,js,image等文件
# 建立static文件夾
STATIC_URL = '/static/' # 至關於別名
STATICFILES_DIRS = (
os.path.join(BASE_DIR,'static'),
)
# 如引用Jquery文件，有倆種形式
一、 直接引入
二、 {% load staticfiles %}
{% static '文件名' %}
# 推薦使用第二種形式，第一條代碼並處理引入文件代碼的上方
# 再每一個app裏面咱們可能會有多個文件配置信息，則能夠相應的將文件夾放在app的文件夾下，並修改路徑。
2.模板
# 在settings裏修改，放html文件
TEMPLATE_DIRS = (
os.path.join(BASE_DIR,'templates'),
3.數據庫
django支持sqlite，mysql, oracle,postgresql數據庫
django默認使用sqlite的數據庫，默認自帶sqlite的數據庫驅動 , 引擎名稱：django.db.backends.sqlite3
因爲Django內部鏈接MySQL時使用的是MySQLdb模塊，而python3中還無此模塊，因此須要使用pymysql來代替
設置放置的與project同名的配置的 init.py文件中
import pymysql
pymysql.install_as_MySQLdb()
# 在settings 中修改DATABASES
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'dbname', # 數據庫名稱
'USER': 'root', # 用戶名
'PASSWORD': 'xxx', # 密碼
'HOST': '', # IP,留空默認localhost
'PORT': '', # 端口
}
}
static的詳細介紹
# 注意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>
# 注意4:
配置STATIC路徑時,記得要最後一個元組後面加逗號,否則會影響渲染
路由系統
URL配置(URLconf)就像Django 所支撐網站的目錄。它的本質是URL模式以及要爲該URL模式調用的視圖函數之間的映射表；你就是以這種方式告訴Django，對於這個URL調用這段代碼，對於那個URL調用那段代碼。
django中的路由系統和其餘語言的框架有所不一樣，在django中每個請求的url都要有一條路由映射，這樣才能將請求交給對一個的view中的函數去處理。其餘大部分的Web框架則是對一類的url請求作一條路由映射，從而是路由系統變得簡潔。
urlpatterns = [
url(正則表達式, views視圖函數，參數，別名),
]
# 參數說明
# 一個正則表達式字符串
# 一個可調用對象，一般爲一個視圖函數或一個指定視圖函數路徑的字符串
# 可選的要傳遞給視圖函數的默認參數（字典形式）
# 一個可選的name參數
下面是一些示例：
一、單一路由分配
url(r'^index$', views.index),
二、基於正則的路由分配
url(r'^index/(\d*)', views.index), # 無命名傳參
url(r'^manage/(?P<name>\w*)/(?P<id>\d*)', views.manage), # 有命名傳參
三、添加額外的參數
url(r'^manage/(?P<name>\w*)', views.manage,{'id':333}),
四、路由映射設置名稱
url(r'^home', views.home, name='h1'),
url(r'^index/(\d*)', views.index, name='h2'),
五、路由分發
若是映射url太多,全寫一個在 urlpatterns 顯得繁瑣，so 路由分發應用而生
url(r'^blog/', include('blog.urls')),
# 須要注意
# url多傳了一個參數，那views函數得多接受一個參數
視圖層
對邏輯負責處理用戶的請求並返回響應。反回能夠是HTML內容的網頁，或重定向，或404錯誤，或一個XML文件，或一個形象......此代碼能夠住在任何你想去的地方，只要它在你的Python路徑。
在一個文件中稱將視圖views.py，放在項目或應用程序目錄。
http請求中產生兩個核心對象：http請求：HttpRequest對象 http響應：HttpResponse對象 所在位置：django.http
HttpRequest對象（一）
#從django.http模塊中導入HttpResponse類[1]
from django.http import HttpResponse
import datetime
def current_datetime(request): #[2]
now=datetime.datetime.now()
html="<html><body>如今時刻：%s.</body></html>" %now
return HttpResponse(html)
# 注意：這是一段很簡單、簡陋的例子
# 在這個(views.py)視圖中每個函數稱做視圖函數，視圖函數都以一個HttpRequest對象爲第一個參數，該參數一般命名爲request
由上面示例獲得視圖函數第一個參數是一個HttpRequest對象，那麼經過這個對象能夠拿到一些信息
# 經過request.XX的方式
path # 請求頁面的全路徑，不包括域名
get_full_path() # 能夠獲得帶數據得路徑，而path就不行
method # 請求中使用的HTTP方法的字符串表示，全大寫表示。
GET # 包含全部HTTP GET參數的類字典對象
POST # 包含全部HTTP POST參數的類字典對象
COOKIES # 一個標準的Python字典，包含全部cookie。鍵和值都是字符串。
FILES # 經過表單上傳的文件全都封裝在該屬性中
"""
filename ：字符串，表示上傳文件的文件名。
content-type ：上傳文件的內容類型。
content ：上傳文件的原始內容。
"""
META # 一個標準的Python字典，包含全部有效的HTTP頭信息
"""
CONTENT_LENGTH
CONTENT_TYPE
QUERY_STRING ：未解析的原始請求字符串
REMOTE_ADDR ：客戶端IP地址
REMOTE_HOST ：客戶端主機名
SERVER_NAME ：服務器主機名
SERVER_PORT ：服務器端口號
HTTP_ACCEPT_ENCODING
HTTP_ACCEPT_LANGUAGE
HTTP_HOST ：客戶端發送的 Host 頭信息。
HTTP_REFERER ：被指向的頁面，若是存在的。
HTTP_USER_AGENT ：客戶端的user-agent字符串。
HTTP_X_BENDER ： X-Bender 頭信息的值，若是已設的話
"""
session # 一個可讀寫的類字典對象，表示當前session
body # POST的原始數據, 用於對數據的複雜處理
has_key() # 返回 True 或 False ，標識 request.GET 或 request.POST 是否包含所給的鍵
is_secure() # 若是請求是安全的，則返回 True 。也就是說，請求是以HTTPS的形式提交的
is_ajax() # 待補充說明...
user # 待補充說明..
HttpResponse對象（二）
對於HttpRequest對象來講，是由django自動建立的，可是，HttpResponse對象就必須咱們本身建立。每一個view請求處理方法必須返回一個HttpResponse對象。
在HttpResponse對象上擴展的經常使用方法：
render()
render(request, template_name, context=None, content_type=None, status=None, using=None)[source]
結合給定的模板與一個給定的上下文，返回一個字典HttpResponse在渲染文本對象
template_name 一個模板的使用或模板序列名稱全稱。若是序列是給定的，存在於第一個模板將被使用。
可選參數
- context 一組字典的值添加到模板中。默認狀況下，這是一個空的字典。
- content_type MIME類型用於生成文檔。
- status 爲響應狀態代碼。默認值爲200
using 這個名字一個模板引擎的使用將模板。
from django.shortcuts import render
def index(request_info):
test = 1return render(request_info,'index.html',{'test':test})
render_to_response()
render_to_response(template_name, context=None, content_type=None, status=None, using=None)[source]
這個和 render() 差很少，它不須要傳入request對象，並不推薦使用
redirect()
redirect(to, permanent=False, *args, **kwargs)[source]
此方法可稱之爲頁面跳轉，能夠獲得達到某種條件時，如再登錄淘寶界面，登錄成功以後會跳轉到用戶的主界面
默認狀況下，爲臨時重定向；經過 permanent=True 設置永久重定向
from django.shortcuts import render, HttpResponse,redirect
def register(request_info):
if request_info.method == 'POST':
user = request_info.POST.get('user')
pwd = request_info.POST.get('pwd')
if user == 'leguan' and pwd == '187418':
return redirect('/login/')
return HttpResponse('帳號或密碼錯誤')
return render(request_info,'register.html')
def login(request_info):
return render(request_info,'login.html')
# 在此可能會想到用render也能夠再條件達成以後進行頁面的跳轉。
# 那麼倆者之間有什麼區別呢
# 一、the most important: url沒有跳轉到/login/,而是還在/register/,因此當刷新後又得從新登陸.
DEMO
from django.http import JsonResponse
在經過Ajax發送請求時，後端傳參時可能會用到JSON序列化，經過JsonResponse便可
from django.http import JsonResponse
result = {'status': True, 'data': None}
return JsonResponse(result)
# 等同於
import json
return HttpResponse(json.dumps(result))
DEMO
補充
一般再後端想要將一些變量給前端或替換一些內容
一般在views視圖是這樣
def index(request_info):
user = ['蒼空','波多','飯島',16]
return render(request_info,'index.html',{'user':user})
那麼若是變量不少的狀況下，還須要再組成多組鍵值對進行傳遞麼，locals()很好的解決了這個問題
# 等同於上面
def index(request_info):
user = ['蒼空','波多','飯島',16]
return render(request_info,'index.html',locals())
# locals()
它是局部的，渲染全部的局部變量，能夠將函數內全部的變量傳遞request對象獲取到。
注意點、此時視圖函數內的變量名稱要和前端代碼的變量名稱對應
模板層
做爲一個Web框架，Django 須要模板。模板包含所需的 HTML 輸出靜態部分以及動態內容插入。
模板由 HTML代碼＋邏輯控制代碼 構成，既然叫模板層，相應有一個模板語言的概念（語法格式：{{var_name}}），那麼簡單的瞭解下
>>> python manange.py shell (進入該django項目的環境)
>>> from django.template import Context, Template
>>> t = Template('My name is {{ name }}.')
>>> c = Context({'name': 'Tony'})
>>> t.render(c)
'My name is Tony.'
# 同一模板，多個上下文，一旦有了模板對象，你就能夠經過它渲染多個context，不管什麼時候咱們均可以
# 像這樣使用同一模板源渲染多個context，只進行 一次模板建立而後屢次調用render()方法渲染會
# 更爲高效：
# Low
for name in ('John', 'Julie', 'Pat'):
t = Template('Hello, {{ name }}')
print t.render(Context({'name': name}))
# Good
t = Template('Hello, {{ name }}')
for name in ('John', 'Julie', 'Pat'):
print t.render(Context({'name': name}))
A、深度變量查找
在到上述爲止的例子中，經過 context 傳遞的簡單參數值主要是字符串，然而，模板系統可以很是簡潔地處理更加複雜的數據結構，例如list、dictionary和自定義的對象。
# python manage.py shell 首先進入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.'
# 二、訪問字典索引
>>> from django.template import Template,Context
>>> person = {"name":"Alex","age":18}
>>> t = Template("{{person.name}} is {{person.age}} years old.")
>>> c = Context({"person":person})
>>> t.render(c)
'Alex is 18 years old.'
# 三、datetime示例
>>> from django.template import Template,Context
>>> import datetime
>>> day = datetime.datetime.utcnow()
>>> day.year
>>> day.month
>>> day.day
>>> t = Template('The month is {{ date.month }} and the year is {{date.year}}')
>>> c = Context({'date':day})
>>> t.render(c)
'The month is 3 and the year is 2017'
# 四、類的實例
>>> 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.'
# 五、引用對象方法
>>> 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":"666"}))
'666--666--True'
# 注意點
調用方法時並* 沒有* 使用圓括號 並且也沒法給該方法傳遞參數；你只能調用不需參數的方法。
POINT DEMO
B、變量的過濾器（filter的使用）
# 格式 {{obj|filter:param}}
# 1 add ： 給變量加上相應的值
#
# 2 addslashes : 給變量中的引號前加上斜線
#
# 3 capfirst : 首字母大寫
#
# 4 cut ： 從字符串中移除指定的字符
#
# 5 date ： 格式化日期字符串
#
# 6 default ： 若是值是False,就替換成設置的默認值，不然就是用原本的值
#
# 7 default_if_none: 若是值是None，就替換成設置的默認值，不然就使用原本的值
# DEMO
#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 %} # Django安全機制關閉
{{ value6 }}
{% endautoescape %}
{{ value6|safe }}<br> # 若是標籤不被渲染,加safe便可
{{ 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 Tony'
Filter DEMO
C、模板語言的控制語句
if AND for DEMO
# 一、{% if %} 的使用
{% if %}標籤計算一個變量值，若是是「true」，即它存在、不爲空而且不是false的boolean值,系統則會顯示{% if %}和{% endif %}間的全部內容
{% if num >= 100 and 8 %}
{% if num > 200 %}
<p>num大於200</p>
{% else %}
<p>num大於100小於200</p>
{% endif %}
{% elif num < 100%}
<p>num小於100</p>
{% else %}
<p>num等於100</p>
{% endif %}
# {% if %} 標籤接受and，or或者not來測試多個變量值或者否認一個給定的變量
# {% if %} 標籤不容許同一標籤裏同時出現and和or，不然邏輯容易產生歧義，例以下面的標籤是不合法的：
# {% if obj1 and obj2 or obj3 %}
# 二、{% for %}的使用
{% for %}標籤容許你按順序遍歷一個序列中的各個元素,每次循環模板系統都會渲染{% for %}和{% endfor %}之間的全部內容
<ul>
{% for obj in list %}
<li>{{ obj.name }}</li>
{% endfor %}
</ul>
#在標籤裏添加reversed來反序循環列表：
{% for obj in list reversed %}
...
{% endfor %}
#{% for %}標籤能夠嵌套：
{% for country in countries %}
<h1>{{ country.name }}</h1>
<ul>
{% for city in country.city_list %}
<li>{{ city }}</li>
{% endfor %}
</ul>
{% endfor %}
# 系統不支持中斷循環，系統也不支持continue語句，{% for %}標籤內置了一個forloop模板變量，
# 這個變量含有一些屬性能夠提供給你一些關於循環的信息
1，forloop.counter表示循環的次數，它從1開始計數，第一次循環設爲1:
{% for item in todo_list %}
<p>{{ forloop.counter }}: {{ item }}</p>
{% endfor %}
2，forloop.counter0 相似於forloop.counter，但它是從0開始計數，第一次循環設爲0
3，forloop.revcounter
4，forloop.revcounter0
5，forloop.first當第一次循環時值爲True，在特別狀況下頗有用：
{% for object in objects %}
{% if forloop.first %}<li class="first">{% else %}<li>{% endif %}
{{ object }}
</li>
{% endfor %}
# 富有魔力的forloop變量只能在循環中獲得，當模板解析器到達{% endfor %}時forloop就消失了
# 若是你的模板context已經包含一個叫forloop的變量，Django會用{% for %}標籤替代它
# Django會在for標籤的塊中覆蓋你定義的forloop變量的值
# 在其餘非循環的地方，你的forloop變量仍然可用
#{% empty %}
{{li }}
{% for i in li %}
<li>{{ forloop.counter0 }}----{{ i }}</li>
{% empty %}
<li>this is empty!</li>
{% endfor %}
# [11, 22, 33, 44, 55]
# 0----11
# 1----22
# 2----33
# 3----44
# 4----55
D、自定義filter和simple_tag
# 一、在app中建立templatetags模塊(必須的)
# 二、建立任意 .py 文件，如：my_tags.py
from django import template
from django.utils.safestring import mark_safe
register = template.Library() # register的名字是固定的,不可改變
@register.filter
def custom_filter(x,y):
return x*y
@register.simple_tag
def custom_simple(x,y,z):
return x+y+z
# 三、在使用自定義simple_tag和filter的html文件中導入以前建立的 my_tags.py ：{% load my_tags %}
# 四、使用simple_tag和filter（如何調用）
-------------------------------HTML文件
{% load xxx %} # 位於首行,xxx表明自定義的文件名
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>Hello {{ user.0 }}</h1>
{{ user.3|custom_filter:8 }}
{% custom_simple user.3 2 3 %}
</body>
</html>
# 五、在settings中的INSTALLED_APPS配置當前app，否則django沒法找到自定義的simple_tag
# 六、注意點、filter能夠用在if等語句後，simple_tag不能夠
{% if num|filter_multi:30 > 100 %}
{{ num|filter_multi:30 }}
{% endif %}
fileter simple_tag DEMO
E、模板繼承及模板語言
常常瀏覽淘寶的諸多不一樣頁面中，導航欄一些其它部分的內容始終是不變的。那麼，在整個網站中，如何減小共用頁面區域所引發的重複和冗餘代碼？
Django 解決此類問題的首選方法是使用更加優雅的策略—— 模板繼承
本質上來講，模板繼承就是先構造一個基礎框架模板，然後在其子模板中對它所包含站點公用部分和定義塊進行重載
母板：{% block title %}{% endblock %} # 定義盒子
子板：{% extends "base.html" %} # 繼承母板的內容，且必須放在模板第一行
{% block title %}{% endblock %} # 能夠對盒子的內容進行修改
{% csrf_token %} # 取消csrf安全保護
{% black.super %}
{% include '小組件路徑' %} # HTML出現相同塊代碼時，新建公用小組件HTML文件
Model層
Django提供了一個抽象層（"Model"）的構建和管理Web應用程序的數據。
Django使用一種新的方式，即：關係對象映射（Object Relational Mapping，簡稱ORM）。
- 每一個模型是一個Python類，子類django.db.models.model
模型中的每一個屬性表明一個數據庫字段。
DEMO
class Student(models.Model):
name = models.CharField(max_length=10)
sex = models.CharField(max_length=10)
age = models.IntegerField()
grade = models.ForeignKey('Grade')
** 字段**
AutoField(Field)
- int自增列，必須填入參數 primary_key=True
BigAutoField(AutoField)
- bigint自增列，必須填入參數 primary_key=True
注：當model中若是沒有自增列，則自動會建立一個列名爲id的列
from django.db import models
class UserInfo(models.Model):
# 自動建立一個列名爲id的且爲自增的整數列
username = models.CharField(max_length=32)
class Group(models.Model):
# 自定義自增列
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32)
SmallIntegerField(IntegerField):
- 小整數 -32768 ～ 32767
PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
- 正小整數 0 ～ 32767
IntegerField(Field)
- 整數列(有符號的) -2147483648 ～ 2147483647
PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
- 正整數 0 ～ 2147483647
BigIntegerField(IntegerField):
- 長整型(有符號的) -9223372036854775808 ～ 9223372036854775807
自定義無符號整數字段
class UnsignedIntegerField(models.IntegerField):
def db_type(self, connection):
return 'integer UNSIGNED'
PS: 返回值爲字段在數據庫中的屬性，Django字段默認的值爲：
'AutoField': 'integer AUTO_INCREMENT',
'BigAutoField': 'bigint AUTO_INCREMENT',
'BinaryField': 'longblob',
'BooleanField': 'bool',
'CharField': 'varchar(%(max_length)s)',
'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
'DateField': 'date',
'DateTimeField': 'datetime',
'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
'DurationField': 'bigint',
'FileField': 'varchar(%(max_length)s)',
'FilePathField': 'varchar(%(max_length)s)',
'FloatField': 'double precision',
'IntegerField': 'integer',
'BigIntegerField': 'bigint',
'IPAddressField': 'char(15)',
'GenericIPAddressField': 'char(39)',
'NullBooleanField': 'bool',
'OneToOneField': 'integer',
'PositiveIntegerField': 'integer UNSIGNED',
'PositiveSmallIntegerField': 'smallint UNSIGNED',
'SlugField': 'varchar(%(max_length)s)',
'SmallIntegerField': 'smallint',
'TextField': 'longtext',
'TimeField': 'time',
'UUIDField': 'char(32)',
BooleanField(Field)
- 布爾值類型
NullBooleanField(Field):
- 能夠爲空的布爾值
CharField(Field)
- 字符類型
- 必須提供max_length參數， max_length表示字符長度
TextField(Field)
- 文本類型
EmailField(CharField)：
- 字符串類型，Django Admin以及ModelForm中提供驗證機制
IPAddressField(Field)
- 字符串類型，Django Admin以及ModelForm中提供驗證 IPV4 機制
GenericIPAddressField(Field)
- 字符串類型，Django Admin以及ModelForm中提供驗證 Ipv4和Ipv6
- 參數：
protocol，用於指定Ipv4或Ipv6， 'both',"ipv4","ipv6"
unpack_ipv4， 若是指定爲True，則輸入::ffff:192.0.2.1時候，可解析爲192.0.2.1，開啓刺功能，須要protocol="both"
URLField(CharField)
- 字符串類型，Django Admin以及ModelForm中提供驗證 URL
SlugField(CharField)
- 字符串類型，Django Admin以及ModelForm中提供驗證支持 字母、數字、下劃線、鏈接符（減號）
CommaSeparatedIntegerField(CharField)
- 字符串類型，格式必須爲逗號分割的數字
UUIDField(Field)
- 字符串類型，Django Admin以及ModelForm中提供對UUID格式的驗證
FilePathField(Field)
- 字符串，Django Admin以及ModelForm中提供讀取文件夾下文件的功能
- 參數：
path, 文件夾路徑
match=None, 正則匹配
recursive=False, 遞歸下面的文件夾
allow_files=True, 容許文件
allow_folders=False, 容許文件夾
FileField(Field)
- 字符串，路徑保存在數據庫，文件上傳到指定目錄
- 參數：
upload_to = "" 上傳文件的保存路徑
storage = None 存儲組件，默認django.core.files.storage.FileSystemStorage
ImageField(FileField)
- 字符串，路徑保存在數據庫，文件上傳到指定目錄
- 參數：
upload_to = "" 上傳文件的保存路徑
storage = None 存儲組件，默認django.core.files.storage.FileSystemStorage
width_field=None, 上傳圖片的高度保存的數據庫字段名（字符串）
height_field=None 上傳圖片的寬度保存的數據庫字段名（字符串）
DateTimeField(DateField)
- 日期+時間格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]
DateField(DateTimeCheckMixin, Field)
- 日期格式 YYYY-MM-DD
TimeField(DateTimeCheckMixin, Field)
- 時間格式 HH:MM[:ss[.uuuuuu]]
DurationField(Field)
- 長整數，時間間隔，數據庫中按照bigint存儲，ORM中獲取的值爲datetime.timedelta類型
FloatField(Field)
- 浮點型
DecimalField(Field)
- 10進制小數
- 參數：
max_digits，小數總長度
decimal_places，小數位長度
BinaryField(Field)
- 二進制類
Field參數
null 數據庫中字段是否能夠爲空
db_column 數據庫中字段的列名
db_tablespace
default 數據庫中字段的默認值
primary_key 數據庫中字段是否爲主鍵
db_index 數據庫中字段是否能夠創建索引
unique 數據庫中字段是否能夠創建惟一索引
unique_for_date 數據庫中字段【日期】部分是否能夠創建惟一索引
unique_for_month 數據庫中字段【月】部分是否能夠創建惟一索引
unique_for_year 數據庫中字段【年】部分是否能夠創建惟一索引
verbose_name Admin中顯示的字段名稱
blank Admin中是否容許用戶輸入爲空
editable Admin中是否能夠編輯
help_text Admin中該字段的提示信息
choices Admin中顯示選擇框的內容，用不變更的數據放在內存中從而避免跨表操做
如：gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1)
error_messages 自定義錯誤信息（字典類型），從而定製想要顯示的錯誤信息；
字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date
如：{'null': "不能爲空.", 'invalid': '格式錯誤'}
validators 自定義錯誤驗證（列表類型），從而定製想要的驗證規則
from django.core.validators import RegexValidator
from django.core.validators import EmailValidator,URLValidator,DecimalValidator,\
MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator
如：
test = models.CharField(
max_length=32,
error_messages={
'c1': '優先錯信息1',
'c2': '優先錯信息2',
'c3': '優先錯信息3',
},
validators=[
RegexValidator(regex='root_\d+', message='錯誤了', code='c1'),
RegexValidator(regex='root_112233\d+', message='又錯誤了', code='c2'),
EmailValidator(message='又錯誤了', code='c3'), ]
)
二、連表結構例如在建表的時候應該瞭解到如何
- 一對多：models.ForeignKey(其餘表)
- 多對多：models.ManyToManyField(其餘表)
- 一對一：models.OneToOneField(其餘表)
三、表操做
a、基本操做
# 增
#
# models.Tb1.objects.create(c1='xx', c2='oo') 增長一條數據，能夠接受字典類型數據 **kwargs
# obj = models.Tb1(c1='xx', c2='oo')
# obj.save()
# 查
#
# models.Tb1.objects.get(id=123) # 獲取單條數據，不存在則報錯（不建議）
# models.Tb1.objects.all() # 獲取所有
# models.Tb1.objects.filter(name='seven')# 獲取指定條件的數據
# 刪
#
# models.Tb1.objects.filter(name='seven').delete() # 刪除指定條件的數據
# 改
# models.Tb1.objects.filter(name='seven').update(gender='0') # 將指定條件的數據更新，均支持 **kwargs
# obj = models.Tb1.objects.get(id=1)
# obj.c1 = '111'
# obj.save() # 修改單條數據
b、進階操做(了不得的雙下劃線)
# 獲取個數
#
# models.Tb1.objects.filter(name='seven').count()
# 大於，小於
#
# models.Tb1.objects.filter(id__gt=1) # 獲取id大於1的值
# models.Tb1.objects.filter(id__gte=1) # 獲取id大於等於1的值
# models.Tb1.objects.filter(id__lt=10) # 獲取id小於10的值
# models.Tb1.objects.filter(id__lte=10) # 獲取id小於10的值
# models.Tb1.objects.filter(id__lt=10, id__gt=1) # 獲取id大於1 且 小於10的值
# in
#
# models.Tb1.objects.filter(id__in=[11, 22, 33]) # 獲取id等於十一、2二、33的數據
# models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in
# isnull
# Entry.objects.filter(pub_date__isnull=True)
# contains
#
# models.Tb1.objects.filter(name__contains="ven")
# models.Tb1.objects.filter(name__icontains="ven") # icontains大小寫不敏感
# models.Tb1.objects.exclude(name__icontains="ven")
# range
#
# models.Tb1.objects.filter(id__range=[1, 2]) # 範圍bettwen and
# 其餘相似
#
# startswith，istartswith, endswith, iendswith,
# order by
#
# models.Tb1.objects.filter(name='seven').order_by('id') # asc
# models.Tb1.objects.filter(name='seven').order_by('-id') # desc
# group by
#
# from django.db.models import Count, Min, Max, Sum
# models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))
# SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"
# limit 、offset
#
# models.Tb1.objects.all()[10:20]
# regex正則匹配，iregex 不區分大小寫
#
# Entry.objects.get(title__regex=r'^(An?|The) +')
# Entry.objects.get(title__iregex=r'^(an?|the) +')
# date
#
# Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
# Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))
# year
#
# Entry.objects.filter(pub_date__year=2005)
# Entry.objects.filter(pub_date__year__gte=2005)
# month
#
# Entry.objects.filter(pub_date__month=12)
# Entry.objects.filter(pub_date__month__gte=6)
# day
#
# Entry.objects.filter(pub_date__day=3)
# Entry.objects.filter(pub_date__day__gte=3)
# week_day
#
# Entry.objects.filter(pub_date__week_day=2)
# Entry.objects.filter(pub_date__week_day__gte=2)
# hour
#
# Event.objects.filter(timestamp__hour=23)
# Event.objects.filter(time__hour=5)
# Event.objects.filter(timestamp__hour__gte=12)
# minute
#
# Event.objects.filter(timestamp__minute=29)
# Event.objects.filter(time__minute=46)
# Event.objects.filter(timestamp__minute__gte=29)
# second
#
# Event.objects.filter(timestamp__second=31)
# Event.objects.filter(time__second=2)
# Event.objects.filter(timestamp__second__gte=31)
c、連表操做(了不得的雙下劃線)
表結構實例
# DEMO
# 班級和老師存在多對多關係、班級和學生存在一對多關係
from django.db import models
class Classes(models.Model):
titile = models.CharField(max_length=32)
m = models.ManyToManyField('Teachers')
class Teachers(models.Model):
name = models.CharField (max_length=32)
class Student(models.Model):
username = models.CharField(max_length=32)
age = models.IntegerField()
gender = models.BooleanField()
cs = models.ForeignKey(Classes)
單表
# 增 # Teachers.objects.create(name='root') # obj = Teachers(name='root') # obj.save() # 查 # Teachers.objects.all() # Teachers.objects.filter(id=1) # Teachers.objects.filter(id=1,name='root') # result = Teachers.objects.filter(id__gt=1) # [obj(id,name),] # result = Teachers.objects.filter(id__gt=1).first() # 刪 # Teachers.objects.filter(id=1).delete() # 改 # Teachers.objects.all().update(name='alex') # Teachers.objects.filter(id=1).update(name='alex')
一對多
# 增長
# Student.objects.create(username='東北',age=18,gender='男',cs_id=1)
# Student.objects.create(username='東北',age=18,gender='男',cs= Classes.objects.filter(id=1).first() )
# 查看
"""
ret = Student.objects.all()
# []
# [ obj(..),]
# [ obj(1 東北 18 男 1),obj(2 東北1 118 男 2),obj(..),]
for item in ret:
print(item.id)
print(item.username)
print(item.age)
print(item.gender)
print(item.cs_id)
print(item.cs.id)
print(item.cs.name)
"""
# 刪除
# Student.objects.filter(id=1).delete()
# Student.objects.filter(cs_id=1).delete()
# cid = input('請輸入班級ID')
# Student.objects.filter(cs_id=cid).delete()
# cname = input('請輸入班級名稱')
# Student.objects.filter(cs_id=cid).delete()
# Student.objects.filter(cs__name=cname).delete()
多對多
班級：
id title
3班
4班
5班
老師：
id title
Whatmini
Tom
Honny
Eric
老師班級關係表(類):
id 班級id 老師id
1 2
1 3
2 2
2 3
2 4
1 5
# 增
obj = Classes.objects.filter(id=1).first() #1 3班
obj.m.add(2)
obj.m.add([4,3])
# obj = Classes.objects.filter(id=2).first() #1 3班
# obj.m.add(2)
# obj.m.add([4,3])
obj = Classes.objects.filter(id=1).first() #1 3班
# 刪除
# obj.m.remove([4,3])
# 清空
obj.m.clear()
# 重置
obj.m.set([2,3,5])
# 查第三張表
# 把3班的全部老師列舉
obj = Classes.objects.filter(id=1).frist()
obj.id
obj.titile
ret = obj.m.all() # 第三張表
# ret是一個 [ 老師1(id,name),obj(id,name) ]
d、其它操做
# extra
#
# extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
# Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
# Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
# Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
# Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])
# F 使用查詢條件的值,專門取對象中某列值的操做
#
# from django.db.models import F
# models.Tb1.objects.update(num=F('num')+1)
# Q 與 或 非 的關係構建搜索條件
#
# 方式一：
# Q(nid__gt=10)
# Q(nid=8) | Q(nid__gt=10)
# Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
# 方式二：
# con = Q()
# q1 = Q()
# q1.connector = 'OR'
# q1.children.append(('id', 1))
# q1.children.append(('id', 10))
# q1.children.append(('id', 9))
# q2 = Q()
# q2.connector = 'OR'
# q2.children.append(('c1', 1))
# q2.children.append(('c1', 10))
# q2.children.append(('c1', 9))
# con.add(q1, 'AND')
# con.add(q2, 'AND')
#
# models.Tb1.objects.filter(con)
# exists()方法來檢查是否有數據 exists()的檢查能夠避免數據放入queryset的cache。
# obj = Book.objects.filter(id=4)
# if obj.exists():print("hello world!")
# 執行原生SQL
#
# from django.db import connection, connections
# cursor = connection.cursor() # cursor = connections['default'].cursor()
# cursor.execute("""SELECT * from auth_user where id = %s""", [1])
# row = cursor.fetchone()
Q、F、exists()
e、補充
# values 取到的是字典集合
# values_list 取到的是沒有鍵的元祖形式
# get 只有在能取到一條數據的時候纔不會報錯(不推薦)
# filter([篩選條件])
# all() 倆者取到的都是Query set集合對象 是可迭代、可切片、索引取值
# iterator() ORM的惰性機制
# Publisher.objects.all()或者.filter()等都只是返回了一個QuerySet
# 並不會立刻執行sql，而是當調用QuerySet的時候才執行。
相關文章
- 1. Django（一）
- 2. Django(一)
- 3. Django 安裝 —Django學習 （一）
- 4. Python-Django 第一個Django app
- 5. Django框架（一）-- Django簡介
- 6. django - (一) 創建一個django工程
- 7. django之todolist(一)
- 8. django serializer（一）
- 9. Django Web(一)
- 10. 使用Django（一）
- 更多相關文章...
- • 一對一關聯查詢 - MyBatis教程
- • MySQL唯一約束（UNIQUE KEY） - MySQL教程
- • RxJava操作符（一）Creating Observables
- • Kotlin學習（一）基本語法
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
