码迷，mamicode.com
首页 > 编程语言 > 详细

Python自动化开发学习19-Django

时间：2018-03-26 16:08:15      阅读：168      评论：0      收藏：0      [点我收藏+]

标签：python   django   

接下来，我们把Django分为视图（View）、路由系统（URL）、ORM（Model）、模板（Templates ）这4块进行学习。

视图

提交数据

上节课已经用过 request.POST.get() 获取提交的数据了，现在来看看有多选框的情况，多选的话应该要提交多个数据。先写一个有单选、多选、下拉列表的html：

<body>
<form action="/choice/" method="post">
    <p>
        性别：
        <input type="radio" name="gender" id="man" value="male" />
            <label for="man">男性</label>
        <input type="radio" name="gender" id="female" value="female" />
            <label for="female">女性</label>
    </p>
    <p>
        爱好：
        <input type="checkbox" id="football" name="favor" value="football" />
            <label for="football">足球</label>
        <input type="checkbox" id="basketball" name="favor" value="basketball" />
            <label for="basketball">篮球</label>
        <input type="checkbox" id="volleyball" name="favor" value="volleyball" />
            <label for="volleyball">排球</label>
        <input type="checkbox" id="baseball" name="favor" value="baseball" />
            <label for="baseball">棒球</label>
    </p>
    <p>
        <label for="city">城市：</label>
        <select name="city" id="city">
            <option value="BJ">北京</option>
            <option value="SH">上海</option>
            <option value="GJ">广州</option>
            <option value="SZ">深圳</option>
        </select>
    </p>
    <p>
        <label for="skill">技能：</label>
        <select name="skill" id="skill" multiple="multiple">
            <option value="python">Python</option>
            <option value="html">HTML</option>
            <option value="css">CSS</option>
            <option value="js">JavaScript</option>
        </select>
    </p>
    <p>
        上传：<input type="file" name="file" />
    </p>
    <input type="submit" value="提交" />
</form>
</body>

然后写一个处理函数，用get方法获取一下提交的值：

def choice(request):
    if request.method == ‘GET‘:
        return render(request, ‘choice.html‘)
    elif request.method == ‘POST‘:
        gender = request.POST.get(‘gender‘)
        favor = request.POST.get(‘favor‘)
        city = request.POST.get(‘city‘)
        skill = request.POST.get(‘skill‘)
        file = request.POST.get(‘file‘)
        print(gender, favor, city, skill)
        print(file, type(file))
        return render(request, ‘choice.html‘)
    # 处理POST和GET，还有其他的提交方法，比如：PUT、DELETE、HEAD、OPTION
    else:
        return redirect(‘/admin/‘)

所有的值都能获取到，但是对于多选的值也只能获取到一个，对于这种情况，我们需要用到另一个方法 request.POST.getlist() ，把上面的代码都替换成新的方法：

def choice(request):
    if request.method == ‘GET‘:
        return render(request, ‘choice.html‘)
    elif request.method == ‘POST‘:
        gender = request.POST.getlist(‘gender‘)
        favor = request.POST.getlist(‘favor‘)
        city = request.POST.getlist(‘city‘)
        skill = request.POST.getlist(‘skill‘)
        file = request.POST.getlist(‘file‘)
        print(gender, favor, city, skill)
        print(file, type(file))
        return render(request, ‘choice.html‘)
    # 除了POST和GET，客户端还可能有其他的提交方法，比如：PUT、DELETE、HEAD、OPTION
    else:
        return redirect(‘/admin/‘)

使用 getlist() 方法，返回的是一个列表，多个值的情况也能获取完整。当然，单选的话还是继续使用 get() 方法方便。
例子中还有个上传文件的input，这里只能获取到文件名，下面接着讲。

上传文件

普通的form接收不了文件，需要在form标签中要定义 enctype="multipart/form-data" 。然后把 type="file" 的input标签放在这个form里。所以得为上传文件单独写一个form。另外POST里并没有文件内容，文件内容再FILES里：

<form action="/upload/" method="post" enctype="multipart/form-data">
    <p>
        上传：<input type="file" name="file" />
    </p>
    <input type="submit" value="提交" />
</form>

然后再处理函数里先尝试获取一下接收到的内容：

def upload(request):
    if request.method == ‘GET‘:
        return render(request, ‘upload.html‘)
    elif request.method == ‘POST‘:
        obj = request.FILES.get(‘file‘)
        print(obj, type(obj), obj.name)
        return render(request, ‘upload.html‘)
    # 处理POST和GET，还有其他的提交方法，比如：PUT、DELETE、HEAD、OPTION
    else:
        return redirect(‘/admin/‘)

上面打印了3个变量，obj打印出来是个文件名，但是实际是个class。打印type(obj)可以看到它的类型。obj.name才是真正的文件名。现在要把文件保存到本地，先建一个专门的文件夹upload，准备存放接收到的文件。要接收文件的内容，我们需要读取 obj.chunks() ，所以要接收文件上传参考下面的方法：

def upload(request):
    if request.method == ‘GET‘:
        return render(request, ‘upload.html‘)
    elif request.method == ‘POST‘:
        # 获取文件对象
        obj = request.FILES.get(‘file‘)
        # 本地创建一个文件用来接收上传的文件内容
        with open(‘%s/%s‘ % (‘upload‘, obj.name), ‘wb‘) as file:
            # 循环接收文件的内容，写入到本地的文件中去
            for data in obj.chunks():
                file.write(data)
        return render(request, ‘upload.html‘)
    # 处理POST和GET，还有其他的提交方法，比如：PUT、DELETE、HEAD、OPTION
    else:
        return redirect(‘/admin/‘)

CBV 和 FBV

到目前为止，所有的处理都是写在一个函数里的。Django还提供另外一个方式，我们也可以通过类来处理。

  • FBV（function base views） 就是在视图里使用函数处理请求。
  • CBV（class base views） 就是在视图里使用类处理请求。

创建处理请求的类
现在使用CBV把上面提交数据里的choice方法重新写一下：

from django.views import View
# CBV 的类需要继承上面的View
class Choice(View):

    def get(self, request):
        """GET请求提交到这里"""
        print(‘get‘)
        return render(request, ‘choice.html‘)

    def post(self, request):
        """POST请求提交到这里"""
        gender = request.POST.getlist(‘gender‘)
        favor = request.POST.getlist(‘favor‘)
        city = request.POST.getlist(‘city‘)
        skill = request.POST.getlist(‘skill‘)
        file = request.POST.getlist(‘file‘)
        print(gender, favor, city, skill)
        print(file, type(file))
        return render(request, ‘choice.html‘)

创建对应关系
urls.py 里的对应关系也要修改一下，中间写上类名，后面固定跟一个 .as_view() ，就是执行这个类的as_view()方法，具体如下：

from cmdb import views
urlpatterns = [
    # path(‘choice/‘, views.choice),
    path(‘choice/‘, views.Choice.as_view()),
]

各种类型的提交方法
先去看看继承的View类里有什么，在源码的base.py这个文件里。首先里面定义了一个公有属性：

http_method_names = [‘get‘, ‘post‘, ‘put‘, ‘patch‘, ‘delete‘, ‘head‘, ‘options‘, ‘trace‘]

所以处理post和get，还可以处理这么多的请求方法，用一起来也很简单，在类里照着别的一样定义一个同名方法就可以了。
处理执行前后自定义操作
继续看源码的View。这里可以跳过只看结论，调用了as_view()方法里面会再调用一个dispatch()方法。这个dispatch()方法里是通过映射获取我们的 request.method 即提交的方法来调用我们的处理方法的。dispatch()的源码如下：

    def dispatch(self, request, *args, **kwargs):
        # Try to dispatch to the right method; if a method doesn‘t exist,
        # defer to the error handler. Also defer to the error handler if the
        # request method isn‘t on the approved list.
        if request.method.lower() in self.http_method_names:
            handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
        else:
            handler = self.http_method_not_allowed
        return handler(request, *args, **kwargs)

结论就是，根据不同的请求类型提交到不同的处理方法，是用过dispatch()方法里通过映射来实现的。先执行dispatch()方法然后再调用对应的提交类型的处理方法。所以通过继承和重构dispatch()方法，可以在处理方法执行前和执行后自定义一些操作。如果需要的话就在我们的类里继承并重构，参考这里：

from django.views import View
# CBV 的类需要继承上面的View
class Choice(View):

    def dispatch(self, request, *args, **kwargs):
        print(‘before‘)  # 处理前执行的操作
        # 完全执行父类的这个方法
        obj = super(Choice, self).dispatch(request, *args, **kwargs)
        print(‘after‘)  # 处理后执行的操作
        # 这里一定要把处理结果返回
        return obj

所有提交类型都不匹配的情况
还是上面的dispatch()方法，在最后return之前，也就是提交的类型没有匹配的处理方法的时候，默认调用执行 http_method_not_allowed() 方法，返回一个405页面。如果需要按照之前FBV中的else那样匹配其余所有类型的提交方法的话，那就在我们的类里重构这个方法，把之前FBV中if里面最后的else的逻辑补上：

    def http_method_not_allowed(self, request, *args, **kwargs):
        return redirect(‘/admin/‘)

路由系统，URL

模板言语循环字典

模板语言不属于路由系统，由于后面的例子会用到，先讲一点。
先看一下模板语言如何处理字典的，在 views.py 里添加一个字典，然后在页面里返回：

DICT = {
    ‘k1‘: ‘value1‘,
    ‘k2‘: ‘value2‘,
    ‘k3‘: ‘value3‘,
}

def dict(request):
    return render(request, ‘dict.html‘, {‘dict‘: DICT})

下面的html里演示了用法：

<body>
<p>返回整个字典</p>
{{ dict }}
<p>返回的是key</p>
<ul>
    {% for i in dict %}
        <li>{{ i }}</li>
    {% endfor %}
</ul>
<p>返回的是key</p>
<ul>
    {% for key in dict.keys %}
        <li>{{ key }}</li>
    {% endfor %}
</ul>
<p>返回的是value</p>
<ul>
    {% for value in dict.values %}
        <li>{{ value }}</li>
    {% endfor %}
</ul>
<p>返回key和value</p>
<ul>
    {% for k,v in dict.items %}
        <li>{{ k }}: {{ v }}</li>
    {% endfor %}
</ul>
</body>

循环字典，和python里是差不多的，就是后面没有括号()：

  • 直接dict ：循环的是key，不明确所以不推荐
  • dict.keys ：循环key
  • dict.values ：循环values
  • dict.items ：循环key和values

一条对应关系对应多个页面

现在我们已经可以用模板语言处理字典了，先来一个有点数据的字典：

USER_DICT = {
    ‘1‘: {‘name‘: ‘Adam‘, ‘age‘: 22, ‘dept‘: ‘IT‘},
    ‘2‘: {‘name‘: ‘Bob‘, ‘age‘: 32, ‘dept‘: ‘IT‘},
    ‘3‘: {‘name‘: ‘Carmen‘, ‘age‘: 30, ‘dept‘: ‘Sales‘},
    ‘4‘: {‘name‘: ‘David‘, ‘age‘: 40, ‘dept‘: ‘HR‘},
    ‘5‘: {‘name‘: ‘Edda‘, ‘age‘: 26, ‘dept‘: ‘HR‘},
}

def users(request):
    return render(request, ‘users.html‘, {‘user_dict‘: USER_DICT})

上面的处理函数只是把内存的数据变的复杂了一点。另外这里的key用的是数字，我们可以把它当做是数据库获取到的数据的自增id。

基于get方法的实现

接下来重新写一个简单的html，页面里只显示字典的name的值，其他的值都不显示出来。换做提供一个a标签，可以通过点击a标签打开一个显示详细内容的页面：

<ul>
    {% for k,v in user_dict.items %}
        <li><a target=‘_blank‘ href=‘/detail/?nid={{ k }}‘>{{ v.name }}</a></li>
    {% endfor %}
</ul>

去urls.py里添加完对应关系后，就可以打开这个页面。上面a标签里的连接指向的是一个detail的页面，并且提交的同时也提交一个nid值用于detail页面查找并显示出详细的内容。
显示详细的处理函数：

def detail(request):
    # 用get方法获取到nid
    nid = request.GET.get(‘nid‘)
    # 通过nid获取到详细数据，最后给return返回
    detail_info = USER_DICT[nid]
    return render(request, ‘detail.html‘, {‘detail_info‘: detail_info})

还要写一个detail.html 的页面。上面处理函数已经通过get请求的nid去获取到具体得详细数据并返回了，这里直接把数据显示出来：

<body>
<h1>详细信息</h1>
<h3>用户名：{{ detail_info.name }}</h3>
<h3>年龄：{{ detail_info.age }}</h3>
<h3>部门：{{ detail_info.dept }}</h3>
</body>

上面的方法是在users页面以get形式提交到detail页面，然后detail页面里分析get的请求内容，获取到对应的详细信息，在页面里显示出来。

基于正则表达式的url来实现

还有另外一种实现方式。下面说的效果一样，但是这种方式更好。不传入参数，而是不同的urel ‘/detail-1/‘ 这样，这个就需要用到正则表达式。先把urls.py里的对应关系改成正则的形式：

from django.urls import path, re_path
from cmdb import views
urlpatterns = [
    # path(‘detail/‘, views.detail),
    re_path(‘^detail-(\d+).html‘, views.detail),
]

因为这里要匹配正则了，之前的path不再适用，这里要导入re_path来匹配正则。url的正则表达式都以^开头，从头开始匹配
users.html显示不用改，但是要修改一个a标签里的内容，现在url后面不需要用get方式提交任何数据，但是请求的url本事是会变化的：

<ul>
    {% for k,v in user_dict.items %}
        <!--
        <li><a target=‘_blank‘ href=‘/detail/?nid={{ k }}‘>{{ v.name }}</a></li>
        -->
        <li><a target=‘_blank‘ href=‘/detail-{{ k }}.html‘>{{ v.name }}</a></li>
    {% endfor %}
</ul>

最后是显示详细信息的页面，detail.html不需要任何变动，只要views.py里处理函数的return不变就好，但是获取数据的方式变了：

def detail(request, nid):
    # print(nid)
    detail_info = USER_DICT[nid]
    return render(request, ‘detail.html‘, {‘detail_info‘: detail_info})

这里的处理函数多传入了一下参数nid。名字不重要，但是这个值是正确分组匹配的结果。正则是这个 ‘detail-(\d+).html‘ ，里面括号中的 \d+ 的内容就传给了后面的第一个参数。也可以传多个参数（用多个括号），但是数量要一致（处理函数开头的形式参数），否则打开的页面会报错。
为什么这种更好：路由关系是一个动态的关系，一对多，一类url对应一个函数或类。

捕获参数

捕获组就是把正则表达式中子表达式匹配的内容，保存到内存中以数字编号或显式命名的组里，方便后面引用。当然，这种引用既可以是在正则表达式内部，也可以是在正则表达式外部。捕获组有两种形式：

  • 普通捕获组：(Expression)
  • 命名捕获组：(?P&lt;name&gt;Expression) ，这个是python中的语法，其他语言了有的有，但是可能有点小差别，比如没有这个P，比如不用尖括号换成引号
    前面的就是普通捕获组的例子。如果你的正则有多个子表达式，比如：‘detail-(\d+)-(\d+).html’ 。那么定义函数的时候必须注意参数的位置（名字为所谓）。这里可以使用命名捕获组来写正则表达式，正则本身没有任何变化，只是在子表达式前面加上加上一个命名。views.py里的对应关系可以这么写 
    from django.urls import path, re_path
from cmdb import views
urlpatterns = [
# re_path(‘^detail2-(\d+)-(\d+).html‘, views.detail2),
re_path(‘^detail2-(?P<nid>\d?)-(?P<uid>\d?).html‘, views.detail2),
]

    上面被注释的是普通捕获组的写法，下面的是命名捕获组的写法。使用了命名捕获组后，我们的处理函数的参数名字就是正则中的命名，但是位置无所谓了。下面的处理函数直接在页面输出2个参数的值，就不写页面了：

    def detail2(request, uid, nid):
return HttpResponse(‘%s-%s‘ % (nid, uid))

    可以用这样的url测试 http://127.0.0.1:8000/detail2-1-3.html 。

    用 path() 方法实现捕获参数

    课上讲的是旧版本，现在Django已经2.0了，url()方法被path()方法替代，用法也有区别。
    re_path() 可以看做是2.0里向下兼容的一个方法，也就是旧的1.0的 url() 方法。在2.0里用 path() 方法也可以实现捕获组的对应关系。使用 path() 方法需要注意：

    1. 要捕获一段url中的值，需要使用尖括号，而不是之前的圆括号；
    2. 可以转换捕获到的值为指定类型，比如int。默认情况下，捕获到的结果保存为字符串类型，不包含 ‘/‘ 这个特殊字符；
    3. 匹配模式的最开头不需要添加 ‘/‘ ，因为默认情况下，每个url都带一个最前面的 ‘/‘ ，既然大家都有的部分，就不用浪费时间特别写一个了。

那么现在 urls.py 里的对应关系可以这么写：

    # re_path(‘detail2-(\d+)-(\d+).html‘, views.detail2),
    # re_path(‘^detail2-(?P<nid>\d+)-(?P<uid>\d+).html‘, views.detail2),
    path(‘detail2-<int:nid>-<int:uid>.html‘, views.detail2),

上面的例子，就是捕获一个0或正整数，并且返回一个int类型，再用冒号把命名也完成了。除了int，还有下面这些。
默认情况下，Django内置下面的路径转换器：

  • str：匹配任何非空字符串，但不含斜杠/，如果你没有专门指定转换器，那么这个是默认使用的；
  • int：匹配0和正整数，返回一个int类型；
  • slug：可理解为注释、后缀、附属等概念，是url拖在最后的一部分解释性字符。该转换器匹配任何ASCII字符以及连接符和下划线，比如’ building-your-1st-django-site‘ ；
  • uuid：匹配一个uuid格式的对象。为了防止冲突，规定必须使用破折号，所有字母必须小写，例如’075194d3-6885-417e-a8a8-6c931e272f00‘ 。返回一个UUID对象；
  • path：匹配任何非空字符串，重点是可以包含路径分隔符’/‘。这个转换器可以帮助你匹配整个url而不是一段一段的url字符串。

小结

上面各种实现的方法由浅入深，并且一个比一个好，推荐用最后面的实现方式：

  • 基于正则的url比使用get方式获取参数的好
  • 命名捕获组比普通捕获组好
  • 推荐还是用最后的 path() 方法来实现，如果是1.x的版本，那么就是推荐基于正则的命名捕获组的方法。

另外，在定义函数的时候也可以写成这种万能的模式： def detail2(request, *args, **kwargs): ，这样的话，要使用 args[0] （普通捕获组）或 kwargs[‘nid‘] （命名捕获组）来取值。

路由对应的名称

还可以对url的关系进行命名，完成命名后，以后可以通过这个名字获取到对应的url。好处是html里使用url的名称而不是写死，那么urls.py里修改了url，不用到html里修改了。
命名是在写对应关系的时候，加上一个参数 name=[url的名称]

    path(‘myurl/‘, views.myurl, name=‘myurl‘),

然后再网页中使用的时候用 {% url [url的名称] %} 替代原来写死的url。

<form action="{% url ‘myurl‘ %}" method="get">
    <input type="text" name="name" placeholder="NAME" />
    <input type="submit" value="提交" />
</form>

打开页面后可以按F12进入开发这模式查看页面中的url已经是转化后的具体的url了，就是我们在 urls.py 的对应关系里写的内容。
带捕获参数的情况：
url如果带有捕获参数，比如要捕获2个参数：

    path(‘jump-<int:nid>-<int:uid>/‘, views.jump, name=‘jump‘),

那么首先处理函数你必须写上这2个参数（不写会报错），也可以用通用的 *args,**kwargs 的形式：

def jump(request, nid, uid):
    # return HttpResponse(‘%s-%s‘ % (nid, uid))
    return render(request, ‘jump.html‘)

然后页面上做使用模板语言的时候，引用jump作为动态的url，但是后面也要跟上需要捕获的值：

<a href="{% url ‘jump‘ 3 4 %}">跳转</a>
<a href="{% url ‘jump‘ uid=3 nid=4 %}">跳转</a>

上面两种写法都可以，上面的是按照位置传参。下面故意先写了uid，会按照名字来传参。
访问测试页面随便输一个url，比如 “http://127.0.0.1:8000/jump-1-2/” 。然后页面里的两个a连接生成的是各自新的url。新url整体不变，但是捕获参数的值是在url名字后面的参数决定的。
引用当前页面的url：引申一下，{{ request.path_info }} 就是当前页面的url，如要要用的话，request默认就是处理函数里要返回的变量，所以页面里直接用就可以了。
在处理函数中根据名称获取url：
先 from django.urls import reverse 使用这个reverse也能获取到url。直接看获取带捕获的url的方法：

def jump(request, nid, uid):
    from django.urls import reverse
    r1 = reverse(‘jump‘, args=(3, 4))
    r2 = reverse(‘jump‘, kwargs={‘uid‘:3, ‘nid‘:4})
    print(r1, r2, request.path_info)
    # return HttpResponse(‘%s-%s‘ % (nid, uid))
    return render(request, ‘jump.html‘)

也是2种形式都可以。

路由分发

之前所有的对应关系都是写在app目录外的urls文件里的。当我们的项目有多个app的时候，所有的页面都写在一起也不好。应该是每个app各自管理自己的那部分url。这就需要路由分发。
首先我们app目录外的公共url文件中导入一个include方法，声明好app的url文件的位置：

from django.urls import include
urlpatterns = [
    path(‘admin/‘, admin.site.urls),
    path(‘cmdb/‘, include("cmdb.urls"))
]

上面的例子中保留了原有的admin的对应关系，如果有别的公共页面还是可以在这里写的。然后是声明了cmdb这个app的url文件的位置。现在去 cmdb 目录下创建一个 urls.py 的文件。在这里写这个app的对应关系：

from django.urls import path
from cmdb import views
urlpatterns = [
    path(‘login/‘, views.login),
]

上面例子中的url是在cmdb这个app中的，所以访问的时候要带先加上app的名字，应该是 http://127.0.0.1:8000/cmdb/login/ 。这样app里可以有一个login页面，外面也可以有一个login页面。如果还有别的app，那个app也可以有login页面。名字前面会加上自己的app的名字，命名空间不冲突。
梳理一下逻辑：当一个url请求过来之后，先到达项目目录下的urls文件进行匹配。这里如果匹配到了项目名，比如cmdb。那么会再把它分发给之后的（就是app目录里的）urls文件继续处理。所以配置过分发后，首先还是到项目目录下的urls文件里进行匹配，然后再用这里的规则分发出去。

ORM

连接sqlite数据库

默认使用的是sqlite3作为数据库，使用数据库需要一下步骤
一、创建你的数据库表结构
app目录下的models.py文件就是用来写你的表结构的：

from django.db import models

# Create your models here.

# 文件默认会有上面的2行，下面是我们添加的内容
class UserInfo(models.Model):
    # 默认会自动创建自增id并作为主键
    username = models.CharField(max_length=32)  # 字符串，长度32
    password = models.CharField(max_length=64)

上面的类等到去数据库创建表的时候，表名是 “cmdb_userinfo” ，也就是 [app名]_[类名] 。
二、设置settings.py文件
在 INSTALLED_APPS 注册你的app，把你的app追加到这个列表里：

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

配置你的数据库连接，默认已经配置好了一个sqlite3，所以不需要修改：

# Database
# https://docs.djangoproject.com/en/2.0/ref/settings/#databases

DATABASES = {
    ‘default‘: {
        ‘ENGINE‘: ‘django.db.backends.sqlite3‘,
        ‘NAME‘: os.path.join(BASE_DIR, ‘db.sqlite3‘),
    }
}

三、去终端执行2条命令

python manage.py makemigrations
python manage.py migrate

第一条命令会在 app 目录下的 migrations 目录下创建一个文件（0001_initial.py），记录我们对 models.py 所做的变动。
第二条命令是真正去操作数据库了，除了创建我们自己写的表以外，还创建了很多 django 自己的表。
上面两条命令都是作用于全局的，如果要限定作用于只在某个app，可以在最后加上app的名称：

python manage.py makemigrations cmbd
python manage.py migrate cmdb

关于SQLite：

SQLite是一种嵌入式数据库，它的数据库就是一个文件。由于SQLite本身是C写的，而且体积很小，所以，经常被集成到各种应用程序中，甚至在iOS和Android的App中都可以集成。
Python就内置了SQLite3，所以，在Python中使用SQLite，不需要安装任何东西，直接使用。

使用SQLite

连接mysql数据库

步骤同上，理论上只要修改一下 settings.py 里的 DATABASES 的值就好了。但是还有一些别的坑。这里主要演示一下怎么连上mysql数据库，连上之后，后面的操作还是在SQLite下来做。
DATABASES 设置的上面就是官方的帮助文档的连接，或者直接参考下面的进行设置就好了：

DATABASES = {
    ‘default‘: {
        ‘ENGINE‘: ‘django.db.backends.mysql‘,
        ‘NAME‘: ‘cmdb‘,
        ‘USER‘: ‘admin‘,
        ‘PASSWORD‘: ‘admin123‘,
        ‘HOST‘: ‘192.168.246.12‘,
        ‘port‘: ‘3306‘,
    }
}

然后是坑，首先用户我们得自己去数据库上创建好，注意如果不是本地的数据库，需要能够远程访问。库也要自己创建好，创建库：

CREATE DATABASE cmdb CHARSET "utf8";

然后可以试着执行终端的2条命令，但是可能会报错：

import MySQLdb as Database
ModuleNotFoundError: No module named ‘MySQLdb‘

意思是找不到这个库，在python3里mysql我们用 pymysql 这个库。不过装好了pymysql还是会提示找不到库，因为django就是耿直的要找MySQLdb。解决办法是编辑项目名同名目录下的 __init__.py 文件，在这里导入我们的pymysql并且会把它的名字就当做是 MySQLdb ：

import pymysql
pymysql.install_as_MySQLdb()

ORM操作

添加

添加数据有2种方法，推荐用第一种。下面是写在app目录的views.py里的处理函数：

from cmdb import models
def add_user(request):
    models.UserInfo.objects.create(
        username=‘root‘,
        password=‘123456‘
    )
    # 另外一个方法，先创建一个实例，然后调用它的save()方法
    obj = models.UserInfo(
        username=‘admin‘,
        password=‘admin123‘
    )
    obj.save()
    # 方法一的变种，把字典直接作为参数传入
    dic = {‘username‘: ‘user‘, ‘password‘: ‘user123‘}
    models.UserInfo.objects.create(**dic)
    return HttpResponse("add user")

首先我们要操作某个表，就要先把这个创建这个表的那个类导入进来，例子的第一行。上面一个创建了3条数据了。

查询

用all方法查询到的数据，首先是放在一个列表里，列表的元素是一个一个的对象，每一个对象就是一条记录。
筛选的方法有filter，这个返回的也是个列表，因为可能返回多条。

def show_user(request):
    res = models.UserInfo.objects.all()
    for row in res:
        print(row.id, row.username, row.password)
    users = models.UserInfo.objects.filter(username=‘root‘)
    for row in users:
        print(row.id, row.username, row.password)
    return HttpResponse("show user")

filter()里面还可以传入多个参数，就是多个条件，他们之间的关系是逻辑与（and）。
还有一个first()方法，取出第一个值，这样返回就不是列表而直接就是对象了。可以直接用，也可以用在filter()方法后面。all()方法后面也是可以用的，不过没意义：

models.UserInfo.objects.first()
models.UserInfo.objects.filter(username=‘root‘, password=‘123456‘).first()
# 上面就是一个验证用户登录的逻辑了，返回结果是None或者是找到的第一个对象

另外还有一个get方法也可以获取到一条数据，但是如果数据不存在不是返回空而是会报错。如果要用那就得写个try：

models.UserInfo.objects.get(id=10)

QuerySet 对象，分别打印出查询结果和这个对象的query属性：

res = models.UserInfo.objects.all()
print(res)  # 结果在下面
# <QuerySet [<UserInfo: UserInfo object (1)>, <UserInfo: UserInfo object (2)>, <UserInfo: UserInfo object (3)>]>
print(res.query)  # 结果写下面
# SELECT "cmdb_userinfo"."id", "cmdb_userinfo"."username", "cmdb_userinfo"."password" FROM "cmdb_userinfo"

可以看到这是一个 QuerySet 对象，不是一个普通的列表。这里要引出它的一个属性 query 。
这个对象有一个query属性，该属性的内容是获取这个对象时对应的SQL语句。

删除

删除前首先要先做查找，调用查找结果的delete()方法，就完成了删除：

models.UserInfo.objects.all().delete
models.UserInfo.objects.filter(id=2).delete

修改

修改也是在查找的基础上，调用update()方法来完成的：

models.UserInfo.objects.filter(id=1).update(password=‘root123‘)

示例

先来写一个登录页面 index.html 用来提交用户名和密码进行验证：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style>
        label{
            width: 80px;
            text-align: right;
            display: inline-block;
        }
    </style>
</head>
<body>
<form action="/login/" method="post">
    <p>
        <label for="usernmae">用户名：</label>
        <input id="usernmae" name="user" type="text" />
    </p>
    <p>
        <label for="password">密码：</label>
        <input id="password" name="pwd" type="password" />
        <input type="submit" value="提交">
        <span style="color: red">{{ error_msg }}</span>
    </p>
</form>
</body>
</html>

然后是index的处理函数，用户验证失败报错误信息，验证成功跳转的下一个页面：

def login(request):
    if request.method == ‘GET‘:
        return render(request, ‘login.html‘)
    elif request.method == ‘POST‘:
        user = request.POST.get(‘user‘)
        pwd = request.POST.get(‘pwd‘)
        obj = models.UserInfo.objects.filter(username=user, password=pwd).first()
        if obj:
            # 先跳转到admin，可以测一下，之后再写index页面
            return redirect(‘/admin/‘)
            # return redirect(‘/userlist/‘)
        else:
            return render(request,
                          ‘login.html‘,
                          {‘error_msg‘: ‘用户名或密码错误‘})
    else:
        return HttpResponse("不支持您的请求方式")

测试跳转没问题之后，就可以把上面的跳转从admin页面换到userlist页面，然后就来写这个userlist页面：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<div>
    <h2>添加用户</h2>
    <form method="post" action="/userlist/">
        <input type="text" name="user" placeholder="username">
        <input type="text" name="pwd" placeholder="password">
        <input type="submit" value="添加">
    </form>
</div>
<div>
    <h2>用户列表</h2>
    <table border="1">
        <thead>
        <tr>
            <th>id</th>
            <th>username</th>
            <th>password</th>
            <th>按钮</th>
        </tr>
        </thead>
        <tbody>
        {% for row in users %}
        <tr>
            <td>{{ row.id }}</td>
            <td>{{ row.username }}</td>
            <td>{{ row.password }}</td>
            <td>
                <a href="/userdel-{{ row.id }}/">删除</a>
                <span>|</span>
                <a href="/useredit-{{ row.id }}/">编辑</a>
            </td>
        </tr>
        {% endfor %}
        </tbody>
    </table>
</div>
</body>
</html>

首先页面的中要实现数据库查询的功能，就是显示用户列表，通过GET方法来实现。
另外还有一个增加数据的功能，页面上面的添加用户，请求是通过POST方法提交过来，完成的数据添加。POST方法可以有2中return的方式，直接的方式就是和GET方法一样。或者也可以用例子里使用的方法，就是再提交一次GET请求：

def user_list(request):
    if request.method == ‘GET‘:
        users = models.UserInfo.objects.all()
        return render(request, ‘userlist.html‘, {‘users‘: users})
    elif request.method == ‘POST‘:
        username = request.POST.get(‘user‘)
        password = request.POST.get(‘pwd‘)
        models.UserInfo.objects.create(username=username, password=password)
        # 这里可以和get返回的一样
        # return render(request, ‘userlist.html‘, {‘users‘: users})
        # 这里选择用redirect()方法返回，就是再调用一次get方法返回页面
        return redirect(‘/userlist/‘)

删除功能不需要写页面，只需要一个处理函数：

def user_del(request, nid):
    models.UserInfo.objects.filter(id=nid).delete()
    return redirect(‘/userlist/‘)

最后还有一个编辑功能，现在只能用写一个新的页面然后再那个页面里提交。这样实现起来比较简单，主要就是通过这个示例把数据库的最删改查都用一遍：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<div>
    <h2>编辑用户</h2>
    <form method="post" action="/useredit-{{ obj.id }}/">
        <input type="text" name="user" value="{{ obj.username }}">
        <input type="text" name="pwd" value="{{ obj.password }}">
        <input type="submit" value="提交">
    </form>
</div>
</body>
</html>

这个页面对应的处理函数是如下：

def user_edit(request, nid):
    if request.method == ‘GET‘:
        obj = models.UserInfo.objects.filter(id=nid).first()
        return render(request, ‘useredit.html‘, {‘obj‘: obj})
    elif request.method == ‘POST‘:
        username = request.POST.get(‘user‘)
        password = request.POST.get(‘pwd‘)
        models.UserInfo.objects.filter(id=nid).update(
            username=username, password=password)
        return redirect(‘/userlist/‘)

在userlist页面点击编辑按钮后，GET请求跳转到useredit页面。在编辑页面提交后向useredit发送一个POST请求修改数据，然后返回userlist页面，完成一次编辑。
上面一个有4个处理函数，其中3个有html页面，urls.py的对应关系如下：

    path(‘login/‘, views.login),
    path(‘userlist/‘, views.user_list),
    path(‘userdel-<int:nid>/‘, views.user_del),
    path(‘useredit-<int:nid>/‘, views.user_edit),

ORM表结构

修改表结构

修改过表结构之后，需要再执行一下下面的2行命令，把新的表结构应用到数据库。

python manage.py makemigrations
python manage.py migrate

修改数据长度、删除一列，这类情况没什么特别的问题。
增加一列，默认情况下字段值不允许为空，此时会有提示。要么全部都设为空，要么你给个默认值，全部都设为默认值。另外还可以直接定义到表结构中：

class UserInfo(models.Model):
    # 默认会自动创建自增id并作为主键
    username = models.CharField(max_length=32)  # 字符串，长度32
    password = models.CharField(max_length=64)
    email = models.CharField(max_length=64, null=True)  # 设置为允许空值

字段类型

基本的字段类型有：字符串、数字、时间、二进制。
Django的ORM提供了非常多的字段类型，比如：EmailField、URLField、GenericIPAddressField。这些其实都是字符串类型而已，并且确实对我们没任何用（并不能帮我们做数据验证）。这些字段类型的只有在用Django的后台管理页面 admin 的时候才能发挥数据验证的效果。只有通过admin提交数据的时候才会验证你的数据格式是否正确。接下来就先讲怎么登进去
自增id，之前定义表结构的时候，省略了主键，让Django帮我创建了自增id。也可以自己定义主键和自增id：

class UserGroup(models.Model):
    uid = models.AutoField(primary_key=True)  # 数据类型是自增，并且设为主键
    group = models.CharField(max_length=32)

登录Admin

admin具体要到后面讲，这里先让我们登录进去

  1. 创建超级管理员，输入命令后会提示你输入用户名、邮箱（可以直接回车）、密码（似乎有长度和复杂度的要求）： 
    python manage.py createsuperuser
  2. 配置后台管理url，就是admin页面的对应关系，默认urls.py里面已经配好了： 
    path(‘admin/‘, admin.site.urls),
  3. 注册和配置 admin 后台管理页面，把你的表注册号之后，就可以通过admin进行管理了： 
    from django.contrib import admin
# Register your models here.
# 上面是文件默认就有的内容
from cmdb import models
admin.site.register(models.UserInfo)

参数

null ：数据库中字段是否可以为空
default ：数据库中字段的默认值
db_column ：数据库中字段的列名。默认列明就是我们的变量名，可以通过这个参数设置成不一样的

class UserInfo(models.Model):
    username = models.CharField(max_length=32)  # 字段名就是变量名 username
    password = models.CharField(max_length=64, db_column=‘pwd‘)  # 数据库中的字段名会是 pwd

db_index ：是否建立索引
unique ：是否可以建立索引
unique_for_date ：只对字段中【日期】部分建立唯一索引
unique_for_month ：只对字段中【月】部分建立唯一索引
unique_for_year ：只对字段中【年】部分建立唯一索引
auto_now ：自动生成一个当前时间，数据更新时（包括创建）
auto_now_add ：自动生成一个当前时间，数据创建时

class UserInfo(models.Model):
    # 比如用户注册时会生成用户名和密码
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=64)
    # 创建记录时会生成当前时间存放在ctime里，这个就是用户的注册时间
    ctime = models.DataTimeField(auto_now_add=True)
    # 用户修改密码会更新uptime的时间，这个就是上次修改密码的时间
    uptime = models.DataTimeField(auto_now=True)

# models.UserInfo.objects.filter(id=nid).update(password=‘123456‘) 这种方法更新是不会刷新 auto_now 的时间的
# 用save()方法更新可以刷新 auto_now 的时间
# obj =  models.UserInfo.objects.filter(id=nid).first()
# obj.password = ‘654321‘
# obj.save()

Admin中有效果的参数
choices ：Admin中显示选择框的内容。（用不变动的数据放在内存中从而避免跨表操作，跨表操作会涉及到性能问题）

class UserInfo(models.Model):
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=64)
    # 用户有各种类型
    user_type_choices = (
        (1, ‘管理员‘)
        (2, ‘普通用户‘)
        (3, ‘访客‘)
    )
    # 定义一个用户类型的字段
    user_type_id = models.IntegerField(choices=user_type_choices, default=2)
# 这样数据库里是一个整数类型，值是1、2、3
# 但是我们在admin里看选择框的时候看到的是“管理员”、“普通用户”、“访客”，这就是因为把选项所对应的内容放到了内存中了
# 有了Django这个功能就不用再搞一张表，存放各个数值对应的内容了，还要做外键关联，用的时候还要连表查询
# 即使不用admin，我们也可以在自己的代码里读取这个属性获取到内容，避免连表查询

blank ：Admin中是否允许用户输入为空
verbose_name ：Admin中显示的字段名称，默认显示为变量名
editable ：Admin中是否可以编辑。默认是True，设为False后就是在admin中不可编辑了，也不会显示出来了。
error_messages ：自定义错误信息（字典类型）。字典key：null、blank、invalid、invalid_choice、unique、unique_for_date

class UserInfo(models.Model):
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=64, error_messages={‘null‘: "不能为空", ‘invalid‘: ‘格式错误‘})

help_text ：Admin中该字段的提示信息。默认没有提示信息，设置后会显示在input框的下方
validators ：自定义错误验证（列表类型），具体要等到后面讲

外键操作-一对多

上面讲的choices参数，提供了一种将数据存在内存中来提高效率的方法。好处是避免了跨表操作提高了效率。坏处也有，就是数据不方便修改。如果要修改，那就要修改好之后重启一下服务使你的修改生效。而重启操作是有风险的应该避免，那么对于这种经常要修改的内容就不适合放在内存中了，而是要放到另外一张表里。

创建外键关联-修改表结构

在models.py里修改我们的表结构，新增一张用户部门表，原来的用户信息表中新增一列部门id：

from django.db import models

# Create your models here.

# 新增一张表
class UserGroup(models.Model):
    group_id = models.AutoField(primary_key=True)  # 这次自己写自增id
    dept = models.CharField(max_length=32, unique=True)

class UserInfo(models.Model):
    # 默认会自动创建自增id并作为主键
    username = models.CharField(max_length=32)  # 字符串，长度32
    password = models.CharField(max_length=64)
    # 新增一列存放部门
    # to_field参数可以缺省，默认就是主键
    # on_delete=models.CASCADE，这个在1里应该是默认值，现在不能缺省了
    user_group = models.ForeignKey(‘UserGroup‘, on_delete=models.CASCADE, to_field=‘group_id‘)

然后去终端执行那2条命令使新的表结构生效：

python manage.py makemigrations
python manage.py migrate

添加部门数据

这里可以的话最好直接是直接去操作数据库，否则简单搞个网页来添加数据。参看之前的userlist，简单搞个只做显示和添加的页面：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<div>
    <h2>添加部门</h2>
    <form method="post" action="/grouplist/">
        <input type="text" name="dept" placeholder="部门名称">
        <input type="submit" value="添加">
    </form>
</div>
<div>
    <h2>部门列表</h2>
    <table border="1">
        <thead>
        <tr>
            <th>id</th>
            <th>dept</th>
        </tr>
        </thead>
        <tbody>
        {% for row in dept %}
        <tr>
            <td>{{ row.group_id }}</td>
            <td>{{ row.dept }}</td>
        </tr>
        {% endfor %}
        </tbody>
    </table>
</div>
</body>
</html>

然后是views.py里的处理函数：

def group_list(request):
    if request.method == ‘GET‘:
        dept = models.UserGroup.objects.all()
        return render(request, ‘grouplist.html‘, {‘dept‘: dept})
    elif request.method == ‘POST‘:
        dept = request.POST.get(‘dept‘)
        models.UserGroup.objects.create(dept=dept)
        return redirect(‘/grouplist/‘)

urls.py里的对应g关系：

    path(‘grouplist/‘, views.group_list),

查看被关联的属性

对于UserInfo中新增的一列，在类中我们的属性名称是 "user_group" ，而实在在数据库中创建的自动名是 "user_group_id"。
我们再操作的时候就有2个属性可以操作：

  • .user_group_id ：就是这个字段里的值，也就是数据库里实际存放的内容
  • .user_group ：这是一个对象，通过这个对象取到UserGroup里的内容，比如：
    • .user_group.group_id ：就是UserGroup表里的自增id，结果和 .user_group_id 应该是一样的
    • .user_group.dept ：就是这个username锁关联的部门名称了

修改之前的userlist页面，现在把部门名称也显示出来。这里只需要改html，处理函数时不用修改的。实际也只需要在表格中加上一列直接可以去到关联的表里的属性值。下面是userlist表格的部分内容：

<div>
    <h2>用户列表</h2>
    <table border="1">
        <thead>
        <tr>
            <th>id</th>
            <!-- 这里加一列 -->
            <th>username</th>
            <th>dept</th>
            <th>password</th>
            <th>按钮</th>
        </tr>
        </thead>
        <tbody>
        {% for row in users %}
        <tr>
            <td>{{ row.id }}</td>
            <td>{{ row.username }}</td>
            <!-- 这里加一列，直接就能取到部门名称 -->
            <td>{{ row.user_group.dept }}</td>
            <td>{{ row.password }}</td>
            <td>
                <a href="/userdel-{{ row.id }}/">删除</a>
                <span>|</span>
                <a href="/useredit-{{ row.id }}/">编辑</a>
            </td>
        </tr>
        {% endfor %}
        </tbody>
    </table>
</div>

添加用户时选择部门

显示没问题了，页面的上部还有添加用户，现在再要添加用户就需要把用户部门也加上了。部门搞成一个下拉框，不过下拉框的内容还需要修改处理函数传值过来。处理函数还要处理页面提交的内容：

def user_list(request):
    if request.method == ‘GET‘:
        users = models.UserInfo.objects.all()
        # 这里多获取一个部门的列表，传给页面，页面的下来列表会用到。直接找UserGroup获取数据
        # 把对象传给页面的下拉列表，列表的value就是对象的id，列表的内容就是对象的dept
        depts = models.UserGroup.objects.all()
        return render(request, ‘userlist.html‘, {‘users‘: users, ‘depts‘: depts})
    elif request.method == ‘POST‘:
        username = request.POST.get(‘user‘)
        password = request.POST.get(‘pwd‘)
        # 这里通过select获取到的直接就是id的值，所以提交的时候也简单的提交值就可以了
        group_id = request.POST.get(‘group_id‘)
        models.UserInfo.objects.create(username=username, password=password, user_group_id=group_id)
        return redirect(‘/userlist/‘)

页面里加上下拉列表，下面是添加用户的部分：

<div>
    <h2>添加用户</h2>
    <form method="post" action="/userlist/">
        <input type="text" name="user" placeholder="username">
        <select name="group_id">
            {% for item in depts %}
            <option value="{{ item.group_id }}">{{ item.dept }}</option>
            {% endfor %}
        </select>
        <input type="text" name="pwd" placeholder="password">
        <input type="submit" value="添加">
    </form>
</div>

数据添加的另外一种方法
上面通过下拉列表方便的获取到了部门id的值，所以直接通过传值给user_group_id完成了数据的添加。也可以通过传对象给user_group完成数据的添加，大概是这样的：

        group = models.UserGroup.objects.filter(id=1).first()
        models.UserInfo.objects.create(username=username, password=password, user_group=group)

两种方法根据实际情况选择，不过传值的方法更好，少一次数据库的操作。
还有更多内容要下节讲了

模板

这天没讲到

课后练习

用户管理：

  • 一张用户表、一张用户组表。做好外键关联。分别实现对两张表的增删改查
  • 添加，做成模态对话框的形式
  • 修改，目前可以用页面跳转的形式，但是要显示默认值
  • 做一个比较好看的页面，推荐套用模板

Python自动化开发学习19-Django

标签：python   django   

原文地址：http://blog.51cto.com/steed/2091163
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！