54-1 django-Models
对象关系映射（Object Relation Mapping，ORM），通过将“对象”和“数据库中的表”建立映射关系，将数据库中的“sql操作”转化为面向对象语言中的“对象操作”。
主要好处是：便于在不同DBMS间迁移，其次还可避免不熟悉sql的写sql语句带来的性能问题（当然若精通sql，用原生sql性能更好）。
不足之处是：目前对于个别复杂查询，ORM仍然力不从心，为了解决这个问题，ORM一般也支持写raw sql。
LOGGING = { 'version': 1, 'disable_existing_loggers': False, 'handlers': { 'console':{ 'level':'DEBUG', 'class':'logging.StreamHandler', }, }, 'loggers': { 'django.db.backends': { 'handlers': ['console'], 'propagate': True, 'level':'DEBUG', }, } }
一、数据库配置
django默认支持sqlite，mysql, oracle,postgresql数据库。
主要配置步骤：
- 环境准备：安装相应的数据库驱动
- django参数配置：setting中配置app和database
- 在models中写好类代码，执行makemigrations和makemigrate
1、sqlite
django默认使用sqlite的数据库。
使用步骤：
（1）pycharm的database窗口中：添加 --> DataSource --> Sqlite(Xerial) 查看并安装sqlite驱动
（2）setting中
① INSTALLED_APPS 下加入当前的app
② DATABASES 配置为：
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
}
（3）models写好数据库操作代码
（4）terminal中进行makemigrations和makemigrate
python manage.py makemigrations # 在当前应用的migrations文件夹下生成本次数据库操作的初始化文件 python manage.py migrate # 执行初始化文件，真正完成对数据库的操作
2、mysql
（1）pycharm的database窗口中：添加 --> DataSource -->mysql 查看并安装mysql驱动
- 安装pymysql
- 安装mysqlclient驱动
（2）setting中
① INSTALLED_APPS 下加入当前的app
② DATABASES 配置为：
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'regent', # 数据库名称
'USER': 'sa', # 数据库用户名
'PASSWORD': 'Abc456', # 数据库密码
'HOST': '192.168.3.33', # 数据库主机，留空默认为localhost
'PORT': '1433', # 数据库端口
}
}
因为django默认你导入的驱动是MySQLdb，可是MySQLdb对于py3有很大问题，所以我们需要的驱动是PyMySQL。所以，我们只需要找到项目名文件下的__init__,在里面写入：
import pymysql pymysql.install_as_MySQLdb()
二、数据库的模式操作
1、三种关系
- 一对一：实质就是给外键列再加了一个 UNIQUE=True 的属性；
- 一对多：就是主外键关系；（foreign key）
- 多对多：(ManyToManyField) 自动创建第三张表(当然我们也可以自己创建第三张表：两个foreign key)
书籍/作者/出版商示例数据库结构：
- 作者模型：一个作者有姓名。
- 作者详细模型：把作者的详情放到详情表，包含性别，email地址和出生日期，作者详情模型和作者模型之间是一对一的关系（one－to－one）（类似于每个人和他的身份证之间的关系），在大多数情况下我们没有必要将他们拆分成两张表，这里只是引出一对一的概念。
- 出版商模型：出版商有名称，地址，所在城市，省，国家和网站。
- 书籍模型：书籍有书名、出版日期、价格、作者（一本书可能会有多个作者，一个作者也可以写多本书，所以作者和书籍是 may-to-many关系）、出版社（一本书只应该由一个出版商出版，所以出版商和书籍是 one－to－many关系）。
2、model中类的写法示例
每个数据模型（类）都是django.db.models.Model的子类，它的父类Model包含了所有必要的和数据库交互的方法。并提供了一个简介漂亮的定义数据库字段的语法。每个模型相当于单个数据库表（多对多关系例外，会多生成一张关系表），每个属性也是这个表中的字段。属性名就是字段名，它的类型（例如CharField）相当于数据库的字段类型（例如varchar）。
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 Author(models.Model):
name = models.CharField(max_length=30)
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) # 多对多.系统给自动创建一个新表，实现多对多关系。在Book表中不增加新字段
publisher = models.ForeignKey(Publisher) # 一对多，也可以写为 models.ForeignKey("Publisher")。系统自动给Book表加个publiser_id列。FK字段代指关联表中的一行数据（一个对象）
publication_date = models.DateField()
price=models.DecimalField(max_digits=5, decimal_places=2, default=10)
3、常用的字段类型
<1> AutoField # int自增列. # 你通常不需要直接使用这个字段,因为当model中如果没有自定义主键，则自动会创建一个列名为id的列作为主键 # 自定义一个主键：my_id=models.AutoField(primary_key=True) # 示例： class 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) <2> BigAutoField(AutoField) # bigint自增列，必须填入参数 primary_key=True <3> CharField # 字符类型, 用于较短的字符串. # 必须提供参数 maxlength, max_length表示字符长度 <4> EmailField # 字符串类型，Django Admin以及ModelForm中提供验证机制,不接受 maxlength 参数. <5> URLField # 字符串类型，Django Admin以及ModelForm中提供验证 URL # 若 verify_exists 参数为 True (默认), 给定的 URL 会预先检查是否存在 <6> SlugField # 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号） # "Slug" 是一个报纸术语. slug 是某个东西的小小标记(短签), 只包含字母,数字,下划线和连字符.#它们通常用于URLs <7> UUIDField(Field) # 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证 <8> TextField # 文本类型 <9> XMLField #一个校验值是否为合法XML的 TextField,必须提供参数: schema_path, 它是一个用来校验文本的 RelaxNG schema #的文件系统路径. <10> IPAddressField # 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制 <11> 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" <12> CommaSeparatedIntegerField # 字符串类型，格式必须为逗号分割的数字 <13> IntegerField # 整数列(有符号的) -2147483648 ～ 2147483647 <14> PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField) # 正整数 0 ～ 2147483647 <15> SmallIntegerField(IntegerField): # 小整数 -32768 ～ 32767 <16> PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField) # 正小整数 0 ～ 32767 <17> BigIntegerField(IntegerField): # 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807 <18> FloatField # 一个浮点数. 必须 提供两个参数: # # 参数 描述 # max_digits 总位数(不包括小数点和符号) # decimal_places 小数位数 # 示例： # 要保存最大值为 999 (小数点后保存2位),你要这样定义字段: # models.FloatField(..., max_digits=5, decimal_places=2) # admin 用一个文本框(<input type="text">)表示该字段保存的数据. <19> DecimalField(Field) # 10进制小数 # 参数： max_digits，小数总长度 decimal_places，小数位长度 <20> BooleanField # 布尔值类型 <21> NullBooleanField # 类似 BooleanField, 不过允许 NULL 作为其中一个选项. 推荐使用这个字段而不要用 BooleanField 加 null=True 选项 # admin 用一个选择框 <select> (三个可选择的值: "Unknown", "Yes" 和 "No" ) 来表示这种字段数据. <22> FileField # 字符串，路径保存在数据库，文件上传到指定目录 # 参数： upload_to = "" 上传文件的保存路径 storage = None 存储组件，默认django.core.files.storage.FileSystemStorage <23> ImageField # 字符串，路径保存在数据库，文件上传到指定目录 # 参数： upload_to = "" 上传文件的保存路径 storage = None 存储组件，默认django.core.files.storage.FileSystemStorage width_field=None, 上传图片的高度保存的数据库字段名（字符串） height_field=None 上传图片的宽度保存的数据库字段名（字符串） # 注意：在一个 model 中使用 FileField 或 ImageField 需要以下步骤: #（1）在你的 settings 文件中, 定义一个完整路径给 MEDIA_ROOT 以便让 Django在此处保存上传文件. # (出于性能考虑,这些文件并不保存到数据库.) 定义MEDIA_URL 作为该目录的公共 URL. 要确保该目录对 # WEB服务器用户帐号是可写的. #（2）在你的 model 中添加 FileField 或 ImageField, 并确保定义了 upload_to 选项,以告诉 Django # 使用 MEDIA_ROOT 的哪个子目录保存上传文件.你的数据库中要保存的只是文件的路径(相对于MEDIA_ROOT). # 出于习惯你一定很想使用 Django 提供的 get_<#fieldname>_url 函数.举例来说,如果你的 ImageField # 叫作 mug_shot, 你就可以在模板中以 {{ object.#get_mug_shot_url }} 这样的方式得到图像的绝对路径. <24> FilePathField # 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能 # 参数： path, 文件夹路径 match=None, 正则匹配 recursive=False, 递归下面的文件夹 allow_files=True, 允许文件 allow_folders=False, 允许文件夹 <25> DateTimeField(DateField) # 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] <26> DateField(DateTimeCheckMixin, Field) # 日期格式 YYYY-MM-DD <27> TimeField(DateTimeCheckMixin, Field) # 时间格式 HH:MM[:ss[.uuuuuu]] <28>DurationField(Field) # 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型 <29>BinaryField(Field) # 二进制类型
（1）实际上每个字段都是由数据库中的数据类型+封装的正则表达式规则组成：
# 自定义无符号整数字段 class UnsignedIntegerField(models.IntegerField): def db_type(self, connection): return 'integer UNSIGNED' PS: 返回值为字段在数据库中的属性，Django字段默认的值为： 'AutoField': 'integer AUTO_INCREMENT', 'BigAutoField': 'bigint AUTO_INCREMENT', 'BinaryField': 'longblob', 'BooleanField': 'bool', 'CharField': 'varchar(%(max_length)s)', 'CommaSeparatedIntegerField': 'varchar(%(max_length)s)', 'DateField': 'date', 'DateTimeField': 'datetime', 'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)', 'DurationField': 'bigint', 'FileField': 'varchar(%(max_length)s)', 'FilePathField': 'varchar(%(max_length)s)', 'FloatField': 'double precision', 'IntegerField': 'integer', 'BigIntegerField': 'bigint', 'IPAddressField': 'char(15)', 'GenericIPAddressField': 'char(39)', 'NullBooleanField': 'bool', 'OneToOneField': 'integer', 'PositiveIntegerField': 'integer UNSIGNED', 'PositiveSmallIntegerField': 'smallint UNSIGNED', 'SlugField': 'varchar(%(max_length)s)', 'SmallIntegerField': 'smallint', 'TextField': 'longtext', 'TimeField': 'time', 'UUIDField': 'char(32)',
（2）Field通用的参数：
--------------数据库中生效的------------------------------- null 数据库中字段值是否可以为空 db_column 自定义数据库中字段的列名 default 数据库中字段的默认值 primary_key 主键索引，数据库中字段是否为主键，若为True，则建立唯一索引，且值不能为空 unique 唯一索引，数据库中字段是否可以建立唯一索引，若True，值可以为空，但空只能出现一次 db_index 普通索引，数据库中字段是否建立索引。仅有索引提升查询速度的基本功能，没有任何约束 unique_for_date 数据库中字段【日期】部分是否可以建立唯一索引 unique_for_month 数据库中字段【月】部分是否可以建立唯一索引 unique_for_year 数据库中字段【年】部分是否可以建立唯一索引 ----------------Admin中生效的------------------------------- verbose_name Admin中显示的字段名称 blank Admin中是否允许用户输入为空 editable Admin中是否可以编辑。False时不可编辑，此时直接就隐藏不显示了 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'), ] )
4、特殊字段
OneToOneField、ForeignKey、ManyToMany
ForeignKey(ForeignObject) # ForeignObject(RelatedField) to, # 要进行关联的表名，如：to='Publiser',常直接简写为要关联的表名'Publiser' to_field=None, # 要关联的表中的字段名称，省略时，会默认设置为要关联的表的主键 on_delete=None, # 当删除关联表（即一对多关系中，"一"端的表）中的数据时，当前表（即"多"端的表）与其关联的行的行为 （django 2.0后，必须写on_delete参数，否则报错） - 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】 # 如：related_name='b', 则反向操作时用obj.b.all()代替obj.表名_set.all() related_query_name=None, # 反向操作时，使用的连接前缀，用于替换【小写的表名】 # 如：related_query_name='b',则反向操作时用obj.b_set.all()代替obj.表名_set.all() limit_choices_to=None, # 在Admin或ModelForm中显示关联数据时，提供的筛选条件： # 如： - limit_choices_to={'nid__gt': 5} #只把nid大于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 # 是否在数据库中创建外键约束，False取消外键约束，此列可随意非外键数据，但外键功能依然在 parent_link=False # 在Admin中是否显示关联数据 ----------------------------------------------------------------------------------------------------------------------------- OneToOneField(ForeignKey) # 继承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) ----------------------------------------------------------------------------------------------------------------------------- ManyToManyField(RelatedField) to, # 要进行关联的表名 related_name=None, # 反向操作时，使用的字段名，用于代替 【小写的表名_set】 related_query_name=None, # 反向操作时，使用的连接前缀，用于替换【小写的表名】 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, # 是否在数据库中创建外键约束 db_table=None, # 自动创建第三张表时，第三张表的表名 through=None, # 当不用ManyToManyField自动创建第三张表，而是自己写第三张表时，用于指定关系表 through_fields=None, # 自己写第三张表时，使用字段用于指定关系表中哪些字段做多对多关系表 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 # 可选字段多了一个bb class BB(models.Model): code = models.CharField(max_length=12) m1 = models.ManyToManyField('self',symmetrical=False)
特别地，多对多关系的第三张表可以自己手动创建，这样的好处是可以在第三张表中加入自己定义的其他列。
# 手动创建第三张表 from django.db import models class User(models.Model): username = models.CharField(max_length=32, db_index=True) class Tag(models.Model): title = models.CharField(max_length=16) class UserToTag(models.Model): nid = models.AutoField(primary_key=True) u = models.ForeignKey(to='User') t = models.ForeignKey(to='Tag') ctime = models.DateField() class Meta: unique_together=[ ('u','t'), # u与t联合唯一 ] # 手动+自动创建第三章表（不建议这样用，因为比较乱） # 好处是可以用ManyToMany的内置的查询功能（增删改等无法用），坏处是乱。 from django.db import models class User(models.Model): username = models.CharField(max_length=32, db_index=True) class Tag(models.Model): title = models.CharField(max_length=16) m = models.ManyToManyField( to='User', through='UserToTag', through_fields=['u','t'] ) class UserToTag(models.Model): nid = models.AutoField(primary_key=True) u = models.ForeignKey(to='User') t = models.ForeignKey(to='Tag') ctime = models.DateField() class Meta: unique_together=[ ('u','t'), ]
自关联
class User(models.Model): username = models.CharField(max_length=32,db_index=True) d = models.ManyToManyField('User',related_name='b') # 自关联一定要写上related_name，不然反向操作时会乱
三、数据库中的数据操作
1、增
（1）单表
① 方式一：用面向对象中的实例化对象的方法
因为数据库中的表对应ORM中的类，表中的记录对应ORM中的对象。所以可以通过对象实例化的方式，往数据库中添加记录。一条记录就是一个对象。
# 实例化对象的同时，传入对象的属性值 publisher = Publisher(name='南方出版社', address='001', city="武汉", state_province='湖北', country='中国', website='www.nf.com') publisher.save() # 注意：执行save后，才写入数据库 # 先实例化对象，再传入属性值 publisher = Publisher() publisher.name = "北大出版社" publisher.address = "002" publisher.city = "北京" publisher.state_province = "北京" publisher.country = "中国" publisher.website = "www.bd.com" publisher.save()
② 方式二：用ORM中的create方法
Publisher.objects.create(name='山东出版社', address='003', city='济南', state_province='山东', country='中国', website='www.sd.com')
在生产环境中传入参数时常用的写法：
dic = {"name": "上海出版社", "address": "004", "city": "上海", "state_province": "上海","country": "中国", "website": "www.sh.com"}
Publisher.objects.create(**dic) # 通过字典一次性传入
（2） 一对多关系的表
示例：一个出版社可以出版多本书，一本书是由唯一的一个出版社出版的。
① 方式一：直接对Book表中的publisher_id字段赋值（只是django中有这种写法），外键publisher在Book表中实际上存的是一个publisher_id。
Book.objects.create(title='linux运维', publication_date='2017-2-1', price=77, publisher_id='2')
② 方式二：先获取要绑定的Publisher对象publisher_obj，再将上例中的publisher_id='2'改为publisher=publisher_obj。
publisher_obj = Publisher.objects.get(id=3)
Book.objects.create(title='python基础', publication_date='2016-6-1', price=58, publisher=publisher_obj)
（3）多对多关系的表
示例：一本书可以由多个作者合著，一个作者可以写多本书。
因为这张多对多关系表在model中没有对应的类，所以对这张django自动生成的多对多关系表的操作是通过其所关联的表的操作来间接完成的。
# 正向添加
author1 = Author.objects.get(id=1)
author2 = Author.objects.get(id=3)
book = Book.objects.get(id=2)
book.authors.add(author1, author2) # 等价于： book.authors.add(*[author1,author2])
#还可以直接添加id：
book = Book.objects.get(id=2)
book.authors.add(1) # 将id=1的作者添加给此book对象，同时加多个作者 add（*[1,2,3]）
#反向添加
book1 = Book.objects.get(id=1)
book2 = Book.objects.get(id=2)
author = Author.objects.get(id=2)
author.book_set.add(book1, book2)
如果第三张表是自己创建的，可直接操作第三张表（通过models.ManyToManyField()自动创建的,添加方式仅上面一种）:
# 如果第三张表是自己创建的: class Book2Author(models.Model): author = models.ForeignKey("Author") Book = models.ForeignKey("Book") # 那么就还有一种方式就是自己直接往第三种表中插入数据: author_obj = models.Author.objects.filter(id=2)[0] book_obj = models.Book.objects.filter(id=3)[0] s=models.Book2Author.objects.create(author_id=1,Book_id=2) s.save() #或 s=models.Book2Author(author=author_obj,Book_id=1) s.save()
2、删
（1）修改删除模式
def delete(request):
Book.objects.get(id='1').delete()
return HttpResponse("删除成功!")
我们表面上删除了一条信息，实际上在其他表中也有可能有记录被同时删除，因为：Book表中既存在一对多关系（与Publiser），又存在多对多关系（与Author）。
- 当删除Book表的一条记录时，不会影响Publiser（因为Book表是此一对多关系中的“多”端）。
- 当删除Book表的一条记录时，会默认级联删除多对多关系中的所有和此记录相关的记录。
若删除的是一对多关系的“一”端呢？默认是级联删除“多”端的所有相关记录。这对于“书籍出版模型”而言是非常符合现实的，因为不可能存在没有出版社的书。但有些现实情况下，未必是这样，比如：
学生和班级间是一对多关系，一个学生只能在一个班级，而一个班级能有多个学生。当一个班级记录删除时可能意为着仅是此班级撤销，里面的学生可以处于暂时未分班状态，等待后续的分班。如果是这样，"多"端就不能被级联删除。设置如下：
可以在model中定义FK时（若是对已定义的进行修改，改完需重新migrations和migrate），对删除模式进行修改：
class Student(models.Model):
name = models.CharField(max_length=30)
age = models.IntegerField()
gender = models.BooleanField()
classes = models.ForeignKey("Classes", null=True, on_delete=models.SET_NULL) # 注意null=True必须有才可以on_delete=models.SET_NULL
（2）只删除除多对多关系表中的记录
def remove(request):
book_obj = Book.objects.get(id='2')
# 方式1：
# book_obj.authors.remove(2) # 删除book_author关系表中的第二条记录
# 方式2：
author_obj1 = Author.objects.get(id=1)
author_obj2 = Author.objects.get(id=3)
book_obj.authors.remove(*[author_obj1, author_obj2])
return HttpResponse("remove成功!")
def clear(request):
book_obj = Book.objects.get(id='2')
book_obj.authors.clear() # 删除book_author关系表中所有book_id为2的记录
return HttpResponse("clear成功!")
注意：也可以像添加多对多关系一样反向进行删除。
3、改
def update(request):
# 方式一：
# b = Book.objects.get(id=2)
# b.price = 100
# b.save()
# 方式二(推荐)：
Book.objects.filter(id='2').update(price='50') # update是queryset的方法，所以这里不能用get(id='2')
return HttpResponse("修改成功!")
注意：save()方法会更新一行里的所有列，而update方法仅更新需要更新的列，故update方法高效。
多对多关系修改：
book = Book.objects.get(id=1) book.authors.set([2, 5]) # 将此book对象的作者设置为id为2和5两个作者
内部处理时是先删除老的不需要了的关系，再新建新的没有的关系，老的和新的都有的关系不动。
4、查
（1）基础查询
①结果为：单个对象obj
book_obj = Book.objects.get(id=2) book_obj = Book.objects.first() # 等价于 Book.objects.all()[0] book_obj = Book.objects.last()
②结果为：QuerySet集合，其内部为obj
结果的形式为：[obj1, obj2, ... , objn]，QuerySet的元素为对象。
book_list = Book.objects.filter(price='50', publisher__name='山东出版社') # 所有price为50且出版社为“山东出版社”的书 book_list = Book.objects.exclude(price='50') # 所有price不为50的书 book_list = Book.objects.all()
<1> Django的queryset是惰性的 Publisher.objects.all()或者.filter()等都只是返回了一个QuerySet（查询结果集对象），它并不会马上执行sql，而是当调用QuerySet的时候才执行。 queryset是可迭代的、可切片的。 <2> 要真正从数据库获得数据，你可以遍历queryset或者使用if queryset,总之你用到数据时就会执行sql. 为了验证这些,需要在settings里加入 LOGGING(验证方式) obj=models.Book.objects.filter(id=3) # for i in obj: # print(i) # if obj: # print("ok") <3> queryset是具有cache的 当你遍历queryset时，所有匹配的记录会从数据库获取，然后转换成Django的model。这被称为执行 （evaluation）.这些model会保存在queryset内置的cache中，这样如果你再次遍历这个queryset， 你不需要重复运行通用的查询。 obj=models.Book.objects.filter(id=3) # for i in obj: # print(i) ## models.Book.objects.filter(id=3).update(title="GO") ## obj_new=models.Book.objects.filter(id=3) # for i in obj: # print(i) #LOGGING只会打印一次 <4> 简单的使用if语句进行判断也会完全执行整个queryset并且把数据放入cache，虽然你并不需要这些 数据！为了避免这个，可以用exists()方法来检查是否有数据： obj = Book.objects.filter(id=4) # exists()的检查可以避免数据放入queryset的cache。 if obj.exists(): print("hello world!") <5>当queryset非常巨大时，cache会成为问题 处理成千上万的记录时，将它们一次装入内存是很浪费的。更糟糕的是，巨大的queryset可能会锁住系统 进程，让你的程序濒临崩溃。要避免在遍历数据的同时产生queryset cache，可以使用iterator()方法 来获取数据，处理完数据就将其丢弃。 objs = Book.objects.all().iterator() # iterator()可以一次只从数据库获取少量数据，这样可以节省内存 for obj in objs: print(obj.name) #BUT,再次遍历没有打印,因为迭代器已经在上一次遍历(next)到最后一次了,没得遍历了 for obj in objs: print(obj.name) #当然，使用iterator()方法来防止生成cache，意味着遍历同一个queryset时会重复执行查询。所以使 #用iterator()的时候要当心，确保你的代码在操作一个大的queryset时没有重复执行查询 总结: queryset的cache是用于减少程序对数据库的查询，在通常的使用下会保证只有在需要的时候才会查询数据库。 使用exists()和iterator()方法可以优化程序对内存的使用。不过，由于它们并不会生成queryset cache，可能 会造成额外的数据库查询。
③结果为：只要对象的某些属性。返回QuerySet集合，内部为字典或元组。
book_list = Book.objects.filter(price='50').values("title", "price")
print(book_list) # QuerySet的元素为字典: <QuerySet [{'title': 'html', 'price': Decimal('50.00')}, {'title': 'css', 'price': Decimal('50.00')}]>
book_list = Book.objects.filter(price='50').values_list("title", "price")
print(book_list) # QuerySet的元素为元组: <QuerySet [('html', Decimal('50.00')), ('css', Decimal('50.00'))]>
（2）条件查询进阶
①一对多关系：一本书肯定是在一个出版社出版的，一个出版社可以出版多本书
查询id为3的书是由哪个出版社出版的，打印此出版设的名字：
book_obj=Book.objects.get(id='3') print(book_obj.publisher.name) # publisher是个对象，name是对象的一个属性
查询北大出版社所出书的名字和价格：
#思路一：对象形式的操作
pub_obj = Publisher.objects.get(name='北大出版社')
#方式1：正向获取（推荐）
book_list = Book.objects.filter(publisher=pub_obj).values('title', 'price') # 每本书各对应唯一的一个pub_obj对象
#方式2：反向获取（因为实际上Publiser表中，隐含的有个字段关联到Book表，此字段默认名为book_set）
book_list = pub_obj.book_set.values('title', 'price') # 每个出版社对应一个book_set集合。默认格式为："小写类名_set"，可在Book中定义FK时，通过related_name自定义。
#思路二：利用特殊的标识符“双下滑线”直接获取另一个表的属性值
book_list = Book.objects.filter(publisher__name='北大出版社') # 注意：在做filter条件时，publisher.name不能写点，而要写双下滑下，即 publiser__name
查询 linux 这本书的出版社名：
# 查询linux这本书的出版社名
# 写法1：
ret = Publisher.objects.filter(book__title="linux").values("name")
print(ret) # <QuerySet [{'name': '山东出版社'}]>
# 写法2：
ret = Book.objects.filter(title="linux").values("publisher__name")
print(ret) # <QuerySet [{'publisher__name': '山东出版社'}]> 注意:与上例返回结果的键名不同
查询所有在北京的出版社出过的书：
book_list = Book.objects.filter(publisher__city="北京").values("title", "price")
# 大于、小于 Book.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值 # in、not in Book.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据 Book.objects.exclude(id__in=[11, 22, 33]) # not in # 模糊查询 Book.objects.filter(name__contains="p") Book.objects.filter(name__icontains="p") # icontains大小写不敏感 # 范围 Book.objects.filter(id__range=[1, 2]) # 范围bettwen and # 其他 startswith，istartswith, endswith, iendswith # 跨两个或更多个表，多次应用双下滑线 stu_list = Student.objects.all().values("name","cs__title","cs__school__name")
②多对多关系：一个作者可以写多本书，一本书可以由多个作者所写
查询作者为 alex 的书名和价格（写法与一对多中的写法完全相同）：
book_list = Book.objects.filter(authors__name='alex').values("title","price")
查id为1的书是由哪些作者写的：
book = Book.objects.filter(id="1").first() authors = book.authors.all()
③F查询和Q查询
# F查询：使用查询条件的值,专门取对象中某列值的操作
from django.db.models import F
Book.objects.update(price=F('price')+20)
# Q查询：构建搜索条件
from django.db.models import Q
ret=Book.objects.filter(Q(title="java"), Q(price=60)) # 满足“且”的逻辑，等价于 Book.objects.filter(title="java",price=60)
ret=Book.objects.filter(Q(title="java") | Q(price=50)) # 满足“或”的逻辑
ret=Book.objects.filter(~Q(price=77)) # 满足“非”的逻辑
（3）对查询结果的处理
# 聚合函数
book_list = Book.objects.all().aggregate(Avg("price")) # 返回{'price__avg': 57.5} 键名是按字段和聚合函数的名称自动生成的，值是计算出来的聚合值
book_list = Book.objects.aggregate(average_price=Avg('price')) # 返回{'average_price': 57.5} 自定义聚合值得名称
book_list = Book.objects.aggregate(Avg('price'), Max('price')) # 返回{'price__avg': 57.5, 'price__max': Decimal('70.00')}
# 分组
# 查询每个作者所出书的总价
ret=Book.objects.values("authors__name").annotate(Sum("price")) # 返回<QuerySet [{'authors__name': 'alex', 'price__sum': Decimal('170.00')}, {'authors__name': 'alvin', 'price__sum': Decimal('60.00')}]>
# 每个出版社出的最便宜的书
ret= Publisher.objects.values("name").annotate(Min("book__price"))
# 排序
book_list = Book.objects.all().order_by('price') # 对查询结果由小到大排序
book_list = Book.objects.all().order_by('-price')reverse() # 对查询结果反向排序。结果与上面一次查询相同。符号表示反转一次，reverse再反转一次。reverse必须与order_by配合使用
# 去重
book_list = Book.objects.all().values("price").distinct() # 从返回结果中剔除重复纪录
# 计数
book_list = Book.objects.all().count() # 返回数据库中匹配查询(QuerySet)的对象数量
# 判断
book_list = Book.objects.filter(price='90').exists() # 如果QuerySet包含数据，就返回True，否则返回False
四、admin的配置
django admin是关于数据库的一个后台管理工具。在配置好ORM建立model后，admin能共从数据库中读取数据，呈现在页面中，并可对其进行管理。
1、创建用户
首次使用，需要先创建一个用户才能登录。在Terminal中执行如下命令：
python manage.py createsuperuser
用户建好登入进后台，再在后台建其他用户并给用户授权。
如果你觉得英文界面不好用，可以在setting.py 文件中修改以下选项：
LANGUAGE_CODE = 'en-us' #LANGUAGE_CODE = 'zh-hans'
2、注册到admin和深入定制admin
要在admin中管理自定义的表，需要先将自定义的表注册到admin。根据需要，可通过自定义类对admin进行深入定制。
from django.contrib import admin
from app01.models import *
# 自定义admin的功能和样式：
class MyAdmin(admin.ModelAdmin):
list_display = ("title", "price", "publisher") # 指定要显示的字段
search_fields = ("title", "publisher") # 指定搜索的字段
list_filter = ("publisher",) # 配置过滤器
ordering = ("price",) # 按price升序排列，-price是降序排列
# 将自己建的表注册到admin：
admin.site.register(Book, MyAdmin) # MyAdmin作为第二参数输入，自定义效果才生效
admin.site.register(Author)
admin.site.register(Publisher)
修改数据时 admin下拉列表不显示值，显示为object的处理：
在model中每个类中加入__str__函数：
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()
def __str__(self):
return self.name
参考：
http://www.cnblogs.com/yuanchenqi/articles/6083427.html
http://www.cnblogs.com/wupeiqi/articles/6216618.html
浙公网安备 33010602011771号