Django 二——models（admin、ORM），一对一、一对多、多对多操作，all、values、value_list的对比

时间：2023-03-09 15:09:33
Django 二——models（admin、ORM），一对一、一对多、多对多操作，all、values、value_list的对比

内容概要

1.关系对象映射ORM

2.admin的配置（选修）

3、all（）、values（）、value_list（）的对比

4、数据库操作（一对一、一对多、多对多）

5、HttpResponse和render的对比

1.关系对象映射ORM

一、用于实现面向对象编程语言里不同类型系统的数据之间的转换，换言之，就是用面向对象的方式去操作数据库的创建表以及增删改查等操作。

优点： 1 ORM使得我们的通用数据库交互变得简单易行，而且完全不用考虑该死的SQL语句。快速开发，由此而来。

2 可以避免一些新手程序猿写sql语句带来的性能问题。

缺点：1  性能有所牺牲，不过现在的各种ORM框架都在尝试各种方法，比如缓存，延迟加载登来减轻这个问题。效果很显著。

2  对于个别复杂查询，ORM仍然力不从心，为了解决这个问题，ORM一般也支持写raw sql。

3  通过QuerySet的query属性查询对应操作的sql语句

二、表(模型)的创建：

（1）、创建类，一个类指代一张表

（2）、创建字段，字段类型、长度、显示名称

一对一

一对多（外键）

多对多

（3）、生成同步数据库的脚本：python manage.py makemigrations

                               同步数据库:  python manage.py migrate

例：

from django.db import models

class Publisher(models.Model):

    name = models.CharField(max_length=30, verbose_name="名称")

    address = models.CharField("地址", max_length=50)

    city = models.CharField('城市',max_length=60)

    state_province = models.CharField(max_length=30)

    country = models.CharField(max_length=50)

    website = models.URLField()

    class Meta:

        verbose_name = '出版商'

        verbose_name_plural = verbose_name

    def __str__(self):

        return self.name

class Author(models.Model):

    name = models.CharField(max_length=30)

    def __str__(self):

        return self.name

class AuthorDetail(models.Model):

    sex = models.BooleanField(max_length=1, choices=((0, '男'),(1, '女'),))

    email = models.EmailField()

    address = models.CharField(max_length=50)

    birthday = models.DateField()

    author = models.OneToOneField(Author)

class Book(models.Model):

    title = models.CharField(max_length=100)

    authors = models.ManyToManyField(Author)

    publisher = models.ForeignKey(Publisher)

    publication_date = models.DateField()

    price=models.DecimalField(max_digits=5,decimal_places=2,default=10)

    def __str__(self):

        return self.title

　

三、模型常用的字段类型参数：

<1> CharField

        #字符串字段, 用于较短的字符串.

        #CharField 要求必须有一个参数 maxlength, 用于从数据库层和Django校验层限制该字段所允许的最大字符数.

<2> IntegerField

       #用于保存一个整数.

等等

四、Field重要参数

　　<1> null ： 数据库中字段是否可以为空

    <2> blank： django的 Admin 中添加数据时是否可允许空值

    <3> default：设定缺省值
等等

五、表的操作(增删改查)：

5.1、单表操作

--------基本操作：增删改查

1、增(create  ,  save)

from app01.models import *

    #create方式一:   Author.objects.create(name='Alvin')

    #create方式二:   Author.objects.create(**{"name":"alex"})

    #save方式一:     author=Author(name="alvin")

                    author.save()

    #save方式二:     author=Author()

                    author.name="alvin"

                    author.save()

2、删（delete）

Book.objects.filter(id=1).delete()

(3, {'app01.Book_authors': 2, 'app01.Book': 1})

3、改（update和save）

#---------------- update方法直接设定对应属性----------------

    models.Book.objects.filter(id=3).update(title="PHP")

#--------------- save方法会将所有属性重新设定一遍,效率低-----------

    obj=models.Book.objects.filter(id=3)[0]

    obj.title="Python"

    obj.save()

4、查（filter，value等)

查询相关API：

#  <1>filter(**kwargs):      它包含了与所给筛选条件相匹配的对象

#  <2>all():                 查询所有结果

#  <3>get(**kwargs):         返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。

#-----------下面的方法都是对查询的结果再进行处理:比如 objects.filter.values()--------

#  <4>values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列 model的实例化对象，而是一个可迭代的字典序列

#  <5>exclude(**kwargs):     它包含了与所给筛选条件不匹配的对象

#  <6>order_by(*field):      对查询结果排序

#  <7>reverse():             对查询结果反向排序

#  <8>distinct():            从返回结果中剔除重复纪录

　惰性机制：

所谓惰性机制：Publisher.objects.all()或者.filter()等都只是返回了一个QuerySet（查询结果集对象），它并不会马上执行sql，而是当调用QuerySet的时候才执行。

QuerySet特点：

<1>  可迭代的

<2>  可切片

--------进阶操作（双下划线）：大于、小于、in、contains、range、等

# 获取个数

        #

        # models.Tb1.objects.filter(name='seven').count()

        # 大于，小于

        #

        # 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的值

        # in

        #

        # models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据

        # models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in

        # isnull

        # Entry.objects.filter(pub_date__isnull=True)

        # contains

        #

        # models.Tb1.objects.filter(name__contains="ven")

        # models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感

        # models.Tb1.objects.exclude(name__icontains="ven")

        # range

        #

        # models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and

        # 其他类似

        #

        # startswith，istartswith, endswith, iendswith,

        # order by

        #

        # models.Tb1.objects.filter(name='seven').order_by('id')    # asc

        # models.Tb1.objects.filter(name='seven').order_by('-id')   # desc

        # group by

        #

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

        # models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))

        # SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"

        # limit 、offset

        #

        # models.Tb1.objects.all()[10:20]

        # regex正则匹配，iregex 不区分大小写

        #

        # Entry.objects.get(title__regex=r'^(An?|The) +')

        # Entry.objects.get(title__iregex=r'^(an?|the) +')

        # date

        #

        # Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))

        # Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))

        # year

        #

        # Entry.objects.filter(pub_date__year=2005)

        # Entry.objects.filter(pub_date__year__gte=2005)

        # month

        #

        # Entry.objects.filter(pub_date__month=12)

        # Entry.objects.filter(pub_date__month__gte=6)

        # day

        #

        # Entry.objects.filter(pub_date__day=3)

        # Entry.objects.filter(pub_date__day__gte=3)

        # week_day

        #

        # Entry.objects.filter(pub_date__week_day=2)

        # Entry.objects.filter(pub_date__week_day__gte=2)

        # hour

        #

        # Event.objects.filter(timestamp__hour=23)

        # Event.objects.filter(time__hour=5)

        # Event.objects.filter(timestamp__hour__gte=12)

        # minute

        #

        # Event.objects.filter(timestamp__minute=29)

        # Event.objects.filter(time__minute=46)

        # Event.objects.filter(timestamp__minute__gte=29)

        # second

        #

        # Event.objects.filter(timestamp__second=31)

        # Event.objects.filter(time__second=2)

        # Event.objects.filter(timestamp__second__gte=31)

进阶操作

--------其他操作：F、Q、原生SQL

# extra

    #

    # 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'])

    # F

    #

    # from django.db.models import F

    # models.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)

    # 执行原生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()

其他操作

　　

 5.2、联表操作（利用双下划线和 _set 将表之间的操作连接起来）：

　　  一对一

一对多   见博客第4点、

多对多   时见   http://www.cnblogs.com/tangtingmary/p/7994148.html    第12点。

2.admin的配置（选修）

　　admin是django强大功能之一，它能共从数据库中读取数据，呈现在页面中，进行管理。默认情况下，它的功能已经非常强大，如果你不需要复杂的功能，它已经够用，但是有时候，一些特殊的功能还需要定制，比如搜索功能，下面这一系列文章就逐步深入介绍如何定制适合自己的admin应用。

步骤：

1.在models中建几张表（类）

　　　　　　生成同步数据库的脚本：python manage.py makemigrations

                      同步数据库:  python manage.py migrate

注意：在开发过程中，数据库同步误操作之后，难免会遇到后面不能同步成功的情况，解决这个问题的一个简单粗暴方法是把migrations目录下

的脚本（除__init__.py之外）全部删掉，再把数据库删掉之后创建一个新的数据库，数据库同步操作再重新做一遍。

2.创建超级管理员：python manage.py createsuperuser，设置好用户名和密码后便可登录http://127.0.0.1:8080/admin/啦！

3.在app01的admin.py中进行配置

一  认识ModelAdmin

管理界面的定制类，如需扩展特定的model界面需从该类继承。

二 注册medel类到admin的两种方式：

<1>   使用register的方法

1
admin.site.register(Book,MyAdmin)

<2>   使用register的装饰器

1
@admin.register(Book)

三 掌握一些常用的设置技巧

  • list_display:     指定要显示的字段
  • search_fields:  指定搜索的字段
  • list_filter:        指定列表过滤器
  • ordering：       指定排序字段

实例：

from django.contrib import admin

from app01.models import *  #导入

# Register your models here.

admin.site.register(Author)#该语句用来注册

admin.site.register(Publisher)#该语句用来注册

class MyAdmin(admin.ModelAdmin):

    list_display = ("title","price","publisher")#定制显示哪些字段

    search_fields = ("title", "publisher")#搜索插件，可根据title和publisher来搜索

    list_filter = ("publisher",)#过滤器

    ordering = ("price",)#排序

    # fieldsets = [

    #     (None, {'fields': ['title']}),

    #     ('price information', {'fields': ['price', "publisher"], 'classes': ['collapse']}),

    # ]

admin.site.register(Book,MyAdmin)#该语句用来注册，且将MyAdmin与Book绑定

3、all（）、values（）、value_list（）的对比

一对多操作：
　　获取所有的学生--------获取DB数据

class Classes(models.Model):

	caption = models.CharField(max_length=32)

class Student(models.Model):

	name = models.CharField(max_length=32)

	email = models.CharField(max_length=32,null=True)

	cls = models.ForeignKey('Classes')

　原理讲解：

.all()
result = models.Student.object.all()

# QuerySet类型, select * from ....

# [obj,obj,obj,]，Django内部有一个模块，可以转换

# obj.name, obj.email, obj.cls_id, obj.cls.id, obj.cls.caption
.all().values（）
result = models.Student.object.all().values('id','name','email', 'cls_id', 'cls__id', 'cls__caption')

# QuerySet, select id.. from ...

# list(result)  -> QuerySet -> list， json.dumps()

# [ {'id': 1, 'name': ...,},{'id': 1, 'name': ...,},{'id': 1, 'name': ...,},{'id': 1, 'name': ...,} ]

　　

.all().value_list（）
result = models.Student.object.all().value_list('id','name','email', 'cls_id', 'cls__id', 'cls__caption')

# QuerySet, select id.. from ...

# list(result)  -> QuerySet -> list， json.dumps()

# [ (1,'root'..),(1,'root'..),(1,'root'..),(1,'root'..),(1,'root'..) ]

　　

# PS: QuerySet,无法直接使用json.dumps()序列化
# QuerySet
　　- Django内部有一个模块，可以转换
　　- values, value_list, 转换成 list(result)， json.dumps

获取数据：三种形式
请求数据：form(url)，ajax

all（）、values（）、value_list（）-------------------在模版语言显示数据(URL,Form表单的形式）

def index(request):

	result = models.Student.object.all()

	return render(request, 'index.html', {'reuslt': result})

{% for item in result%}

	{{item.id}} - {{item.name}} - {{item.cls.id}} - {{item.cls.caption}}

{% endfor %}

　　

def index(request):

	result = models.Student.object.all().values('id','name','email', 'cls_id', 'cls__id', 'cls__caption')

	# [ {'id': 1, 'name': ...,},{'id': 1, 'name': ...,},{'id': 1, 'name': ...,},{'id': 1, 'name': ...,} ]

	return render(request, 'index.html', {'reuslt': result})

{% for item in result%}

	{{item.id}} - {{item.name}} - {{item.cls__id}} - {{item.cls__caption}}

{% endfor %}

　　

def index(request):

	result = models.Student.object.all().value_list('id','name','email', 'cls_id', 'cls__id', 'cls__caption')

	# QuerySet, select id.. from ...

	# list(result)  -> QuerySet -> list， json.dumps()

	# [ (1,'root'..),(1,'root'..),(1,'root'..),(1,'root'..),(1,'root'..) ]

	return render(request, 'index.html', {'reuslt': result})

{% for item in result%}

	{{item.0}} - {{item.1}} - {{item.4}} - {{item.5}}

{% endfor %}

　　

- Ajax请求

a.

	$(function(){

		   $.ajax...

	})

b.

	def index(request):

		result = models.Student.object.all()

		# Django内部序列化工具

		result = Django内部序列化工具

		return HttpResponse(result)

	def index(request):

		result = models.Student.object.all().values('id','name','email', 'cls_id', 'cls__id', 'cls__caption')

		result = list(result)

		result_str = json.dumps(result)

		return HttpResponse(result_str)

	def index(request):

		result = models.Student.object.all().value_list('id','name','email', 'cls_id', 'cls__id', 'cls__caption')

		result = list(result)

		result_str = json.dumps(result)

		return HttpResponse(result_str)

c.

	$.each(function(){

		# 构建html标签

		# 将标签添加到HTML指定位置

	})

4、数据库操作（一对一、一对多、多对多）

　　- 单表操作

- all

- filter   （过滤）内部也可以放字典

	models.tb.objects.filter(id=123)

	dic = {'id': 123, 'age__gt': 3}

	models.tb.objects.filter(**dic)

- count

- order_by

...

　　- 一对多

1.（ForeignKey时，默认和主键id进行关联，也可以自定义nid（必须时唯一的unique=True）进行关联）
如：models.ForeignKey("Province", to_filed='nid')自定义和Province的nid进行关联

省

# id     name

  1      河北

  2      广东

  3      山东

class Province(models.Model):

	name = models.CharField(max_length=32,)

	# nid = models.Intergar(unique=True) # 唯一

市				  省

# id     name      pro

   1     东莞       2

   2     深圳       2

   3     惠州       2

   4     河源       2

   5     泰安       3

   6     青岛       3

   7     济南       3

   8     张家口     1

   9     邢台       1

class City(models.Model):

	name = models.CharField(max_length=32)

	pro = models.ForeignKey("Province", to_filed='id')（外键列，在数据库创建时的名称，自动会是pro_id，即【列名_id】)

---------------------------------------------------------------------

1、 正向查找（基于市查省份表，foreignkey在city里）	（_ _id）

	result = models.City.objects.all()

	result[0].pro.name	跨表查询

	models.City.objects.all().values('id','name','pro_id','pro__id','pro__name')	内部为字典#'pro__id','pro__name'是关联表里面的id和name

	models.City.objects.all().values_list('id','name','pro_id','pro__id','pro__name')	内部为元祖

2、反向查找	（_set）

	result = models.Province.objects.values('id','name', 'city__name')

	result = models.Province.objects.all()

	result[0]                  #  获取河北

	result[0].city_set.all()   #  获取河北下的所有市 张家口 、邢台

	for pro in result:

		a1 = pro.id

		a2 = pro.name

		a3 = pro.city_set.all()

		print(a1,a2,a3)

	=====> 多对多即使基于一对多来构造

　　

　　-多对多（自己创建关系表或Django默认帮我们创建）

class Book(models.Model):

    name =models.CharField(max_length=32)

class Author(models.Model):

    name = models.CharField(max_length=32)

    m = models.ManyToManyField('Book')

　　

1.自己创建第三张表（后续操作方便）：

	class Book(models.Model):

		name = ..

	class Author(models.Model):

		name = ..

	class A_to_B(models.Model): #这种方式就不能使用Django自带的clear、remove等方法

		bid = ForeignKey(Book)

		aid = ForeignKey(Author)

	====> 所有操作：化简为 单表操作 和 一对多操作

2.默认生成第三张表

	只能间接对第三张表进行操作（因为没有第三张表的类）

	# 正向查找

	# obj,人，金鑫

	# obj = models.Author.objects.get(id=1)

	#

	# # 金鑫所有的著作全部获取到

	# obj.m.all()

	# 反向查找

	# 金品买

	# obj = models.Book.objects.get(id=1)

	# # 金鑫，吴超

	# obj.author_set.all()

	# 10

	# author_list = models.Author.objects.all()

	# for author in author_list:

	#     print(author.name,author.m.all())

	# author_list = models.Author.objects.values('id','name','m', "m__name")

	# for item in author_list:

	#     print(item['id'],item['name'],'书籍ID:',item['m'],item['m__name'])

	# 添加

	# obj = models.Author.objects.get(id=1)

	# 第三张表中增加一个对应关系

	# 增加

	# obj.m.add(5)

	# obj.m.add(5,6)

	# obj.m.add(*[4,5])

	# 删除

	# obj.m.remove(5)

	# obj.m.remove(5,6)

	# obj.m.remove(*[5,6])

	# 清空

	# obj.m.clear()

	# 更新

	# obj.m.set([1,2,3])

	# 反向操作

	# obj = models.Book.objects.get(id=1)

	# obj.author_set.add(1)

	# obj.author_set.add(1,2,3,4)

	# ... 

补充：

select_related 和 prefetch_related 函数优化查询

1. select_related()

对于一对一字段（OneToOneField）和外键字段（ForeignKey），可以使用select_related 来对QuerySet进行优化

作用和方法

在对QuerySet使用select_related()函数后，Django会获取相应外键对应的对象，从而在之后需要的时候不必再查询数据库了。以上例说明，如果我们需要打印数据库中的所有市及其所属省份，最直接的做法是：

>>> citys = City.objects.all()

>>> for c in citys:

...   print c.province

...  

这样会导致线性的SQL查询，如果对象数量n太多，每个对象中有k个外键字段的话，就会导致n*k+1次SQL查询。在本例中，因为有3个city对象就导致了4次SQL查询。

--------------------------------------------

如果我们使用select_related()函数：

>>> citys = City.objects.select_related().all()

>>> for c in citys:

...   print c.province

...  

就只有一次SQL查询，显然大大减少了SQL查询的次数：

这里我们可以看到，Django使用了INNER JOIN来获得省份的信息。

小结

1.select_related主要针一对一和多对一关系进行优化。
2.select_related使用SQL的JOIN语句进行优化，通过减少SQL查询的次数来进行优化、提高性能。
3.可以通过可变长参数指定需要select_related的字段名。也可以通过使用双下划线“__”连接字段名来实现指定的递归查询。没有指定的字段不会缓存，没有指定的深度不会缓存，如果要访问的话Django会再次进行SQL查询。
4.也可以通过depth参数指定递归的深度，Django会自动缓存指定深度内所有的字段。如果要访问指定深度外的字段，Django会再次进行SQL查询。
5.也接受无参数的调用，Django会尽可能深的递归查询所有的字段。但注意有Django递归的限制和性能的浪费。
6.Django >= 1.7，链式调用的select_related相当于使用可变长参数。Django < 1.7，链式调用会导致前边的select_related失效，只保留最后一个。

2. prefetch_related()

对于多对多字段（ManyToManyField）和一对多字段，可以使用prefetch_related()来进行优化。或许你会说，没有一个叫OneToManyField的东西啊。实际上 ，ForeignKey就是一个多对一的字段，而被ForeignKey关联的字段就是一对多字段了。

作用和方法

prefetch_related()和select_related()的设计目的很相似，都是为了减少SQL查询的数量，但是实现的方式不一样。后者是通过JOIN语句，在SQL查询内解决问题。但是对于多对多关系，使用SQL语句解决就显得有些不太明智，因为JOIN得到的表将会很长，会导致SQL语句运行时间的增加和内存占用的增加。若有n个对象，每个对象的多对多字段对应Mi条，就会生成Σ(n)Mi 行的结果表。prefetch_related()的解决方法是，分别查询每个表，然后用Python处理他们之间的关系。继续以上边的例子进行说明，如果我们要获得张三所有去过的城市，使用prefetch_related()应该是这么做：

最佳实践：

1.prefetch_related主要针一对多和多对多关系进行优化。
2.prefetch_related通过分别获取各个表的内容，然后用Python处理他们之间的关系来进行优化。
3.可以通过可变长参数指定需要select_related的字段名。指定方式和特征与select_related是相同的。
4.在Django >= 1.7可以通过Prefetch对象来实现复杂查询，但低版本的Django好像只能自己实现。
5.作为prefetch_related的参数，Prefetch对象和字符串可以混用。
6.prefetch_related的链式调用会将对应的prefetch添加进去，而非替换，似乎没有基于不同版本上区别。
7.可以通过传入None来清空之前的prefetch_related。

小结

  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()是有效的，之后的将会被无视掉。

5、HttpResponse和render的对比

HttpResponse，传入的数据，直接返回给用户

render(request,'a.html', {'k':123})
　　1、找到html模版，open函数打开获取到内存
　　2、Django的模版引擎： html模版的内容 + 数据 => 渲染（替换） ===》 最终字符串
　　3、HttpResponse(最终字符串)

6、补充

a.
def index(request):
　　request.POST.get('k')
　　# checkbox--name相同,、select（多选时）可用getlist
　　request.POST.getlist('k')

b.模板语言里面（.html）调用方法不需要加括号

　

参考博客：

http://www.cnblogs.com/wupeiqi/articles/5246483.html

http://www.cnblogs.com/yuanchenqi/articles/6083427.html