Django基础——Model篇(二)

时间：2024-01-20 19:48:45

一 Model连表关系

一对多：models.ForeignKey(其他表)
    多对多：models.ManyToManyField(其他表)
    一对一：models.OneToOneField(其他表)
    一般在数据库中创建外键关联时，就有一对多或者多对多，而一对一是Django独有的。

应用场景：
    一对多：当一张表中创建一行数据时，有一个单选的下拉框（下拉框中内容，可被重复选择）
    例如：创建用户信息时，需要选择一个用户类型：普通用户、金牌用户、铂金用户等。
    
    多对多：在某表中创建一行数据时，有一个可以多选的下拉框
    例如：创建用户信息时，需要为用户选择多个爱好
    
    一对一：在某表中创建一行数据时，有一个单选的下拉框(下拉框中内容只能被选择1次)
    例如：原有含10列数据的一张表保存相关信息，经过一段时间之后，10列无法满足需求，需要为原来的表再添加5列数据

1 一对多

一对多表结构是为了解决空间浪费问题，通过一张数据库表去关联另外一张数据库表来解决重复出现的字段，这样在这张表中只会存储相应的ID来代替相应的字段。

Django基础——Model篇(二)    Django基础——Model篇(二)     Django基础——Model篇(二)

为什么是1对多呢？因为在第2张表里，金牌会员的ID=3，而在第3张表里有好2个3，即表示1对多。

在Model中生成一对多表结构(models.py文件)

例1：第1种一对多(默认关联id)

# 用户类型类

class UserType(models.Model):

    user_type = models.CharField(max_length=64)

#用户信息类

class UserInfo(models.Model):

    username = models.CharField(max_length=64)

    email = models.CharField(max_length=32)

    # 外键关联 usertype对应着UserInfo表中的1列数据,他自动关联了UserType类

     usertype = models.ForeignKey(UserType)

例2：第2种一对多(指定关联字段)

# 业务线类

class Business(models.Model):
    #设置为主键

    nid = models.AutoField(primary_key=True)

    name = models.CharField(max_length=32)

# 主机类，表示主机属于哪一条业务线

class Host(models.Model):

    hostname = models.CharField(max_length=16)

    # 括号中的参数可加引号，也可以不加引号，效果一样，to_field参数表示关联哪个字段

     business = models.ForeignKey(Business,to_field='nid')

   例3：第3种一对多(多级外键关联)

#一对多 多级外键关联

class A(models.Model):

    name = models.CharField(max_length=16)

    def __unicode__(self):

        return self.name

class UserGroup(models.Model):

    caption = models.CharField(max_length=32)

    obj_a = models.ForeignKey(A)

    def __unicode__(self):

        return self.caption

class User(models.Model):

    username = models.CharField(max_length=32)

    user_group = models.ForeignKey(UserGroup)

    def __unicode__(self):

        return self.hostname

 2 多对多

在Zabbix监控中会存在用户与用户组的概念，在这里同一个人可以属于多个用户组，同时同一个用户组也可以包括多个人。在这个场景中一对多的表关系结构是不能解决这个问题的，从而引出了多对多的概念。

Django基础——Model篇(二)    Django基础——Model篇(二)    Django基础——Model篇(二)

为什么是多对多呢？因为在对于CEO组，有两个人，即1个组包括了多个人；同时对于alex，他分别属于两个不同组，那么认为这种关系就是多对多。

在Model中生成多对多表结构(models.py文件)

# model中的多对多

# 应用场景:用户与用户组(一个用户可以在多个组，同时一个组可以同时存在多个用户)

class UserGroup(models.Model):

    group_name = models.CharField(max_length=16)

class User(models.Model):

    name = models.CharField(max_length=16)

    email = models.CharField(max_length=16)

    mobile = models.CharField(max_length=16)

    # 两张表建立多对多，django默认会生成一张数据库表来建立两者的关系

    relationship = models.ManyToManyField(UserGroup)

注：对于多对多，在models.py中我们只写了两个类，即生成两张数据库表，但两张表明显不能很好的表示多对多的关系，在这种情况下Django默认为我们生成另外一张表来建立这种关系，即用3张表来表示用户和用户组之间的关系。

  3 一对一

一对一不是数据库的连表结构，而是Django独有的，他是在一对多的基础伪造出来的。即在一对多中限定某个指定的字段不能重复，一旦重复数据库报错，这样就相当于构造了一个一对一的连表关系。在上述一对多中，用户级别是可重复的，但在一对一关系中，一个用户级别只能对应一个用户，不允许重复。

应用场景：假设在一个公司的所有用户中，只有alex和eric可以登录后台管理，那么这个场景就可以使用一对一的连表关系。

Django基础——Model篇(二)       Django基础——Model篇(二)

在Model中生成一对一表结构(models.py文件)

# model中的一对一，相当于对一对多进行限制后产生的，由Django完成，且是Django独有的

# 应用场景：在很多用户中只有某些用户能够登录，这时id不能重复，即同一个账号ID不能出现多次

# 下表为所有的用户信息表

class User(models.Model):

    name = models.CharField(max_length=16)

    email = models.CharField(max_length=16)

    mobile = models.CharField(max_length=16)

# 下表为能够登录的用户的用户名和密码

class admim(models.Model):

    username = models.CharField(max_length=64)

    password = models.CharField(max_length=64)

    # django自动完成关系的建立

    user_info = models.OneToOneField(User)

二 Model连表操作(了不起的双下划线)

1 一对多连表操作

实例1：在页面创建用户，同时在页面进行展示

models.py文件

#-*- coding:utf-8 -*-

from __future__ import unicode_literals

from django.db import models

#一对多连表关系

#用户组表

class UserGroup(models.Model):

    caption = models.CharField(max_length=32)

    def __unicode__(self):

        return self.caption

#用户表

class User(models.Model):

    username = models.CharField(max_length=32)
    #user_group为对象，对应UserGroup中的一行数据

    user_group = models.ForeignKey(UserGroup)

    def __unicode__(self):

        return self.hostname

forms模块中的foreign.py文件

#!/usr/bin/env python

#-*- coding:utf-8 -*-

__author__ = 'mcp'

from django import forms

from app01 import models

class UserForm(forms.Form):

    # 创建用户名

    username = forms.CharField()

    # 创建用户组的两种方法

    # 第1种方法:

    # group = forms.IntegerField(widget=forms.Select())

    # 第2种方法：用户组字段名=models.py中User类的用户组字段名+"_id"

    # 因为外键user_group字段在User数据库表中字段名默认变成了"user_group_id"，这样做的好处：username和user_group_id直接组成字典

    # 传给Model，因为Model创建数据时是接受字典形式参数的，就是views/foreign.py中的all_data

    user_group_id = forms.IntegerField(widget=forms.Select())

    def __init__(self,*args,**kwargs):

        # 执行父类的构造方法

        super(UserForm,self).__init__(*args,**kwargs)

        # 配合创建用户组的第1种方法使用，这里同时注意values_list方法的使用

        # self.fields['group'].widget.choices = models.UserGroup.objects.all().values_list('id','caption')

        # 配合创建用户组的第2种方法使用

        self.fields['user_group_id'].widget.choices = models.UserGroup.objects.all().values_list('id','caption')

views模块中foreign.py文件

#!/usr/bin/env python

#-*- coding:utf-8 -*-

__author__ = 'mcp'

from django.shortcuts import HttpResponse,render

from app01 import models

from app01.forms import foreign as ForeignForm

# 创建用户组表

def create_user_group(request):

    # 创建用户组的类型，运行一次后注释，防止多次生成

    # models.UserGroup.objects.create(caption='CEO')

    # models.UserGroup.objects.create(caption='CTO')

    # models.UserGroup.objects.create(caption='COO')

    return HttpResponse('ok')

# 创建用户表

def create_user(request):

    # 将请求数据作为参数传递给UserForm，生成相应对象

    obj = ForeignForm.UserForm(request.POST)

    # 判断请求类型是否为'POST'类型

    if request.method == 'POST':

        # 进行From表单验证，验证其有效性

        if obj.is_valid():

          # 获取请求数据

            all_data = obj.clean()

          # 把获取的数据存储到数据库，有3种方法

            # 第1种方法(对象级别操作)：先获取对象

            # group_obj = models.UserGroup.objects.get(id=all_data['group'])

            # 为什么创建数据库表时，第二个参数(关联外键)user_group=group_obj?

            # 这是因为在Model里user_group = models.ForeignKey('UserGroup')，这里user_group实际上是关联了一个对象，

            # 所以在传递参数时要传递相应的对象参数。

            # models.User.objects.create(username=all_data['username'],user_group=group_obj)

            # 第2种方法(数据库级别操作，这里注意Django默认给外键字段名加上了"_id")

            # models.User.objects.create(username=all_data['username'],user_group_id=all_data['group'])

            # 第3种方法(传字典参数，但是要注意form中已经组成了字典数据)

            models.User.objects.create(**all_data)

           # 打印数据库中所以信息的条数

            print models.User.objects.all().count()

        else:

            # 写上报错提示信息，form表单的验证信息，这里省略了

            pass

    # 获取所有的用户信息列表

    user_list = models.User.objects.all()

   return render(request,'foreign/create_user.html',{'obj':obj,'user_list':user_list})

templates/foreign目录下的create_user.html文件

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

</head>

<body>

    <form action="/create_user/" method="post">

        <p>用户名:{{ obj.username }}</p>

       {#<p>用户组:{{ obj.user_group }}</p>#}

        <p>用户组:{{ obj.user_group_id }}</p>

        <input type="submit" value="submit"/>

    </form>

    <table>

        {% for item in user_list %}

        <tr>

            <td>{{ item.username }}</td>
           {#注意此处的操作，user_group是1个对象(表示数据库中一行数据)，而用户组在数据库中是按ID存储的，所以要转换成中文，注意模板中的.号操作#}

            <td>{{ item.user_group.caption }}</td>

        </tr>

        {% endfor %}

    </table>

</body>

</html>

运行效果如下图所示：

Django基础——Model篇(二)

实例2：在页面查询用户，同时在页面展示该用户的相关信息

在实例1的基础上，修改views模块中foreign.py文件即可

#!/usr/bin/env python

#-*- coding:utf-8 -*-

__author__ = 'mcp'

from django.shortcuts import HttpResponse,render

from app01 import models

from app01.forms import foreign as ForeignForm

# 创建用户组表

def create_user_group(request):

    # 创建用户组的类型，运行一次后注释，防止多次生成

    # models.UserGroup.objects.create(caption='CEO')

    # models.UserGroup.objects.create(caption='CTO')

    # models.UserGroup.objects.create(caption='COO')

    return HttpResponse('ok')

# 创建用户表

def create_user(request):

    # 将请求数据作为参数传递给UserForm，生成相应对象

    obj = ForeignForm.UserForm(request.POST)

    # 判断请求类型是否为'POST'类型

    if request.method == 'POST':

        # 进行From表单验证，验证其有效性

        if obj.is_valid():

          # 获取请求数据

            all_data = obj.clean()

          # 把获取的数据存储到数据库，有3种方法

            # 第1种方法(对象级别操作)：先获取对象

            # group_obj = models.UserGroup.objects.get(id=all_data['group'])

            # 为什么创建数据库表时，第二个参数(关联外键)user_group=group_obj?

            # 这是因为在Model里user_group = models.ForeignKey('UserGroup')，这里user_group实际上是关联了一个对象，

            # 所以在传递参数时要传递相应的对象参数。

            # models.User.objects.create(username=all_data['username'],user_group=group_obj)

            # 第2种方法(数据库级别操作，这里注意Django默认给外键字段名加上了"_id")

            # models.User.objects.create(username=all_data['username'],user_group_id=all_data['group'])

            # 第3种方法(传字典参数，但是要注意form中已经组成了字典数据)

            models.User.objects.create(**all_data)

           # 打印数据库中所以信息的条数

            print models.User.objects.all().count()

        else:

            # 写上报错提示信息，form表单的验证信息，这里省略了

            pass

    # 根据输入的用户名，查找该用户所在的组

    # 例如URL中输入http://127.0.0.1:8000/create_user/?user=alex，表示获取数据库中username='alex'的相关数据

    # 获取get请求中user的值，例如user='alex',那么下面的val='alex'

    val = request.GET.get('user')

    # 获取数据库中对应字段username='val'的一行数据

    user_list = models.User.objects.filter(username=val)

    return render(request,'foreign/create_user.html',{'obj':obj,'user_list':user_list})

运行效果如下图所示:

Django基础——Model篇(二)

实例3：在页面查询用户组，同时在页面展示该用户组的用户

在实例1的基础上，修改views模块中foreign.py文件即可

#!/usr/bin/env python

#-*- coding:utf-8 -*-

__author__ = 'mcp'

from django.shortcuts import HttpResponse,render

from app01 import models

from app01.forms import foreign as ForeignForm

# 创建用户组表

def create_user_group(request):

    # 创建用户组的类型，运行一次后注释，防止多次生成

    # models.UserGroup.objects.create(caption='CEO')

    # models.UserGroup.objects.create(caption='CTO')

    # models.UserGroup.objects.create(caption='COO')

    return HttpResponse('ok')

# 创建用户表

def create_user(request):

    # 将请求数据作为参数传递给UserForm，生成相应对象

    obj = ForeignForm.UserForm(request.POST)

    # 判断请求类型是否为'POST'类型

    if request.method == 'POST':

        # 进行From表单验证，验证其有效性

        if obj.is_valid():

          # 获取请求数据

            all_data = obj.clean()

          # 把获取的数据存储到数据库，有3种方法

            # 第1种方法(对象级别操作)：先获取对象

            # group_obj = models.UserGroup.objects.get(id=all_data['group'])

            # 为什么创建数据库表时，第二个参数(关联外键)user_group=group_obj?

            # 这是因为在Model里user_group = models.ForeignKey('UserGroup')，这里user_group实际上是关联了一个对象，

            # 所以在传递参数时要传递相应的对象参数。

            # models.User.objects.create(username=all_data['username'],user_group=group_obj)

            # 第2种方法(数据库级别操作，这里注意Django默认给外键字段名加上了"_id")

            # models.User.objects.create(username=all_data['username'],user_group_id=all_data['group'])

            # 第3种方法(传字典参数，但是要注意form中已经组成了字典数据)

            models.User.objects.create(**all_data)

           # 打印数据库中所以信息的条数

            print models.User.objects.all().count()

        else:

            # 写上报错提示信息，form表单的验证信息，这里省略了

            pass

    # 根据输入的用户组，查找该组的所有用户信息

    # http://127.0.0.1:8000/create_user/?usergroup=CEO

    # 获取输入的用户组信息

    val = request.GET.get('usergroup')

    # 跨表查询，双下划线

    user_list = models.User.objects.filter(user_group__caption=val)

   return render(request,'foreign/create_user.html',{'obj':obj,'user_list':user_list})

运行效果如下图所示:

Django基础——Model篇(二)

实例4：一对多连表关系中的多级关联

models.py文件

#/usr/bin/env python

#-*- coding:utf-8 -*-

from __future__ import unicode_literals

from django.db import models

# Create your models here.

#一对多连表关系中的多级关联

#用户类型表

class UserType(models.Model):

    type_list = models.CharField(max_length=64,null=True,blank=True)

    def __unicode__(self):

        return self.type_list

# 用户组表

class UserGroup(models.Model):

    caption = models.CharField(max_length=32)

    user_type = models.ForeignKey('UserType')

    def __unicode__(self):

        return self.caption

# 用户表

class User(models.Model):

    username = models.CharField(max_length=32)

    user_group = models.ForeignKey('UserGroup')

    def __unicode__(self):

        return self.username

views模块中foreign.py文件

#!/usr/bin/env python

#-*- coding:utf-8 -*-

__author__ = 'mcp'

from django.shortcuts import HttpResponse,render

from app01 import models

from app01.forms import foreign as ForeignForm

#!/usr/bin/env python

#-*- coding:utf-8 -*-

__author__ = 'mcp'

from django.shortcuts import HttpResponse,render

from app01 import models

from app01.forms import foreign as ForeignForm

def create_user_group(request):

    #添加用户类型

    models.UserType.objects.create(type_list='金牌会员')

    models.UserType.objects.create(type_list='银牌会员')

    models.UserType.objects.create(type_list='普通会员')

    #添加用户组

    models.UserGroup.objects.create(caption='CEO',user_type_id=1)

    models.UserGroup.objects.create(caption='CTO',user_type_id=2)

    models.UserGroup.objects.create(caption='COO',user_type_id=3)

    return HttpResponse('OK')

def create_user(request):

    obj = ForeignForm.UserForm(request.POST)

    if request.method == 'POST':

        if obj.is_valid():

            all_data = obj.clean()

            #先获取对象，然后把对象作为参数

            group_obj = models.UserGroup.objects.get(id=all_data['user_group'])

            models.User.objects.create(username=all_data['username'],user_group=group_obj)

    # 测试1：获取所有的用户信息表

    # user_list = models.User.objects.all()

    #测试2：从URL中获取请求的信息

    val = request.GET.get('usertype')

    # 注意跨表多级查询外键时，双下划线的使用

    user_list = models.User.objects.filter(user_group__user_type__type_list=val)

    return render(request,'foreign/create_user.html',{'obj':obj,'user_list':user_list})

forms模块中foreign.py文件

#!/usr/bin/env python

#-*- coding:utf-8 -*-

__author__ = 'mcp'

from django import forms

from app01 import models

class UserForm(forms.Form):

    username = forms.CharField()

    user_group = forms.IntegerField(widget=forms.Select())

    user_type = forms.IntegerField(widget=forms.Select())

    def __init__(self,*args,**kwargs):

        super(UserForm,self).__init__(*args,**kwargs)

        self.fields['user_group'].widget.choices = models.UserGroup.objects.all().values_list('id','caption')

        self.fields['user_type'].widget.choices = models.UserType.objects.all().values_list('id','type_list')

templates/foreign目录下的create_user.html文件

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

</head>

<body>

    <form action="/create_user/" method="post">

        <p>用户名:{{ obj.username }}</p>

        <p>用户组:{{ obj.user_group }}</p>

        <p>用户类型{{ obj.user_type }}</p>

        <input type="submit" value="submit"/>

    </form>

    <table>

        {% for item in user_list %}

        <tr>

            <td>{{ item.username }}</td>

            <td>{{ item.user_group.caption }}</td>

            <td>{{ item.user_group.user_type.type_list }}</td>

        </tr>

        {% endfor %}

    </table>

</body>

</html>

测试1和测试2运行结果分别如下图所示:(在实例4的多级关联中，实际上用户组合用户类型是已经绑定死了的，不能选择，例如加入用户组是CEO，那么用户类型就是金牌会员，不能选择)

Django基础——Model篇(二)       Django基础——Model篇(二)

一对多小结：
1、外键user_group在数据库中是以新字段名称user_group_id(Django自动生成的名称:外键名+'_id')存储的，
   这样将前端的数据存入数据库时，就可以构造字典参数，直接把字典作为参数传给数据库创建函数create；
2、在实例中，外键user_group为对象，对应着UserGroup中的一行数据；
3、数据库中获取数据采用"."操作符；
4、数据库中跨表查询关联外键的字段值采用"__"双下划线操作符(注意双下划线操作符)，比如实例中的
   user_list = models.User.objects.filter(user_group__caption=val)，它表示查询关联外键user_group
   中caption字段值为val的User表中的相关用户数据

5、在外键的多级关联中，在数据库中查询数据时，下划线可以连着使用

参考资料:

http://www.cnblogs.com/wupeiqi/articles/5246483.html

http://www.cnblogs.com/luotianshuai/p/5301343.html

相关文章