models说明

class UserType(models.Model):
    caption = models.CharField(max_length=32)

class User(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    userType = models.ForeignKey('UserType', to_field='id', on_delete=models.CASCADE)

a = models.User.objects.filter(id=1)
结果返回的是一个Querset，内部元素都是对象
递归打印结果：
for i in a:
    print(i.name, i.age, i.userType.caption)
因为结果QuerySet里面是一个列表，所以可以通过[0]的方式将对象取出
print(a[0].name, a[0].age, a[0].userType.caption)

a = models.User.objects.filter(id=1).values('name', 'age', 'userType__caption')
结果返回的是一个Querset，内部元素都是字典
打印结果
print(a[0]['name'], a[0]['userType__caption'])

a = models.User.objects.filter(id=1).values_list('name', 'age', 'userType__caption')
结果返回的是一个Querset，内部元素都是元组

models.User.objects.get(id=1)
获取到的是一个对象，如果不存在，会抛出异常
models.User.objects.filter(id=1).first()
返回的是一个对象或者none，如果不存在，不会抛出异常。在获取单个值时，此方法更加。

获取外键数据
a = models.User.objects.filter(id=1)
for i in a:
    print(i.name, i.age, i.userType.caption)
userType为外键，i.userType在获取时是一个对象，所以在获取其他表的数据时，直接加“.”+另一个表字段名（此例i.userType.caption），即可获取数据。

id作为数据库表的唯一值，可以在前端作为一个查询条件，例如
<table>
    <tr host-id="{{ row.id}}">
        <td>######</td>
    </tr>
</table>


forigenkey在使用是可以被嵌套使用，比如一个表中包含一个外键，外键关联的表中又包含一个外键，因为只要能获取对象，就可以通过"."+字段名称获取相应表中的数据。

多对多
　　创建多对多
　　　　方式一：自定义关系表
　　　　

class UserType(models.Model):
    caption = models.CharField(max_length=32)

class User(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    userType = models.ForeignKey('UserType', to_field='id', on_delete=models.CASCADE)



class Host(models.Model):
    nid = models.AutoField(primary_key=True)
    hostname = models.CharField(max_length=32, db_index=True)
    ip = models.GenericIPAddressField(protocol='ipv4', db_index=True)
    port = models.IntegerField()
    b = models.ForeignKey(to='User', to_field='id', on_delete=models.CASCADE)

class Application(models.Model):
    name = models.CharField(max_length=32)

class HostToApp(models.Model):
    hobj = models.ForeignKey(to='Host', to_field='nid', on_delete=models.CASCADE)
aobj = models.ForeignKey(to='Application', to_field='id', on_delete=models.CASCADE)

　　　　方式二：

class UserType(models.Model):
    caption = models.CharField(max_length=32)

class User(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    userType = models.ForeignKey('UserType', to_field='id', on_delete=models.CASCADE)



class Host(models.Model):
    nid = models.AutoField(primary_key=True)
    hostname = models.CharField(max_length=32, db_index=True)
    ip = models.GenericIPAddressField(protocol='ipv4', db_index=True)
    port = models.IntegerField()
    b = models.ForeignKey(to='User', to_field='id', on_delete=models.CASCADE)

class Application(models.Model):
    name = models.CharField(max_length=32)
    r = models.ManyToManyField('Host')

 二者都能创建多对多关系，区别在于采用ForigenKey的方式需要自己创建关系表，并且字段数量可以自定制，因为可以得到第三张表的对象，所以可以直接对第三张表做操作；采用ManyToManyField的方式无需字定义关系表（关系表自动生成），缺点是字段不算id列，只能有两个（即两张表的id），而且无法直接对第三张生成的表进行操作（因为models文件中并没有那个对象）。

操作ManyToManyField生成的第三张表：
obj = Application.objects.get(id=1)

obj.r.add(1)
obj.r.add(2)
obj.r.add(2,3,4)
obj.r.add(*[1,2,3,4])

obj.r.remove(1)
obj.r.remove(2,3)
obj.r.remove(*[2,3,4])

obj.r.clear()
# set代表更新指定id的数据，本例为id=1
obj.r.set([3,5,7])

获取一个应用对应的所有主机：
obj = Application.objects.get(id=1)
obj.r.all()

获取一个主机对应的所有应用：
obj = Host.objects.get(id=1)
obj.application_set.all()

采用ManyToManyField方式也可以进行字段扩展，不过需要添加through参数，该参数指定了中间模型，例如：
class Author(models.Model):
　　name = models.CharFiled(max_length=32)
　　email = models.EmailField()

class Book(models.Model):
　　title = models.CharField(max_length=32)
　　authors = models.ManyToManyField(Author, through='BookAuthor')

class BookAuthor(models.Model):
　　author = models.ForeignKey(Author, on_delete=models.CASCADE)
　　book = models.ForeignKey(Book, on_delete=models.CASCADE)

　　pushd_at = models.DateTimeField(default=timezone_now)

当我们使用多对多的中间模型之后，add(),remove(),create()这些方法都会被禁用，所以在创建这种类型的关系的时候唯一的方法就是通过创建中间模型的实例，例：

#  添加作者  ringo
   ringo = Author.objects.create(name='Ringo',email='ringo@qq.com')
   # 添加作者paul
   paul = Author.objects.create(name='Paul',email='paul@qq.com')
  # 添加书籍 python book1
  book1 = Book.objects.create(title='python book1')
  #  给多对多添加值也就是添加多对多关系
  m1 = BookAuthor(author=ringo,book=book)
  #  第二种添加方式
  m2 = BookAuthor.objects,create(author=paul,book=book1)

https://docs.djangoproject.com/en/dev/ref/models/instances/#django.db.models.Model.get_FOO_display

Model.get_FOO_display()¶

For every field that has choices set, the object will have a get_FOO_display() method, where FOO is the name of the field. This method returns the “human-readable” value of the field.

For example:

from django.db import models

class Person(models.Model):
    SHIRT_SIZES = (
        ('S', 'Small'),
        ('M', 'Medium'),
        ('L', 'Large'),
    )
    name = models.CharField(max_length=60)
    shirt_size = models.CharField(max_length=2, choices=SHIRT_SIZES)

>>> p = Person(name="Fred Flintstone", shirt_size="L")
>>> p.save()
>>> p.shirt_size
'L'
>>> p.get_shirt_size_display()
'Large'