通过之前的课程我们可以对于Django的models进行简单的操作，今天了解下进阶操作和modelform；
1. Models进阶操作
1.1 字段操作
AutoField(Field) - int自增列，必须填入参数 primary_key=True
BigAutoField(AutoField) - bigint自增列，必须填入参数 primary_key=True
注：当model中如果没有自增列，则自动会创建一个列名为id的列form django.db import modelsclass UserInfo(models.Model): # 自动创建一个列名为id的且为自增的整数列 username = models.CharField(max_length=32) class Group(models.Model): # 自定义自增列 nid = models.AutoField(primary_key=True) name = models.CharField(max_length=32)
SmallIntegerField(IntegerField): - 小整数 -32768 ～ 32767 PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField) - 正小整数 0 ～ 32767 IntegerField(Field) - 整数列(有符号的) -2147483648 ～ 2147483647 PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField) - 正整数 0 ～ 2147483647 BigIntegerField(IntegerField): - 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807
BooleanField(Field) - 布尔值类型NullBooleanField(Field): - 可以为空的布尔值
CharField(Field) - 字符类型 - 必须提供max_length参数， max_length表示字符长度TextField(Field) - 文本类型EmailField(CharField)： - 字符串类型，Django Admin以及ModelForm中提供验证机制IPAddressField(Field) - 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制GenericIPAddressField(Field) - 字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6 - 参数： protocol，用于指定Ipv4或Ipv6， 'both',"ipv4","ipv6" unpack_ipv4， 如果指定为True，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启刺功能，需要protocol="both"URLField(CharField) - 字符串类型，Django Admin以及ModelForm中提供验证 URLSlugField(CharField) - 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号）CommaSeparatedIntegerField(CharField) - 字符串类型，格式必须为逗号分割的数字UUIDField(Field) - 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证FilePathField(Field) - 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能 - 参数： path, 文件夹路径 match=None, 正则匹配 recursive=False, 递归下面的文件夹 allow_files=True, 允许文件 allow_folders=False, 允许文件夹FileField(Field) - 字符串，路径保存在数据库，文件上传到指定目录 - 参数： upload_to = "" 上传文件的保存路径 storage = None 存储组件，默认django.core.files.storage.FileSystemStorage ImageField(FileField) - 字符串，路径保存在数据库，文件上传到指定目录 - 参数： upload_to = "" 上传文件的保存路径 storage = None 存储组件，默认django.core.files.storage.FileSystemStorage width_field=None, 上传图片的高度保存的数据库字段名（字符串） height_field=None 上传图片的宽度保存的数据库字段名（字符串）
DateTimeField(DateField) - 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]DateField(DateTimeCheckMixin, Field) - 日期格式 YYYY-MM-DDTimeField(DateTimeCheckMixin, Field) - 时间格式 HH:MM[:ss[.uuuuuu]]
DurationField(Field) - 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型FloatField(Field) - 浮点型DecimalField(Field) - 10进制小数 - 参数： max_digits，小数总长度 decimal_places，小数位长度BinaryField(Field) - 二进制类型
1.2 字段参数
null 数据库中字段是否可以为空db_column 数据库中字段的列名default 数据库中字段的默认值primary_key 数据库中字段是否为主键db_index 数据库中字段是否可以建立索引unique 数据库中字段是否可以建立唯一索引unique_for_date 数据库中字段【日期】部分是否可以建立唯一索引unique_for_month 数据库中字段【月】部分是否可以建立唯一索引unique_for_year 数据库中字段【年】部分是否可以建立唯一索引verbose_name Admin中显示的字段名称blank Admin中是否允许用户输入为空editable Admin中是否可以编辑help_text Admin中该字段的提示信息choices Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作 如：gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1)error_messages 自定义错误信息（字典类型），从而定制想要显示的错误信息； 字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date 如：{ 'null': "不能为空.", 'invalid': '格式错误'}validators 自定义错误验证（列表类型），从而定制想要的验证规则 from django.core.validators import RegexValidator from django.core.validators import EmailValidator,URLValidator,DecimalValidator,\ MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator 如： test = models.CharField( max_length=32, error_messages={ 'c1': '优先错信息1', 'c2': '优先错信息2', 'c3': '优先错信息3', }, validators=[ RegexValidator(regex='root_\d+', message='错误了', code='c1'), RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'), EmailValidator(message='又错误了', code='c3'), ] ) 1.3 ORM基本操作
1. models.Tb1.objects.create(c1='xx', c2='oo') 增加一条数据，可以接受字典类型数据 **kwargs2. obj = models.Tb1(c1='xx', c2='oo') obj.save()
models.Tb1.objects.filter(name='seven').delete() # 删除指定条件的数据
1. models.Tb1.objects.filter(name='seven').update(gender='0') # 将指定条件的数据更新，均支持 **kwargs2.obj = models.Tb1.objects.get(id=1)#修改单条数据 obj.c1 = '111' obj.save()
1. models.Tb1.objects.get(id=123) # 获取单条数据，不存在则报错（不建议）2. models.Tb1.objects.all() # 获取全部3. models.Tb1.objects.filter(name='cc') # 获取指定条件的数据4. models.Tb1.objects.exclude(name='cc') # 获取指定条件的数据
1.4 ORM进阶操作
1. 获取个数models.Tb1.objects.filter(name='seven').count()2. 大于，小于models.Tb1.objects.filter(id__gt=1) # 获取id大于1的值models.Tb1.objects.filter(id__gte=1) # 获取id大于等于1的值models.Tb1.objects.filter(id__lt=10) # 获取id小于10的值models.Tb1.objects.filter(id__lte=10) # 获取id小于10的值models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值3. inmodels.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in4. isnull #是否为空 Entry.objects.filter(pub_date__isnull=True)5. contains #包含 等同sql语句like操作models.Tb1.objects.filter(name__contains="ven")models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感models.Tb1.objects.exclude(name__icontains="ven")6. rangemodels.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and7. 其他类似 开头、结尾startswith，istartswith, endswith, iendswith,8. order by #排序可写多值，优先第一个值排序models.Tb1.objects.filter(name='seven').order_by('id') # asc 从小到大models.Tb1.objects.filter(name='seven').order_by('-id',) # desc 从大到下 9. group by #分组from django.db.models import Count, Min, Max, Summodels.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num')) #根据id分组，并获取每组个数，可加Min，Max，SumSELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id" #等同于这句10.limit 、offset #分页models.Tb1.objects.all()[10:20]11. regex正则匹配，iregex 不区分大小写Entry.objects.get(title__regex=r'^(An?|The) +')Entry.objects.get(title__iregex=r'^(an?|the) +')12. date #时间 Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1)) #pub_date__date根据日期查询，不包含时、分Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))13. yearEntry.objects.filter(pub_date__year=2005)Entry.objects.filter(pub_date__year__gte=2005)14. monthEntry.objects.filter(pub_date__month=12)Entry.objects.filter(pub_date__month__gte=6)15. dayEntry.objects.filter(pub_date__day=3)Entry.objects.filter(pub_date__day__gte=3)16. week_dayEntry.objects.filter(pub_date__week_day=2)Entry.objects.filter(pub_date__week_day__gte=2)17. hourEvent.objects.filter(timestamp__hour=23)Event.objects.filter(time__hour=5)Event.objects.filter(timestamp__hour__gte=12)18. minuteEvent.objects.filter(timestamp__minute=29)Event.objects.filter(time__minute=46)Event.objects.filter(timestamp__minute__gte=29)19. secondEvent.objects.filter(timestamp__second=31)Event.objects.filter(time__second=2)Event.objects.filter(timestamp__second__gte=31) 1.5 ORM高级操作
# extraextra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None) Entry.objects.extra(select={ 'new_id': "select col from sometable where othercol > %s"}, select_params=(1,)) Entry.objects.extra(where=['headline=%s'], params=['Lennon']) Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"]) Entry.objects.extra(select={ 'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])# Ffrom django.db.models import Fmodels.Tb1.objects.update(num=F('num')+1)# Q方式一：Q(nid__gt=10)Q(nid=8) | Q(nid__gt=10)Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')# 方式二：con = Q()q1 = Q()q1.connector = 'OR'q1.children.append(('id', 1))q1.children.append(('id', 10))q1.children.append(('id', 9))q2 = Q()q2.connector = 'OR'q2.children.append(('c1', 1))q2.children.append(('c1', 10))q2.children.append(('c1', 9))con.add(q1, 'AND')con.add(q2, 'AND')models.Tb1.objects.filter(con)# 执行原生SQLfrom django.db import connection, connectionscursor = connection.cursor() # cursor = connections['default'].cursor()cursor.execute("""SELECT * from auth_user where id = %s""", [1])row = cursor.fetchone() 1.6 ORM其他操作
################################################################### PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET ###################################################################def all(self) # 获取所有的数据对象def filter(self, *args, **kwargs) # 条件查询 # 条件可以是：参数，字典，Qdef exclude(self, *args, **kwargs) # 条件查询 # 条件可以是：参数，字典，Qdef select_related(self, *fields) 性能相关：表之间进行join连表操作，一次性获取关联的数据。 model.tb.objects.all().select_related() model.tb.objects.all().select_related('外键字段') model.tb.objects.all().select_related('外键字段__外键字段')def prefetch_related(self, *lookups) 性能相关：多表连表操作时速度会慢，使用其执行多次SQL查询在Python代码中实现连表操作。 # 获取所有用户表 # 获取用户类型表where id in (用户表中的查到的所有用户ID) models.UserInfo.objects.prefetch_related('外键字段') from django.db.models import Count, Case, When, IntegerField Article.objects.annotate( numviews=Count(Case( When(readership__what_time__lt=treshold, then=1), output_field=CharField(), )) ) students = Student.objects.all().annotate(num_excused_absences=models.Sum( models.Case( models.When(absence__type='Excused', then=1), default=0, output_field=models.IntegerField() )))def annotate(self, *args, **kwargs) # 用于实现聚合group by查询 from django.db.models import Count, Avg, Max, Min, Sum v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')) # SELECT u_id, COUNT(ui) AS `uid` FROM UserInfo GROUP BY u_id v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')).filter(uid__gt=1) # SELECT u_id, COUNT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1 v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id',distinct=True)).filter(uid__gt=1) # SELECT u_id, COUNT( DISTINCT ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1def distinct(self, *field_names) # 用于distinct去重 models.UserInfo.objects.values('nid').distinct() # select distinct nid from userinfo 注：只有在PostgreSQL中才能使用distinct进行去重def order_by(self, *field_names) # 用于排序 models.UserInfo.objects.all().order_by('-id','age')def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None) # 构造额外的查询条件或者映射，如：子查询 Entry.objects.extra(select={ 'new_id': "select col from sometable where othercol > %s"}, select_params=(1,)) Entry.objects.extra(where=['headline=%s'], params=['Lennon']) Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"]) Entry.objects.extra(select={ 'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid']) def reverse(self): # 倒序 models.UserInfo.objects.all().order_by('-nid').reverse() # 注：如果存在order_by，reverse则是倒序，如果多个排序则一一倒序 def defer(self, *fields): models.UserInfo.objects.defer('username','id') 或 models.UserInfo.objects.filter(...).defer('username','id') #映射中排除某列数据 def only(self, *fields): #仅取某个表中的数据 models.UserInfo.objects.only('username','id') 或 models.UserInfo.objects.filter(...).only('username','id') def using(self, alias): 指定使用的数据库，参数为别名（setting中的设置）################################################### PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS ###################################################def raw(self, raw_query, params=None, translations=None, using=None): # 执行原生SQL models.UserInfo.objects.raw('select * from userinfo') # 如果SQL是其他表时，必须将名字设置为当前UserInfo对象的主键列名 models.UserInfo.objects.raw('select id as nid from 其他表') # 为原生SQL设置参数 models.UserInfo.objects.raw('select id as nid from userinfo where nid>%s', params=[12,]) # 将获取的到列名转换为指定列名 name_map = { 'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'} Person.objects.raw('SELECT * FROM some_other_table', translations=name_map) # 指定数据库 models.UserInfo.objects.raw('select * from userinfo', using="default") ################### 原生SQL ################### from django.db import connection, connections cursor = connection.cursor() # cursor = connections['default'].cursor() cursor.execute("""SELECT * from auth_user where id = %s""", [1]) row = cursor.fetchone() # fetchall()/fetchmany(..)def values(self, *fields): # 获取每行数据为字典格式def values_list(self, *fields, **kwargs): # 获取每行数据为元祖def dates(self, field_name, kind, order='ASC'): # 根据时间进行某一部分进行去重查找并截取指定内容 # kind只能是："year"（年）, "month"（年-月）, "day"（年-月-日） # order只能是："ASC" "DESC" # 并获取转换后的时间 - year : 年-01-01 - month: 年-月-01 - day : 年-月-日 models.DatePlus.objects.dates('ctime','day','DESC')def datetimes(self, field_name, kind, order='ASC', tzinfo=None): # 根据时间进行某一部分进行去重查找并截取指定内容，将时间转换为指定时区时间 # kind只能是 "year", "month", "day", "hour", "minute", "second" # order只能是："ASC" "DESC" # tzinfo时区对象 models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.UTC) models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai')) """ pip3 install pytz import pytz pytz.all_timezones pytz.timezone(‘Asia/Shanghai’) """def none(self): # 空QuerySet对象##################################### METHODS THAT DO DATABASE QUERIES #####################################def aggregate(self, *args, **kwargs): # 聚合函数，获取字典类型聚合结果 from django.db.models import Count, Avg, Max, Min, Sum result = models.UserInfo.objects.aggregate(k=Count('u_id', distinct=True), n=Count('nid')) ===> { 'k': 3, 'n': 4}def count(self): # 获取个数def get(self, *args, **kwargs): # 获取单个对象def create(self, **kwargs): # 创建对象def bulk_create(self, objs, batch_size=None): # 批量插入 # batch_size表示一次插入的个数 objs = [ models.DDD(name='r11'), models.DDD(name='r22') ] models.DDD.objects.bulk_create(objs, 10)def get_or_create(self, defaults=None, **kwargs): # 如果存在，则获取，否则，创建 # defaults 指定创建时，其他字段的值 obj, created = models.UserInfo.objects.get_or_create(username='root1', defaults={ 'email': '1111111','u_id': 2, 't_id': 2})def update_or_create(self, defaults=None, **kwargs): # 如果存在，则更新，否则，创建 # defaults 指定创建时或更新时的其他字段 obj, created = models.UserInfo.objects.update_or_create(username='root1', defaults={ 'email': '1111111','u_id': 2, 't_id': 1})def first(self): # 获取第一个def last(self): # 获取最后一个def in_bulk(self, id_list=None): # 根据主键ID进行查找 id_list = [11,21,31] models.DDD.objects.in_bulk(id_list)def delete(self): # 删除def update(self, **kwargs): # 更新def exists(self): # 是否有结果 1.7 数据表定制
class UserInfo(models.Model): nid = models.AutoField(primary_key=True) username = models.CharField(max_length=32) pwd = models.CharField(max_length=32 class Meta: # 数据库中生成的表名称 默认 app名称 + 下划线 + 类名 db_table = "table_name" # 联合索引 index_together = [ ("username", "pwd"), ] # 联合唯一索引 unique_together = (("driver", "restaurant"),) # admin中显示的表名称 verbose_name # verbose_name加s verbose_name_plural 其中联合索引命中支持最左前缀模式，比如有如下语句：
-
select * from userinfo where username="xxx"
-
select * from userinfo where username = "XXX" and pwd="ZZZ"
-
select * from userinfo where pwd='xxx'
则只有第一个和第二个语句可以命中索引，第三个sql语句无法命中索引；
1.8 外键关联
1.8.1 外键关联ForeignKey
ForeignKey(ForeignObject) # ForeignObject(RelatedField) to, # 要进行关联的表名 to_field=None, # 要关联的表中的字段名称 on_delete=None, # 当删除关联表中的数据时，当前表与其关联的行的行为 - models.CASCADE，删除关联数据，与之关联也删除 - models.DO_NOTHING，删除关联数据，引发错误IntegrityError - models.PROTECT，删除关联数据，引发错误ProtectedError - models.SET_NULL，删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空） - models.SET_DEFAULT，删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值） - models.SET，删除关联数据， a. 与之关联的值设置为指定值，设置：models.SET(值) b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象) def func(): return 10 class MyModel(models.Model): user = models.ForeignKey( to="User", to_field="id" on_delete=models.SET(func),) related_name=None, # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all() related_query_name=None, # 反向操作时，使用的连接前缀，用于替换【表名】 如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名') limit_choices_to=None, # 在Admin或ModelForm中显示关联数据时，提供的条件： # 如： - limit_choices_to={ 'nid__gt': 5} - limit_choices_to=lambda : { 'nid__gt': 5} from django.db.models import Q - limit_choices_to=Q(nid__gt=10) - limit_choices_to=Q(nid=8) | Q(nid__gt=10) - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root') db_constraint=True # 是否在数据库中创建外键约束 parent_link=False # 在Admin中是否显示关联数据 关联表实例：
class UserType(models.Model): name = models.CharField(max_length=32) class User(models.Model): name = models.CharField(max_length=32) pwd = models.CharField(max_length=32) u_type = models.ForiegnKey(to="UserType", to_field='id',)
Django上删除指定数据及其关联数据：
models.UserType.objects.filter(id=1).delete()
Django可通过对关联表进行定制，根据不同的程序环境，对删除关联表时做相应的设置，下面就介绍都有哪些参数 设置
① models.CASCADE 删除关联数据，与之关联也删除；
u_type=models.ForiegnKey(to="UserType",to_field='id',on_delete=models.CASCADE)
② models.SET() 删除关联数据,与之关联的值设置为指定值（可以是函数）；
u_type = models.ForiegnKey(to="UserType",to_field='id',on_delete=models.SET(10))
1.8.2 外键关联OneToOneField
一对一操作：
OneToOneField(ForeignKey) to, # 要进行关联的表名 to_field=None # 要关联的表中的字段名称 on_delete=None, # 当删除关联表中的数据时，当前表与其关联的行的行为 ###### 对于一对一 ###### # 1. 一对一其实就是 一对多 + 唯一索引 # 2.当两个类之间有继承关系时，默认会创建一个一对一字段 # 如下会在A表中额外增加一个c_ptr_id列且唯一： class C(models.Model): nid = models.AutoField(primary_key=True) part = models.CharField(max_length=12) class A(C): id = models.AutoField(primary_key=True) code = models.CharField(max_length=1)
1.8.3 外键关联ManyToManyField
多对多操作参数：
ManyToManyField(RelatedField) to, # 要进行关联的表名 related_name=None, # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all() related_query_name=None, # 反向操作时，使用的连接前缀，用于替换【表名】 如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名') limit_choices_to=None, # 在Admin或ModelForm中显示关联数据时，提供的条件： # 如： - limit_choices_to={ 'nid__gt': 5} - limit_choices_to=lambda : { 'nid__gt': 5} from django.db.models import Q - limit_choices_to=Q(nid__gt=10) - limit_choices_to=Q(nid=8) | Q(nid__gt=10) - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root') symmetrical=None, # 仅用于多对多自关联时，symmetrical用于指定内部是否创建反向操作的字段 # 做如下操作时，不同的symmetrical会有不同的可选字段 models.BB.objects.filter(...) # 可选字段有：code, id, m1 class BB(models.Model): code = models.CharField(max_length=12) m1 = models.ManyToManyField('self',symmetrical=True) # 可选字段有: bb, code, id, m1 class BB(models.Model): code = models.CharField(max_length=12) m1 = models.ManyToManyField('self',symmetrical=False) through=None, # 自定义第三张表时，使用字段用于指定关系表 through_fields=None, # 自定义第三张表时，使用字段用于指定关系表中那些字段做多对多关系表 from django.db import models class Person(models.Model): name = models.CharField(max_length=50) class Group(models.Model): name = models.CharField(max_length=128) members = models.ManyToManyField( Person, through='Membership', through_fields=('group', 'person'), ) class Membership(models.Model): group = models.ForeignKey(Group, on_delete=models.CASCADE) person = models.ForeignKey(Person, on_delete=models.CASCADE) inviter = models.ForeignKey( Person, on_delete=models.CASCADE, related_name="membership_invites", ) invite_reason = models.CharField(max_length=64) db_constraint=True, # 是否在数据库中创建外键约束 db_table=None, # 默认创建第三张表时，数据库中表的名称 多对多操作：
a. django创建第三张表及操作 m2m.remove m2m.add m2m.set m2m.clear m2m.filter()b. 自定义第三张表（无m2m字段） 自己连表查询 c. 自定义第三张表（有m2m字段） # 通过m2m字段查操作 # 通过m2m字段 clear
自定义第三张表：
class Blog(models.Model): site = models.CharField(max_length=32) # 不指定through时 会生成4张表 # through 通过B2T表进行ManyToMany # through_fields B2T表中那几个字段进行MangyToMany m = models.ManyToManyField('Tag',through='B2T',through_fields=['b','t']) class Tag(models.Model): name = models.CharField(max_length=32) class B2T(models.Model): b = models.ForeignKey('Blog') t = models.ForeignKey('Tag') 1.9 性能调优（*****）
表数据：
from django.db import modelsclass UserType(models.Model): name = models.CharField(max_length=32)class User(models.Model): user = models.CharField(max_length=32) pwd = models.CharField(max_length=32) ut = models.ForeignKey(to='UserType', to_field='id', related_name='b', related_query_name='a', limit_choices_to={'id__gt':1}) 1）普通查询：
from app01 import modelsdef index(request): # 假设有用户10 users = models.User.objects.all() #发起一次查询操作，不包含关联表内容 for row in users: print(row.user,row.pwd,row.ut_id) #打印row中包含内容 print(row.ut.name) #第一次请求row中不包含UserType表内容，此时会再发一次请求 return HttpResponse('OK') 缺点：之前我们用到的查询方法如上，这种查询方法操作简单，但是很影响性能；每次执行print(row.ut.name)时，都会向数据库发起一次请求查询，假设一共10个用户，上述执行操作会向数据库发起11次查询；假如有多个外键字段打印的话，效率就更低了
2）效率高的方法values()：
# values() 字典形式from app01 import modelsdef index(request): users = models.User.objects.all().values('user','pwd','ut_id','name') #发起一次查询操作，包含所有内容 for row in users: print(row.user,row.pwd,row.ut_id) print(row.ut.name) #包含ut.name内容不用再次发起查询 return HttpResponse('OK') 缺点：valuse方法确实是比all（）效率高了，也是最简单的方法；但是values查询出来的数据是字典形式，而不是QuerySet，QuerySet中的很多方法都不在能使用；所以也不是最佳的解决方法；
3）连表查询select_related()：
-
select_related主要针一对一和多对一关系进行优化；
-
select_related使用SQL的JOIN语句进行优化，通过减少SQL查询的次数来进行优化、提高性能；
users = models.User.objects.all().select_related('ut')for row in users: print(row.user,row.pwd,row.ut_id) print(row.ut.name) print(row.tu.name) # 再发起一次SQL请求 缺点：上述操作解决了vaules()的问题，一次查询即可完成操作；但是，select_related()用到的是连表操作，如果关联数据表多个的话，也会非常的影响性能；连表查询速度慢
4）多次查询连表prefetch_related()：
-
prefetch_related主要针一对多和多对多关系进行优化。
-
prefetch_related通过分别获取各个表的内容，然后用Python处理他们之间的关系来进行优化。
# prefetch_related() 执行多次SQL查询在Python代码中实现连表操作from app01 import modelsdef index(request): # 非连表查询 users = models.User.objects.filter(id__gt=30).prefetch_related('ut') #第一查询id>30的User表内容包含ut_id,根据 #ut_id再次查询UserType表查询 没有连表操作 # select * from users where id > 30 第一次请求 # 获取上一步骤中所有的ut_id=[1,2] # select * from user_type where id in [1,2] 第二次请求 for row in users: print(row.user,row.pwd,row.ut_id) print(row.ut.name) #拼接两次查询到的数据 return HttpResponse('OK') 优点：Django操作优化的最优选择，执行两次操作，避免低效率的连表操作；
总结：
-
因为select_related()总是在单次SQL查询中解决问题，而prefetch_related()会对每个相关表进行SQL查询，因此select_related()的效率通常比后者高。
-
鉴于第一条，尽可能的用select_related()解决问题。只有在select_related()不能解决问题的时候再去想prefetch_related()。
-
你可以在一个QuerySet中同时使用select_related()和prefetch_related()，从而减少SQL查询的次数。
-
只有prefetch_related()之前的select_related()是有效的，之后的将会被无视掉。
2. Modelform操作
略