Django在开发中的基本操作小结

文章目录
  1. 1. Django项目创建
  2. 2. Django项目下创建应用
  3. 3. Django创建超级管理员
  4. 4. Django创建视图
    1. 4.1. 基础视图创建
    2. 4.2. 高级视图创建
      1. 4.2.1. 用户登录与退出
  5. 5. Django与MySQL进行交互
  6. 6. 在外部文件中调用Django的model

预感到以后会经常和Django打交道，写个备忘吧，什么时候忘了什么时候回来翻。

开发基于Windows。
p.s. 由于懒，示例代码大部分截取自我的毕设。

Django项目创建

直接进入cmd环境，在需要开发应用的文件夹下面执行如下命令：

1
django-admin startproject 项目名称

创建好的django文件夹如下图所示：

Django项目文件夹review_django下文件包括一个同名的项目文件夹review_django和manage.py文件。
分别说明：

  1. manage.py：用以运行整个项目，执行:

    1
    python3 manage.py runserver

  2. review_django文件夹说明，其中包含3个主要文件：

    (1) settings.py：用来设置全局各种环境变量，例如，在项目中注册应用，前端文件存放的文件夹，数据库的链接配置，时区设置等；
    e.g. 注册应用

e.g. 设置前端文件存放文件夹

e.g. 设置数据库连接

参数说明：
NAME:需要连接的数据库的名称
PASSWORD：数据库用户的密码

e.g. 时区和语言配置

e.g. 设置静态文件读取路径

(2) urls.py：用来创建不同页面对应的总链接。
以用户为例，用户要以 https://lalalal.com/user/ 开头，这个文件夹存在的目的就是建立这个user路径。
这里的用户可以看作是存在于项目中的user应用。

同理，对于其他的应用创建对应的url，只需要创建如同user的链接即可。
^ 表示以xx开头。

(3) wsgi.py：在部署项目到服务器上时需要，这里暂时跳过。

Django项目下创建应用

上述中仅描述了如何创建一个Django的框架，现在要在框架里填东西，就需要构建一个个具体的应用。
创建应用的命令：

1
python3 manage.py startapp 应用名

这里创建一个叫做user的应用，创建完之后，要记得去settings.py文件的INSTALLED_APPS下面添加一个user应用。

创建好的应用文件夹如下，其中也包含了Django框架提前为我们生成好的文件：

(1) admin.py: 这个文件用户创建默认管理员目录下的应用，也就是可以通过Django框架下默认的管理员界面来管理各个应用，但是如果需要自定义管理员界面，则可以不在里面写东西。然而，如果需要注册应用，则可以写为：

1
2
3
4
# 引入应用
from 应用名.models import 类名

admin.site.register(类名)

(2) models.py：这个文件很重要，里面需要设置在数据库中生成的表。
首先需要在其中引入抽象类和基类，还有时间类：

1
2
3
from django.contrib.auth.models import AbstractUser
from db.base_model import BaseModel
import time

然后以类的形式，创建数据库中包含的基本表，害，这里拿出我毕设中的一个表作为例子：

1
2
3
4
5
6
7
8
class TeamCount(BaseModel):
    '''统计球队提到次数'''
    team_name=models.CharField(max_length=32,default='',verbose_name='球队名称')
    count=models.IntegerField(default=0,verbose_name='提到次数')
    class Meta:
        db_table = 'bundesliga_teamname_count'
        verbose_name = '球队问及次数'
        verbose_name_plural = verbose_name

这个表中包含两个字段：team_name和count，models提供的CharFiled和IntegerField类型用来对这两个字段进行描述，包括最大长度，默认值，verbose_name(别名)。
class Meta属于对数据表进行自定义（包括表名以及别名），如果不设置这条，数据表得名字就由框架自动生成，会很长，不方便查表。

根据以上描述，针对项目中对数据表的需求对表进行设置，然后迁移并生成数据表，执行命令：

1
2
生成迁移文件：python3 manage.py makemigrations
生成迁移表： python3 manage.py migrate

然后再查看数据库，可以看到数据表已经成功生成。

Django创建超级管理员

从创建项目那一块中的urls.py中可以看出，其中有一个默认的admin页面，而这里创建的Django超级管理员就是用来登录这个后台的。
执行命令：

1
python3 manage.py createsuperuser

注意，在创建超级用户时，要确认数据库中已经包含了用户表，否则创建失败。
用户模型类示例：

1
2
3
4
5
6
class User(AbstractUser, BaseModel):
    '''用户模型类'''
    class Meta:
        db_table = 'df_user'
        verbose_name = '用户'
        verbose_name_plural = verbose_name

Django创建视图

视图一般是在应用的views.py中通过定义函数的方式来定义对应的视图。
定义视图一般包含两个步骤：
(1) 定义一个完整的视图功能；
(2) 在应用的urls.py（这个文件需要自己创建，可以把项目下面的urls.py复制过来修改后直接用）下面配置应用下面不同视图对应的链接。

基础视图创建

1. HttpResponse响应：

1
2
3
4
from django.http import HttpResponse

def index(request):
	return HttpResponse('index page')

在views.py中写完这块内容，毫无疑问需要到urls.py中进行url的配置。
(1) 首先需要在项目的urls.py中设置：

1
2
3
4
5
6
7
from django.conf.urls import include, url
from django.contrib import admin

urlpatterns = [
    url(r'^admin/', include(admin.site.urls)),
	url(r'^user/',include('user.urls',namespace='user')),# 可以是任何你自定义的模块
]

(2) 在应用的urls下面创建连接

1
2
3
4
5
6
from django.conf.urls import url
from 应用 import views

urlpatterns=[
	url(r'^index',views.index)
]

然后启动项目，访问localhost:8000/index界面，就可以看到index page字样。

2. 调用模板：

1
2
3
4
5
6
7
8
9
10
11
12
13
from django.shortcuts import render
from django.http import HttpResponse
from django.template import loader,RequestContext

def index(request):
	# 1.加载模板文件
    temp=loader.get_template('booktest/index.html')
    # 2.定义模板上下文:给模板文件传递数据
    context=RequestContext(request,{})
    # 3.模板渲染：产生标准的html内容
    res_html=temp.render(context)
    # 4.返回给浏览器
    return HttpResponse(res_html)

定义url的部分如1中所示，这里不再赘述。

高级视图创建

上述视图创建会有一个问题，一旦某个视图改了名字，全盘都要改。
所以这里可以使用from django.views.generic import View，让每个页面作为一个类继承于View。
同理，还是拿出我毕设里的一小块代码来示例-管理员登录界面：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# /user/login
class LoginView(View):
    '''登录'''
    def get(self,request):
        '''显示登录页面'''
        return render(request,'login.html')
    def post(self,request):
        '''处理登录'''
        # print(request.POST.get('username'))
        # print(request.POST.get('password'))
        username=request.POST.get('username')
        password=request.POST.get('password')
        # 校验数据
        if not all([username,password]):
            return render(request,'login.html',{'errmsg':'您输入的用户名或密码不完整!'})
        
        # 业务处理:登录校验
        user=authenticate(username=username,password=password)
        if user is not None:
            # 用户名密码正确
            # 记住用户的登录状态
            login(request,user)
            #return render(request,'admin.html',{'username':user.username})
            url=reverse('user:admin')
            return redirect(url)
        else:
            # 用户名或密码错误
            return render(request,'login.html',{'errmsg':'用户名或密码错误'})

View中需要处理两种响应，get和post，我对get和post简单且粗暴的理解如下：
get:不和前端页面有任何交互信息；
post：需要接收处理并返回给前端页面数据。

前端交互的时候会返回一个request，通过request.POST.get取出关键词对应的数据就能获取前端返回的信息。
这里涉及到的ajax响应部分，后面会单独写一篇ajax博客进行讲解。

继承于View的视图在创建url时是这样(以上述LoginView为例)：

1
2
3
4
5
from user.views import LoginView

urlpatterns = [
    url(r'^login$',LoginView.as_view(),name='login'),# 管理员登录
]

用户登录与退出

既然这里提到了用户登录，就简单说一下Django框架提供的用户认证功能吧。
核心包:

1
2
from django.contrib.auth import authenticate, login, logout
from django.core.urlresolvers import reverse

然后通过request.POST.get取出关键字段：

1
2
username=request.POST.get('username')
password=request.POST.get('password')

使用authenticate验证输入是否正确:

1
user=authenticate(username=username,password=password)

如果用户名和密码输入正确，那么user的值就不为空，说明这个用户是存在的，所以直接调用login:

1
2
3
4
5
6
7
if user is not None:
    # 用户名密码正确
    # 记住用户的登录状态
    login(request,user)
    #return render(request,'admin.html',{'username':user.username})
    url=reverse('user:admin')
    return redirect(url)

反之，使用render功能跳转会登录的初始界面，并提示错误信息:

1
2
3
else:
    # 用户名或密码错误
    return render(request,'login.html',{'errmsg':'用户名或密码错误'})

render和redirect的区别:
render:同时返回request,跳转的页面,页面上需要显示的信息;
redirect：直接指定需要跳转过去的链接。

Django与MySQL进行交互

好吧，这里仍然是取出我毕设的一小部分代码来做示例。
如先前所示，我们在models.py中创建了一个TeamCount类，ok，导入。

1
from user.models import TeamCount

同时，这里需要引入另外一个包LoginRequiredMixin，因为这个界面需要登录后才能查看，这个包的作用就是用来查看用户是否登录。
这需要在整个项目的下面创建一个utils文件夹，并设置init.py使其成为一个自定义的python包。

其中的内容如下：

1
2
3
4
5
6
7
8
9
10
11
from django.contrib.auth.decorators import login_required

'''
这个文件存在的目的就是为了使某些页面只有在登录后才能访问
'''
class LoginRequiredMixin(object):
    @classmethod
    def as_view(cls,**initkwargs):
        # 调用父类的 as_view
        view=super(LoginRequiredMixin,cls).as_view(**initkwargs)
        return login_required(view)

然后在视图views.py中引入相应包：

1
from utils.mixin import LoginRequiredMixin

现在正式进入交互正题：
(1) 取出一个表中某列对应的全部值

1
tcs=TeamCount.objects.values_list('team_name')

注意：这里的TeamCount是表名,team_name是列名，取出的tcs中就包含了这列中的全部数据；
(2) 根据列中的唯一值，取出该列值所在行的数据

1
2
tco=TeamCount.objects.get(team_name='具体值')
count=tco.count

tco取出的就是一整列，使用tco.count，就是取出这行中列名为count得全部数据值。

然后通过构建上下文的方式将值传回给前端。

1
2
3
4
5
6
7
# 构建上下文
context={
    'team_name': json.dumps(team_name),
    'team_value': json.dumps(team_value)
    }

return render(request,'admin_team_question.html',context=context)

核心就两个功能：
(1) values_list;
(2) get.

在外部文件中调用Django的model

Django这个model是真的方便啊，直接类名+objects+get就能取出来了，其他的多麻烦…
但是这个引用，是需要在头部加一些参数的，不然报错报得你一个头两个大。
直接放定义文件：

1
2
3
4
5
6
7
8
9
10
11
import os
import sys
import django

pathname = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, pathname)
# 项目所在文件夹的相对于需要引入文件的相对地址
sys.path.insert(0, os.path.abspath(os.path.join(pathname, '..')))
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "django项目名.settings")

django.setup()

引入完毕，下面直接

1
from user.models import Django应用中model的定义类

歪瑞古德，歪瑞方便。