本文转载自https://blog.csdn.net/xiaogeldx/article/details/88084034
表关系
一对一（OneToOne）
-
通过本表的主键外键关联另一张表的主键
-
创建张学生详情表（在students的models.py文件中）
from django.db import models class Student(models.Model): name = models.CharField(max_length=20) age = models.SmallIntegerField(default=0) gender = models.SmallIntegerField(default=1) qq = models.CharField(max_length=20,default='') phone = models.CharField(max_length=20,default='') c_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True) def __str__(self): return '%s-%s' % (self.name, self.age) class StudentDetail(models.Model): #学生对学生详情，一对一 num = models.CharField(max_length=20, default='') college = models.CharField(max_length=20,default='') #Student最好用字符串 student = models.OneToOneField('Student', on_delete=models.CASCADE) #外键和一对一关系的时候需要加on_delete选项，此参数为了避免两个表里的数据不一致问题，不然会报错 #一般使用CASCADE表示级联删除图中的student_id就是外键关联
一对多（OneToMany）
from django.db import models
class Student(models.Model):
name = models.CharField(max_length=20)
age = models.SmallIntegerField(default=0)
gender = models.SmallIntegerField(default=1)
grade = models.ForeignKey('Grade', on_delete=models.SET_NULL, null=True) #删除某个学生后，班级对应的位置会显示为NULL
qq = models.CharField(max_length=20,default='')
phone = models.CharField(max_length=20,default='')
c_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True)
def __str__(self):
return '%s-%s' % (self.name, self.age)
class StudentDetail(models.Model): #学生对学生详情，一对一
num = models.CharField(max_length=20, default='')
college = models.CharField(max_length=20,default='')
#Student最好用字符串
student = models.OneToOneField('Student', on_delete=models.CASCADE)
class Grade(models.Model): #学生对班级，一对多
num = models.CharField(max_length=20)
name = models.CharField(max_length=20)
多对多（ManyToMany）
class Course(models.Model):
name = models.CharField('课程名称', max_length=20) #参数第一位就是verbose_name，“verbose_name=”可省略
students = models.ManyToManyField('Student', through='Enroll') #Student表和Course表可以不通过Enrol就能相互访问l#如果只有外键和id两个字段时会自动创建第三张表关联
class Enroll(models.Model): #报名表，有多个字段
student = models.ForeignKey('Student', on_delete=models.CASCADE)
course = models.ForeignKey('Course', on_delete=models.CASCADE)
pay = models.FloatField('缴费金额', default=0)
c_time = models.DateTimeField('报名时间', auto_now_add=True)
关联表的数据操作
进入项目目录的idle
- 为了能方便学习，进入项目的idle去执行操作
- 通过python manage.py shell就能进入当前目录下的idle
- 进入idle
- 查看当前的目录路径
- 导入我们项目中的模型类
OneToMany
-
正向：一个模型如果定义了一个外键字段，通过这个模型去操作这个外键就是正向
In [2]: from students.models import Student,StudentDetail,Grade,Course,Enroll In [3]: Grade.objects.all() Out[3]: <QuerySet [<Grade: 33期-django框架>, <Grade: 256期-爬虫>]> In [4]: s = Student() In [5]: s.name = 'xiaoge' In [6]: g1 = Grade.objects.first() In [7]: g1 Out[7]: <Grade: 33期-django框架> In [8]: s.grade = g1 #增 #方法1 In [9]: s.save() In [10]: s2 = Student(name='na') In [11]: g2 = Grade.objects.last() In [12]: s2.grade_id = g2.id #增 #方法2，效果和方法1一样 In [13]: s2.save() In [18]: s = Student.objects.first() In [21]: s.grade = g2 #改 #grade是定义在模型Student里面的ForeignKey，对它的操作就是正向 #它的修改和普通字段修改没什么区别，赋值然后保存 In [22]: s.grade Out[22]: <Grade: 256期-爬虫> In [24]: s.grade = None #删 In [25]: s.save() In [26]: s = Student.objects.first() In [28]: s.grade #返回值为空#只有外键定义了null=True才能删除，否则不能 In [30]: s2 Out[30]: <Student: na-0> In [31]: s2.grade.name #查 #和属性操作一样 Out[31]: '爬虫' In [33]: s2.grade.num #查 #和属性操作一样 Out[33]: '256期' -
反向：
In [36]: g3 = Grade.objects.create(name='进阶',num='40期') #如果模型1有一个ForeignKey，那么该ForeignKey所指的模型2实例可以通过一个管理器返回前面有Foreignkey的模型1的所有实例，默认情况下，这个管理器的名字为模型名字的小写+_set In [37]: g3.student_set.create(name='long') #反向增1 #模型名的小写_set 是个管理器 ，是对象的集合 Out[37]: <Student: long-0> In [38]: s = Student.objects.last() In [39]: s.grade.name #查 Out[39]: '进阶' In [40]: s.grade.num Out[40]: '40期' In [47]: s = Student.objects.first() In [49]: g3.student_set.add(s) #增2 #可以一次增多个 In [51]: g3.student_set.all() #查 #student_set在此处的用法相当于objects Out[51]: <QuerySet [<Student: xiaoge-0>, <Student: long-0>]> In [52]: g3.student_set.filter(name='xiaoge') #查 Out[52]: <QuerySet [<Student: xiaoge-0>]> In [53]: g3.student_set.filter(name='xiaoge').count() #查 Out[53]: 1 In [54]: g3.student_set.remove(s) #删1 #可以一次删多个 In [55]: g3.student_set.all() Out[55]: <QuerySet [<Student: long-0>]> In [56]: g3.student_set.clear() #删2 清空 In [57]: g3.student_set.all() Out[57]: <QuerySet []> In [58]: g3.student_set.set([s,s2]) #改 #set方法会先调用clear，再添加 （如果没有clear方法，clear不执行，直接添加） In [59]: g3.student_set.all() Out[59]: <QuerySet [<Student: xiaoge-0>, <Student: na-0>]> In [60]: res = Student.objects.filter(grade__name='django框架') In [61]: print(res.query) SELECT `students_student`.`id`, `students_student`.`name`, `students_student`.`age`, `students_student`.`gender`, `students_student`.`grade_id`, `students_student`.`qq`, `students_student`.`phone`, `students_student`.`c_time` FROM `students_student` INNER JOIN `students_grade` ON (`students_student`.`grade_id` = `students_grade`.`id`) WHERE `students_grade`.`name` = django框架 In [62]: res Out[62]: <QuerySet []>
ManyToMany
In [64]: Course.objects.create(name='python全栈')
Out[64]: <Course: python全栈>
In [65]: Course.objects.create(name='python全套')
Out[65]: <Course: python全套>
In [66]: Course.objects.create(name='english')
Out[66]: <Course: english>
In [67]: c1,c2,c3 = Course.objects.all()
In [68]: c1
Out[68]: <Course: python全栈>
In [69]: c2
Out[69]: <Course: python全套>
In [70]: c3
Out[70]: <Course: english>
In [71]: Student.objects.all().count()
Out[71]: 3
In [72]: s1,s2,s3 = Student.objects.all()
In [73]: s1
Out[73]: <Student: xiaoge-0>
In [74]: s2
Out[74]: <Student: na-0>
In [75]: s3
Out[75]: <Student: long-0>
In [76]: e = Enroll()
In [77]: e.course = c1
In [78]: e.student = s1
In [79]: e.save()
In [80]: Enroll.objects.create(student=s1,course=c3)
Out[80]: <Enroll: Enroll object (2)>
In [81]: Enroll.objects.create(student=s3,course=c1)
Out[81]: <Enroll: Enroll object (3)>
In [82]: Enroll.objects.create(student=s1,course=c1)
Out[82]: <Enroll: Enroll object (4)>
In [83]: c1.students
Out[83]: <django.db.models.fields.related_descriptors.create_forward_many_to_many_manager.<locals>.ManyRelatedManager at 0x7fdc1d9d46a0>
In [84]: c1.students.all()
Out[84]: <QuerySet [<Student: xiaoge-0>, <Student: xiaoge-0>, <Student: long-0>]>
In [85]: s1.course_set.all()
Out[85]: <QuerySet [<Course: python全栈>, <Course: english>, <Course: python全栈>]>
多对多时如果指定了中间表(本例中是Enroll表)，则不能用add，remove，set，必须用中间表
OneToOne
-
正向
In [1]: from students.models import Student,StudentDetail,Course,Enroll,Grade In [3]: s1 = Student.objects.first() In [4]: s2 = Student.objects.filter(name='na') In [5]: s3 = Student.objects.last() In [6]: s1 Out[6]: <Student: xiaoge-0> In [7]: s2 Out[7]: <QuerySet [<Student: na-0>]> In [8]: s3 Out[8]: <Student: long-0> In [9]: sd = StudentDetail.objects.create(num='121204040',college='辽工',student=s1) In [10]: sd Out[10]: <StudentDetail: StudentDetail object (1)> In [11]: sd.student Out[11]: <Student: xiaoge-0> -
反向
In [12]: s1.studentdetail #用模块名的小写，是个对象，不是管理器（没有_set） Out[12]: <StudentDetail: StudentDetail object (1)> In [13]: s1.studentdetail.college Out[13]: '辽工'
跨表查询
-
Django提供一种强大而直观的方式来处理查询中的关联关系，他在后台自动帮你处理join
-
若要跨越关联关系，只需使用关联的模型字段的名称，并使用双下划线分隔，直至你想要的字段
#查询男生报了什么课程#最终是要查课程，所以用Course模型，通过本模型里的字段正向查 In [14]: res = Course.objects.filter(students__gender=1) #正向，本模型里的字段名+__想要查的字段 In [15]: print(res.query) SELECT `students_course`.`id`, `students_course`.`name` FROM `students_course` INNER JOIN `students_enroll` ON (`students_course`.`id` = `students_enroll`.`course_id`) INNER JOIN `students_student` ON (`students_enroll`.`student_id` = `students_student`.`id`) WHERE `students_student`.`gender` = 1 In [16]: res Out[16]: <QuerySet [<Course: python全栈>, <Course: python全栈>, <Course: python全栈>, <Course: english>]> In [17]: res = Course.objects.filter(students__name='long') In [18]: res Out[18]: <QuerySet [<Course: python全栈>]> #查询报Python的学生#最终是要查学生，所以用Student模型，通过course反向查 In [19]: res = Student.objects.filter(course__name__contains='python') #相关模型名的小写+__相关字段名 In [20]: print(res.query) SELECT `students_student`.`id`, `students_student`.`name`, `students_student`.`age`, `students_student`.`gender`, `students_student`.`grade_id`, `students_student`.`qq`, `students_student`.`phone`, `students_student`.`c_time` FROM `students_student` INNER JOIN `students_enroll` ON (`students_student`.`id` = `students_enroll`.`student_id`) INNER JOIN `students_course` ON (`students_enroll`.`course_id` = `students_course`.`id`) WHERE `students_course`.`name` LIKE BINARY %python% In [21]: res Out[21]: <QuerySet [<Student: xiaoge-0>, <Student: xiaoge-0>, <Student: long-0>]> #查询报了英语33期的学生 In [31]: res = Student.objects.filter(course__name__contains='english',grade__num__contains='33期') In [32]: res Out[32]: <QuerySet []> #查询缴费金额小于3000的学生 In [33]: res = Student.objects.filter(enroll__pay__lt=3000) In [34]: print(res.query) SELECT `students_student`.`id`, `students_student`.`name`, `students_student`.`age`, `students_student`.`gender`, `students_student`.`grade_id`, `students_student`.`qq`, `students_student`.`phone`, `students_student`.`c_time` FROM `students_student` INNER JOIN `students_enroll` ON (`students_student`.`id` = `students_enroll`.`student_id`) WHERE `students_enroll`.`pay` < 3000.0 #查询报了python课程的学生的班级有哪些 In [35]: res = Grade.objects.filter(student__course__name__contains='python') In [36]: print(res.query) SELECT `students_grade`.`id`, `students_grade`.`num`, `students_grade`.`name` FROM `students_grade` INNER JOIN `students_student` ON (`students_grade`.`id` = `students_student`.`grade_id`) INNER JOIN `students_enroll` ON (`students_student`.`id` = `students_enroll`.`student_id`) INNER JOIN `students_course` ON (`students_enroll`.`course_id` = `students_course`.`id`) WHERE `students_course`.`name` LIKE BINARY %python%