Python自動化運維之2七、Django(一)

時間 2019-11-17

標籤 python 自動化 django 欄目 Python 简体版

原文原文鏈接

1、概述

一、什麼是框架？

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

二、常見的Python Web框架：

Full-Stack Frameworks（全棧框架、重量級框架）：
Django、web2py、TurboGears、Pylons、...css

Non Full-Stack Frameworks（非全棧框架、輕量級的框架）：
tornado、Flask、Bottle、web.py、Pyramid、...html

詳見：https://wiki.python.org/moin/WebFrameworks前端

三、這麼多框架，如何選擇？

a、根據項目需求去選擇。
b、根據框架的特色去選擇java

國內經常使用：django、tornado、flask、bottle，Django相較與其餘WEB框架其優點爲：大而全，框架自己集成了ORM、模型綁定、模板引擎、緩存、Session等諸多功能。python

Django官網：https://docs.djangoproject.com/en/1.11/mysql

2、基本配置

一、建立django程序

終端命令：django-admin startproject sitename
IDE建立Django程序時，本質上都是自動執行上述命令

經常使用命令：jquery

django-admin startproject sitename
django-admin startapp appname
python manage.py runserver 0.0.0.0:8000
python manage.py makemigrations
python manage.py migrate
python manage.py createsuperuser
python manage.py changepassword
python manage.py clearsessions

其餘命令：git

python manage.py shell     #進入django shell
python manage.py dbshell   #進入django dbshell
python manage.py check     #檢查django項目完整性
python manage.py flush     #清空數據庫
python manage.py compilemessages   #編譯語言文件
python manage.py makemessages      #建立語言文件
python manage.py showmigrations    #查看生成的數據庫同步腳本
python manage.py sqlflush          #查看生成清空數據庫的腳本
python manage.py sqlmigrate        #查看數據庫同步的sql語句
python manage.py dumpdata          #導出數據
python manage.py loaddata          #導入數據
python manage.py diffsettings      #查看你的配置和django默認配置的不一樣之處

其餘命令

二、程序目錄,django 1.9以上templates會自動建立

三、配置文件

(1)APP配置,後續建立app須要添加進這裏web

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

(2)數據庫配置,默認是sqlite3

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

因爲Django內部鏈接MySQL時使用的是MySQLdb模塊，而python3中還無此模塊，因此須要使用pymysql來代替
以下設置放置的與project同名的配置的 __init__.py文件中

import pymysql
pymysql.install_as_MySQLdb()

(3)模版配置

templates是用於放置模板html,在django1.9以上中會自動建立並設置

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')]
        ,
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

(4)靜態文件配置

static是本身建立的目錄用於放置css,js,image，須要在settings中設置這個目錄　　

STATIC_URL = '/static/'   
# 這個路徑是對應 src="/static/ 這個的別名， 若是這個路徑改成 STATIC_URL = '/abc/' 那麼<script src="/abc/jquery-2.2.4.min.js"></script>

STATICFILES_DIRS = (
    os.path.join(BASE_DIR,'static'),
)

<script src="/static/jquery-2.2.4.min.js"></script>

MEDIA是本身建立的目錄用於上傳圖片和文件

MEDIA_ROOT：是本地路徑的絕對路徑，通常是這樣寫
MEDIA_URL：是指從瀏覽器訪問時的地址前綴

MEDIA_URL = '/upload/'
MEDIA_ROOT = os.path.join(BASE_DIR,'upload')

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

urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^upload/(?P<path>.*)$', "django.views.static.serve", {"document_root": settings.MEDIA_ROOT,}), #之前是這種
] + static(settings.MEDIA_URL, document_root = settings.MEDIA_ROOT) #如今的版本應該是這樣

from django.db import models

class Article(models.Model):
    '''
    圖片上傳的路徑就會在/upload/article/2016/09/23/a1.jpg
    瀏覽器訪問：http://127.0.0.1:8000/upload/article/2016/09/23/a1.jpg
    '''
    head_img = models.ImageField(max_length=200,upload_to='article/%Y/%m/%d',\
                                default='article/default.png',null=True,blank=True)

models.py

文件上傳相似,前端form屬性要有enctype='multipart/form-data'，models中的字段爲models.FileField(max_length='',upload_to='')

3、路由系統詳解

urlpatterns = [
    url(正則表達式, views視圖函數, 參數, 別名name=""), 
    url(r'^index/(\d*)', views.index, {'id':333}, name="test")
]

#別名name="test" 那麼前端好比form  <form action="{% url "test" %}" method="post"></form> 這樣提交就會交給 views.index這個方法

一、每一個路由規則對應一個view中的函數,前端傳的任何數據類型到後端都是字符串

# 有分組後端view即須要參數接收
url(r'^index/(\d*)', views.index),
url(r'^list/(\d*)/(\d*)/$', views.list),    
url(r'^manage/(?P<name>\w*)/(?P<id>\d*)', views.manage),
url(r'^login/(?P<name>\w*)', views.login,{'id':333}),
url(r'^login/(?P<id>[0-9]{4})', views.login,{'id':333}),  #id:333會覆蓋掉前面匹配到的值

def index(request,id):  # id形參的名字是隨便定義的
    
    return render_to_response('index.html')

    
def list(request,id1,id2): # id1,id2形參的名字是隨便定義的
    
    return render_to_response('list.html')


def manage(request,name,id):  # name,id形參的名字是和(?P<name>\w*)/(?P<id>\d*)是同樣的
    
    return render_to_response('index.html')


def login(request,name,id):  # name,id形參的名字是和(?P<name>\w*)，{'id':333}是同樣的
    
    return render_to_response('login.html')

二、根據app對路由規則進行一次分類

from django.conf.urls import include

urlpatterns = patterns[
    url(r'^web/', include('web.url')),
    url(r'^app01/', include('app01.url')),
]

django中的路由系統和其餘語言的框架有所不一樣，在django中每個請求的url都要有一條路由映射，這樣才能將請求交給對一個的view中的函數去處理。其餘大部分的Web框架則是對一類的url請求作一條路由映射，從而是路由系統變得簡潔。

經過反射機制，爲django開發一套動態的路由系統Demo： 點擊下載

4、views詳解

http請求中產生的兩個核心對象： 所在位置：django.http

http請求：HttpRequest

http響應：HttpResponse

一、HttpRequest：

(1)HttpRequest對象的屬性：

(2)HttpRequest對象的方法（部分）：

get_full_path()：返回包含查詢字符串的請求路徑。例如， "/music/bands/the_beatles/?print=true"

(3)QueryDict對象（部分）

get()：若是key對應多個value，get()返回最後一個value。

在HttpRequest對象中, GET和POST屬性是django.http.QueryDict類的實例。

二、HttpResponse：

對於HttpRequest 對象來講，是由Django自動建立, 可是，HttpResponse對象就必須咱們本身建立。

每一個View請求處理方法必須返回一個HttpResponse對象。若是沒有返回，則會捕獲valueerror異常，HttpResponse類在django.http.HttpResponse。

(1)構造HttpResponse：

>>> response = HttpResponse("Here's the text of the Web page.")
>>> response = HttpResponse("Text only, please.", mimetype="text/plain")
 
# 在HttpResponse對象上經常使用方法：render、render_to_response、redirect(重定向)
>>> response = render(request,'index.html',{向模板傳遞的變量})
>>> response = render_to_response('index.html',{向模板傳遞的變量})
>>> response = redirect("http://www.baidu.com")  或者 redirect("/blog/py/login")
 
# render與render_to_response區別在於第一個參數是否要request，因此就用render
# 表單提交的時候render_to_response還須要添加 context_instance=RequestContext(request)不然會報csrf錯誤

(2)HttpResponse的子類（部分）：

更詳細的有關request和response對象的介紹：
https://docs.djangoproject.com/en/1.11/ref/request-response/

(3)locals()

能夠直接將函數中全部的變量所有傳給模板，自動拼接成字典，很方便。

可是它會多傳遞一些沒用的變量，有點浪費

5、模板詳解

一、模版的執行

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

# "index.html是Template模板
# {"name":"alex"}是上下文

HttpResponse模版的建立過程，對於模版，其實就是讀取模版（其中嵌套着模版標籤），

是經過Template,Context對象來建立渲染模板的，因此render已經封裝了HttpResponse,Template,Context因此很簡單

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

手動嵌套變量到模板中

from django import template
t = template.Template('My name is {{ name }}.')
c = template.Context({'name': 'Adrian'})
print(t.render(c))

django經過模板語言將變量嵌套html中(一)

import datetime
from django import template
import DjangoDemo.settings
 
now = datetime.datetime.now()
fp = open(settings.BASE_DIR+'/templates/Home/Index.html')
t = template.Template(fp.read())
fp.close()
html = t.render(template.Context({'current_date': now}))
return HttpResponse(html)

django經過模板語言將變量嵌套html中(二)

from django.template.loader import get_template
from django.template import Context
from django.http import HttpResponse
import datetime
 
def current_datetime(request):
    now = datetime.datetime.now()
    t = get_template('current_datetime.html')
    html = t.render(Context({'current_date': now}))
    return HttpResponse(html)

django經過模板語言將變量嵌套html中(三)

return render_to_response('Account/Login.html',data,context_instance=RequestContext(request))
注意：當數據POST的時候，Django作了跨站請求僞造

二、模版語言

　模板中也有本身的語言，該語言能夠實現數據展現

(1)模板取值

# views函數返回的是字符串,經過{{ k1 }}獲取字符串v1,前端引用的名字是k1
return render('index.html',{'k1':'v1'}

# views函數返回的是列表,經過{{ list.0 }}獲取字符串11,{{ list.1 }}獲取字符串22,前端引用的名字是list
return render('index.html',{'list':[11,22,33,44]}

# views函數返回的是字典,經過{{ dict.k1 }}獲取字符串v1,{{ dict.k2 }}獲取字符串v2,前端引用的名字是dict
return render('index.html',{'dict':{'k1':'v1','k2':'v2'}}

# views把所有變量傳入前端，locals(),前端引用的名字直接是views中的變量名
return render('index.html',locals()}

# views把一個對象傳入前端，前端經過obj.name,obj.age來取值
def index(request):
    class Person():
        def __init__(self,name,age):
             self.name = name
             self.age = age
    s4 = Person("xiao",18)
    return render(request,"index.html",{"obj":s4})

(2)流程控制

{% if a > b %}
    .......
{% elif a == b %}
    .......
{% else %}
    .......
{% endif %}

(3)for循環

{% for item in data %}
　　{{ item }}

   {# 下面幾個是特殊變量 #}
   forloop.counter   {# 索引從1開始 #}
   forloop.counter0  {# 索引從0開始 #}
   forloop.first     {# 是不是循環的第一個 #}
   forloop.last      {# 是不是循環的最後一個 #}
{% endfor %}

一、{% if %}
    可使用and, or, not來組織你的邏輯。但不容許and和or同時出現的條件語句中。新版本中已經支持{% elif %}這樣的用法。
二、{% ifequal %}和{% ifnotequal %}
    比較是否相等，只限於簡單的類型，好比字符串，整數，小數的比較，列表，字典，元組不支持。
三、{% for %}
    用來循環一個list，還可使用resersed關鍵字來進行倒序遍歷，通常能夠用if語句來先判斷一下列表是否爲空，再進行遍歷；還可使用empty關鍵字來進行爲空時候的跳轉。
    
    ** for標籤中可使用forloop
    a. forloop.counter 當前循環計數，從1開始
    b. forloop.counter0 當前循環計數，從0開始，標準索引方式
    c. forloop.revcounter 當前循環的倒數計數，從列表長度開始
    d. forloop.revcounter0 當前循環的倒數計數，從列表長度減1開始，標準
    e. forloop.first bool值，判斷是否是循環的第一個元素
    f. forloop.last 同上，判斷是否是循環的最後一個元素
    g. forloop.parentloop 用在嵌套循環中，獲得parent循環的引用，而後可使用以上的參數
四、{% cycle %} 
    在循環時輪流使用給定的字符串列表中的值。
五、{# #} 單行註釋，{% comment %}多行註釋
六、{% csrf_token %}
    生成csrf_token的標籤，用於防止跨站攻擊驗證。
七、{% debug %}
    調用調試信息
八、{% filter %}
    將filter 標籤圈定的內容執行過濾器操做。
九、{% autoescape %}
    自動轉義設置
十、{% firstof %}
    輸出第一個值不等於False的變量
十一、{% load %}
    加載標籤庫
十二、{% now %}
    獲取當前時間
1三、{% spaceless %}
    移除空格
1四、{% url %}
    引入路由配置的地址
1五、{% verbatim %}
    禁止render
1六、{% with %}
    用更簡單的變量名緩存複雜的變量名

更多經常使用標籤

(4)內置過濾器

{{ item.event_start|date:"Y-m-d H:i:s"}}
{{ bio|truncatewords:"30" }}
{{ my_list|first|upper }}
{{ name|lower }}
{{ obj | safe }}
{% autoescape off %}
    {{ obj }}
{% endautoescape %}
{% csrf_token %}  # 提交表單的時候須要加上不然django中間件會報csrf錯誤

其餘經常使用內置過濾器

0、date：date:"F j Y",data過濾器經過使用"F j Y"這幾個參數來格式化日期數據。
1、add：給變量加上響應的值
2、addslashes：給變量中的引號前加上斜線
3、capfirst：首字母大寫
4、cut：從字符串中移除指定的字符
5、date：格式化日期字符串
6、default：若是值是False，就替換成設置的默認值，不然就使用原本的值
7、default_if_none：若是值是None，就替換成設置的默認值，不然就使用原本的值
8、dictsort：按照設定參數（key）對應的value對列表進行排序
9、dictsortreversed：和上面剛好相反
10、divisibleby：是否可以被某個數字整除，是的話返回True，不然返回False
11、escape：對字符串進行轉義
12、escapejs：替換value中的某些字符，以適應JAVASCRIPT和JSON格式
13、filesizeformat：格式化文件大小顯示
14、first：返回列表中的第一個值
15、last：返回列表中最後一個值
16、floatformat：格式化浮點數
17、length：求字符串或者列表長度
18、length_is：比較字符串或者列表的長度
19、urlencode：對URL進行編碼處理
20、upper\lower：大寫\小寫
21、safe：對某個變量關閉自動轉義
22、slice：切片操做
23、time：格式化時間
2四、timesince：格式化時間 (e.g., 「4 days, 6 hours」).
25、truncatechars：按照字符截取字符串
26、truncatewords：按照單詞截取字符串
2七、striptags：過濾掉html標籤

其餘經常使用內置過濾器

(5)自定義方法filter或者simple_tag

filter和simple_tag的區別：

　　filter：限制傳參2個，支持 if 條件

　　simple_tag：不限制傳參，不支持 if 條件

官網：https://docs.djangoproject.com/en/1.11/howto/custom-template-tags/

一、在app01中建立templatetags模塊(templatetags名字是不能變)

二、建立任意 .py 文件，如：mysimple.py

from django import template
from django.utils.safestring import mark_safe
   
register = template.Library() # 這一句必定是這樣寫的
   
@register.simple_tag  
def my_simple_time(v1,v2,v3): 
'''傳遞多個參數'''
    return  v1 + v2 + v3
   
@register.simple_tag
def my_input(id,arg):
    result = "<input type='text' id='%s' class='%s' />" %(id,arg,)
    return mark_safe(result)
    
@register.filter
    def f1(value):
        return value + '1000'
        
@register.filter
def f2(value,arg):
'''傳遞一個參數'''
return value + '1000' + arg

@register.filter
def f3(value):
    if value == 'vvv':
        return True
    else:    
        return False

三、在使用自定義simple_tag的html文件中導入以前建立的 mysimple.py 文件名

{% load mysimple %}

四、使用simple_tag和filter,它們使用是不同的

{% my_simple_time 1 2 3%}    # 能夠傳遞多個參數
{% my_input 'id_username' 'hide'%}
{{ k1 | f1 }}
{{ k1 | f2:'python' }}       # 只能傳遞一個參數
{% if k1 | f3 %}
    <h1>True</h1>
{% else %}
    <h1>False</h1>
{% endif %}

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

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app01',
)

(六)模板繼承

母板：{% block title %}{% endblock %}
子板：{% extends "base.html" %}
     　　{% include "xx.html" %}  # 在子板中使用其餘模板
　　　{% block title %}{% endblock %}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title></title>
    <link rel="stylesheet" href="..." />
    <style>
        .pg-header{
            height: 48px;
            background-color: cadetblue;
        }
        .pg-body{
            min-height: 500px;
        }
        .pg-body .body-menu{
            width: 20%;
            float: left;
        }
        .pg-body .body-content{
            width: 80%;
            float: left;
        }
        .pg-footer{
            height: 100px;
            background-color: brown;
        }
        .active{
            background-color: aquamarine;
            color: white;
        }
    </style>

    {% block css %}{% endblock %}
</head>
<body>
    <div class="pg-header">
        後臺系統V1
    </div>
    <div class="pg-body">
        <div class="body-menu">
            <ul>
                <li><a id="userinfo" href="/userinfo">用戶管理</a></li>
                <li><a id="assets" href="/assets">資產管理</a></li>
            </ul>
        </div>
        <div class="body-content">
            {% block body %}{% endblock %}
        </div>

    </div>
    <div class="pg-footer"></div>
    <script src="xxx"></script>
    {% block js %}{% endblock %}
</body>
</html>

layout.html

{% extends 'layout.html' %}

{% block body %}
    {% include 'xx.html' %}
    <table>
        {% for item in assets_list %}
            <tr>
                <td>{{ item.hostname }}</td>
                <td>{{ item.port }}</td>
            </tr>
        {% endfor %}
    </table>
{% endblock %}

{% block js %}
    <script>
        document.getElementById('assets').className = 'active';
    </script>
{% endblock %}

assets.html

{% extends 'layout.html' %}

{% block css %}
    <style></style>
{% endblock %}

{% block body %}
    {% include 'xx.html' %}
    <ul>
    {% for item in user_list %}
        <li>{{ item.username }},{{ item.salary }}</li>
    {% endfor %}
    </ul>

{% endblock %}

{% block js %}
    <script>
        document.getElementById('userinfo').className = 'active';
    </script>
{% endblock %}

userinfo.html

<form>
    <input type="text" placeholder="請輸入內容"/>
    <input type="text" placeholder="請輸入內容"/>
    <input type="text" placeholder="請輸入內容"/>
    <input type="text" placeholder="請輸入內容"/>
</form>

xx.html

from django.shortcuts import render,HttpResponse

# Create your views here.

USER_LSIT = []

for item in range(94):
    temp = {"id":item, "ip":"192.168.1." + str(item),"username":"user" + str(item)}
    USER_LSIT.append(temp)

def index(request,page):
    page = int(page)
    start = (page - 1) * 10
    end = page * 10
    user_list = USER_LSIT[start:end]
    return render(request,'index.html',{'user_list':user_list})

def detail(request,nid):
    nid = int(nid)
    current_detail_dict = USER_LSIT[nid]
    return render(request,"detail.html",{"current_detail_dict":current_detail_dict})


def assets(request):
    assets_list = []
    for i in range(10):
        temp = {'hostname':'192.168.1.'+str(i),'port':80}
        assets_list.append(temp)

    return render(request,'assets.html',{'assets_list':assets_list})


def userinfo(request):
    user_list = []
    for i in range(10):
        temp = {'username': 'user' + str(i),'salary':80}
        user_list.append(temp)

    return render(request,'userinfo.html',{'user_list':user_list})

views

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


urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^assets/', views.assets),
    url(r'^userinfo/', views.userinfo),
]

urls

https://docs.djangoproject.com/en/1.11/ref/templates/builtins/#extends

https://docs.djangoproject.com/en/1.11/ref/templates/builtins/#block

https://docs.djangoproject.com/en/1.11/ref/templates/builtins/#include

6、Model詳解

一、django默認支持sqlite、mysql、oracle、postgresql數據庫，像db2和sqlserver之類的數據庫須要第三方的支持。具體詳見：

https://docs.djangoproject.com/en/1.11/ref/databases/

二、mysql驅動程序：

MySQLdb（mysql-python）：https://pypi.python.org/pypi/MySQL-python/1.2.5（支持python2）
mysqlclient：https://pypi.python.org/pypi/mysqlclient （支持python3）
MySQL Connector/Python：  https://dev.mysql.com/downloads/connector/python
PyMySQL（純python的mysql驅動）：https://pypi.python.org/pypi/PyMySQL （python3中使用，經常使用）

三、model配置步驟：

一、建立數據庫
    >> CREATE DATABASE IF NOT EXISTS testdb DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
二、配置文件settings裏鏈接數據庫
    INSTALLED_APPS = [
        .......
        'app02',
        'app01',
    ]
    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.mysql’,#注意改爲mysql後臺
            'NAME': 'hello_django_db',
            'USER':'root',
            'PASSWORD':'123456’,#就是鏈接mysql的密碼
            #'HOST':'',
            #'PORT':'',
        }
    }
三、和項目project同名的__init__中
    import pymysql
    pymysql.install_as_MySQLdb()
四、建立model,繼承自models.Model類
    name = models.CharField(max_length=50)
五、同步數據庫
    python manage.py makemigrations
    python manage.py migrate

(一)、使用原生SQL

到目前爲止，當咱們的程序涉及到數據庫相關操做時，咱們通常都會這麼搞：

建立數據庫，設計表結構和字段
使用 MySQLdb 來鏈接數據庫，並編寫數據訪問層代碼
業務邏輯層去調用數據訪問層執行數據庫操做

import pymysql
 
def GetList(sql):
    db = pymysql.connect(user='root', db='wupeiqidb', passwd='1234', host='localhost')
    cursor = db.cursor()
    cursor.execute(sql)
    data = cursor.fetchall()
    db.close()
    return data
 
def GetSingle(sql):
    db = pymysql.connect(user='root', db='wupeiqidb', passwd='1234', host='localhost')
    cursor = db.cursor()
    cursor.execute(sql)
    data = cursor.fetchone()
    db.close()
    return data

經過pymysql操做數據庫

(二)、使用Django的ORM

django爲使用一種新的方式，即：關係對象映射（Object Relational Mapping，簡稱ORM）。

　　PHP：activerecord

　　Java：Hibernate

　 C#：Entity Framework

django中遵循 Code Frist 的原則，即：根據代碼中定義的類來自動生成數據庫表。

一、建立Model，以後能夠根據Model來建立數據庫表

from django.db import models
  
class userinfo(models.Model):
    name = models.CharField(max_length=30)
    email = models.EmailField()
    memo = models.TextField()

更多字段：　　

一、models.AutoField　　自增列 = int(11)
　　若是沒有的話，默認會生成一個名稱爲 id 的列，若是要顯示的自定義一個自增列，必須將給列設置爲主鍵 primary_key=True。
2、models.CharField　　字符串字段
　　必須 max_length 參數
三、models.BooleanField　　布爾類型=tinyint(1)
　　不能爲空，Blank=True
四、models.ComaSeparatedIntegerField　　用逗號分割的數字=varchar
　　繼承CharField，因此必須 max_lenght 參數
5、models.DateField　　日期類型 date
　　對於參數，auto_now = True 則每次更新都會更新這個時間；auto_now_add 則只是第一次建立添加，以後的更新再也不改變。
6、models.DateTimeField　　日期類型 datetime
　　同DateField的參數
七、models.Decimal　　十進制小數類型 = decimal
　　必須指定整數位max_digits和小數位decimal_places
八、models.EmailField　　字符串類型（正則表達式郵箱） =varchar
　　對字符串進行正則表達式
九、models.FloatField　　浮點類型 = double
10、models.IntegerField　　整形
11、models.BigIntegerField　　長整形
　　integer_field_ranges = {
　　　　'SmallIntegerField': (-32768, 32767),
　　　　'IntegerField': (-2147483648, 2147483647),
　　　　'BigIntegerField': (-9223372036854775808, 9223372036854775807),
　　　　'PositiveSmallIntegerField': (0, 32767),
　　　　'PositiveIntegerField': (0, 2147483647),
　　}
12、models.IPAddressField　　字符串類型（ip4正則表達式）,django1.10逐步廢棄使用下面一種
13、models.GenericIPAddressField　　字符串類型（ip4和ip6是可選的）
　　參數protocol能夠是：both、ipv四、ipv6
　　驗證時，會根據設置報錯
14、models.NullBooleanField　　容許爲空的布爾類型
15、models.PositiveIntegerFiel　　正Integer
16、models.PositiveSmallIntegerField　　正smallInteger
17、models.SlugField　　減號、下劃線、字母、數字
18、models.SmallIntegerField　　數字
　　數據庫中的字段有：tinyint、smallint、int、bigint
1九、models.TextField　　  字符串=longtext
20、models.TimeField　　  時間 HH:MM[:ss[.uuuuuu]]
21、models.URLField　　   字符串，地址正則表達式
22、models.BinaryField　　二進制
23、models.ImageField    圖片,須要max_length
2四、models.FilePathField 文件,須要max_length

更多參數：

一、null=True   # 數據庫中字段是否能夠爲空
二、blank=True  # django的 Admin 中添加數據時是否可容許空值
三、primary_key = False    #主鍵，對AutoField設置主鍵後，就會代替原來的自增 id 列
4、auto_now、auto_now_add
　　auto_now      # 自動建立---不管添加或修改，都是當前操做的時間
　　auto_now_add  # 自動建立---永遠是建立時的時間
5、choices
    GENDER_CHOICE = (
            (u'M', u'Male'),
            (u'F', u'Female'),
    )
    gender = models.CharField(max_length=2,choices = GENDER_CHOICE)

    gender_choice = (
        (0,'男'),
        (1,'女'),
    )
    gender = models.IntergetFiled(choice=gener_choice)  # 數據庫中存儲的是0，1可是顯示的是男，女

6、max_length      # 在charfield必須指定最大長度
7、default　　      # 默認值
8、verbose_name　　 # Admin中字段的顯示名稱
九、name|db_column　 # 數據庫中的字段名稱
十、unique=True　　 # 不容許重複
十一、db_index = True　　# 數據庫索引
十二、editable=True　　  # 在Admin裏是否可編輯
1三、error_messages=None　　# 在Admin錯誤提示
1四、auto_created=False　　 # 自動建立
15、help_text　　   # 在Admin中提示幫助信息
1六、validators=[]  # 自定義規則
1七、upload-to      # 指定上傳的路徑
1八、class Meta():
        verbose_name = '這張表的名字在admin後臺的顯示名字'
        verbose_name_plural = verbose_name
        ordering = ['-id']  # 根據id反向排序

二、數據庫操做

增長：create()、bulk_create()

# create 第一種方式
models.類名.objects.create(hostname="name")  

# create 第二種方式，推薦這種
models.類名.objects.create(**{"hostname":"name"})

# save 第三種方式
obj = 類名(hostname="name")
obj.save()

# save 第四種方式，其實和第三種是同樣的，推薦第二種
obj = 類名()
obj.hostname = "name"
obj.save()

注意：hostname是數據庫中的字段名，name是值

# bulk_create() 批量建立數據
models.類名.objexts.bulk_create([
    類名(字段=值),
    類名(字段=值),
])

更新：update()

# 第一種方式，推薦這種,並且高效
models.類名.objects.filter(id=2).update(hostname='tomcat')  

# 第二種方式
obj = models.類名.objects.get(id=2)
obj.hostname = 'tomcat'
obj.save()

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

刪除：delete()

models.類名.objects.get(id=2).delete() # 不建議
models.類名.objects.filter(id=2).delete()
models.類名.objects.all().delete()

查詢：

filter() 集合queryset對象

all(), 集合queryset對象

get(),獲取單條數據，不存在就報錯

getlist()用於取多個值

models.類名.objects.get(id=123)         # 獲取單條數據，不存在則報錯（不建議），
models.類名.objects.all()                      # 獲取所有
models.類名.objects.filter(name='tomcat') # 獲取指定條件的數據

顯示指定字段：values(),values_list()

models.類名.objects.get(id=123).values('id','name')  # 返回的是queryset字典
models.類名.objects.get(id=123).values__list('id','name') # 返回的是queryset元組

複雜查詢：Q()表達式：

https://docs.djangoproject.com/en/1.11/topics/db/queries/#complex-lookups-with-q-objects

數量：count()

models.類名.objects.filter(name='tomcat').count()
models.類名.objects.get(name='tomcat').count()
models.類名.objects.all().count()

去重：distinct()

models.類名.objects.values('字段').distinct()

大於小於：__gt,__lt,__gte,__lte

models.類名.objects.filter(id__gt=1)              # 獲取id大於1的值
models.類名.objects.filter(id__lt=10)             # 獲取id小於10的值
models.類名.objects.filter(id__lt=10, id__gt=1)   # 獲取id大於1 且 小於10的值

等於多個值：__in

models.類名.objects.filter(id__in=[11, 22, 33])   # 獲取id等於十一、2二、33的數據
models.類名.objects.exclude(id__in=[11, 22, 33])  # not in

模糊查詢：__contains,__icontains　　

models.類名.objects.filter(name__contains="ven")
models.類名.objects.filter(name__icontains="ven")    # icontains大小寫不敏感
models.類名.objects.exclude(name__icontains="ven")

範圍查詢：__range

models.類名.objects.filter(id__range=[1, 2])   # 範圍bettwen and

其餘相似：__startswith,__endswith, __iendswith, __istartswith　　

排序：order_by("name") 至關於asc；order_by("-name") 至關於desc；　　

models.類名.objects.filter(name='seven').order_by('id')     # asc,從小到大
models.類名.objects.filter(name='seven').order_by('-id')   # desc,從大到小

返回第n-m條：第n條[0]；前兩條[0:2]　　

# limit 、offset

models.類名.objects.all()[10:20]

分組與聚合：group_by,annotate,aggregate

annotate(*args, **kwargs)：能夠爲 QuerySet 中的每一個對象添加註解。能夠經過計算查詢結果中每一個對象所關聯的對象集合，從而得出總計值(也能夠是平均值或總和，等等)

aggregate(*args, **kwargs)：經過對 QuerySet 進行計算，返回一個聚合值的字典。 aggregate() 中每一個參數都指定一個包含在字典中的返回值。用於聚合查詢

Avg(返回所給字段的平均值)
Count(根據所給的關聯字段返回被關聯 model 的數量)
Max(返回所給字段的最大值)
Min(返回所給字段的最小值)
Sum(計算所給字段值的總和)

# group by
from django.db.models import Count, Min, Max, Sum
# models.類名.objects.filter(c1=1).values('id').annotate(c=Count('num'))
# SELECT "app01_類名"."id", COUNT("app01_類名"."num") AS "c" FROM "app01_類名" WHERE "app01_類名"."c1" = 1 GROUP BY "app01_類名"."id"

更多實例：

>>> Publisher.objects.filter(name='廣東人民出版社').aggregate(Count('name'))

還能夠自定義別名
>>> Publisher.objects.filter(name='廣東人民出版社').aggregate(mycount = Count('name'))

查詢胡大海出的書的總價格是多少
>>> Book.objects.filter(authors__name='胡大海').aggregate(Sum('price'))

查詢各個做者出的書的總價格是多少
>>> Book.objects.values('authors__name').annotate(Sum('price'))

查詢各個出版社最便宜的書價是多少
>>> Book.objects.values('publisher__name').annotate(Min('price'))

View Code

https://docs.djangoproject.com/en/1.11/topics/db/aggregation/

https://docs.djangoproject.com/en/1.11/topics/db/annotate/

原始SQL：

注意：使用原生sql的方式主要目的是解決一些 很複雜的sql，不能用ORM的方式寫出的問題。

extra：結果集修改器 - 一種提供額外查詢參數的機制
raw：執行原始sql並返回模型實例，最適合用於查詢,(異常：Raw query must include the primary key,返回結果必須包含主鍵)
直接執行自定義SQL（這種方式徹底不依賴model，前面兩種方式仍是要依賴於model），適合增刪改

A.使用extra：
>>> Book.objects.filter(publisher__name='廣東人民出版社').extra(where=['price>50’])
>>> Book.objects.filter(publisher__name='廣東人民出版社', price__gt=50)
>>> Book.objects.extra(select={'count':'select count(*) from hello_book'})

B.使用raw：
>>> Book.objects.raw('select * from hello_book')

C.自定義sql：
from django.db import connection
cursor = connection.cursor()            #得到一個遊標(cursor)對象
 
cursor.execute("insert into hello_author(name) values('郭敬明')")    #插入操做
cursor.execute("update hello_author set name = '韓寒' where name='郭敬明'")  #更新操做 
cursor.execute("delete from hello_author where name='韓寒'")   #刪除操做
cursor.execute('select * from hello_author')  #查詢操做
raw = cursor.fetchone()                       #返回結果行
cursor.fetchall()

更多詳見：

https://docs.djangoproject.com/en/1.11/topics/db/sql/

自定義Manager:

https://docs.djangoproject.com/en/1.11/topics/db/managers/

三、連表操做：

一對多，models.ForeignKey('UserType')
一對一，models.OneToOneField('UserType',on_delete=models.SET_NULL)
多對多，models.ManyToManyField('UserType',on_delete=models.CASCADE)

應用場景：

一對一：在某表中建立一行數據時，有一個單選的下拉框（下拉框中的內容被用過一次就消失了）。
例如：原有含10列數據的一張表保存相關信息，通過一段時間以後，10列沒法知足需求，須要爲原來的表再添加5列數據。

一對多：當一張表中建立一行數據時，有一個單選的下拉框（能夠被重複選擇）。
例如：建立用戶信息時候，須要選擇一個用戶類型【普通用戶】【金牌用戶】【鉑金用戶】等。

多對多：在某表中建立一行數據是，有一個能夠多選的下拉框。
例如：建立用戶信息，須要爲用戶指定多個愛好。

利用雙下劃線和 _set 將表之間的操做鏈接起來

from django.db import models

class UserProfile(models.Model):
    username = models.CharField(max_length=64)
    password = models.CharField(max_length=64)
    user_info = models.OneToOneField('UserInfo')

    def __str__(self):       # __unicode__ on python2
        return self.username


class UserInfo(models.Model):
    user_type_choice = (
        (0, '普通用戶'),
        (1, '高級用戶'),
    )
    user_type = models.IntegerField(choices=user_type_choice)
    name = models.CharField(max_length=32)
    email = models.CharField(max_length=32)
    address = models.CharField(max_length=128)

    def __str__(self):       # __unicode__ on python2
        return self.name


class UserGroup(models.Model):

    caption = models.CharField(max_length=64)

    user_info = models.ManyToManyField('UserInfo')

    def __str__(self):       # __unicode__ on python2
        return self.caption


class Host(models.Model):
    hostname = models.CharField(max_length=64)
    ip = models.GenericIPAddressField()
    user_group = models.ForeignKey('UserGroup')

    def __str__(self):       # __unicode__ on python2
        return self.hostname

表結構實例：models.py

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^add/', views.addata),
    url(r'^danbiao/', views.danbiao),
    url(r'^yiduiyi/', views.yiduiyi),
    url(r'^yiduiduo/', views.yiduiduo),
    url(r'^duoduiduo/', views.duoduiduo),
]

urls.py

def addata(request):

    # 批量插入UserInfo表
    models.UserInfo.objects.bulk_create([
        UserInfo(user_type=0, name='Shi Zhongyu', email='shizhongyu@163.com', address='深圳市'),
        UserInfo(user_type=0, name='Sun Dasheng', email='sundasheng@163.com', address='佛山市'),
        UserInfo(user_type=0, name='Lin Daiyu', email='lindaiyu@163.com', address='揭陽市'),
        UserInfo(user_type=0, name='Lin Chong', email='linchong@163.com', address='中山市'),
        UserInfo(user_type=0, name='Ma Chao', email='machao@126.com', address='福州市'),
        UserInfo(user_type=0, name='Xie Yanke', email='xieyanke@126.com', address='廈門市'),
        UserInfo(user_type=0, name='Xiao Qiao', email='xiaoqiao@yahoo.com', address='漳州市'),
        UserInfo(user_type=0, name='Tian Boguang', email='tianboguang@qq.com', address='龍巖市'),
        UserInfo(user_type=0, name='Yuan Chengzhi', email='yuanchengzhi@qq.com', address='北京市'),
        UserInfo(user_type=0, name='Ren Yingying', email='renyingying@360.com', address='上海市'),
        UserInfo(user_type=0, name='Diao Chan', email='diaochan@baidu.com', address='南京市'),
        UserInfo(user_type=0, name='Lu Wushuang', email='luwushuang@ali.com', address='青島市'),
        UserInfo(user_type=0, name='Xue Baochai', email='xuebaochai@live.com', address='浙江市'),
        UserInfo(user_type=1, name='Xiao Dasheng', email='xiaodasheng@gmail.com', address='伊拉克'),
    ])

    # 批量插入UserProfile表
    userprofile_list = []
    for i in range(1,16):
        username = 'zhanghao' + str(i)
        password = '123456'
        userinfo = i
        uprofile = models.UserProfile(username=username,password=password,userinfo=userinfo)
        userprofile_list.append(uprofile)
    models.UserProfile.objects.bulk_create(userprofile_list)

    # 批量插入UserGroup表
    models.UserGroup.objects.bulk_create([
        UserInfo(capation='CTO'),
        UserInfo(capation='CEO'),
        UserInfo(capation='COO'),
    ])


    # 批量插入Host表
    models.Host.objects.bulk_create([
        UserInfo(hostname='c1.salt.com',ip='192.168.1.1',user_group_id=1),
        UserInfo(hostname='c2.salt.com',ip='192.168.1.2',user_group_id=1),
        UserInfo(hostname='c3.salt.com',ip='192.168.1.3',user_group_id=1),
        UserInfo(hostname='c4.salt.com',ip='192.168.1.4',user_group_id=1),
        UserInfo(hostname='c5.salt.com',ip='192.168.1.5',user_group_id=1),
        UserInfo(hostname='c6.salt.com',ip='192.168.1.6',user_group_id=2),
        UserInfo(hostname='c7.salt.com',ip='192.168.1.7',user_group_id=2),
        UserInfo(hostname='c8.salt.com',ip='192.168.1.8',user_group_id=2),
        UserInfo(hostname='c9.salt.com',ip='192.168.1.9',user_group_id=2),
        UserInfo(hostname='c10.salt.com',ip='192.168.1.10',user_group_id=2),
        UserInfo(hostname='c11.salt.com',ip='192.168.1.11',user_group_id=3),
        UserInfo(hostname='c12.salt.com',ip='192.168.1.12',user_group_id=3),
        UserInfo(hostname='c13.salt.com',ip='192.168.1.13',user_group_id=3),
        UserInfo(hostname='c14.salt.com',ip='192.168.1.14',user_group_id=3),
        UserInfo(hostname='c15.salt.com',ip='192.168.1.15',user_group_id=3),
    ])

    return render(request,'addata.html')

增長數據：views.py

多對多那張表能夠本身在數據庫插入數據,全部html都是空的

def danbiao(request):

    # filter是querset對象，因此要迭代取出值
    queryset = models.UserInfo.objects.filter(name='user')
    print(queryset.query)
    print(type(queryset))
    for item in queryset:
        print(item.id)
        print(item.user_type)
        print(item.name)
        print(item.email)
        print(item.address)

    # get是userinfo類對象,不須要迭代取值,直接取
    obj = models.UserInfo.objects.get(id=10)
    print(type(obj))
    print(obj.id)
    print(obj.name)
    print(obj.user_type)
    print(obj.email)
    print(obj.address)

    # values也是queryset對象,須要迭代取值,values是字典
    obj1 = models.UserInfo.objects.filter(name='redhat').values('id','name')
    print(type(obj1))
    for i in obj1:
        print(i['id'])
        print(i['name'])

    # values_list也是queryset對象,須要迭代取值,values_list元組
    obj2 = models.UserInfo.objects.filter(name='centos').values_list('id','name')
    print(type(obj2))
    for i in obj2:
        print(i[0])
        print(i[1])


    obj3 = models.UserInfo.objects.all()
    print(type(obj3))
    for iter in obj3:
        print(iter.id)
        print(iter.name)

    return render(request,'danbiao.html',locals())

單表操做：views.py

def yiduiyi(request):

    # 正向查詢
    u_profile = models.UserProfile.objects.all()
    for i in u_profile:
        print(i.id)
        print(i.username)
        print(i.password)
        print(i.user_info.get_user_type_display())
        print(i.user_info.name)
        print(i.user_info.email)
        print(i.user_info.address)

    # 正向連表查詢
    u_profile1 = models.UserProfile.objects.values('username','password','user_info__user_type','user_info__name')
    for i in u_profile1:
        print(i['username'])
        
    obj = models.UserProfile.objects.values('username','password','user_info__user_type','user_info__name').first()
    print(obj['username'])
    print(obj['password'])
    print(obj['user_info__user_type'])
    print(obj['user_info__name'])


    # 反向查詢userprofile表
    user_info_obj = models.UserInfo.objects.filter(id=1).first()
    print(type(user_info_obj))
    print(user_info_obj.user_type)
    print(user_info_obj.get_user_type_display())
    print(user_info_obj.userprofile.password)

    # 反向連表查詢
    user_info_obj1 = models.UserInfo.objects.filter(id=1).values('email', 'userprofile__username').first()
    print(type(user_info_obj1))
    print(user_info_obj1.keys())
    print(user_info_obj1.values())

    return render(request,'yiduiyi.html',locals())

一對一操做：views.py

def yiduiduo(request):

    # 正向查詢
    obj = models.Host.objects.all()
    for i in obj:
        print(i.id)
        print(i.hostname)
        print(i.ip)
        print(i.user_group.caption)

    # 正向查詢連表操做
    obj1 = models.Host.objects.all().values('hostname','user_group__caption').first()
    print(obj1)
    print(obj1['hostname'])
    print(obj1['user_group__caption'])
    
    obj2 = models.Host.objects.all().values('hostname','user_group__caption')
    print(type(obj2))
    for i in obj2:
        print(i.keys())
        print(i.values())


    # 反向查詢
    obj3 = models.UserGroup.objects.all()
    print(obj3)
    print(type(obj3))
    for i in obj3:
        print(i.caption)
        print(i.host_set.all())
        host_obj = i.host_set.all()
        for j in host_obj:
            print(j.hostname)
            print(j.ip)

    # 反向查詢連表操做
    obj4 = models.UserGroup.objects.all().values('caption','host__hostname').first()
    print(obj4['caption'])
    print(obj4['host__hostname'])

    obj5 = models.UserGroup.objects.all().values('caption','host__hostname')
    for i in obj5:
        print(i['caption'])
        print(i['host__hostname'])




    # 一對多,三表關聯
    allobj = models.Host.objects.filter(user_group__user_info__user_type=0)
    print(allobj.query)
    print(type(allobj))
    for i in allobj:
        print(i)
        print(i.user_group.caption)

    return render(request,'yiduiduo.html',locals())

一對多：views.py

def duoduiduo(request):

    # 在關聯連表的時候不知道填什麼字段，故意填錯，django會提示能夠填入的字段

    # 正向添加數據,多對多的第三表存儲的是兩張表的主鍵id
    user_info_obj = models.UserInfo.objects.get(id=1)
    user_info_objs = models.UserInfo.objects.all()
    group_obj = models.UserGroup.objects.get(id=1)

    group_obj.user_info.add(user_info_obj)
    group_obj.user_info.add(*user_info_objs)
    group_obj.user_info.add(1)
    group_obj.user_info.add(*[1,2,4])

    # 正向刪除數據
    group_obj.user_info.clear()   # 清空全部與第三張表usergroup id=1的全部數據
    group_obj.user_info.remove(*[2,3,4])  # 刪除，2,3,4條數據

    # 正向查詢數據
    group_obj = models.UserGroup.objects.get(id=1)
    obj = group_obj.user_info.all()
    for i in obj:
        print(i.id)
        print(i.name)
        print(i.email)
        print(i.address)
        print(i.get_user_type_display())

    # 正向關聯表查詢
    dic = models.UserGroup.objects.all().values('caption','user_info__name','user_info__address','user_info__email')
    print(dic)


    # 反向添加數據
    user_info_obj = models.UserInfo.objects.get(id=1)
    group_obj1 = models.UserGroup.objects.get(id=1)
    group_obj2 = models.UserGroup.objects.all()
    obj2 = user_info_obj.usergroup_set.add(group_obj1)
    obj3 = user_info_obj.usergroup_set.add(*group_obj2)
    user_info_obj.usergroup_set.add(1)
    user_info_obj.usergroup_set.add(*[1,2,3,4])

    # 反向刪除數據
    user_info_obj.usergroup_set.clear() # 清空全部第三張表userinfo id=1的全部數據
    user_info_obj.usergroup_set.remove(*[2,3,4])

    # 反向查詢
    user_info_obj = models.UserInfo.objects.get(id=1)
    obj4 = user_info_obj.usergroup_set.all()
    print(obj4)
    print(type(obj4))
    for i in obj4:
        print(i.id)
        print(i.caption)

    # 反向連表查詢
    dic1 = models.UserInfo.objects.all().values('name','email','address','usergroup__caption')
    print(dic)

    return render(request,'duoduiduo.html',locals())

多對多操做：views.py

其餘操做中包含：F()和Q查詢

# F 使用查詢條件的值
    #
    # from django.db.models import F
    # models.Tb1.objects.update(num=F('num')+1)

    # Q 構建搜索條件
    from django.db.models import Q
    # 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)

    #
    # from django.db import connection
    # cursor = connection.cursor()
    # cursor.execute("""SELECT * from tb where name = %s""", ['Lennon'])
    # row = cursor.fetchone()

其餘操做

注意：xx_set中的【_set】是多對多中的固定搭配，用於反響查詢,一對多中反向也能夠用_set

自鏈接F()表達式：

https://docs.djangoproject.com/en/1.9/ref/models/expressions/#

四、擴展：

(1)自定義上傳

def upload_file(request):
    if request.method == "POST":
        obj = request.FILES.get('fafafa')
        f = open(obj.name, 'wb')
        for chunk in obj.chunks():
            f.write(chunk)
        f.close()
    return render(request, 'file.html')

(2)Form上傳文件實例

form.py

class FileForm(forms.Form):
    ExcelFile = forms.FileField()

model.py

from django.db import models

class UploadFile(models.Model):
    userid = models.CharField(max_length = 30)
    file = models.FileField(upload_to = './upload/')
    date = models.DateTimeField(auto_now_add=True)

view.py

def UploadFile(request):
    uf = AssetForm.FileForm(request.POST,request.FILES)
    if uf.is_valid():
            upload = models.UploadFile()
            upload.userid = 1
            upload.file = uf.cleaned_data['ExcelFile']
            upload.save()
            
            print upload.file

更多model相關：https://docs.djangoproject.com/en/1.9/topics/db/models/

7、admin

django amdin是django提供的一個後臺管理頁面，改管理頁面提供完善的html和css，使得你在經過Model建立完數據庫表以後，就能夠對數據進行增刪改查，而使用django admin 則須要如下步驟：

建立後臺管理員
配置url
註冊和配置django admin後臺管理頁面

一些經常使用的設置技巧：

　　list_display：指定要顯示的字段

　　search_fields：指定搜索的字段

　　list_filter：指定列表過濾器

　　ordering：指定排序字段

　　fields\exclude：指定編輯表單須要編輯\不需編輯的字段

　　fieldsets：設置分組表單

　　filter_horizontal：指定多對多選擇

　　raw_id_fields：一對多選擇

admin基本使用：

一、建立後臺管理員

python manage.py createsuperuser
python manage.py changepassword

二、配置後臺管理url

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

三、註冊和配置django admin 後臺管理頁面

a、設置數據表名稱

class UserType(models.Model):
    name = models.CharField(max_length=50,verbose_name='類型的名字')
  
    class Meta:
        verbose_name = '用戶類型'
        verbose_name_plural = verbose_name
        
    def __str__(self):   # __unicode__ on python2 
        return self.name

b、在admin中執行以下配置

from django.contrib import admin
from app01 import models admin.site.register(models.UserType)

(1)在admin中顯示的字段

from django.contrib import admin
from app01 import  models
  
class UserInfoAdmin(admin.ModelAdmin):
    list_display = ('id','name')
 
admin.site.register(models.UserType,UserInfoAdmin)

(2)爲數據表添加搜索功能

from django.contrib import admin
from app01 import  models
  
class UserInfoAdmin(admin.ModelAdmin):
    list_display = ('id','name')
    search_fields = ('name')
  
admin.site.register(models.UserType,UserInfoAdmin)

(3)添加快速過濾、可編輯、分頁

from django.contrib import admin
from app01 import  models
  
class UserInfoAdmin(admin.ModelAdmin):
    list_display = ('id','name')
    search_fields = ('name')
    list_filter = ('name')
    list_editable = ('name') 
　　 list_per_page = 10 
  
admin.site.register(models.UserType,UserInfoAdmin)

admin中的action：

models.py

from django.db import models

STATUS_CHOICES = (
    ('d', 'Draft'),
    ('p', 'Published'),
    ('w', 'Withdrawn'),
)

class Article(models.Model):
    title = models.CharField(max_length=100)
    body = models.TextField()
    status = models.CharField(max_length=1, choices=STATUS_CHOICES)

    def __str__(self):              # __unicode__ on Python 2
        return self.title

admin.py

from django.contrib import admin
from myapp.models import Article

def make_published(modeladmin, request, queryset):
    queryset.update(status='p')
make_published.short_description = "Mark selected stories as published"  # 在admin後臺action顯示的操做

class ArticleAdmin(admin.ModelAdmin):
    list_display = ['title', 'status']
    ordering = ['title']
    actions = [make_published]   # 將上面定義的action function添加進來

admin.site.register(Article, ArticleAdmin)

給狀態加上html

from django.db import models
from django.utils.html import format_html

STATUS_CHOICES = (
    ('d', 'Draft'),
    ('p', 'Published'),
    ('w', 'Withdrawn'),
)

class Article(models.Model):
    title = models.CharField(max_length=100)
    body = models.TextField()
    status = models.CharField(max_length=1, choices=STATUS_CHOICES)

    def __str__(self):              # __unicode__ on Python 2
        return self.title
        
    def colored_status(self):
        if self.status == 'd':
            format_td = format_html('<span style="padding:2px;background-color:yellowgreen;color:white">Draft</span>')
        elif self.status == 'p':
            format_td = format_html('<span style="padding:2px;background-color:green;color:white">Published</span>')
        elif self.status == 'w':
            format_td = format_html('<span style="padding:2px;background-color:orange;color:white">Withdrawn</span>')
    
        return format_td
    colored_status.short_description = 'status'  # 在admin後臺顯示字段更名字

models.py

from django.contrib import admin
from myapp.models import Article

def make_published(modeladmin, request, queryset):
    queryset.update(status='p')
make_published.short_description = "Mark selected stories as published"  # 在admin後臺action顯示的操做

class ArticleAdmin(admin.ModelAdmin):
    list_display = ['title', 'status','colored_status']  # 這裏直接添加一個字段便可
    ordering = ['title']
    actions = [make_published]   # 將上面定義的action function添加進來

admin.site.register(Article, ArticleAdmin)