Django框架搭建（windows系统）

Django框架搭建（windows系统）

1、Django简介

开放源代码的Web应用框架，由Python语言编写，一个大而全的框架。

1.web框架介绍

具体介绍Django以前，必须先介绍WEB框架等概念。

web框架： 别人已经设定好的一个web网站模板，你学习它的规则，而后“填空”或“修改”成你本身须要的样子。

通常web框架的架构是这样的：

其它基于python的web框架，如tornado、flask、webpy都是在这个范围内进行增删裁剪的。例如tornado用的是本身的异步非阻塞“wsgi”，flask则只提供了最精简和基本的框架。Django则是直接使用了WSGI，并实现了大部分功能。

2. MVC/MTV介绍

（1）MVC：全名Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑汇集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不须要从新编写业务逻辑。

（2）通俗解释：一种文件的组织和管理形式！不要被缩写吓到了，这其实就是把不一样类型的文件放到不一样的目录下的一种方法，而后取了个高大上的名字。固然，它带来的好处有不少，好比先后端分离，松耦合等等。　　　　　　　

（3）模型(model)：定义数据库相关的内容，通常放在models.py文件中。

（4）视图(view)：定义HTML等静态网页文件相关，也就是那些html、css、js等前端的东西。

（5）控制器(controller)：定义业务逻辑相关，就是你的主要代码。　　

（6）MTV：有些WEB框架以为MVC的字面意思很别扭，就给它改了一下。view再也不是HTML相关，而是主业务逻辑了，至关于控制器。html被放在Templates中，称做模板，因而MVC就变成了MTV。这其实就是一个文字游戏，和MVC本质上是同样的，换了个名字和叫法而已，换汤不换药。

3.Django的MTV模型组织

目录分开，就必须有机制将他们在内里进行耦合。在Django中，urls、orm、static、settings等起着重要的做用。一个典型的业务流程是以下图所示：

那么咱们学Django学的是什么？

1. 目录结构规范

2. urls路由方式

3. settings配置

4. ORM操做

5. 模板渲染

6.其它

2、Diango安装（windows系统）

1，pip3命令安装方式

　win+r，调出cmd，运行命令：

pip3 install django

2，配置系统环境变量

    配置环境变量，将这几个目录添加到系统环境变量中：D:\Python36\Lib\site-packages\django;D:\Python36\Scripts 

　在环境变量的path后面加入：

;D:\Python36\Lib\site-packages\django;D:\Python36\Scripts 

    添加完成后就可使用Django的django-admin.py命令新建工程了。　

    测试是否配置成功，cmd输入：

>>> python
>>> import django
>>> django.get_version()

 　出现以下内容，即表示成功；

三，建立django项目（windows系统）

1，建立django应用

安装django后会有django-admin命令，经过django-admin startproject mysite便可建立（能够先切换到某个文件夹做为工程的文件夹）；

切换到工做目录：cd /d E:\DjangoWorks

进入目录经过python manage.py runserver（或者python manage.py runserver 0.0.0.0:8000【0.0.0.0 让其它电脑可链接到开发服务器，8000 为端口号。若是不说明，那么端口号默认为 8000】）.启动应用

访问地址：http://127.0.0.1:8000/

 2，django工程结构

（1）manage.py：django项目管理文件

（2）templates目录（手动建立）：html文件存放也就是MTV中的T

（3）settings.py：主配置文件

（4）urls.py：url路由文件

（5）wegi.py：网络通讯接口

3.视图和 URL 配置

（1）在先前建立的 mysite 目录下的 mysite 目录新建一个 view.py 文件，并输入代码：

from django.http import HttpResponse
 
def hello(request):
    return HttpResponse("Hello world ! ")

（2）接着，绑定 URL 与视图函数。打开 urls.py 文件，删除原来代码，将如下代码复制粘贴到 urls.py 文件中：

from django.conf.urls import url
from . import view

urlpatterns = [
    url(r'^$', view.hello),
]

完成后，启动 Django 开发服务器，并在浏览器访问打开浏览器并访问：

（3）咱们也能够修改如下规则，urls.py 文件代码：

from django.conf.urls import url
from . import view

urlpatterns = [
    url(r'^hello$', view.hello),
]

经过浏览器打开 http://127.0.0.1:8000/hello，输出结果以下：

 

（4）url() 函数

　　Django url() 能够接收四个参数，分别是两个必选参数：regex、view 和两个可选参数：kwargs、name，接下来详细介绍这四个参数。

• regex: 正则表达式，与之匹配的 URL 会执行对应的第二个参数 view。
• view: 用于执行与正则表达式匹配的 URL 请求。
• kwargs: 视图使用的字典类型的参数。
• name: 用来反向获取 URL。

注意：项目中若是代码有改动，服务器会自动监测代码的改动并自动从新载入，因此若是你已经启动了服务器则不需手动重启。

4、Django 模板

1，django模版

使用 django.http.HttpResponse() 来输出 "Hello World！"。该方式将数据与视图混合在一块儿，不符合 Django 的 MVC 思想。

Django 模板的应用，模板是一个文本，用于分离文档的表现形式和内容。

mysite目录底下建立 templates 目录并创建 hello.html文件，hello.html 文件代码以下：

<h1>{{ hello }}</h1>

从模板中咱们知道变量使用了双括号。

接下来咱们须要向Django说明模板文件的路径，修改HelloWorld/settings.py，修改 TEMPLATES 中的 DIRS 为 [BASE_DIR+"/templates",]，settings.py 文件代码：

...TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [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',
            ],
        },
    },
]
...

咱们如今修改 view.py，增长一个新的对象，用于向模板提交数据，view.py 文件代码：

#from django.http import HttpResponse
from django.shortcuts import render
 
def hello(request):
    context          = {}
    context['hello'] = 'Hello World!'
    return render(request, 'hello.html', context)

能够看到，咱们这里使用 render 来替代以前使用的 HttpResponse。render 还使用了一个字典 context 做为参数。

context 字典中元素的键值 "hello" 对应了模板中的变量 "{{ hello }}"。

再访问访问 http://127.0.0.1:8000/hello，能够看到页面：

这样咱们就完成了使用模板来输出数据，从而实现数据与视图分离。

接下来咱们将具体介绍模板中经常使用的语法规则。

2，Django 模板标签

（1）if/else 标签：

 基本语法格式以下：

{% if condition %}
     ... display
{% endif %}
或者：
{% if condition1 %}
   ... display 1
{% elif condition2 %}
   ... display 2
{% else %}
   ... display 3
{% endif %}

根据条件判断是否输出。if/else 支持嵌套。

{% if %} 标签接受 and ， or 或者 not 关键字来对多个变量作判断 ，或者对变量取反（ not )，例如：

{% if athlete_list and coach_list %}
     athletes 和 coaches 变量都是可用的。
{% endif %}

（2）for 标签：

{% for %} 容许咱们在一个序列上迭代。

与Python的 for 语句的情形相似，循环语法是 for X in Y ，Y是要迭代的序列而X是在每个特定的循环中使用的变量名称。

每一次循环中，模板系统会渲染在 {% for %} 和 {% endfor %} 之间的全部内容。

例如，给定一个运动员列表 athlete_list 变量，咱们可使用下面的代码来显示这个列表：

<ul>
{% for athlete in athlete_list %}
    <li>{{ athlete.name }}</li>
{% endfor %}
</ul>

给标签增长一个 reversed 使得该列表被反向迭代：

{% for athlete in athlete_list reversed %}
...
{% endfor %}

能够嵌套使用 {% for %} 标签：

{% for athlete in athlete_list %}
    <h1>{{ athlete.name }}</h1>
    <ul>
    {% for sport in athlete.sports_played %}
        <li>{{ sport }}</li>
    {% endfor %}
    </ul>
{% endfor %}

（3）ifequal/ifnotequal 标签：

{% ifequal %} 标签比较两个值，当他们相等时，显示在 {% ifequal %} 和 {% endifequal %} 之中全部的值。

下面的例子比较两个模板变量 user 和 currentuser :

{% ifequal user currentuser %}
    <h1>Welcome!</h1>
{% endifequal %}

和 {% if %} 相似， {% ifequal %} 支持可选的 {% else%} 标签：8

{% ifequal section 'sitenews' %}
    <h1>Site News</h1>
{% else %}
    <h1>No News Here</h1>
{% endifequal %}

（4）注释标签：

Django 注释使用 {# #}。

{# 这是一个注释 #}

（5）过滤器：

模板过滤器能够在变量被显示前修改它，过滤器使用管道字符，以下所示：

{{ name|lower }}

{{ name }} 变量被过滤器 lower 处理后，文档大写转换文本为小写。

过滤管道能够被* 套接* ，既是说，一个过滤器管道的输出又能够做为下一个管道的输入：

{{ my_list|first|upper }}

以上实例将第一个元素并将其转化为大写。

有些过滤器有参数。 过滤器的参数跟随冒号以后而且老是以双引号包含。 例如：

{{ bio|truncatewords:"30" }}

这个将显示变量 bio 的前30个词。

其余过滤器：

• addslashes : 添加反斜杠到任何反斜杠、单引号或者双引号前面。
• date : 按指定的格式字符串参数格式化 date 或者 datetime 对象，实例：

  {{ pub_date|date:"F j, Y" }}

• length : 返回变量的长度。

（6）include 标签：

{% include %} 标签容许在模板中包含其它的模板的内容。

下面这个例子都包含了 nav.html 模板：

{% include "nav.html" %}

3，模板继承：

模板能够用继承的方式来实现复用。

接下来咱们先建立以前项目的 templates 目录中添加 base.html 文件，代码以下：

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Django教程(runoob.com)</title>
</head>
<body>
    <h1>Hello World!</h1>
    <p>Django教程测试。</p>
    {% block mainbody %}
       <p>original</p>
    {% endblock %}
</body>
</html>

以上代码中，名为 mainbody 的 block 标签是能够被继承者们替换掉的部分。

全部的 {% block %} 标签告诉模板引擎，子模板能够重载这些部分。

hello.html 中继承 base.html，并替换特定 block，hello.html 修改后的代码以下：

{% extends "base.html" %}
 
{% block mainbody %}<p>继承了 base.html 文件</p>
{% endblock %}

第一行代码说明 hello.html 继承了 base.html 文件。能够看到，这里相同名字的 block 标签用以替换 base.html 的相应 block。

从新访问地址 http://127.0.0.1:8000/hello，输出结果以下：

5、 Django 模型

Django 对各类数据库提供了很好的支持，包括：PostgreSQL、MySQL、SQLite、Oracle。

Django 为这些数据库提供了统一的调用API。

若是你没安装 mysql 驱动，能够执行如下命令安装：

pip install mysqlclient#只适用Python2.x版本

#Python3.x版本:在tmode/__init__.py中增长代码
import pymysql
pymysql.install_as_MySQLdb()

1，数据库配置

项目的 settings.py 文件中找到 DATABASES 配置项，将其信息修改成：

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',  # 或者使用 mysql.connector.django
        'NAME': 'test',
        'USER': 'test',
        'PASSWORD': 'test123',
        'HOST':'localhost',
        'PORT':'3306',
    }
}

2，定义模型

建立 APP

 Django规定，若是要使用模型，必需要建立一个app。咱们使用如下命令建立一个 tmode 的 app:

django-admin startapp tmode

修改 tmode/models.py 文件，代码以下：

# models.py
from django.db import models
 
class Test(models.Model):
    name = models.CharField(max_length=20)

以上的类名表明了数据库表名，且继承了models.Model，类里面的字段表明数据表中的字段(name)，数据类型则由CharField（至关于varchar）、DateField（至关于datetime）， max_length 参数限定长度。

接下来在settings.py中找到INSTALLED_APPS这一项，以下：

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'tmode',               # 添加此项
)

在命令行中运行：

python manage.py migrate   # 建立表结构

python manage.py makemigrations tmode  # 让 Django 知道咱们在咱们的模型有一些变动
python manage.py migrate tmode   # 建立表结构

看到几行 "Creating table…" 的字样，你的数据表就建立好了。

Creating tables ...
……
Creating table tmode_test  #咱们自定义的表
……

表名组成结构为：应用名_类名（如：tmode_test）。

注意：尽管咱们没有在models给表设置主键，可是Django会自动添加一个id做为主键。

3，数据库操做

 在 mysite目录中添加 testdb.py 文件（下面介绍），并修改 urls.py：

from django.conf.urls import *
from . import view,testdb
 
urlpatterns = [
    url(r'^hello$', view.hello),
    url(r'^testdb$', testdb.testdb),
]

（1）添加数据

添加数据须要先建立对象，而后再执行 save 函数，至关于SQL中的INSERT：

# -*- coding: utf-8 -*-
 
from django.http import HttpResponse
 
from TestModel.models import Test
 
# 数据库操做
def testdb(request):
    test1 = Test(name='django')
    test1.save()
    return HttpResponse("<p>数据添加成功！</p>")

访问 http://127.0.0.1:8000/testdb 就能够看到数据添加成功的提示。

输出结果以下：

（2）获取数据

Django提供了多种方式来获取数据库的内容，以下代码所示：

# -*- coding: utf-8 -*-
 
from django.http import HttpResponse
 
from TestModel.models import Test
 
# 数据库操做
def testdb(request):
    # 初始化
    response = ""
    response1 = ""
    
    
    # 经过objects这个模型管理器的all()得到全部数据行，至关于SQL中的SELECT * FROM
    list = Test.objects.all()
        
    # filter至关于SQL中的WHERE，可设置条件过滤结果
    response2 = Test.objects.filter(id=1) 
    
    # 获取单个对象
    response3 = Test.objects.get(id=1) 
    
    # 限制返回的数据 至关于 SQL 中的 OFFSET 0 LIMIT 2;
    Test.objects.order_by('name')[0:2]
    
    #数据排序
    Test.objects.order_by("id")
    
    # 上面的方法能够连锁使用
    Test.objects.filter(name="runoob").order_by("id")
    
    # 输出全部数据
    for var in list:
        response1 += var.name + " "
    response = response1
    return HttpResponse("<p>" + response + "</p>")

访问 http://127.0.0.1:8000/testdb 就能够看到数据。

输出结果以下：

（3）更新数据

修改数据可使用 save() 或 update():

# -*- coding: utf-8 -*-
 
from django.http import HttpResponse
 
from TestModel.models import Test
 
# 数据库操做
def testdb(request):
    # 修改其中一个id=1的name字段，再save，至关于SQL中的UPDATE
    test1 = Test.objects.get(id=1)
    test1.name = 'Google'
    test1.save()
    
    # 另一种方式
    #Test.objects.filter(id=1).update(name='Baidu')
    
    # 修改全部的列
    # Test.objects.all().update(name='Google_all')
    
    return HttpResponse("<p>修改为功</p>")

访问 http://127.0.0.1:8000/testdb 就能够看到，输出结果以下：

（4）删除数据

删除数据库中的对象只需调用该对象的delete()方法便可：

# -*- coding: utf-8 -*-
 
from django.http import HttpResponse
 
from TestModel.models import Test
 
# 数据库操做
def testdb(request):
    # 删除id=1的数据
    test1 = Test.objects.get(id=1)
    test1.delete()
    
    # 另一种方式
    # Test.objects.filter(id=1).delete()
    
    # 删除全部数据
    # Test.objects.all().delete()
    
    return HttpResponse("<p>删除成功</p>")

访问 http://127.0.0.1:8000/testdb 就能够看到，输出结果以下： 

6、Django 表单

HTML表单是网站交互性的经典方式。 本章将介绍如何用Django对用户提交的表单数据进行处理。

1，HTTP 请求

HTTP协议以"请求－回复"的方式工做。客户发送请求时，能够在请求中附加数据。服务器经过解析请求，就能够得到客户传来的数据，并根据URL来提供特定的服务。

（1）GET 方法

项目中建立一个 search.py 文件，用于接收用户的请求：

# -*- coding: utf-8 -*-
 
from django.http import HttpResponse
from django.shortcuts import render_to_response
 
# 表单
def search_form(request):
    return render_to_response('search_form.html')
 
# 接收请求数据
def search(request):  
    request.encoding='utf-8'
    if 'q' in request.GET:
        message = '你搜索的内容为: ' + request.GET['q']
    else:
        message = '你提交了空表单'
    return HttpResponse(message)

模板目录 templates 中添加 search_form.html 表单：

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Python教程</title>
</head>
<body>
    <form action="/search" method="get">
        <input type="text" name="q">
        <input type="submit" value="搜索">
    </form>
</body>
</html>

urls.py 规则修改成以下形式：

from django.conf.urls import url
from . import view,testdb,search
 
urlpatterns = [
    url(r'^hello$', view.hello),
    url(r'^testdb$', testdb.testdb),
    url(r'^search_form$', search.search_form),
    url(r'^search$', search.search),
]

访问地址 http://127.0.0.1:8000/search-form 并搜索，结果以下所示:

 

（2）POST 方法

面咱们使用了GET方法。视图显示和请求处理分红两个函数处理。

提交数据时更经常使用POST方法。咱们下面使用该方法，并用一个URL和处理函数，同时显示视图和处理请求。

咱们在 templates 建立 post.html：

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>Python教程</title>
</head>
<body>
    <form action="/search_post" method="post">
        <!--csrf 全称是 Cross Site Request Forgery。Django提供的防止假装提交请求的功能。POST 方法提交的表格，必须有此标签。-->
        {% csrf_token %}
        <input type="text" name="q">
        <input type="submit" value="搜索">
    </form>
    <!--模板的末尾，增长一个 rlt 记号，为表格处理结果预留位置-->
    <p>{{ rlt }}</p>
</body>
</html>

在模板的末尾，咱们增长一个 rlt 记号，为表格处理结果预留位置。

表格后面还有一个{% csrf_token %}的标签。csrf 全称是 Cross Site Request Forgery。这是Django提供的防止假装提交请求的功能。POST 方法提交的表格，必须有此标签。

在mysite目录下新建 search2.py 文件并使用 search_post 函数来处理 POST 请求：

# -*- coding: utf-8 -*-
 
from django.shortcuts import render
from django.views.decorators import csrf
 
# 接收POST请求数据
def search_post(request):
    ctx ={}
    if request.POST:
        ctx['rlt'] = request.POST['q']
    return render(request, "post.html", ctx)

urls.py 规则修改成以下形式：

from django.conf.urls import url
from . import view,testdb,search,search2
 
urlpatterns = [
    url(r'^hello$', view.hello),
    url(r'^testdb$', testdb.testdb),
    url(r'^search_form$', search.search_form),
    url(r'^search$', search.search),
    url(r'^search_post$', search2.search_post),
]

访问 http://127.0.0.1:8000/search_post 显示结果以下：

 

 2，Request 对象

每一个 view 函数的第一个参数是一个 HttpRequest 对象，就像下面这个 hello() 函数:

from django.http import HttpResponse

def hello(request):
    return HttpResponse("Hello world")

HttpRequest对象包含当前请求URL的一些信息：

属性	描述
path	请求页面的全路径,不包括域名—例如, "/hello/"。
method	请求中使用的HTTP方法的字符串表示。全大写表示。例如: if request.method == 'GET':     do_something() elif request.method == 'POST':     do_something_else()
GET	包含全部HTTP GET参数的类字典对象。参见QueryDict 文档。
POST	包含全部HTTP POST参数的类字典对象。参见QueryDict 文档。 服务器收到空的POST请求的状况也是有可能发生的。也就是说，表单form经过HTTP POST方法提交请求，可是表单中能够没有数据。所以，不能使用语句if request.POST来判断是否使用HTTP POST方法；应该使用if request.method == "POST" (参见本表的method属性)。 注意: POST不包括file-upload信息。参见FILES属性。
REQUEST	为了方便，该属性是POST和GET属性的集合体，可是有特殊性，先查找POST属性，而后再查找GET属性。借鉴PHP's $_REQUEST。 例如，若是GET = {"name": "john"} 和POST = {"age": '34'},则 REQUEST["name"] 的值是"john", REQUEST["age"]的值是"34". 强烈建议使用GET and POST,由于这两个属性更加显式化，写出的代码也更易理解。
COOKIES	包含全部cookies的标准Python字典对象。Keys和values都是字符串。
FILES	包含全部上传文件的类字典对象。FILES中的每一个Key都是<input type="file" name="" />标签中name属性的值. FILES中的每一个value 同时也是一个标准Python字典对象，包含下面三个Keys: filename: 上传文件名,用Python字符串表示 content-type: 上传文件的Content type content: 上传文件的原始内容 注意：只有在请求方法是POST，而且请求页面中<form>有enctype="multipart/form-data"属性时FILES才拥有数据。不然，FILES 是一个空字典。
META	包含全部可用HTTP头部信息的字典。 例如: CONTENT_LENGTH CONTENT_TYPE QUERY_STRING: 未解析的原始查询字符串 REMOTE_ADDR: 客户端IP地址 REMOTE_HOST: 客户端主机名 SERVER_NAME: 服务器主机名 SERVER_PORT: 服务器端口 META 中这些头加上前缀HTTP_最为Key, 例如: HTTP_ACCEPT_ENCODING HTTP_ACCEPT_LANGUAGE HTTP_HOST: 客户发送的HTTP主机头信息 HTTP_REFERER: referring页 HTTP_USER_AGENT: 客户端的user-agent字符串 HTTP_X_BENDER: X-Bender头信息
user	是一个django.contrib.auth.models.User 对象，表明当前登陆的用户。 若是访问用户当前没有登陆，user将被初始化为django.contrib.auth.models.AnonymousUser的实例。 你能够经过user的is_authenticated()方法来辨别用户是否登陆： if request.user.is_authenticated(): # Do something for logged-in users else: # Do something for anonymous users 只有激活Django中的AuthenticationMiddleware时该属性才可用
session	惟一可读写的属性，表明当前会话的字典对象。只有激活Django中的session支持时该属性才可用。
raw_post_data	原始HTTP POST数据，未解析过。 高级处理时会有用处。

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Request对象也有一些有用的方法：

方法	描述
__getitem__(key)	返回GET/POST的键值,先取POST,后取GET。若是键不存在抛出 KeyError。  这是咱们可使用字典语法访问HttpRequest对象。  例如,request["foo"]等同于先request.POST["foo"] 而后 request.GET["foo"]的操做。
has_key()	检查request.GET or request.POST中是否包含参数指定的Key。
get_full_path()	返回包含查询字符串的请求路径。例如， "/music/bands/the_beatles/?print=true"
is_secure()	若是请求是安全的，返回True，就是说，发出的是HTTPS请求。

 

 

 

 

 

 

 

 

 

3，QueryDict对象

在HttpRequest对象中, GET和POST属性是django.http.QueryDict类的实例。

QueryDict相似字典的自定义类，用来处理单键对应多值的状况。

QueryDict实现全部标准的词典方法。还包括一些特有的方法：

方法	描述
__getitem__	和标准字典的处理有一点不一样，就是，若是Key对应多个Value，__getitem__()返回最后一个value。
__setitem__	设置参数指定key的value列表(一个Python list)。注意：它只能在一个mutable QueryDict 对象上被调用(就是经过copy()产生的一个QueryDict对象的拷贝).
get()	若是key对应多个value，get()返回最后一个value。
update()	参数能够是QueryDict，也能够是标准字典。和标准字典的update方法不一样，该方法添加字典 items，而不是替换它们: >>> q = QueryDict('a=1') >>> q = q.copy() # to make it mutable >>> q.update({'a': '2'}) >>> q.getlist('a') ['1', '2'] >>> q['a'] # returns the last ['2']
items()	和标准字典的items()方法有一点不一样,该方法使用单值逻辑的__getitem__(): >>> q = QueryDict('a=1&a=2&a=3') >>> q.items() [('a', '3')]
values()	和标准字典的values()方法有一点不一样,该方法使用单值逻辑的__getitem__():

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

此外, QueryDict也有一些方法，以下表：

方法	描述
copy()	返回对象的拷贝，内部实现是用Python标准库的copy.deepcopy()。该拷贝是mutable(可更改的) — 就是说，能够更改该拷贝的值。
getlist(key)	返回和参数key对应的全部值，做为一个Python list返回。若是key不存在，则返回空list。 It's guaranteed to return a list of some sort..
setlist(key,list_)	设置key的值为list_ (unlike __setitem__()).
appendlist(key,item)	添加item到和key关联的内部list.
setlistdefault(key,list)	和setdefault有一点不一样，它接受list而不是单个value做为参数。
lists()	和items()有一点不一样, 它会返回key的全部值，做为一个list, 例如: >>> q = QueryDict('a=1&a=2&a=3') >>> q.lists() [('a', ['1', '2', '3'])]
urlencode()	返回一个以查询字符串格式进行格式化后的字符串(e.g., "a=2&b=3&b=5").

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

7、Django Admin 管理工具

Django 提供了基于 web 的管理工具。

Django 自动管理工具是 django.contrib 的一部分。你能够在项目的 settings.py 中的 INSTALLED_APPS 看到它：

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

django.contrib是一套庞大的功能集，它是Django基本代码的组成部分。

1，激活管理工具

一般咱们在生成项目时会在 urls.py 中自动设置好，咱们只需去掉注释便可。

配置项以下所示：

# urls.py
from django.conf.urls import url
from django.contrib import admin
 
urlpatterns = [
    url(r'^admin/', admin.site.urls),
]

当这一切都配置好后，Django 管理工具就能够运行了。

2，使用管理工具

启动开发服务器，而后在浏览器中访问 http://127.0.0.1:8000/admin/，获得以下界面：

你能够经过命令 python manage.py createsuperuser 来建立超级用户，以下所示：

e:\DjangoWorks\mysite>python manage.py createsuperuser
Username (leave blank to use 'administrator'): admin
Email address: admin@python.com
Password:
Password (again):
Superuser created successfully.

以后输入用户名密码登陆，界面以下：

为了让 admin 界面管理某个数据模型，咱们须要先注册该数据模型到 admin。好比，咱们以前在 tmode中已经建立了模型 Test 。修改 tmode/admin.py:

from django.contrib import admin
from tmode.models import Test
 
# Register your models here.
admin.site.register(Test)

刷新后便可看到 Testmodel 数据表:

3，复杂模型

管理页面的功能强大，彻底有能力处理更加复杂的数据模型。

先在 tmode/models.py 中增长一个更复杂的数据模型：

from django.db import models

# Create your models here.
class Test(models.Model):
    name = models.CharField(max_length=20)

class Contact(models.Model):
    name = models.CharField(max_length=200)
    age = models.IntegerField(default=0)
    email = models.EmailField()
    def __unicode__(self):
        return self.name

class Tag(models.Model):
    #在django2.0后，定义外键和一对一关系的时候须要加on_delete选项，此参数为了不两个表里的数据不一致问题，否则会报错（老版本中models.CASCADE参数是默认的）
    contact = models.ForeignKey(Contact,on_delete=models.CASCADE)
    name = models.CharField(max_length=50)
    def __unicode__(self):
        return self.name

这里有两个表。Tag 以 Contact 为外部键。一个 Contact 能够对应多个 Tag。

咱们还能够看到许多在以前没有见过的属性类型，好比 IntegerField 用于存储整数。

在 tmode/admin.py 注册多个模型并显示：

from django.contrib import admin
from TestModel.models import Test,Contact,Tag
 
# Register your models here.
admin.site.register([Test, Contact, Tag])

刷新管理页面，显示结果以下：

在以上管理工具咱们就能进行复杂模型操做。

若是你以前还未建立表结构，可以使用如下命令建立：

$ python manage.py makemigrations tmode # 让 Django 知道咱们在咱们的模型有一些变动
$ python manage.py migrate tmode # 建立表结构

 4，自定义表单

 咱们能够自定义管理页面，来取代默认的页面。好比上面的 "add" 页面。咱们想只显示 name 和 email 部分。修改 tmode/admin.py:

from django.contrib import admin
from TestModel.models import Test,Contact,Tag
 
# Register your models here.
class ContactAdmin(admin.ModelAdmin):
    fields = ('name', 'email')
 
admin.site.register(Contact, ContactAdmin)
admin.site.register([Test, Tag])

以上代码定义了一个 ContactAdmin 类，用以说明管理页面的显示格式。

里面的 fields 属性定义了要显示的字段。

因为该类对应的是 Contact 数据模型，咱们在注册的时候，须要将它们一块儿注册。显示效果以下：

咱们还能够将输入栏分块，每一个栏也能够定义本身的格式。修改 TestModel/admin.py为：

from django.contrib import admin
from TestModel.models import Test,Contact,Tag
 
# Register your models here.
class ContactAdmin(admin.ModelAdmin):
    fieldsets = (
        ['Main',{
            'fields':('name','email'),
        }],
        ['Advance',{
            'classes': ('collapse',), # CSS
            'fields': ('age',),
        }]
    )
 
admin.site.register(Contact, ContactAdmin)
admin.site.register([Test, Tag])

上面的栏目分为了 Main 和 Advance 两部分。classes 说明它所在的部分的 CSS 格式。这里让 Advance 部分隐藏：

Advance 部分旁边有一个 Show 按钮，用于展开，展开后可点击 Hide 将其隐藏，以下图所示：

5，内联(Inline)显示

上面的 Contact 是 Tag 的外部键，因此有外部参考的关系。

而在默认的页面显示中，将二者分离开来，没法体现出二者的从属关系。咱们可使用内联显示，让 Tag 附加在 Contact 的编辑页面上显示。

修改tmode/admin.py：

from django.contrib import admin
from TestModel.models import Test,Contact,Tag
 
# Register your models here.
class TagInline(admin.TabularInline):
    model = Tag
 
class ContactAdmin(admin.ModelAdmin):
    inlines = [TagInline]  # Inline
    fieldsets = (
        ['Main',{
            'fields':('name','email'),
        }],
        ['Advance',{
            'classes': ('collapse',),
            'fields': ('age',),
        }]
 
    )
 
admin.site.register(Contact, ContactAdmin)
admin.site.register([Test])

显示效果以下：

6，列表页的显示

在 Contact 输入数条记录后，Contact 的列表页看起来以下:

咱们也能够自定义该页面的显示，好比在列表中显示更多的栏目，只须要在 ContactAdmin 中增长 list_display 属性:

from django.contrib import admin
from TestModel.models import Test,Contact,Tag
 
# Register your models here.
class TagInline(admin.TabularInline):
    model = Tag
 
class ContactAdmin(admin.ModelAdmin):
    list_display = ('name','age', 'email') # list
    inlines = [TagInline]  # Inline
    fieldsets = (
        ['Main',{
            'fields':('name','email'),
        }],
        ['Advance',{
            'classes': ('collapse',),
            'fields': ('age',),
        }]
 
    )
 
admin.site.register(Contact, ContactAdmin)
admin.site.register([Test])

刷新页面显示效果以下：

搜索功能在管理大量记录时很是有，咱们可使用 search_fields 为该列表页增长搜索栏：

from django.contrib import admin
from TestModel.models import Test,Contact,Tag
 
# Register your models here.
class TagInline(admin.TabularInline):
    model = Tag
 
class ContactAdmin(admin.ModelAdmin):
    list_display = ('name','age', 'email') # list展现列
    search_fields = ('name',) #增长搜索栏
    inlines = [TagInline]  # Inline
    fieldsets = (
        ['Main',{
            'fields':('name','email'),
        }],
        ['Advance',{
            'classes': ('collapse',),
            'fields': ('age',),
        }]
 
    )
 
admin.site.register(Contact, ContactAdmin)
admin.site.register([Test])

咱们搜索了 name 为 baidu 的记录，显示结果以下：

Django Admin 管理工具还有很是多实用的功能，感兴趣的能够深刻研究。