python的Web框架，Django模型系统二，模型属性，及数据库进阶查询

第一种方式设置主键，指定int类型，设置为主键，使用自增长。
id = models.IntegerField(primary_key=True, auto_created=True)第二种方式：使用AutoField方法，这个方法是自增长且为int类型
id = models.AutoField(primary_key=True使用AutoField方法，这个方法是自增长且为int类型)

qq = models.CharField(max_length=20, unique=True, null=True)

>>>Students.objects
<django.db.models.manager.Manager at 0xb36edaec>

>>>Students.objects.first()
<Students: 小明-16>

>>>Students.objects.last()
<Students: 刘一-19>

>>>Students.objects.get(name='刘一')
<Students: 刘一-19>

>>> Students.objects.all()
<QuerySet [<Students: 小明-16>, <Students: XiaoHong-16>, <Students: 王五-24>, <Students: 赵柳-22>, <Students: 张三-23>, <Students: 李思-17>, <Students: 赵柳-19>, <Students: 孙奇-29>, <Students: Ats: abc-6>, <Students: 刘一-19>]>

>>>res = Students.objects.filter(sex=1,age=16)>>>print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE (`teacher_students`.`age` = 16 AND `teacher_students`.`sex` = 1)

>>>res = Students.objects.exclude(sex=1)>>>print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE NOT (`teacher_students`.`sex` = 1)

from django.db.models import Q

>>> res =Students.objects.filter(Q(age=0)|Q(age=1))
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE (`teacher_students`.`age` = 0 OR `teacher_students`.`age` = 1)

>>> res = Students.objects.values('name')>>>print(res.query)
SELECT `teacher_students`.`name` FROM `teacher_students`>>>res
<QuerySet [{'name': '小明'}, {'name': 'XiaoHong'}, {'name': '王五'}, {'name': '赵柳'}, {'name': '张三'}, {'name': '李思'}, {'name': '赵柳'}, {'name': '孙奇'}, {'name': 'ABC'}, {'name': 'abc'}, {>>>>res[0]['name']
'小明'#可以多条查询 res = Students.objects.values('name','age')
#可以增加过滤 res = Students.objects.values('name').filter(age=0)

>>> res = Students.objects.only('name')>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name` FROM `teacher_students`
#会默认拿到id主键>>> res[0].c_time
datetime.datetime(2019, 2, 26, 8, 4, 57, 955584, tzinfo=<UTC>)
#没有获取这个字段也一样可以拿到，这就是only的作用#其他写法：
res = Students.objects.only('name','age').filter(age=16)

>>>res = Students.objects.defer('c_time','age')>>>print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone` FROM `teacher_students`>>>res
<QuerySet [<Students: 小明-16>, <Students: XiaoHong-16>, <Students: 王五-24>, <Students: 赵柳-22>, <Students: 张三-23>, <Students: 李思-17>, <Students: 赵柳-19>, <Students: 孙奇-29>, <Students: nts: abc-6>, <Students: 刘一-19>]> >>>res[0].c_time
datetime.datetime(2019, 2, 26, 8, 4, 57, 955584, tzinfo=<UTC>)

>>>res = Students.objects.order_by('c_time')>>>print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` ORDER BY `teacher_students`.`c_time` ASC#可以配合only使用:
#res = Students.objects.order_by('c_time').only('name')

>>>res = Students.objects.order_by('-c_time')>>>print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` ORDER BY `teacher_students`.`c_time` DESC

from django.db.models.functions import Lower

>>> res = Students.objects.order_by(Lower('name'))>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` ORDER BY LOWER(`teacher_students`.`name`) ASC
#LOWER是数据库本身的功能，它把字段的内容(`teacher_students`.`name`) 变成大写排序。>>> res
<QuerySet [<Students: ABC-5>, <Students: abc-6>, <Students: XiaoHong-16>, <Students: 刘一-19>, <Students: 孙奇-29>, <Students: 小明-16>, <Students: 张三-23>, <Students: 李思-17>, <Students: 王五ents: 赵柳-22>, <Students: 赵柳-19>]>

>>> res = Students.objects.order_by(Lower('name').desc())>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` ORDER BY LOWER(`teacher_students`.`name`) DESC>>> res
<QuerySet [<Students: 赵柳-22>, <Students: 赵柳-19>, <Students: 王五-24>, <Students: 李思-17>, <Students: 张三-23>, <Students: 小明-16>, <Students: 孙奇-29>, <Students: 刘一-19>, <Students: Xiaents: ABC-5>, <Students: abc-6>]>

>>>res = Students.objects.all()[:5]>>>print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` LIMIT 5>>>res = Students.objects.all()[2:6]>>>print(res.query) #打印出他的sql语句
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` LIMIT 4 OFFSET 2>>>res = Students.objects.all()[::2]>>>res
[<Students: 小明-16>, <Students: 赵柳-22>, <Students: 赵柳-19>, <Students: abc-6>]
#得到的直接是一个list列表，不是一个对象，不能再有后续的操作

>>> res = Students.objects.filter(id__exact=4)
#__exact也可以不写，默认的不用写>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`id` = 4

>>> res = Students.objects.filter(name__iexact='abc')>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`name` LIKE abc>>> res
<QuerySet [<Students: ABC-5>, <Students: abc-6>]>

>>> res = Students.objects.filter(name__contains='abc')>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`name` LIKE BINARY %abc%>>> res
<QuerySet [<Students: abc-6>]>

>>> res = Students.objects.filter(name__icontains='abc')>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`name` LIKE %abc%

>>> res = Students.objects.filter(name__in=['abc','ABC','小明'])>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`name` IN (abc, ABC, 小明)

>>> res = Students.objects.filter(age__range=(14,20))>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`age` BETWEEN 14 AND 20>>> res
<QuerySet [<Students: 小明-16>, <Students: XiaoHong-16>, <Students: 李思-17>, <Students: 赵柳-19>, <Students: 刘一-19>]>

#大于 方法
>>> res = Students.objects.filter(age__gt=18)>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`age` > 18#大于等于 方法
>>> res = Students.objects.filter(age__gte=18)>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`age` >= 18

#小于方法
>>> res = Students.objects.filter(age__lt=18)>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`age` < 18#小于等于 方法
>>> res = Students.objects.filter(age__lte=18)>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`age` <= 18

>>> res = Students.objects.filter(name__startswith='小')>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`name` LIKE BINARY 小%

>>> res = Students.objects.filter(name__istartswith='小')>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`name` LIKE 小%

>>> res = Students.objects.filter(name__endswith='小')>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`name` LIKE BINARY %小

>>> res = Students.objects.filter(name__iendswith='小')>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`name` LIKE %小

>>> res = Students.objects.filter(name__isnull=True)>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`name` IS NULL>>> res = Students.objects.filter(name__isnull=False)>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`name` IS NOT NULL

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

小写count
>>> Students.objects.filter(name__startswith='小').count()
1大写Count
>>> Students.objects.filter(sex=1).aggregate(age_count=Count('age'))
{'age_count': 7}

>>> Students.objects.filter(sex=1).aggregate(age_avg=Avg('age'))
{'age_avg': 17.4286}

>>> Students.objects.filter(sex=1).aggregate(age_max=Max('age'))
{'age_max': 29}

>>> Students.objects.filter(sex=1).aggregate(age_min=Min('age'))
{'age_min': 5}

>>> Students.objects.filter(sex=1).aggregate(age_sum=Sum('age'))
{'age_sum': 122}

拿到字段为sex的，然后对sex这个字段来统计聚合后，再分组
>>> Students.objects.values('sex').annotate(num=Count('sex'))
<QuerySet [{'sex': 1, 'num': 7}, {'sex': 0, 'num': 4}]>>>> Students.objects.values('age').annotate(num=Count('age'))
<QuerySet [{'age': 16, 'num': 2}, {'age': 24, 'num': 1}, {'age': 22, 'num': 1}, {'age': 23, 'num': 1}, {'age': 17, 'num': 1}, {'age': 19, 'num': 2}, {'age': 29, 'num': 1}, {'age': 5, 'num': 1}, {'age': 6, 'num': 1}]>>>> res = Students.objects.values('age').annotate(num=Count('age'))>>>print(res.query)
SELECT `teacher_students`.`age`, COUNT(`teacher_students`.`age`) AS `num` FROM `teacher_students` GROUP BY `teacher_students`.`age` ORDER BY NULL

from django.db import models 学生主表（一）
class Students(models.Model):
name = models.CharField(max_length=20)
age = models.SmallIntegerField(default=0)
sex = models.SmallIntegerField(default=1)
qq = models.CharField(max_length=20, unique=True, null=True)
phone = models.CharField(max_length=20, unique=True, null=True)
c_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True)
e_time = models.DateTimeField(verbose_name='编辑时间', auto_now=True) #__str__代码,表示输出格式化，是为了在ipython调试中方便查看数据，对数据库不造成任何影响，不用做数据库迁移
def __str__(self):
return '%s-%s' % (self.name, self.age) 学生详情表（一）
Class StudentsDetail(models.Model):
num = models.CharField(max_length=20, default='')
college = models.CharField(max_length=20, default='')
student = models.OneToOneField('Students', on_delete=models.CASCADE) 一对一的关联操作解析：'OneToOneField'
student = models.OneToOneField('Students', on_delete=models.CASCADE)
第一个参数是需要关联的表，需要字符串操作，第二个参数'on_delete=models.CASCADE'表示级联操作，如果主表有信息删除则此表信息也会跟着删除。

from django.db import models 学生主表(多)
class Students(models.Model):
name = models.CharField(max_length=20)
age = models.SmallIntegerField(default=0)
sex = models.SmallIntegerField(default=1)
qq = models.CharField(max_length=20, unique=True, null=True)
phone = models.CharField(max_length=20, unique=True, null=True)
c_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True)
e_time = models.DateTimeField(verbose_name='编辑时间', auto_now=True)
grade = models.ForeignKey('Grade', on_delete=models.SET_NULL, null=True) 多对一关联解析：'ForeignKey'：设置外键关联Grade表
grade = models.ForeignKey('Grade', on_delete=models.SET_NULL, null=True)
'on_delete=models.SET_NULL'：(必须带一个null=True)代表如果关联的表对应数据被删除，则显示NULL，不会被级联删除(如果班级被删除，学生则还在，所以不能级联) 班级表（一）
class Grade(models.Model):
num = models.CharField(max_length=20)
name = models.CharField(max_length=20)

from django.db import models 学生主表(多)
class Students(models.Model):
name = models.CharField(max_length=20)
age = models.SmallIntegerField(default=0)
sex = models.SmallIntegerField(default=1)
qq = models.CharField(max_length=20, unique=True, null=True)
phone = models.CharField(max_length=20, unique=True, null=True)
c_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True)
e_time = models.DateTimeField(verbose_name='编辑时间', auto_now=True)
grade = models.ForeignKey('Grade', on_delete=models.SET_NULL, null=True) 课程表(多)
class Course(models.Model):
name = models.CharField('课程名称', max_length=20)
students = models.ManyToManyField('Students') #当你的另外一张表里面仅仅只有两个字段的时候（id+外键），Django会自动创建中间表，不需要我们自己来创建。

from django.db import models 学生主表(多)
class Students(models.Model):
name = models.CharField(max_length=20)
age = models.SmallIntegerField(default=0)
sex = models.SmallIntegerField(default=1)
qq = models.CharField(max_length=20, unique=True, null=True)
phone = models.CharField(max_length=20, unique=True, null=True)
c_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True)
e_time = models.DateTimeField(verbose_name='编辑时间', auto_now=True)
grade = models.ForeignKey('Grade', on_delete=models.SET_NULL, null=True) 课程表(多)
class Course(models.Model):
name = models.CharField('课程名称', max_length=20)
students = models.ManyToManyField('Students',through='Enroll') 报名表(多)
class Enrloo(models,Model):
student = models.ForeignKey('Students',on_delete=models.CASCADE)
student = models.ForeignKey('Students',on_delete=models.CASCADE)
pay = models.IntegerField('缴费金额', default=0)
c_time = models.DateTimeField('报名时间', auto_now_add=True)

↓↓↓最后的全部代码参考↓↓↓
from django.db import models # Create your models here. # 学生表
class Students(models.Model):
name = models.CharField(max_length=20)
age = models.SmallIntegerField(default=0)
sex = models.SmallIntegerField(default=1)
qq = models.CharField(max_length=20, unique=True, null=True)
phone = models.CharField(max_length=20, unique=True, null=True)
c_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True)
e_time = models.DateTimeField(verbose_name='修改时间', auto_now=True)
grade = models.ForeignKey('Grade', on_delete=models.SET_NULL, null=True) def __str__(self):
return '%s-%s' % (self.name, self.age) # 学生详情表
class StudentsDetail(models.Model):
num = models.CharField(max_length=20, default='')
college = models.CharField(max_length=20, default='') # 创建一对一需要创建的第一个参数是需要关联的表，第二个参数是主表有信息删除则此表信息也会跟着删除。
student = models.OneToOneField('Students', on_delete=models.CASCADE) # 年级表
class Grade(models.Model):
num = models.CharField(max_length=20)
name = models.CharField(max_length=20) # 课程表
class Course(models.Model):
name = models.CharField(max_length=20)
student = models.ManyToManyField('Students', through='Enroll') # 报名表
class Enroll(models.Model):
student = models.ForeignKey('Students', on_delete=models.CASCADE)
course = models.ForeignKey('Course', on_delete=models.CASCADE)
pay = models.IntegerField('缴费金额', default=0)
c_time = models.DateTimeField('报名时间', auto_now_add=True)

>>> python manage.py sqlmigrate teacher 0001解析： teacher:appname 0001：Django的迁移执行文件

通过获取到的数据，赋值给当前表的外键字段，然后保存。 # 先拿到Grade的一条数据
>>> g1 = Grade.objects.first() # 获取一个Students的空对象
>>> s = Students() # 给对象添加一个name字段的数据
>>> s.name = '张三' # 把g1的数据复制给Students的grade的字段，然后得到数据。
>>> s.grade = g1 # 保存
>>> s.save()

>>> s2 = Students(name='李四')>>> g2 = Grade.objects.last()# 用对象的外键字段名接受关联表的数据，需要是关联表的主键id
>>> s2.grade_id = g2.id>> sa.save()

# 把对象的外键grade字段拿来接受g2的对象数据，以达到修改
>>> s.grade = g2>>> s.save()

# 通过赋值None来操作
>>> s.grade = None>>> s.save()

# 通过外键去拿到关联的数据
>>> s2.grade.name
'爬虫'

#在创建的同时，也直接把g2的对象数据一起增加了，此方法立刻执行
>>> g2.students_set.create(name='王五')
<Students: 王五-0>#把已有的对象通过add方法增加关联的数据，此方法立刻执行，如果本身自带了数据，则自动修改为本对象的数据
>>> g2.students_set.add(s)

>>> g2.students_set.all()
<QuerySet [<Students: 张三-0>, <Students: 李四-0>, <Students: 王五-0>]>#查询的所有方法都可以使用，这里只做一个例子

#删除单条
>>> g2.students_set.remove(s, s2)#删除所有
>>> g2.students_set.clear()

# 获取对象后，添加到本对象的表中
>>> g3.students_set.set([s, s2])>>> g3.students_set.all()

# 使用本表的外键查询('外键'+'__'+'关联表字段名')>>> res = Students.objects.filter(grade__name='爬虫')>>> res
<QuerySet [<Students: 张三-0>, <Students: 李四-0>, <Students: 赵柳-0>]>>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time`, `teacher_students`.`e_time`, `teacher_students`.`grade_id` FROM `teacher_students` INNER JOIN `teacher_grade` ON (`teacher_students`.`grade_id` = `teacher_grade`.`id`) WHERE `teacher_grade`.`name` = 爬虫

# 把创建出来的Course对象获取到变量中得到c1, c2, c3
>>> c1,c2,c3 = Course.objects.all() # 把创建出来的Students对象获取到变量中得到s1, s2, s3
>>> s1,s2,s3 = Students.objects.all()

# 获取一个空对象
>>> e = Enroll()# 把c1的对象赋值给Enroll的这个对象
>>> e.course = c1# 把s1的对象赋值给Enroll的这个对象
>>> e.student = s1>>> e.save()#用两个外键字段名接受 关联表对象的数据。然后保存，可以得到一条外键关联的数据。

#用外键字段名id接受关联的对象id
>>> e.course_id = c2.id>>> e.student_id = s2.id>>> e.save()

# 使用creat方法可以一起指定外键，然后创建
>>> Enroll.objects.create(sudent=s1,course=c3)

#创建表的时候的代码解析：
student = models.ManyToManyField('Students', through='Enroll')
#Course表中的的字段，并不会在数据库中创建，而是django中需要配置的管理器。他可以很方便的在查询中起到作用。

# 在course表中，使用的ManyToMany是一个管理器
>>> c1.student
<django.db.models.fields.related_descriptors.create_forward_many_to_many_manager.<locals>.ManyRelatedManager at 0xaff763ec># 查找c1下面的所有学生
>>> c1.student.all()
<QuerySet [<Students: 张三-0>]># 查找学生报名的所有课程
>>> s1.course_set.all()
<QuerySet [<Course: pyton全栈>]>

>>> sd = StudentsDetail.objects.create(num='', college='家里蹲', student=s1)>>> sd
<StudentsDetail: 家里蹲-20190301001>

>>> sd.student
<Students: 张三-0>>>> sd.student.name
'张三'

>>> s1.studentsdetail
<StudentsDetail: 家里蹲-20190301001>>>> s1.studentsdetail.num
''

# 用相关联的字段名+'__'关联表的字段名
>>> res = Course.objects.filter(student__sex=1)>>> print(res.query)
SELECT `teacher_course`.`id`, `teacher_course`.`name` FROM `teacher_course` INNER JOIN `teacher_enroll` ON (`teacher_course`.`id` = `teacher_enroll`.`course_id`) INNER JOIN `teacher_students` ON (`teacher_enroll`.`student_id` = `teacher_students`.`id`) WHERE `teacher_students`.`sex` = 1

#模糊查询用contains>>> res = Students.objects.filter(course__name__contains='python')>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time`, `teacher_students`.`e_time`, `teacher_students`.`grade_id` FROM `teacher_students` INNER JOIN `teacher_enroll` ON (`teacher_students`.`id` = `teacher_enroll`.`student_id`) INNER JOIN `teacher_course` ON (`teacher_enroll`.`course_id` = `teacher_course`.`id`) WHERE `teacher_course`.`name` LIKE BINARY %python%

>>> res = Students.objects.filter(course__name__contains='englist',grade__num__contains='33期')>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time`, `teacher_students`.`e_time`, `teacher_students`.`grade_id` FROM `teacher_students` INNER JOIN `teacher_enroll` ON (`teacher_students`.`id` = `teacher_enroll`.`student_id`) INNER JOIN `teacher_course` ON (`teacher_enroll`.`course_id` = `teacher_course`.`id`) INNER JOIN `teacher_grade` ON (`teacher_students`.`grade_id` = `teacher_grade`.`id`) WHERE (`teacher_course`.`name` LIKE BINARY %englist% AND `teacher_grade`.`num` LIKE BINARY %33期%)

>>> res = Students.objects.filter(enroll__pay__lt=3000)>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time`, `teacher_students`.`e_time`, `teacher_students`.`grade_id` FROM `teacher_students` INNER JOIN `teacher_enroll` ON (`teacher_students`.`id` = `teacher_enroll`.`student_id`) WHERE `teacher_enroll`.`pay` < 3000.0

>>> res = Grade.objects.filter(students__course__name__contains='python')
通过学生表去查课程名称之后，>>> print(res.query)
SELECT `teacher_grade`.`id`, `teacher_grade`.`num`, `teacher_grade`.`name` FROM `teacher_grade` INNER JOIN `teacher_students` ON (`teacher_grade`.`id` = `teacher_students`.`grade_id`) INNER JOIN `teacher_enroll` ON (`teacher_students`.`id` = `teacher_enroll`.`student_id`) INNER JOIN `teacher_course` ON (`teacher_enroll`.`course_id` = `teacher_course`.`id`) WHERE `teacher_course`.`name` LIKE BINARY %python%