Django Model

 model

到目前为止，当咱们的程序涉及到数据库相关操做时，咱们通常都会这么搞：

• 建立数据库，设计表结构和字段
• 使用 MySQLdb 来链接数据库，并编写数据访问层代码
• 业务逻辑层去调用数据访问层执行数据库操做

首先Django是经过Model操做数据库，无论你数据库的类型是MySql或者Sqlite，Django它自动帮你生成相应数据库类型的SQL语句，因此不须要关注SQL语句和类型，对数据的操做Django帮咱们自动完成。只要回写Model就能够了！

一、建立数据库表

django为使用一种新的方式，即：关系对象映射（Object Relational Mapping，简称ORM）。

• 　　PHP：activerecord
• 　　Java：Hibernate 
•   　C#：Entity Framework

django中遵循 Code Frist 的原则，即：根据代码中定义的类来自动生成数据库表。

对于ORM框架里：

咱们写的类表示数据库的表

若是根据这个类建立的对象是数据库表里的一行数据

对象.id 对象.value 是每一行里的数据 

class UserInfo(models.Model):
    username = models.CharField(max_length=64)
    email = models.EmailField(max_length=64,null=True)
    email2 = models.EmailField(max_length=64,default="luotianshuai@qq.com")

一、models.AutoField　　自增列 = int(11)
　　若是没有的话，默认会生成一个名称为 id 的列，若是要显示的自定义一个自增列，必须将给列设置为主键 primary_key=True。
2、models.CharField　　字符串字段
　　必须 max_length 参数
三、models.BooleanField　　布尔类型=tinyint(1)
　　不能为空，Blank=True
四、models.ComaSeparatedIntegerField　　用逗号分割的数字=varchar
　　继承CharField，因此必须 max_lenght 参数
5、models.DateField　　日期类型 date
　　对于参数，auto_now = True 则每次更新都会更新这个时间；auto_now_add 则只是第一次建立添加，以后的更新再也不改变。
6、models.DateTimeField　　日期类型 datetime
　　同DateField的参数
七、models.Decimal　　十进制小数类型 = decimal
　　必须指定整数位max_digits和小数位decimal_places
八、models.EmailField　　字符串类型（正则表达式邮箱） =varchar
　　对字符串进行正则表达式
九、models.FloatField　　浮点类型 = double
10、models.IntegerField　　整形
11、models.BigIntegerField　　长整形
　　integer_field_ranges = {
　　　　'SmallIntegerField': (-32768, 32767),
　　　　'IntegerField': (-2147483648, 2147483647),
　　　　'BigIntegerField': (-9223372036854775808, 9223372036854775807),
　　　　'PositiveSmallIntegerField': (0, 32767),
　　　　'PositiveIntegerField': (0, 2147483647),
　　}
12、models.IPAddressField　　字符串类型（ip4正则表达式）
13、models.GenericIPAddressField　　字符串类型（ip4和ip6是可选的）
　　参数protocol能够是：both、ipv四、ipv6
　　验证时，会根据设置报错
14、models.NullBooleanField　　容许为空的布尔类型
15、models.PositiveIntegerFiel　　正Integer
16、models.PositiveSmallIntegerField　　正smallInteger
17、models.SlugField　　减号、下划线、字母、数字
18、models.SmallIntegerField　　数字
　　数据库中的字段有：tinyint、smallint、int、bigint
1九、models.TextField　　字符串=longtext
20、models.TimeField　　时间 HH:MM[:ss[.uuuuuu]]
21、models.URLField　　字符串，地址正则表达式
22、models.BinaryField　　二进制
23、models.ImageField   图片
2四、models.FilePathField 文件

基本参数

一、null=True
　　数据库中字段是否能够为空
二、blank=True
　　django的 Admin 中添加数据时是否可容许空值
三、primary_key = False
　　主键，对AutoField设置主键后，就会代替原来的自增 id 列
4、auto_now 和 auto_now_add
　　auto_now   自动建立---不管添加或修改，都是当前操做的时间
　　auto_now_add  自动建立---永远是建立时的时间
5、choices
GENDER_CHOICE = (
        (u'M', u'Male'),
        (u'F', u'Female'),
    )
gender = models.CharField(max_length=2,choices = GENDER_CHOICE)
6、max_length
7、default　　默认值
8、verbose_name　　Admin中字段的显示名称
九、name|db_column　　数据库中的字段名称
十、unique=True　　不容许重复
十一、db_index = True　　数据库索引
十二、editable=True　　在Admin里是否可编辑
1三、error_messages=None　　错误提示
1四、auto_created=False　　自动建立
15、help_text　　在Admin中提示帮助信息
1六、validators=[]
1七、upload-to

更多参数

 

这里单独说下：

models.DateTimeField

class UserInfo(models.Model):
    username = models.CharField(max_length=64)
    email = models.EmailField(max_length=64,null=True)
    email2 = models.EmailField(max_length=64,default="luotianshuai@qq.com")
    ctime = models.DateTimeField(auto_now=True) #默认这样写上就不用管了,每当你建立一行数据的时候就会在那一行数据中增长一个ctime字段
    uptime = models.DateTimeField(auto_now_add=True)#默认写成这样也不一样管了,当前表任何一行有修改的时候他就会自动更新.

　　

他在数据库的存储方式以下：

 

 models.ImageField 图片
models.FilePathField 文件

 

class UserInfo(models.Model):
    username = models.CharField(max_length=64)
    email = models.EmailField(max_length=64,null=True)
    email2 = models.EmailField(max_length=64,default="luotianshuai@qq.com")
    img = models.ImageField(null=True,blank=True,upload_to='user_upload')
    #null=True,表示数据库存储的时候能够为空,blank=True表示在admin后台提交的时候能够为空!
    #upload_to='user_upload' 用户提交的数据保存到哪里

这里须要注意：在数据库中实际保存的并非文件，而是文件的URL

文件保存：

 

 Model扩展知识点（1）：输出Model对象默认返回值

class UserInfo(models.Model):
    username = models.CharField(max_length=64)
    ctime = models.DateTimeField(auto_now=True) #默认这样写上就不用管了,每当你建立一行数据的时候就会在那一行数据中增长一个ctime字段
    uptime = models.DateTimeField(auto_now_add=True)#默认写成这样也不一样管了,当前表任何一行有修改的时候他就会自动更新.

    def __str__(self):
        return self.username 
    #上面的__str__(self)方法,是当你输出这类对象的时候某人输出,好比这个输出的是这个username这一列.

例子（1）输出全部：

def index(request):
    models.UserInfo.objects.create(username='dashuaige')
    models.UserInfo.objects.create(username='sunqihu')
    print(models.UserInfo.objects.all())

输出结果：

[<UserInfo: sunqihu>, <UserInfo: dashuaige>]

若是使用__unicode__方法默认返回的是对象：[<UserInfo: UserInfo object>]

例子（2）单独查询某一条数据：

 

def index(request):
    test = models.UserInfo.objects.filter(username='dashuaige')
    print(test)

输出结果：

[<UserInfo: dashuaige>]

Model扩展知识点（2）：添加新的字段报错（添加新的列）

报错信息：

 

localhost:Django_lastday luotim$ python manage.py makemigrations
You are trying to add a non-nullable field 'email' to userinfo without a default; we can't do that (the database needs something to populate existing rows).
Please select a fix:
 1) Provide a one-off default now (will be set on all existing rows)
 2) Quit, and let me add a default in models.py
Select an option: 

报错，你准备去添加一个非空的字段的时候原表中已经有的行没有这个字段，就会致使报错！能够经过：容许为空、或者设置默认值来解决

email = models.EmailField(max_length=64,null=True)
    email2 = models.EmailField(max_length=64,default="luotianshuai@qq.com")

三、更多参数

一、null=True
　　数据库中字段是否能够为空
二、blank=True
　　django的 Admin 中添加数据时是否可容许空值

#通常null=True & blank=True 我们搭配着用，出现null=True就用上blank=True
三、primary_key = True
　　主键，对AutoField设置主键后，就会代替原来的自增 id 列
四、auto_now 和 auto_now_add
　　auto_now   自动建立---不管添加或修改，都是当前操做的时间
　　auto_now_add  自动建立---永远是建立时的时间
五、choices  （后台admin下拉菜单）
    USER_TYPE_LIST = (
        (1,u'超级用户'),
        (2,u'普通用户'),
    )
    user_type = models.IntegerField(choices=USER_TYPE_LIST,default=1,verbose_name=u'用户类型')
六、max_length 最大长度
七、default　　默认值
八、verbose_name　　Admin（后台显示的名称）中字段的显示名称
九、name|db_column　　数据库中的字段名称
十、unique=True　　不容许重复
十一、db_index = True　　数据库索引,例如：若是你想经过name查询的更快的话，给他设置为索引便可
十二、editable=True　　在Admin里是否可编辑
1三、error_messages=None　　错误提示
1四、help_text　　在Admin中提示帮助信息
1五、validators=[]
1六、upload-to

　　

最后注释为本身：

Form的做用就是建立标签和获取用户的输入并进行判断，它和Model没有任何关系！经过Form咱们能够获取两种状态：正确、错误！

若是是错误的话咱们能够获取错误输出，正确的话经过对象.clean()来获取用户输入（字典形式）。Form里的规则主要和用户打交道！

Model就是操做数据库，若是Django没有这个admin后台的话他根本不须要那么多的数据类型，几个经常使用的便可。Model里的规则主要和Admin打交道。

目的是为了防止用户和admin去肆意操做数据库的两套规则，只是相近的！

 

Model连表结构

• 一对多：models.ForeignKey(其余表)

• 多对多：models.ManyToManyField(其余表)

• 一对一：models.OneToOneField(其余表)

 

Model 操做表

1.一、增长

# 增
#
# models.Tb1.objects.create(c1='xx', c2='oo')  增长一条数据，能够接受字典类型数据 **kwargs
#
# obj = models.Tb1(c1='xx', c2='oo')  先建立一个对象，而后在save下
# obj.save()
'''
#model
class UserInfo(models.Model):
    username = models.CharField(max_length=64)
    password = models.CharField(max_length=64)

    def __str__(self):
        return self.username

#vies
def index(request):
    models.UserInfo.objects.create(username='sunqihu',password='dashuaige')
    print models.UserInfo.objects.all()

    obj = HomeForm.ImportForm(request.POST)
    return render(request,'home/index.html',{'obj':obj})


#结果：
[<UserInfo: sunqihu>]

----------------------------------（**kwargs）-------------------------------------------
咱们建立的时候能够经过字典的方式来建立：
dic = {‘username’:'alex','password':'123'}
models.UserInfo.objects.create(**dic) 能够传字典来建立

例子：
获取用户提交的数据来建立用户：

#hmtl
<form action="/useradd/" method="post">
    <p>用户名:{{ obj.username }}</p>
    <p>密码:{{ obj.password }}</p>
    <input type="submit" value="submit"/>
</form>

#views
def useradd(request):
    obj = AccountForm.UserAdd(request.POST)
    if request.method == 'POST':
        if obj.is_valid():
            user_input = obj.clean()
            print user_input
            models.UserInfo.objects.create(**user_input)  #这里直接经过**加上用户的输入便可，由于用户的输入时字典类型的
            print models.UserInfo.objects.all()
            return render(request,'account/useradd.html',{'obj':obj})
    return render(request,'account/useradd.html',{'obj':obj})

#结果
    --用户输入
        {'username': u'dashuaige', 'password': u'123123'}
    --print models.UserInfo.objects.all() 返回值
        [<UserInfo: sunqihu>, <UserInfo: alex>, <UserInfo: wutenglan>, <UserInfo: dashuaige>]  #注这里咱们是经过__unicode__方法进行输出了不然是对象！
'''

1.二、查

# 查
#
# models.Tb1.objects.get(id=123)         # 获取单条数据，不存在则报错（不建议使用）
# models.Tb1.objects.all()               # 获取所有
# models.Tb1.objects.filter(name='seven') # 获取指定条件的数据

#models.UserInfo.objects.all().values('password')  #获取指定列的值，能够传多个参数！
[{'password': u'dashuaige'}, {'password': u'123'}, {'password': u'123'}, {'password': u'shuaigenihao'}]

#models.UserInfo.objects.all().values_list('password') #获取指定列的值，能够传多个参数！
[(u'dashuaige',), (u'123',), (u'123',), (u'shuaigenihao',)]

#在前端写choices里，生成select标签就能够经过它来获取
models.UserInfo.objects.all().values_list('id','username')
他输出的是一个元组以下：[(1, 'sunqihu ), (2, 'alex'), (3, 'wutenglan'), (4, 'dashuaige')]
'''
#实例
#form
------------------------------------------------------------------------------------------------------
from django import forms
from app01 import models
import json


class ImportForm(forms.Form):
    def __init__(self,*arg,**kwargs):
        super(ImportForm,self).__init__(*arg,**kwargs)
        self.fields['admin'].widget.choices = models.UserInfo.objects.all().values_list('id','username')

    admin = forms.IntegerField(
        widget=forms.Select()
    )
------------------------------------------------------------------------------------------------------

#views
------------------------------------------------------------------------------------------------------
def index(request):
    obj = HomeForm.ImportForm(request.POST)
    return render(request,'home/index.html',{'obj':obj})
------------------------------------------------------------------------------------------------------

#html
------------------------------------------------------------------------------------------------------
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>可更新下拉菜单</h1>
    <p>{{ obj.admin }}</p>
</body>
</html>
------------------------------------------------------------------------------------------------------

'''

效果以下：（Form获取经过Model获取数据生成Select下拉菜单）

补充增长（重要）：

django的get方法是从数据库的取得一个匹配的结果，返回一个对象，若是记录不存在的话，它会报错。

django的filter方法是从数据库的取得匹配的结果，返回一个对象列表，若是记录不存在的话，它会返回[]。

1.三、删

# 删
#
# models.Tb1.objects.filter(name='seven').delete() # 删除指定条件的数据

1.四、改

# 改
# models.Tb1.objects.filter(name='seven').update(gender='0')  # 将指定条件的数据更新，均支持 **kwargs
#
‘’‘
----------------------------------（**kwargs）-------------------------------------------
更新和添加同理
#views
def useradd(request):
    obj = AccountForm.UserAdd(request.POST)
    if request.method == 'POST':
        if obj.is_valid():
            user_input = obj.clean()
            update_username = user_input['username']
            #先找到用户而后更新他
            models.UserInfo.objects.filter(username=update_username).update(**user_input)
            print models.UserInfo.objects.all()
            return render(request,'account/useradd.html',{'obj':obj})
    return render(request,'account/useradd.html',{'obj':obj})
’‘’


# obj = models.Tb1.objects.get(id=1)  经过建立对象，修改save修改单条数据
# obj.c1 = '111'
# obj.save()                                      

二、进阶操做（了不得的双下划线）

利用双下划线将字段和对应的操做链接起来

# 获取个数
#
# models.Tb1.objects.filter(name='seven').count()
# 大于，小于

# models.Tb1.objects.filter(id__gt=1)              # 获取id大于1的值
# models.Tb1.objects.filter(id__lt=10)             # 获取id小于10的值
# models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值

# in
#
# models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于十一、2二、33的数据
# models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in

# contains（和数据中like语法相同）
#
# models.Tb1.objects.filter(name__contains="ven")
# models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
# models.Tb1.objects.exclude(name__icontains="ven")

# range
#
# models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and

# 其余相似
#
# startswith，istartswith, endswith, iendswith,  #以什么开始，以什么结束，和上面同样带i的是大小写不敏感的

#排序
# order by
#
# models.Tb1.objects.filter(name='seven').order_by('id')    # asc正序
# models.Tb1.objects.filter(name='seven').order_by('-id')   # desc反序

#分页时使用
# limit 、offset
#
# models.Tb1.objects.all()[10:20]  #取全部数据的10条到20条，分页的时候用的到

#分组使用
# group by
from django.db.models import Count, Min, Max, Sum
# models.Tb1.objects.all().values('id').annotate(c=Count('num'))
# SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"

分组使用例子：

model

 

class Score(models.Model):
    name = models.CharField(max_length=64)
    scores = models.IntegerField(max_length=3)

    def __unicode__(self):
        return self.name

vies:

from django.db.models import Count,Min,Max,Sum

def index(request):
    print models.Score.objects.all().values('name').annotate(content=Count('scores'))

若是：

输出结果：

[{'content': 2, 'name': u'shuaige'}, {'content': 2, 'name': u'zhangsan'}]

因此：咱们能够经过：value（‘name’).annotate(content=Count('scores')) 或者annotate中参数能够为个数、Count、最小值Min、最大值Max、合Sum、来进行输出

三、连表操做（了不得的双下划线）一对多

from django.db import models

class UserGroup(models.Model):
    caption = models.CharField(max_length=64)

    def __str__(self):
        return self.caption

class Host(models.Model):
    hostname = models.CharField(max_length=64)
    ip = models.CharField(max_length=64)
    user_group = models.ForeignKey('UserGroup')

    def __str__(self):
        return self.hostname

增长UserGroup的时候怎么增长：

models.UserGroup.objects.create(caption='CEO')
    models.UserGroup.objects.create(caption='DBA')
    models.UserGroup.objects.create(caption='CFO')

增长Host的时候怎么添加：

models.Host.objects.create(hostname='a01.shuaige.com',ip='1.1.1.1',user_group=models.UserGroup.objects.filter(id=1))

咱们须要根据对象去找到外键ID对一个的值添加！

实例：

html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <form action="/index/" method="post">
        <p>主机名:{{ obj.hostname }}</p>
        <p>主机IP:{{ obj.ip }}</p>
        <p>所属组:{{ obj.group }}</p>
        <input type="submit" value="添加主机"/>
    </form>

</body>
</html>

form表单

from django import forms
from app01 import models
import json

class ImportForm(forms.Form):
    def __init__(self,*arg,**kwargs):
        super(ImportForm,self).__init__(*arg,**kwargs)
        self.fields['group'].widget.choices = models.UserGroup.objects.all().values_list('id','caption')

    group = forms.CharField(
        widget=forms.Select()
    )
    hostname = forms.CharField()
    ip = forms.GenericIPAddressField()

views重要，仔细看里面的解释（回顾时须要注意看里面的注释）

from django.shortcuts import render
from app01.forms import home as HomeForm
from app01 import models
from django.db.models import Count,Min,Max,Sum

def index(request):
    obj = HomeForm.ImportForm(request.POST)
    if request.method == 'POST':
        if obj.is_valid():
            data = obj.clean()
            '''
            #两种方式
            #第一种方式先获取对象,经过对象的方式添加!
            grop_obj = models.UserGroup.objects.get(id=data['group'])
            print grop_obj
            models.Host.objects.create(hostname=data['hostname'],
                                       ip=data['ip'],
                                       user_group=grop_obj)
                                       #这里须要注意group_obj是一个对象缘由以下:
            [在Model里我们的user_group = user_group = models.ForeignKey('UserGroup') 这里他对应了一个对象,因此咱们添加的时候添加对象便可，我们从前端传过来的时候不是一个对象，因此我们须要先获取一个对象！]
            '''
            print data
            #第二种方式就简单了
            models.Host.objects.create(hostname=data['hostname'],
                                       ip=data['ip'],
                                       user_group_id=data['group'])
                                       #由于在存储的时候Django后默认在ForeignKey后面加一个_id因此咱们给他加一个_id就能够直接添加了！本质上第一种方式也是经过拼接

        return render(request,'home/index.html',{'obj':obj})
    return render(request,'home/index.html',{'obj':obj})

3.二、在实例的基础上咱们在作个展现 

views

def index(request):
    obj = HomeForm.ImportForm(request.POST)
    host_list = models.Host.objects.all() #获取全部的服务器列表而后展现
    if request.method == 'POST':
        if obj.is_valid():
            data = obj.clean()
            '''
            #两种方式
            #第一种方式先获取对象,经过对象的方式添加!
            grop_obj = models.UserGroup.objects.get(id=data['group'])
            print grop_obj
            models.Host.objects.create(hostname=data['hostname'],
                                       ip=data['ip'],
                                       user_group=grop_obj)
                                       #这里须要注意group_obj是一个对象缘由以下:
            [在Model里我们的user_group = user_group = models.ForeignKey('UserGroup') 这里他对应了一个对象,因此咱们添加的时候添加对象便可]
            '''
            print data
            #第二种方式就简单了
            models.Host.objects.create(hostname=data['hostname'],
                                       ip=data['ip'],
                                       user_group_id=data['group'])
                                       #由于在存储的时候Django后默认在ForeignKey后面加一个_id因此咱们给他加一个_id就能够直接添加了


        return render(request,'home/index.html',{'obj':obj,'host_list':host_list})
    
    return render(request,'home/index.html',{'obj':obj,'host_list':host_list})

　　html

<body>
    <form action="/index/" method="post">
        <p>主机名:{{ obj.hostname }}</p>
        <p>主机IP:{{ obj.ip }}</p>
        <p>所属组:{{ obj.group }}</p>
        <input type="submit" value="添加主机"/>
    </form>
    <table>
        {% for item in host_list %}
            <tr>
            <td>{{ item.hostname }}</td>
　　　　　　　{#这里存储的是ID,由于user_group是一个对象（一行数据）,咱们能够根据对象.caption来取出他对一个的中文#}
            <td>{{ item.user_group.caption }}</td>
            </tr>
        {% endfor %}
    </table>
</body>

3.三、在上面的基础上修改成查询的时候：

request只支持两种方式POST或者GET

仅修改views便可

 

def index(request):
    obj = HomeForm.ImportForm(request.POST)
    val = request.GET.get('ip') #请求若是为IP的时候
    host_list = models.Host.objects.filter(ip=val)
    if request.method == 'POST':
        if obj.is_valid():
            data = obj.clean()
            '''
            #两种方式
            #第一种方式先获取对象,经过对象的方式添加!
            grop_obj = models.UserGroup.objects.get(id=data['group'])
            print grop_obj
            models.Host.objects.create(hostname=data['hostname'],
                                       ip=data['ip'],
                                       user_group=grop_obj)
                                       #这里须要注意group_obj是一个对象缘由以下:
            [在Model里我们的user_group = user_group = models.ForeignKey('UserGroup') 这里他对应了一个对象,因此咱们添加的时候添加对象便可]
            '''
            print data
            #第二种方式就简单了
            models.Host.objects.create(hostname=data['hostname'],
                                       ip=data['ip'],
                                       user_group_id=data['group'])
                                       #由于在存储的时候Django后默认在ForeignKey后面加一个_id因此咱们给他加一个_id就能够直接添加了


        return render(request,'home/index.html',{'obj':obj,'host_list':host_list})
    return render(request,'home/index.html',{'obj':obj,'host_list':host_list})

测试：

结果：

那我根据组怎么查询？

这里须要注意在拿数据的时候是用."点"，可是在查询的时候须要用了不得的双下划线！

 val = request.GET.get('usergroup')
    host_list = models.Host.objects.filter(user_group__caption=val)

views

def index(request):
    obj = HomeForm.ImportForm(request.POST)
    val = request.GET.get('usergroup')
    host_list = models.Host.objects.filter(user_group__caption=val)
    if request.method == 'POST':
        if obj.is_valid():
            data = obj.clean()
            '''
            #两种方式
            #第一种方式先获取对象,经过对象的方式添加!
            grop_obj = models.UserGroup.objects.get(id=data['group'])
            print grop_obj
            models.Host.objects.create(hostname=data['hostname'],
                                       ip=data['ip'],
                                       user_group=grop_obj)
                                       #这里须要注意group_obj是一个对象缘由以下:
            [在Model里我们的user_group = user_group = models.ForeignKey('UserGroup') 这里他对应了一个对象,因此咱们添加的时候添加对象便可]
            '''
            print data
            #第二种方式就简单了
            models.Host.objects.create(hostname=data['hostname'],
                                       ip=data['ip'],
                                       user_group_id=data['group'])
                                       #由于在存储的时候Django后默认在ForeignKey后面加一个_id因此咱们给他加一个_id就能够直接添加了


        return render(request,'home/index.html',{'obj':obj,'host_list':host_list})
    return render(request,'home/index.html',{'obj':obj,'host_list':host_list})

　　

总结：在添加的时候经过_id来创建关系、获取数据的时候经过.、若是在filter里面跨表查询的时候就得用两个下划线"__"

双下划线玩：

Model，多关联！

#/usr/bin/env python
#-*- coding:utf-8 -*-

from __future__ import unicode_literals
# Create your models here.

from django.db import models

class UserType(models.Model):
    typelist = models.CharField(max_length=64,null=True,blank=True)

class UserGroup(models.Model):
    caption = models.CharField(max_length=64)
    user_type = models.ForeignKey('UserType')

    def __str__(self):
        return self.caption

class Host(models.Model):
    hostname = models.CharField(max_length=64)
    ip = models.CharField(max_length=64)
    user_group = models.ForeignKey('UserGroup')

    def __str__(self):
        return self.hostname

Views里设置查询规则：__  哈哈，双下划线若是作了多个关联就能够是用多个__下划线去查询到值

def index(request):
    obj = HomeForm.ImportForm(request.POST)
    val = request.GET.get('usertype')
    host_list = models.Host.objects.filter(user_group__user_type__typelist=val)
    if request.method == 'POST':
        if obj.is_valid():
            data = obj.clean()
            '''
            #两种方式
            #第一种方式先获取对象,经过对象的方式添加!
            grop_obj = models.UserGroup.objects.get(id=data['group'])
            print grop_obj
            models.Host.objects.create(hostname=data['hostname'],
                                       ip=data['ip'],
                                       user_group=grop_obj)
                                       #这里须要注意group_obj是一个对象缘由以下:
            [在Model里我们的user_group = user_group = models.ForeignKey('UserGroup') 这里他对应了一个对象,因此咱们添加的时候添加对象便可]
            '''
            print data
            #第二种方式就简单了
            models.Host.objects.create(hostname=data['hostname'],
                                       ip=data['ip'],
                                       user_group_id=data['group'])
                                       #由于在存储的时候Django后默认在ForeignKey后面加一个_id因此咱们给他加一个_id就能够直接添加了


        return render(request,'home/index.html',{'obj':obj,'host_list':host_list})
    return render(request,'home/index.html',{'obj':obj,'host_list':host_list})