初识Django

最新推荐文章于 2024-03-29 11:46:39 发布

笨笨汼秛餹

最新推荐文章于 2024-03-29 11:46:39 发布

阅读量451

点赞数

分类专栏： Python 文章标签： python virtualenv django

Python 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

搭建开发环境

安装Python

使用虚拟环境Virtualenv

Virtualenv是一个Python工具，使用它可以创建一个独立的Python环境。
Virtualenv帮我们从系统的Python环境中克隆一个全新的环境出来，这个环境独立于原来的Python环境。
Virtualenv的使用非常简单，首先安装Virtualenv

C:\User\admin>pip install virtualenv

安装成功后就可以创建虚拟环境了，指定一个你目录，Virtualenv会把新建的虚拟环境装到指定目录下。例如我把它装到D:\Envs目录下，并将虚拟环境命名为test_env。在命令栏运行如下命令：

C:\User\admin>virtualenv D:\Envs\test_env

成功创建虚拟环境后，我们需要运行test_env\Scripts\目录下的activate程序激活虚拟环境：

C:\User\admin>D:\Envs\test_env\Scripts\activate
(test_env) C:\User\admin>

注意Linux下没有Scripts\这个目录，取而代之的是bin/目录。且激活命令为：

$ source test_env/bin/activate

命令提示符前面多了(test_env)，说明我们成功激活了虚拟环境。

安装Django

(test_env) C:\User\admin>pip install django

指定安装版本：

(test_env) C:\User\admin>pip install django==1.x.x

验证是否安装成功：

(test_env) C:\User\admin>python
......
>>> import django
>>> django.get_version()
1.11.7
>>>

Django创建第一个项目

Django 管理工具

(test_env) C:\User\admin>django admin

创建第一个项目

Django工程(Project)是我们项目代码的容器，例如我们的项目中所有的代码(包括Django为我们自动生成的以及我们自己写的)都包含在这个工程里。通俗来说，就是用一个文件夹把一系列Python代码和Django配置文件包裹起来，这个文件就可以看作一个Django工程。我们不必亲自动手新建这个文件夹和代码文件，Django的内置命令已经帮我们做了这些事情。例如把工程的代码放在C:\User\admin\Workspace\，工程名叫做HelloWorld。

(test_env) C:\User\admin\Workspace>django-admin startproject HelloWorld

进入工程所在目录C:\User\admin\Workspace\，会发现多了一个HelloWorld\目录，其内部的文件结构如下：

HelloWorld\
    HelloWorld\
        __init__.py
        settings.py
        urls.py
        wsgi.py
    manage.py

目录说明：

HelloWorld：项目的容器。
HelloWorld__init__.py: 一个空文件，告诉 Python 该目录是一个 Python 包。
HelloWorld\settings.py: 该 Django 项目的设置/配置。
HelloWorld\urls.py: 该 Django 项目的 URL 声明; 一份由 Django 驱动的网站”目录”。
HelloWorld\wsgi.py: 一个 WSGI 兼容的 Web 服务器的入口，以便运行你的项目。
manage.py: 一个实用的命令行工具，可让你以各种方式与该 Django 项目进行交互。manage 是管理的意思，顾名思义 manage.py 就是 Django 为我们生成的管理这个项目的 Python 脚本文件

接下来我们进入HelloWorld目录输入以下命令，启动服务器：

python manage.py runserver 0.0.0.0:8000

0.0.0.0 让其它电脑可连接到开发服务器，8000 为端口号。如果不说明，那么端口号默认为 8000。
在浏览器输入你的服务器的ip及端口号，如果正常启动，输出结果。

HelloWorld\settings.py文件中有几个设置可以稍微注意一下：

登录权限：若要让同一局域网内计算机可以登录到该页面，ALLOWED_HOSTS = []设置为ALLOWED_HOSTS = ['*']。
语言：Django的默认语言是英语，为了让它支持中文，LANGUAGE_CODE = 'en-us'设置为LANGUAGE_CODE = 'zh-hans'
时区：默认时区是TIME_ZONE = 'UTC'，设置为中国时区可以改为TIME_ZONE = Asia/Shanghai

视图和URL配置

在创建的HelloWorld目录下的HelloWorld目录新建一个view.py，并输入代码：

# HelloWorld\HelloWorld\view.py

from django.http import HttpResponse

def hello(request):
    return HttpResponse("Hello World!")

接着，绑定URL与视图函数。打开urls.py，将其修改为如下代码：

# HelloWorld\HelloWorld\urls.py

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

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

现在目录结构如下：

HelloWorld\
    HelloWorld\
        __init__.py
        __init__.pyc
        settings.py
        settings.pyc
        urls.py              # url 配置
        urls.pyc
        view.py              # 添加的视图文件
        view.pyc             # 编译后的视图文件
        wsgi.py
        wsgi.pyc
    manage.py

完成后，刷新浏览器：

我们也可以修改规则如下：

# HelloWorld\HelloWorld\urls.py

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

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

通过浏览器打开http://127.0.0.1:8000/hello，结果如下：

注意：项目中如果代码有改动，服务器会自动监测代码的改动并自动重新载入，所以如果你已经启动了服务器则不需手动重启。

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

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

Django模板

在上一章节中我们使用 django.http.HttpResponse() 来输出 “Hello World！”。该方式将数据与视图混合在一起，不符合 Django 的 MVC 思想。
本章节我们将为大家详细介绍 Django 模板的应用，模板是一个文本，用于分离文档的表现形式和内容。

模板应用实例

我们接着上一章节的项目将在 HelloWorld 目录底下创建 templates 目录并建立 hello.html文件，整个目录结构如下：

    HelloWorld\
        HelloWorld\
            __init__.py
            settings.py
            urls.py
            view.py
            wsgi.py
        manage.py
        templates\
            hello.html

hello.html文件代码如下：

# HelloWorld\templates\hello.html
<h1>{{ hello }}</h1>

hello两边各有一个空格。
从模板中我们知道变量使用了双括号。
接下来我们需要向Django说明模板文件的路径，修改HelloWorld/settings.py，修改 TEMPLATES 中的 DIRS 为[BASE_DIR+”/templates”,]，如下所示:

# HelloWorld\HelloWorld\settings.py

...TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR+"/templates",],       # 修改位置
        #'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',
            ],
        },
    },
]
...

我们现在修改 view.py，增加一个新的对象，用于向模板提交数据：

# HelloWorld\HelloWorld\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，可以看到页面：

这样我们就完成了使用模板来输出数据，从而实现数据与视图分离。
接下来我们将具体介绍模板中常用的语法规则。

模板继承

模板可以用继承的方式来实现复用。
接下来我们先创建之前项目的 templates 目录中添加 base.html 文件，代码如下：

# HelloWorld\templates\base.html

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Learning Django</title>
</head>
<body>
    <h1>Hello World!</h1>
    <p>Django Test</p>
    {% block mainbody %}
       <p>original</p>
    {% endblock %}
</body>
</html>

以上代码中，名为 mainbody 的 block 标签是可以被继承者们替换掉的部分。
所有的 {% block %} 标签告诉模板引擎，子模板可以重载这些部分。
hello.html 中继承 base.html，并替换特定 block，hello.html 修改后的代码如下：

# HelloWorld\templates\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，输出结果如下：

Django模型

Django 对各种数据库提供了很好的支持，包括：PostgreSQL、MySQL、SQLite、Oracle。
Django 为这些数据库提供了统一的调用API。我们可以根据自己业务需求选择不同的数据库。
MySQL 是 Web 应用中最常用的数据库。本章节我们将以 Mysql 作为实例进行介绍。你可以通过本站的 MySQL 教程了解更多Mysql的基础知识。
如果你没安装 mysql 驱动，可以执行以下命令安装：

pip install mysqlclient

数据库配置

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

# HelloWorld\HelloWorld\settings.py

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

注意：上面包含数据库名称和用户的信息，它们与 MySQL 中对应数据库和用户的设置相同。Django 根据这一设置，与 MySQL 中相应的数据库和用户连接起来。

定义模型

创建app

Django规定，如果要使用模型，必须要创建一个app。我们使用以下命令创建一个TestModel的app：

django-admin startapp TestModel

目录结构如下：

HelloWorld\
    TestModel\
        migrations\
            __init__.py
        __init__.py
        admin.py
        apps.py
        models.py
        tests.py    
        views.py

修改HelloWorld\TestModel\models.py文件如下：

#HelloWorld\TestModel\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这一项，如下：

# HelloWorld\HelloWorld\settings.py

INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'TestModel',    # 添加此项
]

在命令行中运行：

python manage.py migrate   # 创建表结构
python manage.py makemigrations TestModel  # 让 Django 知道我们在我们的模型有一些变更
python manage.py migrate TestModel   # 创建表结构

表名组成结构为：应用名_类名（如：TestModel_test）。
注意：尽管我们没有在models给表设置主键，但是Django会自动添加一个id作为主键。

数据库操作

接下来我们在 HelloWorld 目录中添加 testdb.py 文件（下面介绍），并修改 urls.py：

# HelloWorld\HelloWorld\urls.py

from django.conf.urls import *
from . import view,testdb

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

添加数据

添加数据需要先创建对象，然后再执行 save 函数，相当于SQL中的INSERT：

# HelloWorld\HelloWorld\testdb.py

from django.http import HttpResponse

from TestModel.models import Test

# 数据库操作
def testdb(request):
    test1 = Test(name='runoob')
    test1.save()
    return HttpResponse("<p>数据添加成功！</p>")

访问 http://127.0.0.1:8000/testdb 就可以看到数据添加成功的提示。
输出结果如下：

获取数据

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

# HelloWorld\HelloWorld\testdb.py

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>")

更新数据：

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

# HelloWorld\HelloWorld\testdb.py
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='Google')

    # 修改所有的列
    # Test.objects.all().update(name='Google')

    return HttpResponse("<p>修改成功</p>")

删除数据

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

# HelloWorld\HelloWorld\testdb.py

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>")

Django表单

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

HTTP请求

HTTP协议以”请求－回复”的方式工作。客户发送请求时，可以在请求中附加数据。服务器通过解析请求，就可以获得客户传来的数据，并根据URL来提供特定的服务。

GET方法

我们在之前的项目中创建一个 search.py 文件，用于接收用户的请求：

# HelloWorld\HelloWorld\search.py

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 表单：

# HelloWorld\templates\search_form.htm
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>菜鸟教程(runoob.com)</title>
</head>
<body>
    <form action="/search" method="get">
        <input type="text" name="q">
        <input type="submit" value="搜索">
    </form>
</body>
</html>

urls.py 规则修改为如下形式：

# HelloWorld\HelloWorld\url.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 并搜索。

POST方法

上面我们使用了GET方法。视图显示和请求处理分成两个函数处理。
提交数据时更常用POST方法。我们下面使用该方法，并用一个URL和处理函数，同时显示视图和处理请求。
我们在tmplate 创建 post.html：

# HelloWorld\templates\post.htm

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>菜鸟教程(runoob.com)</title>
</head>
<body>
    <form action="/search-post" method="post">
        {% csrf_token %}
        <input type="text" name="q">
        <input type="submit" value="Submit">
    </form>

    <p>{{ rlt }}</p>
</body>
</html>

在模板的末尾，我们增加一个 rlt 记号，为表格处理结果预留位置。
表格后面还有一个{% csrf_token %}的标签。csrf 全称是 Cross Site Request Forgery。这是Django提供的防止伪装提交请求的功能。POST 方法提交的表格，必须有此标签。
在HelloWorld目录下新建 search2.py 文件并使用 search_post 函数来处理 POST 请求：

# HelloWorld\HelloWorld\search2.py

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 规则修改为如下形式：

# HelloWorld\HelloWorld\url.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 并搜索。

Request对象

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

from django.http import HttpResponse

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

QueryDict对象

在HttpRequest对象中, GET和POST属性是django.http.QueryDict类的实例。
QueryDict类似字典的自定义类，用来处理单键对应多值的情况。

Django Admin管理工具

Django 提供了基于 web 的管理工具。
Django 自动管理工具是 django.contrib 的一部分。你可以在项目的 settings.py 中的 INSTALLED_APPS 看到它：

# HelloWorld\HelloWorld\Settings.py

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

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

激活管理工具

通常我们在生成项目时会在 urls.py 中自动设置好，我们只需去掉注释即可。
配置项如下所示：

# HelloWorld\HelloWorld\urls.py

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

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

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

使用管理工具

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

你可以通过命令python manage.py createsuperuser来创建超级用户，如下所示：

python manage.py createsuperuser

Username: admin
Email address:  admin@example.com
Password: testad123
Password (again): testad123
Superuser created successfully.

之后输入用户名密码登录，界面如下：

为了让 admin 界面管理某个数据模型，我们需要先注册该数据模型到 admin。比如，我们之前在 TestModel 中已经创建了模型 Test 。修改 TestModel/admin.py:

# HelloWorld\TestModel\admin.py
from django.contrib import admin
from TestModel.models import Test

# Register your models here.
admin.site.register(Test)

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

复杂模型

管理页面的功能强大，完全有能力处理更加复杂的数据模型。
先在 TestModel/models.py 中增加一个更复杂的数据模型：

# HelloWorld\TestModel\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):
    contact = models.ForeignKey(Contact)
    name    = models.CharField(max_length=50)
    def __unicode__(self):
        return self.name

这里有两个表。Tag 以 Contact 为外部键。一个 Contact 可以对应多个 Tag。
我们还可以看到许多在之前没有见过的属性类型，比如 IntegerField 用于存储整数。

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

# HelloWorld\TestModel\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 TestModel  # 让 Django 知道我们在我们的模型有一些变更
python manage.py migrate TestModel   # 创建表结构

自定义表单

我们可以自定义管理页面，来取代默认的页面。比如上面的 “add” 页面。我们想只显示 name 和 email 部分。修改 TestModel\admin.py:

# HelloWorld\TestModel\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为：

# HelloWorld\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 将其隐藏，如下图所示：

内联(Inline)显示

上面的 Contact 是 Tag 的外部键，所以有外部参考的关系。
而在默认的页面显示中，将两者分离开来，无法体现出两者的从属关系。我们可以使用内联显示，让 Tag 附加在 Contact 的编辑页面上显示。
修改TestModel\admin.py：

# HelloWorld\TestModel\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])

列表页的显示

我们可以自定义该页面的显示，比如在列表中显示更多的栏目，只需要在 ContactAdmin 中增加 list_display 属性:

# HelloWorld\TestModel\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):
    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 为该列表页增加搜索栏：

# HelloWorld\TestModel\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):
    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 为 google 的记录，显示结果如下：