通过之前的课程我们可以对于Django的models进行简单的操作,今天了解下进阶操作和modelform;

1. Models进阶操作

1.1 字段操作

  1. AutoField(Field)
  2. - int自增列,必须填入参数 primary_key=True

AutoField(int自增列)

  1. BigAutoField(AutoField)
  2. - bigint自增列,必须填入参数 primary_key=True

BigAutoField

  1. 注:当model中如果没有自增列,则自动会创建一个列名为id的列
  2. form django.db import models
  3. class UserInfo(models.Model):
  4. # 自动创建一个列名为id的且为自增的整数列
  5. username = models.CharField(max_length=32)
  6. class Group(models.Model):
  7. # 自定义自增列
  8. nid = models.AutoField(primary_key=True)
  9. name = models.CharField(max_length=32)
  1. SmallIntegerField(IntegerField):
  2. - 小整数 -32768 32767
  3.  
  4. PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
  5. - 正小整数 0 32767
  6. IntegerField(Field)
  7. - 整数列(有符号的) -2147483648 2147483647
  8.  
  9. PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
  10. - 正整数 0 2147483647
  11.  
  12. BigIntegerField(IntegerField):
  13. - 长整型(有符号的) -9223372036854775808 9223372036854775807

整数操作

  1. BooleanField(Field)
  2. - 布尔值类型
  3.  
  4. NullBooleanField(Field):
  5. - 可以为空的布尔值

布尔值类型

  1. CharField(Field)
  2. - 字符类型
  3. - 必须提供max_length参数, max_length表示字符长度
  4.  
  5. TextField(Field)
  6. - 文本类型
  7.  
  8. EmailField(CharField):
  9. - 字符串类型,Django Admin以及ModelForm中提供验证机制
  10.  
  11. IPAddressField(Field)
  12. - 字符串类型,Django Admin以及ModelForm中提供验证 IPV4 机制
  13.  
  14. GenericIPAddressField(Field)
  15. - 字符串类型,Django Admin以及ModelForm中提供验证 Ipv4Ipv6
  16. - 参数:
  17. protocol,用于指定Ipv4Ipv6 'both',"ipv4","ipv6"
  18. unpack_ipv4 如果指定为True,则输入::ffff:192.0.2.1时候,可解析为192.0.2.1,开启刺功能,需要protocol="both"
  19.  
  20. URLField(CharField)
  21. - 字符串类型,Django Admin以及ModelForm中提供验证 URL
  22.  
  23. SlugField(CharField)
  24. - 字符串类型,Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符(减号)
  25.  
  26. CommaSeparatedIntegerField(CharField)
  27. - 字符串类型,格式必须为逗号分割的数字
  28.  
  29. UUIDField(Field)
  30. - 字符串类型,Django Admin以及ModelForm中提供对UUID格式的验证
  31.  
  32. FilePathField(Field)
  33. - 字符串,Django Admin以及ModelForm中提供读取文件夹下文件的功能
  34. - 参数:
  35. path, 文件夹路径
  36. match=None, 正则匹配
  37. recursive=False, 递归下面的文件夹
  38. allow_files=True, 允许文件
  39. allow_folders=False, 允许文件夹
  40. FileField(Field)
  41. - 字符串,路径保存在数据库,文件上传到指定目录
  42. - 参数:
  43. upload_to = "" 上传文件的保存路径
  44. storage = None 存储组件,默认django.core.files.storage.FileSystemStorage
  45.  
  46. ImageField(FileField)
  47. - 字符串,路径保存在数据库,文件上传到指定目录
  48. - 参数:
  49. upload_to = "" 上传文件的保存路径
  50. storage = None 存储组件,默认django.core.files.storage.FileSystemStorage
  51. width_field=None, 上传图片的高度保存的数据库字段名(字符串)
  52. height_field=None 上传图片的宽度保存的数据库字段名(字符串)

字符类型

  1. DateTimeField(DateField)
  2. - 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]
  3.  
  4. DateField(DateTimeCheckMixin, Field)
  5. - 日期格式 YYYY-MM-DD
  6.  
  7. TimeField(DateTimeCheckMixin, Field)
  8. - 时间格式 HH:MM[:ss[.uuuuuu]]

时间类型

  1. DurationField(Field)
  2. - 长整数,时间间隔,数据库中按照bigint存储,ORM中获取的值为datetime.timedelta类型
  3. FloatField(Field)
  4. - 浮点型
  5. DecimalField(Field)
  6. - 10进制小数
  7. - 参数:
  8. max_digits,小数总长度
  9. decimal_places,小数位长度
  10. BinaryField(Field)
  11. - 二进制类型

其他

1.2 字段参数

  1. null 数据库中字段是否可以为空
  2. db_column 数据库中字段的列名
  3. default 数据库中字段的默认值
  4. primary_key 数据库中字段是否为主键
  5. db_index 数据库中字段是否可以建立索引
  6. unique 数据库中字段是否可以建立唯一索引
  7. unique_for_date 数据库中字段【日期】部分是否可以建立唯一索引
  8. unique_for_month 数据库中字段【月】部分是否可以建立唯一索引
  9. unique_for_year 数据库中字段【年】部分是否可以建立唯一索引
  10.  
  11. verbose_name Admin中显示的字段名称
  12. blank Admin中是否允许用户输入为空
  13. editable Admin中是否可以编辑
  14. help_text Admin中该字段的提示信息
  15. choices Admin中显示选择框的内容,用不变动的数据放在内存中从而避免跨表操作
  16. 如:gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1)
  17.  
  18. error_messages 自定义错误信息(字典类型),从而定制想要显示的错误信息;
  19. 字典健:null, blank, invalid, invalid_choice, unique, and unique_for_date
  20. 如:{'null': "不能为空.", 'invalid': '格式错误'}
  21.  
  22. validators 自定义错误验证(列表类型),从而定制想要的验证规则
  23. from django.core.validators import RegexValidator
  24. from django.core.validators import EmailValidator,URLValidator,DecimalValidator,\
  25. MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator
  26. 如:
  27. test = models.CharField(
  28. max_length=32,
  29. error_messages={
  30. 'c1': '优先错信息1',
  31. 'c2': '优先错信息2',
  32. 'c3': '优先错信息3',
  33. },
  34. validators=[
  35. RegexValidator(regex='root_\d+', message='错误了', code='c1'),
  36. RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'),
  37. EmailValidator(message='又错误了', code='c3'), ]
  38. )

字段参数

1.3 ORM基本操作

  1. 1. models.Tb1.objects.create(c1='xx', c2='oo') 增加一条数据,可以接受字典类型数据 **kwargs
  2.  
  3. 2. obj = models.Tb1(c1='xx', c2='oo')
  4. obj.save()

  1. models.Tb1.objects.filter(name='seven').delete() # 删除指定条件的数据

  1. 1. models.Tb1.objects.filter(name='seven').update(gender='') # 将指定条件的数据更新,均支持 **kwargs
  2.  
  3. 2.obj = models.Tb1.objects.get(id=1)#修改单条数据
  4. obj.c1 = ''
  5. obj.save()

  1. 1. models.Tb1.objects.get(id=123)
  2. # 获取单条数据,不存在则报错(不建议)
  3. 2. models.Tb1.objects.all() # 获取全部
  4. 3. models.Tb1.objects.filter(name='cc') # 获取指定条件的数据
  5. 4. models.Tb1.objects.exclude(name='cc') # 获取指定条件的数据

1.4 ORM进阶操作

  1. 1. 获取个数
  2. models.Tb1.objects.filter(name='seven').count()
  3.  
  4. 2. 大于,小于
  5. models.Tb1.objects.filter(id__gt=1) # 获取id大于1的值
  6. models.Tb1.objects.filter(id__gte=1) # 获取id大于等于1的值
  7. models.Tb1.objects.filter(id__lt=10) # 获取id小于10的值
  8. models.Tb1.objects.filter(id__lte=10) # 获取id小于10的值
  9. models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值
  10.  
  11. 3. in
  12. models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据
  13. models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in
  14.  
  15. 4. isnull #是否为空
  16. Entry.objects.filter(pub_date__isnull=True)
  17.  
  18. 5. contains #包含 等同sql语句like操作
  19. models.Tb1.objects.filter(name__contains="ven")
  20. models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
  21. models.Tb1.objects.exclude(name__icontains="ven")
  22.  
  23. 6. range
  24. models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and
  25.  
  26. 7. 其他类似 开头、结尾
  27. startswithistartswith, endswith, iendswith,
  28.  
  29. 8. order by #排序
  30. 可写多值,优先第一个值排序
  31. models.Tb1.objects.filter(name='seven').order_by('id') # asc 从小到大
  32. models.Tb1.objects.filter(name='seven').order_by('-id',) # desc 从大到下
  33.  
  34. 9. group by #分组
  35. from django.db.models import Count, Min, Max, Sum
  36. models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num')) #根据id分组,并获取每组个数,可加Min,Max,Sum
  37. SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id" #等同于这句
  38.  
  39. 10.limit offset #分页
  40. models.Tb1.objects.all()[10:20]
  41.  
  42. 11. regex正则匹配,iregex 不区分大小写
  43. Entry.objects.get(title__regex=r'^(An?|The) +')
  44. Entry.objects.get(title__iregex=r'^(an?|the) +')
  45.  
  46. 12. date #时间
  47. Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1)) #pub_date__date根据日期查询,不包含时、分
  48. Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))
  49.  
  50. 13. year
  51. Entry.objects.filter(pub_date__year=2005)
  52. Entry.objects.filter(pub_date__year__gte=2005)
  53.  
  54. 14. month
  55. Entry.objects.filter(pub_date__month=12)
  56. Entry.objects.filter(pub_date__month__gte=6)
  57.  
  58. 15. day
  59. Entry.objects.filter(pub_date__day=3)
  60. Entry.objects.filter(pub_date__day__gte=3)
  61.  
  62. 16. week_day
  63. Entry.objects.filter(pub_date__week_day=2)
  64. Entry.objects.filter(pub_date__week_day__gte=2)
  65.  
  66. 17. hour
  67. Event.objects.filter(timestamp__hour=23)
  68. Event.objects.filter(time__hour=5)
  69. Event.objects.filter(timestamp__hour__gte=12)
  70.  
  71. 18. minute
  72. Event.objects.filter(timestamp__minute=29)
  73. Event.objects.filter(time__minute=46)
  74. Event.objects.filter(timestamp__minute__gte=29)
  75.  
  76. 19. second
  77. Event.objects.filter(timestamp__second=31)
  78. Event.objects.filter(time__second=2)
  79. Event.objects.filter(timestamp__second__gte=31)

进阶操作

1.5 ORM高级操作

  1. # extra
  2. extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
  3. Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
  4. Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
  5. Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
  6. Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])
  7.  
  8. # F
  9. from django.db.models import F
  10. models.Tb1.objects.update(num=F('num')+1)
  11.  
  12. # Q
  13. 方式一:
  14. Q(nid__gt=10)
  15. Q(nid=8) | Q(nid__gt=10)
  16. Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
  17. # 方式二:
  18. con = Q()
  19. q1 = Q()
  20. q1.connector = 'OR'
  21. q1.children.append(('id', 1))
  22. q1.children.append(('id', 10))
  23. q1.children.append(('id', 9))
  24. q2 = Q()
  25. q2.connector = 'OR'
  26. q2.children.append(('c1', 1))
  27. q2.children.append(('c1', 10))
  28. q2.children.append(('c1', 9))
  29. con.add(q1, 'AND')
  30. con.add(q2, 'AND')
  31. models.Tb1.objects.filter(con)
  32.  
  33. # 执行原生SQL
  34. from django.db import connection, connections
  35. cursor = connection.cursor() # cursor = connections['default'].cursor()
  36. cursor.execute("""SELECT * from auth_user where id = %s""", [1])
  37. row = cursor.fetchone()

orm高级操作

1.6 ORM其他操作

  1. ##################################################################
  2. # PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET #
  3. ##################################################################
  4.  
  5. def all(self)
  6. # 获取所有的数据对象
  7.  
  8. def filter(self, *args, **kwargs)
  9. # 条件查询
  10. # 条件可以是:参数,字典,Q
  11.  
  12. def exclude(self, *args, **kwargs)
  13. # 条件查询
  14. # 条件可以是:参数,字典,Q
  15.  
  16. def select_related(self, *fields)
  17. 性能相关:表之间进行join连表操作,一次性获取关联的数据。
  18. model.tb.objects.all().select_related()
  19. model.tb.objects.all().select_related('外键字段')
  20. model.tb.objects.all().select_related('外键字段__外键字段')
  21.  
  22. def prefetch_related(self, *lookups)
  23. 性能相关:多表连表操作时速度会慢,使用其执行多次SQL查询在Python代码中实现连表操作。
  24. # 获取所有用户表
  25. # 获取用户类型表where id in (用户表中的查到的所有用户ID)
  26. models.UserInfo.objects.prefetch_related('外键字段')
  27.  
  28. from django.db.models import Count, Case, When, IntegerField
  29. Article.objects.annotate(
  30. numviews=Count(Case(
  31. When(readership__what_time__lt=treshold, then=1),
  32. output_field=CharField(),
  33. ))
  34. )
  35.  
  36. students = Student.objects.all().annotate(num_excused_absences=models.Sum(
  37. models.Case(
  38. models.When(absence__type='Excused', then=1),
  39. default=0,
  40. output_field=models.IntegerField()
  41. )))
  42.  
  43. def annotate(self, *args, **kwargs)
  44. # 用于实现聚合group by查询
  45.  
  46. from django.db.models import Count, Avg, Max, Min, Sum
  47.  
  48. v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id'))
  49. # SELECT u_id, COUNT(ui) AS `uid` FROM UserInfo GROUP BY u_id
  50.  
  51. v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')).filter(uid__gt=1)
  52. # SELECT u_id, COUNT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1
  53.  
  54. v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id',distinct=True)).filter(uid__gt=1)
  55. # SELECT u_id, COUNT( DISTINCT ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1
  56.  
  57. def distinct(self, *field_names)
  58. # 用于distinct去重
  59. models.UserInfo.objects.values('nid').distinct()
  60. # select distinct nid from userinfo
  61.  
  62. 注:只有在PostgreSQL中才能使用distinct进行去重
  63.  
  64. def order_by(self, *field_names)
  65. # 用于排序
  66. models.UserInfo.objects.all().order_by('-id','age')
  67.  
  68. def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
  69. # 构造额外的查询条件或者映射,如:子查询
  70.  
  71. Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
  72. Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
  73. Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
  74. Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])
  75.  
  76. def reverse(self):
  77. # 倒序
  78. models.UserInfo.objects.all().order_by('-nid').reverse()
  79. # 注:如果存在order_by,reverse则是倒序,如果多个排序则一一倒序
  80.  
  81. def defer(self, *fields):
  82. models.UserInfo.objects.defer('username','id')

  83. models.UserInfo.objects.filter(...).defer('username','id')
  84. #映射中排除某列数据
  85.  
  86. def only(self, *fields):
  87. #仅取某个表中的数据
  88. models.UserInfo.objects.only('username','id')

  89. models.UserInfo.objects.filter(...).only('username','id')
  90.  
  91. def using(self, alias):
  92. 指定使用的数据库,参数为别名(setting中的设置)
  93.  
  94. ##################################################
  95. # PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS #
  96. ##################################################
  97.  
  98. def raw(self, raw_query, params=None, translations=None, using=None):
  99. # 执行原生SQL
  100. models.UserInfo.objects.raw('select * from userinfo')
  101.  
  102. # 如果SQL是其他表时,必须将名字设置为当前UserInfo对象的主键列名
  103. models.UserInfo.objects.raw('select id as nid from 其他表')
  104.  
  105. # 为原生SQL设置参数
  106. models.UserInfo.objects.raw('select id as nid from userinfo where nid>%s', params=[12,])
  107.  
  108. # 将获取的到列名转换为指定列名
  109. name_map = {'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'}
  110. Person.objects.raw('SELECT * FROM some_other_table', translations=name_map)
  111.  
  112. # 指定数据库
  113. models.UserInfo.objects.raw('select * from userinfo', using="default")
  114.  
  115. ################### 原生SQL ###################
  116. from django.db import connection, connections
  117. cursor = connection.cursor() # cursor = connections['default'].cursor()
  118. cursor.execute("""SELECT * from auth_user where id = %s""", [1])
  119. row = cursor.fetchone() # fetchall()/fetchmany(..)
  120.  
  121. def values(self, *fields):
  122. # 获取每行数据为字典格式
  123.  
  124. def values_list(self, *fields, **kwargs):
  125. # 获取每行数据为元祖
  126.  
  127. def dates(self, field_name, kind, order='ASC'):
  128. # 根据时间进行某一部分进行去重查找并截取指定内容
  129. # kind只能是:"year"(年), "month"(年-月), "day"(年-月-日)
  130. # order只能是:"ASC" "DESC"
  131. # 并获取转换后的时间
  132. - year : 年-01-01
  133. - month: 年-月-01
  134. - day : 年-月-日
  135.  
  136. models.DatePlus.objects.dates('ctime','day','DESC')
  137.  
  138. def datetimes(self, field_name, kind, order='ASC', tzinfo=None):
  139. # 根据时间进行某一部分进行去重查找并截取指定内容,将时间转换为指定时区时间
  140. # kind只能是 "year", "month", "day", "hour", "minute", "second"
  141. # order只能是:"ASC" "DESC"
  142. # tzinfo时区对象
  143. models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.UTC)
  144. models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai'))
  145.  
  146. """
  147. pip3 install pytz
  148. import pytz
  149. pytz.all_timezones
  150. pytz.timezone(‘Asia/Shanghai’)
  151. """
  152.  
  153. def none(self):
  154. # 空QuerySet对象
  155.  
  156. ####################################
  157. # METHODS THAT DO DATABASE QUERIES #
  158. ####################################
  159.  
  160. def aggregate(self, *args, **kwargs):
  161. # 聚合函数,获取字典类型聚合结果
  162. from django.db.models import Count, Avg, Max, Min, Sum
  163. result = models.UserInfo.objects.aggregate(k=Count('u_id', distinct=True), n=Count('nid'))
  164. ===> {'k': 3, 'n': 4}
  165.  
  166. def count(self):
  167. # 获取个数
  168.  
  169. def get(self, *args, **kwargs):
  170. # 获取单个对象
  171.  
  172. def create(self, **kwargs):
  173. # 创建对象
  174.  
  175. def bulk_create(self, objs, batch_size=None):
  176. # 批量插入
  177. # batch_size表示一次插入的个数
  178. objs = [
  179. models.DDD(name='r11'),
  180. models.DDD(name='r22')
  181. ]
  182. models.DDD.objects.bulk_create(objs, 10)
  183.  
  184. def get_or_create(self, defaults=None, **kwargs):
  185. # 如果存在,则获取,否则,创建
  186. # defaults 指定创建时,其他字段的值
  187. obj, created = models.UserInfo.objects.get_or_create(username='root1', defaults={'email': '','u_id': 2, 't_id': 2})
  188.  
  189. def update_or_create(self, defaults=None, **kwargs):
  190. # 如果存在,则更新,否则,创建
  191. # defaults 指定创建时或更新时的其他字段
  192. obj, created = models.UserInfo.objects.update_or_create(username='root1', defaults={'email': '','u_id': 2, 't_id': 1})
  193.  
  194. def first(self):
  195. # 获取第一个
  196.  
  197. def last(self):
  198. # 获取最后一个
  199.  
  200. def in_bulk(self, id_list=None):
  201. # 根据主键ID进行查找
  202. id_list = [11,21,31]
  203. models.DDD.objects.in_bulk(id_list)
  204.  
  205. def delete(self):
  206. # 删除
  207.  
  208. def update(self, **kwargs):
  209. # 更新
  210.  
  211. def exists(self):
  212. # 是否有结果

其他操作

1.7 数据表定制

  1. class UserInfo(models.Model):
  2. nid = models.AutoField(primary_key=True)
  3. username = models.CharField(max_length=32)
  4. pwd = models.CharField(max_length=32
  5. class Meta:
  6. # 数据库中生成的表名称 默认 app名称 + 下划线 + 类名
  7. db_table = "table_name"
  8.  
  9. # 联合索引
  10. index_together = [ ("username", "pwd"), ]
  11.  
  12. # 联合唯一索引
  13. unique_together = (("driver", "restaurant"),)
  14. # admin中显示的表名称 verbose_name
  15. # 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

  1. ForeignKey(ForeignObject) # ForeignObject(RelatedField)
  2. to, # 要进行关联的表名
  3. to_field=None, # 要关联的表中的字段名称
  4. on_delete=None, # 当删除关联表中的数据时,当前表与其关联的行的行为
  5. - models.CASCADE,删除关联数据,与之关联也删除
  6. - models.DO_NOTHING,删除关联数据,引发错误IntegrityError
  7. - models.PROTECT,删除关联数据,引发错误ProtectedError
  8. - models.SET_NULL,删除关联数据,与之关联的值设置为null(前提FK字段需要设置为可空)
  9. - models.SET_DEFAULT,删除关联数据,与之关联的值设置为默认值(前提FK字段需要设置默认值)
  10. - models.SET,删除关联数据,
  11. a. 与之关联的值设置为指定值,设置:models.SET(值)
  12. b. 与之关联的值设置为可执行对象的返回值,设置:models.SET(可执行对象)
  13.  
  14. def func():
  15. return 10
  16.  
  17. class MyModel(models.Model):
  18. user = models.ForeignKey(
  19. to="User",
  20. to_field="id"
  21. on_delete=models.SET(func),)
  22. related_name=None, # 反向操作时,使用的字段名,用于代替 【表名_set】 如: obj.表名_set.all()
  23. related_query_name=None, # 反向操作时,使用的连接前缀,用于替换【表名】 如: models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
  24. limit_choices_to=None, # 在Admin或ModelForm中显示关联数据时,提供的条件:
  25. # 如:
  26. - limit_choices_to={'nid__gt': 5}
  27. - limit_choices_to=lambda : {'nid__gt': 5}
  28.  
  29. from django.db.models import Q
  30. - limit_choices_to=Q(nid__gt=10)
  31. - limit_choices_to=Q(nid=8) | Q(nid__gt=10)
  32. - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
  33. db_constraint=True # 是否在数据库中创建外键约束
  34. parent_link=False # 在Admin中是否显示关联数据

参数

关联表实例:

  1. class UserType(models.Model):
  2. name = models.CharField(max_length=32)
  3.  
  4. class User(models.Model):
  5. name = models.CharField(max_length=32)
  6. pwd = models.CharField(max_length=32)
  7. u_type = models.ForiegnKey(to="UserType", to_field='id',)

Django上删除指定数据及其关联数据:

  1. models.UserType.objects.filter(id=1).delete()

Django可通过对关联表进行定制,根据不同的程序环境,对删除关联表时做相应的设置,下面就介绍都有哪些参数 设置

① models.CASCADE 删除关联数据,与之关联也删除;

  1. u_type=models.ForiegnKey(to="UserType",to_field='id',on_delete=models.CASCADE)

② models.SET() 删除关联数据,与之关联的值设置为指定值(可以是函数);

  1. u_type = models.ForiegnKey(to="UserType",to_field='id',on_delete=models.SET(10))

1.8.2 外键关联OneToOneField

一对一操作:

  1. OneToOneField(ForeignKey)
  2. to, # 要进行关联的表名
  3. to_field=None # 要关联的表中的字段名称
  4. on_delete=None, # 当删除关联表中的数据时,当前表与其关联的行的行为
  5.  
  6. ###### 对于一对一 ######
  7. # 1. 一对一其实就是 一对多 + 唯一索引
  8. # 2.当两个类之间有继承关系时,默认会创建一个一对一字段
  9. # 如下会在A表中额外增加一个c_ptr_id列且唯一:
  10. class C(models.Model):
  11. nid = models.AutoField(primary_key=True)
  12. part = models.CharField(max_length=12)
  13.  
  14. class A(C):
  15. id = models.AutoField(primary_key=True)
  16. code = models.CharField(max_length=1)

一对一操作

1.8.3 外键关联ManyToManyField

多对多操作参数:

  1. ManyToManyField(RelatedField)
  2. to, # 要进行关联的表名
  3. related_name=None, # 反向操作时,使用的字段名,用于代替 【表名_set】 如: obj.表名_set.all()
  4. related_query_name=None, # 反向操作时,使用的连接前缀,用于替换【表名】 如: models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
  5. limit_choices_to=None, # 在Admin或ModelForm中显示关联数据时,提供的条件:
  6. # 如:
  7. - limit_choices_to={'nid__gt': 5}
  8. - limit_choices_to=lambda : {'nid__gt': 5}
  9.  
  10. from django.db.models import Q
  11. - limit_choices_to=Q(nid__gt=10)
  12. - limit_choices_to=Q(nid=8) | Q(nid__gt=10)
  13. - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
  14. symmetrical=None, # 仅用于多对多自关联时,symmetrical用于指定内部是否创建反向操作的字段
  15. # 做如下操作时,不同的symmetrical会有不同的可选字段
  16. models.BB.objects.filter(...)
  17.  
  18. # 可选字段有:code, id, m1
  19. class BB(models.Model):
  20.  
  21. code = models.CharField(max_length=12)
  22. m1 = models.ManyToManyField('self',symmetrical=True)
  23.  
  24. # 可选字段有: bb, code, id, m1
  25. class BB(models.Model):
  26.  
  27. code = models.CharField(max_length=12)
  28. m1 = models.ManyToManyField('self',symmetrical=False)
  29.  
  30. through=None, # 自定义第三张表时,使用字段用于指定关系表
  31. through_fields=None, # 自定义第三张表时,使用字段用于指定关系表中那些字段做多对多关系表
  32. from django.db import models
  33.  
  34. class Person(models.Model):
  35. name = models.CharField(max_length=50)
  36.  
  37. class Group(models.Model):
  38. name = models.CharField(max_length=128)
  39. members = models.ManyToManyField(
  40. Person,
  41. through='Membership',
  42. through_fields=('group', 'person'),
  43. )
  44.  
  45. class Membership(models.Model):
  46. group = models.ForeignKey(Group, on_delete=models.CASCADE)
  47. person = models.ForeignKey(Person, on_delete=models.CASCADE)
  48. inviter = models.ForeignKey(
  49. Person,
  50. on_delete=models.CASCADE,
  51. related_name="membership_invites",
  52. )
  53. invite_reason = models.CharField(max_length=64)
  54. db_constraint=True, # 是否在数据库中创建外键约束
  55. db_table=None, # 默认创建第三张表时,数据库中表的名称

多对多

多对多操作:

  1. a. django创建第三张表及操作
  2. m2m.remove
  3. m2m.add
  4. m2m.set
  5. m2m.clear
  6. m2m.filter()
  7. b. 自定义第三张表(无m2m字段)
  8. 自己连表查询
  9.  
  10. c. 自定义第三张表(有m2m字段)
  11. # 通过m2m字段查操作
  12. # 通过m2m字段 clear

自定义第三张表:

  1. class Blog(models.Model):
  2. site = models.CharField(max_length=32)
  3. # 不指定through时 会生成4张表
  4. # through 通过B2T表进行ManyToMany
  5. # through_fields B2T表中那几个字段进行MangyToMany
  6. m = models.ManyToManyField('Tag',through='B2T',through_fields=['b','t'])
  7.  
  8. class Tag(models.Model):
  9. name = models.CharField(max_length=32)
  10.  
  11. class B2T(models.Model):
  12. b = models.ForeignKey('Blog')
  13. t = models.ForeignKey('Tag')

1.9 性能调优(*****)

表数据:

  1. from django.db import models
  2.  
  3. class UserType(models.Model):
  4. name = models.CharField(max_length=32)
  5.  
  6. class User(models.Model):
  7. user = models.CharField(max_length=32)
  8. pwd = models.CharField(max_length=32)
  9. ut = models.ForeignKey(to='UserType',
  10. to_field='id',
  11. related_name='b',
  12. related_query_name='a',
  13. limit_choices_to={'id__gt':1})

1)普通查询:

  1. from app01 import models
  2. def index(request):
  3. # 假设有用户10
  4. users = models.User.objects.all() #发起一次查询操作,不包含关联表内容
  5. for row in users:
  6. print(row.user,row.pwd,row.ut_id) #打印row中包含内容
  7. print(row.ut.name) #第一次请求row中不包含UserType表内容,此时会再发一次请求
  8.  
  9. return HttpResponse('OK')

缺点:之前我们用到的查询方法如上,这种查询方法操作简单,但是很影响性能;每次执行print(row.ut.name)时,都会向数据库发起一次请求查询,假设一共10个用户,上述执行操作会向数据库发起11次查询;假如有多个外键字段打印的话,效率就更低了

2)效率高的方法values():

  1. # values() 字典形式
  2. from app01 import models
  3. def index(request):
  4. users = models.User.objects.all().values('user','pwd','ut_id','name') #发起一次查询操作,包含所有内容
  5. for row in users:
  6. print(row.user,row.pwd,row.ut_id)
  7. print(row.ut.name) #包含ut.name内容不用再次发起查询
  8.  
  9. return HttpResponse('OK')

缺点:valuse方法确实是比all()效率高了,也是最简单的方法;但是values查询出来的数据是字典形式,而不是QuerySet,QuerySet中的很多方法都不在能使用;所以也不是最佳的解决方法;

3)连表查询select_related():

  1. select_related主要针一对一和多对一关系进行优化;

  2. select_related使用SQL的JOIN语句进行优化,通过减少SQL查询的次数来进行优化、提高性能;

  1. users = models.User.objects.all().select_related('ut')
  2. for row in users:
  3. print(row.user,row.pwd,row.ut_id)
  4. print(row.ut.name)
  5. print(row.tu.name) # 再发起一次SQL请求

缺点:上述操作解决了vaules()的问题,一次查询即可完成操作;但是,select_related()用到的是连表操作,如果关联数据表多个的话,也会非常的影响性能;连表查询速度慢

4)多次查询连表prefetch_related():

  1. prefetch_related主要针一对多和多对多关系进行优化。

  2. prefetch_related通过分别获取各个表的内容,然后用Python处理他们之间的关系来进行优化。

  1. # prefetch_related() 执行多次SQL查询在Python代码中实现连表操作
  2. from app01 import models
  3. def index(request):
  4. # 非连表查询
  5. users = models.User.objects.filter(id__gt=30).prefetch_related('ut') #第一查询id>30的User表内容包含ut_id,根据
  6. #ut_id再次查询UserType表查询 没有连表操作
  7. # select * from users where id > 30 第一次请求
  8. # 获取上一步骤中所有的ut_id=[1,2]
  9. # select * from user_type where id in [1,2] 第二次请求
  10. for row in users:
  11. print(row.user,row.pwd,row.ut_id)
  12. print(row.ut.name) #拼接两次查询到的数据
  13.  
  14. return HttpResponse('OK')

优点:Django操作优化的最优选择,执行两次操作,避免低效率的连表操作;

总结:

  1. 因为select_related()总是在单次SQL查询中解决问题,而prefetch_related()会对每个相关表进行SQL查询,因此select_related()的效率通常比后者高。

  2. 鉴于第一条,尽可能的用select_related()解决问题。只有在select_related()不能解决问题的时候再去想prefetch_related()。

  3. 你可以在一个QuerySet中同时使用select_related()和prefetch_related(),从而减少SQL查询的次数。

  4. 只有prefetch_related()之前的select_related()是有效的,之后的将会被无视掉。

2. Modelform操作

web框架-(七)Django补充---models进阶操作及modelform操作的更多相关文章

  1. Python开发【第二十二篇】:Web框架之Django【进阶】

    Python开发[第二十二篇]:Web框架之Django[进阶]   猛击这里:http://www.cnblogs.com/wupeiqi/articles/5246483.html 博客园 首页 ...

  2. Python开发【第十八篇】Web框架之Django【基础篇】

    一.简介 Python下有许多款不同的 Web 框架,Django 是重量级选手中最有代表性的一位,许多成功的网站和APP都基于 Django. Django 是一个开放源代码的Web应用框架,由 P ...

  3. 两个Python web框架:Django & Tornado比较

    就是说它作为 web 框架比 Django 简单,又支援异步 IO,且更不需要前端的 webserver ? 我已经混乱了, Tornado是 Nginx.Django.Node.js 的结合体?又或 ...

  4. Python开发【第二十一篇】:Web框架之Django【基础】

    Python开发[第二十一篇]:Web框架之Django[基础]   猛击这里:http://www.cnblogs.com/wupeiqi/articles/5237704.html Python之 ...

  5. Web框架之Django_01初识(三大主流web框架、Django安装、Django项目创建方式及其相关配置、Django基础三件套:HttpResponse、render、redirect)

    摘要: Web框架概述 Django简介 Django项目创建 Django基础必备三件套(HttpResponse.render.redirect) 一.Web框架概述: Python三大主流Web ...

  6. python笔记-19 javascript补充、web框架、django基础

    一.JavaScript的补充 1 正则表达式 1.1 test的使用 test 测试是否符合条件 返回true or false 1.2 exec的使用 exec 从字符串中截取匹配的字符 1.3 ...

  7. Django 之models进阶操作

    到目前为止,当我们的程序涉及到数据库相关操作时,我们一般都会这么搞: 创建数据库,设计表结构和字段 使用 MySQLdb 来连接数据库,并编写数据访问层代码 业务逻辑层去调用数据访问层执行数据库操作 ...

  8. Django 补充models操作,中间件, 缓存,信号,分页

    1.Model 一对多 补充 models如下: class UserType(models.Model): caption = models.CharField(max_length=16) cla ...

  9. web框架开发-Django模型层(2)-多表操作

    很重要,都是精华 多表关系模型 一对一 一旦确定表关系是一对一,在两张表中的任意一张表中建立关联字段+Unique 一对多 一旦确定表关系是一对多,创建关联字段在多的表中 多对多 一旦确定表关系是多对 ...

随机推荐

  1. 集成ShareSdk一键分享和第三方登录

    在Mob官网http://mob.com/注册,创建应用,下载SDK,申请APP_key 根据官网开发指南导入SDK到你的项目中: 在assets/ShareSDk.xml中修改你的APP_key p ...

  2. no CUDA-capable device is detected,或者GPU is lost

    出现以下问题,程序只能运行一次,而且每运行一次显卡就不见了,出现以下情况,只能重启才可以再次检测到: 最后解决: 我本来安装的是cuda9.0 但是(下面显示是10):  起初是因为说他表示最高可以到 ...

  3. [SQL]数据库常用语句

    1.使用旧表创建新表 SELECT * INTO CC FROM AA ; (适用于版本SQL SERVER)

  4. MYSQL5.6二进制包的安装

    二进制1. 下载包 wget http://mirrors.sohu.com/mysql/MySQL-5.6/mysql-5.6.26-linux-glibc2.5-x86_64.tar.gz2. 解 ...

  5. IDEA/Git 提交/commit 忽略 文件夹

    commit的时候.idea文件夹被默认选中了,如果忘记点掉就会被提交上去,想要默认忽略其实很简单. 找到项目根目录处的.gitignore文件(如果是用git版本控制的话) 双击打开之后  我们在最 ...

  6. Web前端学习书籍

    <Head First HTML5 Programming> 介绍如何利用HTML5来搭建Web应用,包含JavaScript内容. <CSS禅意花园>: 不是入门的书籍,对C ...

  7. MyBatis框架原理1:构建SqlSessionFactory的过程

    SqlSessionFactoryBuilder 首先创建了一个SqlSessionFactoryBuilder对象,然后调用该对象的build方法加载全局XML配置的流文件构建出一个SqlSessi ...

  8. Hibernate——简单的增、删、改、查操作

    思路: 1.导入hibernate jar包 2.导入mysql jar包 3.创建数据库 4.创建java实体类 5.编写hibernate.cfg.xml配置文件 6.编写dao类 目录: 数据表 ...

  9. USACO1.6 Superprime Rib

    题目传送门 每一个特殊质数都会被从右边切掉,所以除了首位外的其它位数一定都不会是偶数,只能是$1$,$3$,$5$,$7$,$9$ 而每一个特殊质数的首位一定是质数,也就是$2$,$3$,$5$,$7 ...

  10. 虚拟机 编辑器 vi使用方法详细介绍

    vi编辑器是所有Unix及Linux系统下标准的编辑器,它的强大不逊色于任何最新的文本编辑器,这里只是简单地介绍一下它的用法和一小部分指令.由于对Unix及Linux系统的任何版本,vi编辑器是完全相 ...