Django-01

Djongo入门

Djongo介绍

Django是一个开放源代码的Web应用框架，由Python写成。采用了MTV的框架模式，即模型M，视图V和模版T。它最初是被开发来用于管理劳伦斯出版集团旗下的一些以新闻内容为主的网站的，即是CMS（内容管理系统）软件。并于2005年7月在BSD许可证下发布。这套框架是以比利时的吉普赛爵士吉他手Django Reinhardt来命名的。

Django是一个基于MVC构造的框架。但是在Django中，控制器接受用户输入的部分由框架自行处理，所以 Django 里更关注的是模型（Model）、模板(Template)和视图（Views），称为 MTV模式，各自职责如下：

层次	职责
模型（Model），即数据存取层	处理与数据相关的所有事务： 如何存取、如何验证有效性、包含哪些行为以及数据之间的关系等。
模板(Template)，即表现层	处理与表现相关的决定： 如何在页面或其他类型文档中进行显示。
视图（View），即业务逻辑层	存取模型及调取恰当模板的相关逻辑。模型与模板的桥梁

Django 框架的核心组件及设计哲学：

• 对象关系映射 (ORM,object-relational mapping)：以Python类形式定义你的数据模型，ORM将模型与关系数据库连接起来，你将得到一个非常容易使用的数据库API，同时你也可以在Django中使用原始的SQL语句。

• URL 分派：使用正则表达式匹配URL，你可以设计任意的URL，没有框架的特定限定。像你喜欢的一样灵活。

• 模版系统：使用Django强大而可扩展的模板语言，可以分隔设计、内容和Python代码。并且具有可继承性。

• 表单处理：你可以方便的生成各种表单模型，实现表单的有效性检验。可以方便的从你定义的模型实例生成相应的表单。

• Cache系统：可以挂在内存缓冲或其它的框架实现超级缓冲 －－ 实现你所需要的粒度。

• 会话(session)，用户登录与权限检查，快速开发用户会话功能。

• 国际化：内置国际化系统，方便开发出多种语言的网站。

• 自动化的管理界面：不需要你花大量的工作来创建人员管理和更新内容。Django自带一个ADMIN site,类似于内容管理系统

Djongo安装

Djongo安装分为三步：

1. 安装 Python

2. 安装 Python 虚拟环境

3. 安装 Django

• 第一步不在赘述，注意使用Python3及以上版本

• 第二步安装虚拟环境的目的是为了解决电脑中的软件相互依赖，每个程序都要依赖某些其他程序，而且要找到运行其他软件的设置（环境变量），编写新软件程序时，可能（经常）要修改其他软件所需的依赖或环境变量，这一步可能会导致各种问题，因此要避免。

Python 虚拟环境能解决这个问题。它把软件所需的全部依赖和环境变量包装到一个文件系统中，与电脑中的其他软件隔离开。

直接使用命令：pip install virtualenv 即可安装完成。

安装完成后执行命令：virtualenv env_mysite为我们自己的项目创建虚拟环境，注意env_mysite可以自定义，执行完成后我们发现在我们电脑家目录下就创建好了一个 \env_mysite 的文件夹，virtualenv 创建了一个完整的 Python 安装，它与其他软件是隔离开的，因此开发项目时不会影响系统中的其他软件。

我们需要激活此虚拟环境，使用命令：env_mysite\scripts\activate，激活后我们就可以使用此虚拟环境。

• 第三步安装Djongo，直接在虚拟环境下执行命令：pip install django==1.8.13，即可安装Djongo1.8.13版本完成

新建Djongo项目

在虚拟环境中执行django-admin startproject mysite，如果不使用虚拟环境，也可以自己找到项目位置，执行此命令创建项目。命令执行完成后我们看到Djongo为我们创建了如下文件：

mysite/
    manage.py
    mysite/
        __init__.py
        settings.py
        urls.py
        wsgi.py

• 外层的mysite/ 根目录是项目的容器。这个目录的名称对 Django 没有什么作用，你可以根据喜好重命名。

• manage.py 是一个命令行实用脚本，可以通过不同的方式与 Django 项目交互。

• 内部的mysite/ 目录是项目的 Python 包。导入这里面的内容时要使用目录的名称（如mysite.urls）。

• mysite/init.py 是一个空文件，目的是让 Python 把这个目录识别为 Python 包。

• mysite/settings.py 是 Django 项目的设置/配置。

• mysite/urls.py 是 Django 项目的 URL 声明，即 Django 驱动的网站的“目录”。

• mysite/wsgi.py 是兼容 WSGI 的 Web 服务器的入口点，用于伺服项目。

这里说明一下settings文件，这是整个项目的配置和设置，我们发现Djongo框架本身已经帮我们创建好了一些项目，这是为常见场景所做的约定，具体看INSTALLED_APPS的配置（这里打开项目为大家讲解一下此文件的配置内容）：

# Application definition
# 注意：此处添加自己开发的应用
INSTALLED_APPS = (
    'django.contrib.admin', # 管理后天
    'django.contrib.auth',  # 身份验证系统
    'django.contrib.contenttypes',  # 内容类型框架
    'django.contrib.sessions',  # 会话框架
    'django.contrib.messages',  # 消息框架
    'django.contrib.staticfiles',   # 管理静态文件的框架
    'cerealsOils',  # 自己开发的应用
)

使用这些项目我们需要在数据库中创建这些项目所需的表，执行命令即可自动创建：python manage.py migratehibernate框架，通过实体类上使用注解，自动创建表。

这样我们的项目就创建完成了，使用命令：python manage.py runserver 就可以启动项目啦，默认端口为8000，我们访问就可以看到主页了。

视图和URl配置

创建视图函数

创建视图需要在项目目录下新创建一个view.py文件，此文件中我们定义函数，返回给视图我们要展示的内容，如下：

# 从django.http 模块中导入HttpResponse 类。导入这个类是因为后面的代码要使用
from django.http import HttpResponse

# 视图函数，传入参数：jango.http.HttpRequest对象实例，注意此参数是视图函数必须的且是第一位的参数

# 静态内容
def hello(request):
   # 返回 Hello World 给response
    return HttpResponse("Hello World")

# 动态内容
def currentDatetime(request):
    now = datetime.datetime.now()
    html = "现在时间： % now
    return HttpResponse(html)

# 动态url
def timeAhead(request, offset):
    try:
        offset = int(offset)
    except ValueError: # 如果传给int() 函数的值不能转换成整数（如字符串"foo"），Python 会抛出ValueError 异常
        raise Http404()
    dt = datetime.datetime.now() + datetime.timedelta(hours=offset)
    html = "In %s hour(s), it will be %s." % (offset, dt)
    return HttpResponse(html)

配置URl

若想把视图函数与特定的 URL 对应起来，要使用 URL 配置（URLconf）。URL 配置相当于 Django 驱动的网站的目录。简单来说，URL 配置把 URL 映射到相应的视图函数上，具体配置及说明如下：

# 从django.conf.urls 模块中导入两个函数：include，用于导入另一个 URL 配置模块；url，使用正则表达式模式匹配浏览器中的 URL，把它映射到 Django 项目中的某个模块上。
from django.conf.urls import include, url
# 从django.contrib 模块中导入admin 函数。这个函数传给include 函数，加载 Django 管理后台的 URL
from django.contrib import admin

# url实例列表
urlpatterns = [
    # 注意：正则表达式字符串前面的'r' 字符。它的目的是告诉 Python，那是“原始字符串”，不要解释里面的反斜线
    # 第一个参数是模式匹配字符串（一个正则表达式，稍后说明），第二个参数是模式使用的视图函数

    # url(r'^$', index),    # 为根地址指定一个 URL 模式
    url(r'^admin/', include(admin.site.urls)),
    # 静态类容
    url(r'^hello/$', hello),  # ^ 和 $  开头和结尾匹配模式   去掉hello就可以作为根地址
    # 动态内容
    url(r'^nowTime/$', currentDatetime),
    # 动态URl，Django 的核心哲学之一是，URL 应该美观，既符合REST风格，这里能匹配time/plus/2  time/plus/20
    url(r'^time/plus/(\d{1,2})/$', timeAhead),  # 正则匹配
]

处理请求过程

运行python manage.py runserver 命令时，manage.py 脚本在内层mysite 目录中寻找名为settings.py 的文件。这个文件中保存着当前 Django 项目的全部配置，各个配置的名称都是大写的，然后找到如下配置：

# 指向URl配置文件，寻找URl详细配置
ROOT_URLCONF = 'mysite.urls'

找到匹配的模式之后，调用对应的视图函数，并把一个HttpRequest 对象作为第一个参数传给视图,视图函数必须返回一个HttpResponse 对象。

随后，余下的工作交给 Django 处理：把那个 Python 对象转换成正确的 Web 响应，并且提供合适的 HTTP 首部和主体（即网页的内容）。综上：

1. 请求/hello/。

2. Django 查看ROOT_URLCONF 设置，找到根 URL 配置。

3. Django 比较 URL 配置中的各个 URL 模式，找到与/hello/ 匹配的那个。

4. 如果找到匹配的模式，调用对应的视图函数。

5. 视图函数返回一个HttpResponse 对象。

6. Django 把HttpResponse 对象转换成正确的 HTTP 响应，得到网页。

Djongo模板

Django 模板是一些文本字符串，作用是把文档的表现与数据区分开。模板定义一些占位符和基本的逻辑（模板标签），规定如何显示文档。通常，模板用于生成 HTML，不过 Django 模板可以生成任何基于文本的格式。

变量和模板标签

* {{ xxx }}     指定变量的值插入这里

* {% xxx %}     模板标签，基本模板标签有如下

    # 逻辑判断标签
    # 注意，此示例中使用了 if elif else and not or 等逻辑判断语句，与python保持一致
    # if标签中不能包含括号，如果需要使用括号判断，必须写成嵌套 if 标签语句
    {% if a1 and a2 %}
        <p>a1为真并且a2为真，显示此内容</p>
    {% elif not a3 %}
        <p> else if a3 为假，显示此内容，注意elif是可选标签</p>
    {% elif a4 or not a5 %}
        <p> else if a4 为真，或者 a5 为假，显示此内容，注意elif是可选标签</p>
    {% else %}
        <p> else显示此内容，注意else是可选标签</p>
    {% endif %}


    # 迭代元素标签
    # 正向迭代
    {% for item in item_list %}
        <li>{{ item }}</li>
    {% endfor %}

    # 反向迭代
    {% for item in item_list reversed %}
        <li>{{ item }}</li>
    {% endfor %}

    # 定义迭代列表为空的行为
    {% for item in item_list %}
        <p>{{ item }}</p>
    {% empty %}
        <p>此处定义要迭代的元素为空的行为</p>
    {% endfor %}

    # 获取迭代当前元素索引
    {% for item in item_list %}
        <p>{{ forloop.counter }}: forloop.counter表示当前元素索引</p>
        <p>{{ forloop.revcounter }}: forloop.revcounter表示剩余元素数量</p>
        {% if forloop.first %}
           <p>forloop.first返回的是boolean，表示是否第一个元素</p>
        {% elif forloop.last %}
            <p>forloop.last返回的也是boolean，表示是否最后一个元素</p>
        {% endif %}
    {% endfor %}


    # 比较值相等标签
    {% ifequal A B %}
        <h1>A 的值和 B 的值相等!</h1>
    {% else %}
        <h1>A 的值和 B 的值不相等!</h1>
    {% endifequal %}

    # 比较值不相等标签
    {% ifnotequal A 'JJW' %}
        <h1>A 的值不等于JJW!</h1>
    {% else %}
        <h1>A 的值等于JJW!</h1>
    {% endifnotequal %}


    # 模板注释
    # 单行注释
    {# 这里是一个注释 #}

    # 多行注释，comment标签
    {% comment %}
        第一行注释
        第二行注释
    {% endcomment %}


    # 过滤器
    # 模板过滤器是在显示变量之前调整变量值的简单方式
    # 把文本转换成小写，然后再显示
    {{ name|lower }}

    # 获取列表中的第一个元素，然后将其转换成大写
    {{ my_list|first|upper }}

    # 显示bio 变量的前 30 个词
    {{ bio|truncatewords:"30" }}

    # 在反斜线、单引号和双引号前面添加一个反斜线。可用于转义字符串
    {{ value|addslashes }}

    # 返回值长度，如果是列表，返回列表元素个数
    {{ name|length }}


    # include 模板标签
    这个标签的作用是引入另一个模板的内容。它的参数是要引入的模板的名称，可以是变量，也可以是硬编码的字符串（放在引号里，单双引号都行）

    {% include 'nav.html' %}
    {% include "nav.html" %}

    # 以下是使用示例
    <html>
        <body>
            {% include "includes/nav.html" %}
            <h1>{{ title }}</h1>
        </body>
    </html>

    # includes/nav.html
    <div id="nav">
        You are in: {{ current_section }}
    </div>


    # 模板继承
    # 模板继承是指创建一个基底“骨架”模板，包含网站的所有通用部分，并且定义一些“块”，让子模板覆盖。

    # 首先定义一个基地模板
    # {% block xxx %}{% endblock %} 表示此标签内容可以被子模板重写
    <html lang="en">
        <head>
            <title>{% block title %}{% endblock %}</title>
        </head>
        <body>
            <h1>My helpful timestamp site</h1>
            {% block content %}{% endblock %}
            {% block footer %}
                <hr>
                <p>Thanks for visiting my site.</p>
            {% endblock %}
        </body>
    </html>

    # 然后定义子模板
    # 子模板需要继承父模板 {% extends "base.html" %}
    # 重写依然要使用 {% block xxx %}{% endblock %} 标签
    {% extends "base.html" %}
    {% block title %}Future time{% endblock %}
    {% block content %}
        <p>
        In {{ hour_offset }} hour(s), it will be {{ next_time }}.
        </p>
    {% endblock %}

使用模板系统

Django 系统经过配置后可以使用一个或多个模板引擎（如果不用模板，那就不用配置）。Django 自带了一个内置的后端，用于支持自身的模板引擎，即 Django Template Language（DTL），若想在 Python 代码中使用 Django 的模板系统，基本方式如下：

1. 以字符串形式提供原始的模板代码，创建Template 对象。

2. 在Template 对象上调用render() 方法，传入一系列变量（上下文）。返回的是完全渲染模板后得到的字符串，模板中的变量和模板标签已经根据上下文求出值了。

以上步骤我们都可以使用一个函数来完成，那就是render()函数，render() 的第一个参数是请求对象，第二个参数是模板名称，第三个参数可选，是一个字段，用于创建传给模板的上下文。如果不指定第三个参数，render() 使用一个空字典，具体使用如下介绍。

模板目录及模板加载

为了从文件系统中加载模板，Django 提供了便利而强大的 API，力求去掉模板加载调用和模板自身的冗余。若想使用这个模板加载 API，首先要告诉框架模板的存储位置。这个位置在设置文件中配置，打开settings.py 文件，找到TEMPLATES 设置。它的值是一个列表，分别针对各个模板引擎：

TEMPLATES = [
    {
        # BACKEND 的值是一个点分 Python 路径，指向实现 Django 模板后端 API 的模板引擎类
        'BACKEND': 'django.template.backends.django.DjangoTemplates',

        #  DIRS 定义一个目录列表，模板引擎按顺序在里面查找模板源文件。
        # 当前设置表示在项目根目录中放一些主模板，模板目录不一定非得叫'templates'，可以自定义
        'DIRS': [os.path.join(BASE_DIR, 'templates')],

        # 去应用所在位置查找模板，APPS_DIRS 设为True 时，DjangoTemplates 会在INSTALLED_APPS 中的各个应用里查找名为“templates”的子目录。这样，即使DIRS 为空，模板引擎还能查找应用模板。
        'APP_DIRS': True,

        # OPTIONS 是一些针对后端的设置
        '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',
            ],
        },
    },
]

查找模板逻辑

• 如果APP_DIRS 的值是True，而且使用 DTL，在当前应用中查找“templates”目录。

• 如果在当前应用中没找到模板，把传给它的模板名称添加到DIRS 中的各个目录后面，按顺序在各个目录中查找。假如DIRS 的第一个元素是’/home/django/mysite/templates’，调用查找的模板是/home/django/mysite/templates/current_datetime.html。

• 找不到指定名称对应的模板，抛出TemplateDoesNotExist 异常。

使用示例及说明

视图函数如下定义：

from django.shortcuts import render
import datetime

def currentDatetime(request):
    now = datetime.datetime.now()
    return render(request, 'test/current_datetime.html', {'current_date': now})

通过以上示例我们发现：

• 不用再导入get_template、Template、Context 或HttpResponse 了，而要导入django.shortcuts.render

• import datetime 不变。

• 在current_datetime 函数中，仍然要计算now，不过加载模板、创建上下文、渲染模板和创建HttpResponse对象全由render() 调用代替了。render() 的返回值是一个HttpResponse 对象，因此在视图中可以直接返回那个值。

注意上述我们还使用了模板子目录：test/current_datetime.html，表示去根目录下寻找templates目录下的test目录，找到模板。

Djongo模型

Django 非常适合构建数据库驱动型网站，它提供了简单而强大的工具，易于使用 Python 执行数据库查询，本章就说明这个功能，即 Django 的数据库层。

配置数据库

数据库连接的配置也在settings文件中，具体如下：

# 数据库配置，这里使用集成的sqllite3，我们配置自己的数据库，类似于我们Java项目中的配置文件中配置即可

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3', # ENGINE 告诉 Django 使用哪个数据库引擎。
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'), # NAME 告诉 Django 数据库的名称。
    }
}

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

创建应用

下面说明项目和应用的区别：

• 一个项目是一系列 Django 应用的实例，外加那些应用的配置。严格来说，一个项目唯一需要的是一个设定文件，定义数据库连接信息、安装的应用列表、DIRS，等等。

• 一个应用是一系列便携的 Django 功能，通常包含模型和视图。打包在一个 Python 包里。Django 自带了一些应用，例如管理后台。这些应用的独特之处是便携，可以在多个项目中复用。

在项目目录，注意是项目目录，使用如下命令创建新的应用，并指定自定义应用名称：python manage.py startapp 应用名称。

Django 通过模型在背后执行 SQL，返回便利的 Python 数据结构，表示数据库表中的行。Django 还通过模型表示 SQL 无法处理的高层级概念，这么做的好处如下：

• 内省（introspection）有开销，而且不完美。为了提供便利的数据访问 API，Django 需要以某种方式知晓数据库布局，而这一需求有两种实现方式。第一种是使用Python 明确描述数据，第二种是在运行时内省数据库，推知数据模型。第二种方式在一个地方存储表的元数据，看似更简单，其实会导致几个问题。首先，运行时内省数据库肯定有消耗。如果每次执行请求，或者只是初始化 Web 服务器都要内省数据库，那带来的消耗是无法接受的，其次，有些数据库，尤其是旧版 MySQL，存储的元数据不足以完成内省。

• Python 编写起来让人心情舒畅，而且使用 Python 编写所有代码无需频繁让大脑切换情境。在一个编程环境（思维）中待久了，有助于提升效率。在 SQL 和 Python 之间换来换去容易打断状态。

• 把数据模型保存在代码中比保存在数据库中易于做版本控制，易于跟踪数据布局的变化。

• SQL 对数据布局的元数据只有部分支持。例如，多数数据库系统没有提供专门表示电子邮件地址或URL 的数据类型。而 Django 模型有。高层级的数据结构有助于提升效率，让代码更便于复用。

• 不同数据库平台使用的 SQL 不一致。

分发 Web 应用程序时，更务实的做法是分发一个描述数据布局的 Python 模块，而不是分别针对MySQL、PostgreSQL 和 SQLite 的CREATE TABLE 语句。

创建自己的模型

在我们新创建的应用的models.py文件中，添加自己定义的模型，如下：

让 Django 具有基本的数据访问能力只需编写这些代码。一般，一个模型对应于一个数据库表，模型中的各个属性分别对应于数据库表中的一列。属性的名称对应于列的名称，字段的类型（如CharField）对应于数据库列的类型(如varchar)

# 厂家
class Manufacturers(models.Model):
    name = models.CharField(max_length=30)
    address = models.CharField(max_length=50)
    city = models.CharField(max_length=60)
    province = models.CharField(max_length=30)
    website = models.URLField(blank=True, null=True, verbose_name='网址') # 表单允许为空    修改数据库结构，表示字段可为空

    def __str__(self):
        return u'%s' % (self.name)

# 经销商
class Vender(models.Model):
    name = models.CharField(max_length=30)
    address = models.CharField(max_length=50)
    city = models.CharField(max_length=60)
    province = models.CharField(max_length=30)
    telephone = models.CharField(max_length=20)

    def __str__(self):
        return u'%s %s %s %s %s' % (self.name, self.address, self.city, self.province, self.telephone)

# 产品
class Product(models.Model):
    title = models.CharField(max_length=100)
    vender = models.ManyToManyField(Vender) # 多对多关系
    manufacturers = models.ForeignKey(Manufacturers)    # 一对多
    product_date = models.DateField()
    # fields = ('title', 'product_date', 'vender', 'manufacturers')

    def __str__(self):
        return u'%s %s' % (self.title, self.product_date)

    # 任何模型都可以使用Meta 类指定多个针对所在模型的选项。
    class Meta:
        ordering = ['product_date']

注意：多对多关系，在上述示例模型中，Django 会创建一个额外的表，一个多对多联结表（join table），处理Product与Vender之间的对应关系。

安装模型

在settings文件中注册上我们自己创建的应用，注册位置已经在之前描述过，如下：

# Application definition
# 注意：此处添加自己开发的应用
INSTALLED_APPS = (
    'django.contrib.admin', # 管理后台
    'django.contrib.auth',  # 身份验证系统
    'django.contrib.contenttypes',  # 内容类型框架
    'django.contrib.sessions',  # 会话框架
    'django.contrib.messages',  # 消息框架
    'django.contrib.staticfiles',   # 管理静态文件的框架

    'cerealsOils',  # 自己开发的应用
)

注册好后就可以验证和安装模型：

验证模型使用命令：python manage.py check check 命令运行 Django 系统检查框架，即验证 Django 项目的一系列静态检查。如果一切正常，你将看到这个消息：System check identified no issues (0 silenced)，不然会抛出出错位置的异常

安装模型使用命令：python manage.py makemigrations cerealsOils，这样我们就安装好了模型，并根据模型定义创建好了数据库表

查看建表语句可以执行命令：python manage.py sqlmigrate cerealsOils 0001，这样建表语句就会输出出来

Djongo后台管理

对多数现代的网站而言，管理界面是基础设施的重要组成部分。这是一个 Web 界面，限制只让授信的网站管理员访问，用于添加、编辑和删除网站内容。常见的示例有：发布博客的界面，网站管理人员审核用户评论的后端，客户用来更新新闻稿的工具。
不过，管理界面有个问题：构建起来繁琐。构建面向公众的功能时，Web 开发是有趣的，但是管理界面一成不变，要验证用户身份、显示并处理表单、验证输入，等等。这个过程无趣、乏味。
在 Django 中，构建管理界面不算个事， Django 为我们自动生成的管理界面，了解它为模型提供的便利界面，以及可以使用的其他功能。

使用管理后台

之前创建项目时我们执行了django-admin startproject mysite命令时，Django 为我们创建并配置了默认的管理后台。我们只需创建一个管理员用户（超级用户），就可以登录管理后台。

1. 创建管理用户：python manage.py createsuperuser

2. 输入要创建的用户：Username: admin

3. 输入邮箱地址：Email address: admin@example.com

4. 输入用户密码，需要输入两次确认：Password: **

启动服务器，访问ttp://127.0.0.1:8000/admin/就可以进入登录页面，登录后具体操作就可以被看懂了，这里不再赘述，可以启动项目为大家演示一下。

将我们创建的模型添加至后台管理

在我们新创建的项目目录下创建admin.py文件，并添加如下代码，这样就将我们创建的模型添加至了后天管理系统：

from django.contrib import admin
from .models import Manufacturers, Vender, Product

# 注册我们创建的模型
admin.site.register(Manufacturers, ManufacturersAdmin)
admin.site.register(Vender, VenderAdmin)
admin.site.register(Product, ProductAdmin)

将字段定义为可选（非必填）及自定义字段标注

默认我们创建的模型在后台管理页面都是必填字段，及显示的名称都是字段的英文名称，我们可以修改model，添加一下属性，来设置字段为非必填及显示的名称为可以看懂的名称，如下示例：

# 厂家
class Manufacturers(models.Model):
    name = models.CharField(max_length=30, verbose_name='厂家名称')
    address = models.CharField(max_length=50, verbose_name='具体地址')
    city = models.CharField(max_length=60, verbose_name='所在地市')
    province = models.CharField(max_length=30, verbose_name='所在省份')
    website = models.URLField(blank=True, null=True, verbose_name='网址') # 表单允许为空    修改数据库结构，表示字段可为空

    def __str__(self):
        return u'%s' % (self.name)
...

注：上述示例中：blank=True表示表单输入可为空， null=True表示数据库存值是如果是空也存为空，而不是字符”NULL”,verbose_name=’网址’表示自定义名称

自定义ModelAdmin类

具体使用及属性设置明细见如下示例（此处可以打开后台管理界面给大家演示一下）：

from django.contrib import admin
from .models import Manufacturers, Vender, Product

# Register your models here.

class ProductAdmin(admin.ModelAdmin):
    list_display = ('title', 'product_date', 'manufacturers')    # 注意 此处不能包含多对多字段
    search_fields = ('title', 'product_date')   # 添加列表搜索框内容，注意只有一个框，但输入内容后悔搜索多个字段，类似于ES的机制
    list_filter = ('product_date',)  # 右侧的过滤条  可以是日期 布尔 一对一外键类型
    date_hierarchy = 'product_date'  # 显示日期导航，注意只能添加一个导航
    ordering = ('-product_date',)   # 列表根据日期降序排序
    fields = ('product_date', 'title', 'manufacturers', 'vender')  # 自定义编辑表单，修改卡片页面排序，还可以排除字段，排除的字段将不能编辑
    raw_id_fields = ('manufacturers',)  # 针对一对一内容太多而做的界面优化，一般为下拉框内容太多的优化
    filter_horizontal = ('vender',) # 针对一对多内容太多而做的通过弹出框筛选

class VenderAdmin(admin.ModelAdmin):
    list_display = ('name', 'address')
    search_fields = ('name', 'address')

class ManufacturersAdmin(admin.ModelAdmin):
    list_display = ('name', 'address')
    search_fields = ('name', 'address')
    
# 将自定义的ModelAdmin注册到后台管理
admin.site.register(Manufacturers, ManufacturersAdmin)
admin.site.register(Vender, VenderAdmin)
admin.site.register(Product, ProductAdmin)

最后更新： 2019年08月05日 17:23

原始链接： https://jjw-story.github.io/2019/08/04/Django-01/

JJW

赏

× 请我吃糖~