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