ORM增删改查

小程序：扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序

orm（对象关系映射）

对象是指 orm的models类名实例化的对象

关系是指 orm中的数据模型和数据库的关系

类----------------》表 #models.py中的类对应数据库中的表
对象--------------》记录(数据行) #obj=models.User.objects.get(id=1) obj对应数据库表中的行数据
属性--------------》字段 #models.py类中的属性对应数据库表中的字段


映射 orm其实就是将models.类名.object.filter类对象的语法通过orm翻译翻译成sql语句的一个引擎

字段介绍

'''<1> CharField
字符串字段, 用于较短的字符串.
CharField 要求必须有一个参数 maxlength, 用于从数据库层和Django校验层限制该字段所允许的最大字符数.<2> IntegerField
#用于保存一个整数.<3> DecimalField
一个浮点数. 必须 提供两个参数: 参数 描述
max_digits 总位数(不包括小数点和符号)
decimal_places 小数位数
举例来说, 要保存最大值为 999 (小数点后保存2位),你要这样定义字段: models.DecimalField(..., max_digits=5, decimal_places=2)
要保存最大值一百万(小数点后保存10位)的话,你要这样定义: models.DecimalField(..., max_digits=17, decimal_places=10) #max_digits大于等于17就能存储百万以上的数了
admin 用一个文本框(<input type="text">)表示该字段保存的数据.<4> AutoField
一个 IntegerField, 添加记录时它会自动增长. 你通常不需要直接使用这个字段;
自定义一个主键：my_id=models.AutoField(primary_key=True)
如果你不指定主键的话,系统会自动添加一个主键字段到你的 model.<5> BooleanField
A true/false field. admin 用 checkbox 来表示此类字段.<6> TextField
一个容量很大的文本字段.
admin 用一个 <textarea> (文本区域)表示该字段数据.(一个多行编辑框).<7> EmailField
一个带有检查Email合法性的 CharField,不接受 maxlength 参数.<8> DateField
一个日期字段. 共有下列额外的可选参数:
Argument 描述
auto_now 当对象被保存时(更新或者添加都行),自动将该字段的值设置为当前时间.通常用于表示 "last-modified" 时间戳.
auto_now_add 当对象首次被创建时,自动将该字段的值设置为当前时间.通常用于表示对象创建时间.
（仅仅在admin中有意义...)<9> DateTimeField
一个日期时间字段. 类似 DateField 支持同样的附加选项.<10> ImageField
类似 FileField, 不过要校验上传对象是否是一个合法图片.#它有两个可选参数:height_field和width_field,
如果提供这两个参数,则图片将按提供的高度和宽度规格保存.
<11> FileField
一个文件上传字段.
要求一个必须有的参数: upload_to, 一个用于保存上载文件的本地文件系统路径. 这个路径必须包含 strftime #formatting,
该格式将被上载文件的 date/time
替换(so that uploaded files don't fill up the given directory).
admin 用一个<input type="file">部件表示该字段保存的数据(一个文件上传部件) . 注意：在一个 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 }} 这样的方式得到图像的绝对路径.<12> URLField
用于保存 URL. 若 verify_exists 参数为 True (默认), 给定的 URL 会预先检查是否存在( 即URL是否被有效装入且
没有返回404响应).
admin 用一个 <input type="text"> 文本框表示该字段保存的数据(一个单行编辑框)<13> NullBooleanField
类似 BooleanField, 不过允许 NULL 作为其中一个选项. 推荐使用这个字段而不要用 BooleanField 加 null=True 选项
admin 用一个选择框 <select> (三个可选择的值: "Unknown", "Yes" 和 "No" ) 来表示这种字段数据.<14> SlugField
"Slug" 是一个报纸术语. slug 是某个东西的小小标记(短签), 只包含字母,数字,下划线和连字符.#它们通常用于URLs
若你使用 Django 开发版本,你可以指定 maxlength. 若 maxlength 未指定, Django 会使用默认长度: 50. #在
以前的 Django 版本,没有任何办法改变50 这个长度.
这暗示了 db_index=True.
它接受一个额外的参数: prepopulate_from, which is a list of fields from which to auto-#populate
the slug, via JavaScript,in the object's admin form: models.SlugField
(prepopulate_from=("pre_name", "name"))prepopulate_from 不接受 DateTimeFields.<13> XMLField
一个校验值是否为合法XML的 TextField,必须提供参数: schema_path, 它是一个用来校验文本的 RelaxNG schema #的文件系统路径.<14> FilePathField
可选项目为某个特定目录下的文件名. 支持三个特殊的参数, 其中第一个是必须提供的.
参数 描述
path 必需参数. 一个目录的绝对文件系统路径. FilePathField 据此得到可选项目.
Example: "/home/images".
match 可选参数. 一个正则表达式, 作为一个字符串, FilePathField 将使用它过滤文件名.
注意这个正则表达式只会应用到 base filename 而不是
路径全名. Example: "foo.*\.txt^", 将匹配文件 foo23.txt 却不匹配 bar.txt 或 foo23.gif.
recursive可选参数.要么 True 要么 False. 默认值是 False. 是否包括 path 下面的全部子目录.
这三个参数可以同时使用.
match 仅应用于 base filename, 而不是路径全名. 那么,这个例子:
FilePathField(path="/home/images", match="foo.*", recursive=True)
...会匹配 /home/images/foo.gif 而不匹配 /home/images/foo/bar.gif<15> IPAddressField
一个字符串形式的 IP 地址, (i.e. "24.124.1.30").
<16> CommaSeparatedIntegerField
用于存放逗号分隔的整数值. 类似 CharField, 必须要有maxlength参数.'''


属性介绍

(1)null如果为True，Django 将用NULL 来在数据库中存储空值。 默认值是 False.(1)blank如果为True，该字段允许不填。默认为False。
要注意，这与 null 不同。null纯粹是数据库范畴的，而 blank 是数据验证范畴的。
如果一个字段的blank=True，表单的验证将允许该字段是空值。如果字段的blank=False，该字段就是必填的。(2)default字段的默认值。可以是一个值或者可调用对象。如果可调用 ，每有新对象被创建它都会被调用，如果你的字段没有设置可以为空，那么将来如果我们后添加一个字段，这个字段就要给一个default值(3)primary_key如果为True，那么这个字段就是模型的主键。如果你没有指定任何一个字段的primary_key=True，
Django 就会自动添加一个IntegerField字段做为主键，所以除非你想覆盖默认的主键行为，
否则没必要设置任何一个字段的primary_key=True。(4)unique如果该值设置为 True, 这个数据字段的值在整张表中必须是唯一的(5)choices
由二元组组成的一个可迭代对象（例如，列表或元组），用来给字段提供选择项。 如果设置了choices ，默认的表单将是一个选择框而不是标准的文本框，<br>而且这个选择框的选项就是choices 中的选项。
(6)db_index
如果db_index=True 则代表着为此字段设置数据库索引。DatetimeField、DateField、TimeField这个三个时间字段，都可以设置如下属性。(7)auto_now_add
配置auto_now_add=True，创建数据记录的时候会把当前时间添加到数据库。(8)auto_now
配置上auto_now=True，每次更新数据记录的时候会更新该字段，标识这条记录最后一次的修改时间。


1.MVC或者MVC框架中包括一个重要的部分，就是ORM，它实现了数据模型与数据库的解耦，即数据模型的设计不需要依赖于特定的数据库，通过简单的配置就可以轻松更换数据库，这极大的减轻了开发人员的工作量

2.ORM是“对象-关系-映射”的简称。

3.执行流程

​类对象--->sql--->pymysql--->mysql服务端--->磁盘

​orm其实就是将类对象的语法翻译成sql语句的一个引擎

​orm语句 -- sql -- 调用pymysql客户端发送sql -- mysql服务端接收到指令并执行

django 连接mysql顺序

1 settings配置文件中

DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql', # 引擎
'NAME': 'day53',# 数据库名称
'HOST': '127.0.0.1',# IP
'PORT': 3306,# 端口号
'USER': 'root',# 用户名
'PASSWORD': '123'# 密码
}
}


2 项目文件夹下的init文件中写上下面内容，

​作用：用pymysql替换mysqldb（djnago自带的）

mysqldb 不能python3.4以上的版本

需要使用第三方模块pymysql进行替换

app01中的--init--文件

补充

MySQLdb的是一个接口连接到MySQL数据库服务器从Python
MySQLdb并不支持Python3.4之后版本


原因：
#python默认连接的MySQLdb并不支持Python3.4之后版本
解决办法：
#12使用第三方模块pymysql进行替换
import pymysql
pymysql.install_as_MySQLdb()

3 models文件中创建一个类（类名就是表名）

#引用一个模块 from django.db import models
class UserInfo(models.Model):
id = models.AutoField(primary_key=True)
name = models.CharField(max_length=10)
bday = models.DateField()
checked = models.BooleanField()
# 1 翻译成sql语句
# 2 django内置的一个sqlite客户端将sql语句发给sqlite服务端
# 3 服务端拿到sql,到磁盘里面进行了数据操作(create table app01_userinfo(id name...))


4.执行数据库同步指令,

添加字段的时候别忘了,该字段不能为空,所有要么给默认值,要么设置它允许为空 null=True

#注意在每次增加字段时候都需要执行一遍这个方法
python manage.py makemigrations#创建一个表记录
python版本号
python manage.py migrate 执行记录


数据库问题mysql 更改时区和改变版本号mysql for 5.1

更改时区连接 https://www.cnblogs.com/strawberry-1/p/11599376.html

5 创建记录

(实例一个对象,调用save方法)

models.py

#创建一条记录,增
def query(request):
new_obj = models.UserInfo(
id=2,
name='子文',
bday='2019-09-27',
checked=1, )
new_obj.save()
#翻译成sql语句,
#然后调用pymysql,发送给服务端
相当于执行insert into app01_userinfo values(2,'子文','2019-09-27',1) return HttpResponse('xxx')


6.字段约束

通过选项实现对字段的约束，选项如下：null：如果为True，表示允许为空，默认值是False。
blank：如果为True，则该字段允许为空白，默认值是False。
对比：null是数据库范畴的概念，blank是表单验证证范畴的。
db_column：字段的名称，如果未指定，则使用属性的名称。
db_index：若值为True, 则在表中会为此字段创建索引，默认值是False。
default：默认值。
primary_key：若为True，则该字段会成为模型的主键字段，默认值是False，一般作为AutoField的选项使用。
unique：如果为True, 这个字段在表中必须有唯一值，默认值是False。


配置数据库

python3 manage.py makemigrations 创建脚本
python3 manage.py migrate 迁移


创建app01中的--init--文件

class Book(models.Model): #必须要继承的
nid = models.AutoField(primary_key=True) #自增id(可以不写，默认会有自增id AutoField是自增)
title = models.CharField(max_length=32)
publishDdata = models.DateField() #出版日期
author = models.CharField(max_length=32)
price = models.DecimalField(max_digits=5,decimal_places=2) #一共5位，保留两位小数


替换数据库的时候需要重新创建表记录

更改字段时候也需要

python36 manage.py makemigrations 创建脚本
python36 manage.py migrate 迁移


数据库的操作（django）

创建字段django特殊说明

1.字段的值默认是不为空的 需要手动设置 不然会报错2.主键无需手动添加 自动生成id字段（主键）
3.引用模块from django.db import models


获取id字段的两种方式

1.表名.id
例
book.id
2.表名.pk
例
book.pk


增:

方式1:
new_obj = models.UserInfo(#直接表名创建
过程
#1.先实例化产生对象，2.然后调用save方法保存
id=2,
name='子文',
bday='2019-09-27',
checked=1, )
new_obj.save()
方式2:
# ret 是创建的新的记录的model对象(重点)
ret = models.UserInfo.objects.create(
name='卫贺',
bday='2019-08-07',
checked=0
) print(ret) #UserInfo object
print(ret.name) #UserInfo object
print(ret.bday) #UserInfo object


时间问题

models.UserInfo.objects.create(
name='杨泽涛2',
bday=current_date,
# now=current_date, 直接插入时间没有时区问题
checked=0
)
但是如果让这个字段自动来插入时间,就会有时区的问题,auto_now_add创建记录时自动添加当前创建记录时的时间,存在时区问题
now = models.DateTimeField(auto_now_add=True,null=True)
解决方法:
settings配置文件中将USE_TZ的值改为False
# USE_TZ = True
USE_TZ = False # 告诉mysql存储时间时按照当地时间来寸,不要用utc时间
使用pycharm的数据库客户端的时候,时区问题要注意


删

from django.db import models
简单查询:filter() -- 结果是queryset类型的数据里面是一个个的model对象,类似于列表
models.UserInfo.objects.filter(id=7).delete() #queryset对象调用
models.UserInfo.objects.filter(id=7)[0].delete() #model对象调用


改

方式1:update
# models.UserInfo.objects.filter(id=2).update(
# name='篮子文',
# checked = 0,
#
# )
# 错误示例,model对象不能调用update方法
# models.UserInfo.objects.filter(id=2)[0].update(
# name='加篮子+2',
# # checked = 0,
# )
方式2
ret = models.UserInfo.objects.filter(id=2)[0]
ret.name = '加篮子+2'
ret.checked = 1
ret.save()更新时的auto_now参数
# 更新记录时,自动更新时间,创建新纪录时也会帮你自动添加创建时的时间,但是在更新时只有使用save方法的方式2的形式更新才能自动更新时间,有缺陷,放弃
now2 = models.DateTimeField(auto_now=True,null=True)


批量插入(bulk_create)

步骤
1.把查询的对象放入字典里一次性传入前端进行交互
# bulk_create
obj_list = []
for i in range(20):
obj = models.Book(
title=f'金瓶{i}',
price=20+i,
publish_date=f'2019-09-{i+1}',
publish='24期出版社'
)
obj_list.append(obj) models.Book.objects.bulk_create(obj_list) #批量创建


form表单提交之字典

request.POST -- querydict类型 {'title': ['asdf '], 'price': ['212'], 'publish_date': ['2019-09-12'], 'publish': ['asdf ']}
data = request.POST.dict() -- 能够将querydict转换为普通的python字典格式创建数据
models.Book.objects.create(
## title=title, #title='asdf '
## price=price, #price='212'
## publish_date=publish_date,
#'publish_date': ['2019-09-12']
## publish=publish,
#publish=['asdf ']
**data#通过打散把键和值转换成以上数据
)


查询api

筛选基本都是queryset类型

reservse 必须要排序才能反转

1.all()

查询对应表名的所有对象,结果是对象列表

结果为queryset类型

写法
models.表名.object.all()
例如
all_books = models.Book.objects.all()
数量过多会自动截断


2.filter条件查询

过滤出符合条件的数据

filter 条件查询
ret = models.Book.objects.filter(title='金瓶7',publish='24期出版社') #相当于mysql数据库中and多条件查询
查询条件不能匹配到数据时,不会报错,返回一个空的queryset,<QuerySet []>,如果没有写查询条件会获取所有数据,queryset类型的数据还能够继续调用fitler方法


3.get()

得到一个满足条件的model对象 有且只有一个

ret = models.Book.objects.get() #得到的是一个model对象,有且只能有一个
1. 查不到数据会报错 :Book matching query does not exist.
2. 超过一个就报错 :returned more than one Book -- it returned 13!


4.exclude()#排除

#除了这个之外
models.BOOK.objects.exclude(title__startswith=('金瓶'))
#model类型不能使用这个方法
1.object能够调用,models.Book.objects.exclude(title__startswith='金瓶')
2.queryset类型数据能够调用, models.Book.objects.all().exclude(title__startswith='金瓶')

5.order by()排序

models.Book.objects.all().order_by('-price','id')
#sql语句写法 orderby price desc,id asc;
models类型不能使用
排序order by 加上-字段名 不加是升序


6.reverse() 反转

models.Book.objects.all().order_by('id').reverse() #数据排序之后才能反转


7.count()

计数,统计返回结果的数量

models.Book.objects.all().count()
sql语句 聚合函数


8.first()

类似于models.类名(表名).objects.filter(条件判断)[0]
models.类名(表名).objects.filter(条件判断).first()
#返回满足条件的第一条数据


返回第一条数据,结果是model对象类型

9.last()

返回最后一条数据,结果是model对象类型

ret = models.Book.objects.all().first()
ret = models.Book.objects.all().last()


10.exists()

判断返回结果集是不是有数据

models.Book.objects.filter(id=9999).exists()
#有结果就是True,没有结果就是False


11.values

(返回的queryset类型,里面是字典类型数据)

12.values_list

(返回的queryset类型,里面是数组类型数据)

ret = models.Book.objects.filter(id=9).values('title','price')
ret = models.Book.objects.all().values_list('title','price')
ret = models.Book.objects.all().values()
ret = models.Book.objects.values() #调用values或者values_list的是objects控制器,那么返回所有数据


13.distinct()

去重,配置values和values_list来使用,不能带有id 因为id默认唯一

models.Book.objects.all().values('publish').distinct()


filter双下划线查询

queryset类型 筛选出来的是queryset类型

get筛选出来一个是model对象

queryset 类型的方法可以多次调用使用

13个api能调用的函数和方法（重点）

# ret = models.Book.objects.all().values('publish').distinct()
# ret = models.Book.objects.filter(price__gt=35) #大于
# ret = models.Book.objects.filter(price__gte=35) # 大于等于
# ret = models.Book.objects.filter(price__lt=35) # 小于等于
# ret = models.Book.objects.filter(price__lte=35) # 小于等于
# ret = models.Book.objects.filter(price__range=[35,38]) # 大于等35,小于等于38 # where price between 35 and 38
# ret = models.Book.objects.filter(title__contains='金瓶') # 字段数据中包含这个字符串的数据都要
# ret = models.Book.objects.filter(title__contains='金瓶')
# ret = models.Book.objects.filter(title__icontains="python") # 不区分大小写
# from app01.models import Book
# ret = models.Book.objects.filter(title__icontains="python") # 不区分大小写
# ret = models.Book.objects.filter(title__startswith="py") # 以什么开头，istartswith 不区分大小写
# ret = models.Book.objects.filter(publish_date='2019-09-15')某年某月某日（对于日期的修改）:
ret = models.Book.objects.filter(publish_date__year='2018')
ret = models.Book.objects.filter(publish_date__year__gt='2018')#2018写数字也可以
ret = models.Book.objects.filter(publish_date__year='2019',publish_date__month='8',publish_date__day='1')找字段数据为空的双下滑线
models.Book.objects.filter(publish_date__isnull=True) #这个字段值为空的那些数据


多表查询

多表是会为减少数据的冗余 加速查询的效率

models.字段类型（）

表结构

rom django.db import models# Create your models here.class Author(models.Model):
"""
作者表
"""
name=models.CharField( max_length=32)
age=models.IntegerField()
#一对一 authorDetail=models.OneToOneField(to="AuthorDetail",to_field="nid",on_delete=models.CASCADE) #
#一对一
au=models.OneToOneField("AuthorDetail",on_delete=models.CASCADE)class AuthorDetail(models.Model):
"""
作者详细信息表
"""
birthday=models.DateField()
telephone=models.CharField(max_length=11)
addr=models.CharField(max_length=64)
# class Meta:
# db_table='authordetail' #指定表名
# ordering = ['-id',]
class Publish(models.Model):
"""
出版社表
"""
name=models.CharField( max_length=32)
city=models.CharField( max_length=32)class Book(models.Model):
"""
书籍表
"""
title = models.CharField( max_length=32)
publishDate=models.DateField()
price=models.DecimalField(max_digits=5,decimal_places=2)
#一对多
publishs=models.ForeignKey(to="Publish",on_delete=models.CASCADE,)
多对多
authors=models.ManyToManyField('Author',)

注意事项

#重中之重 不要把表名和库名设置成一样的
1.不写字段默认外键默认连接id
2.创表默认创建主键 无需手动创建
3.oneto one 一对一#OneToOneField
4.id可以省略（自动连接另一个表的id字段（主键））
5.djnago1.0版本可以不写外键 默认级联删除
6.djnago2.0版本必须写on_delete=models.CASCADE
7.int类型不能进行模糊搜索 例如 电话去模糊匹配 前三位
字段名__startwith='151'
8.外键字段是赋值变量名=变量名_id
9.class AuthorDetail(models.Model) 创建表结构时 要继承 models.Model方法
完整版写法：
authorDetail=models.ForeignKey(to="AuthorDetail",to_field="nid",on_delete=models.CASCADE) class meta：​指定创建表时的源信息​ordering 排序db contrations 去除强制约束效果


多对多关系

# 多对多没办法使用一个表的外键去设置
#多对多关系用第三张表存储关系
优点
存入字段数据少 数据库小 增加执行效率
1.manytomany #authors=models.ManyToManyField('Author',)ManyToManyField不会加字段
book——author 一个表-另一个表
1.会生成一个表 字段会自己建立
2。一个字段是表名——id
3.下一个字段是另一个表——id
会自动创建 对应id字段，存入到一个属性中
使用方法
4.类名或者实例化对象（表名）去调用这个属性


一对一关系

#注意事项
1.如果两张表数据不统一 是表数据少的去连接数据多的（数据多的是主表）
2.如果数据统一 建哪个东西
sql语句 把外键变成unique（唯一）格式一样
authorDetail=models.OneToOneField(to="AuthorDetail",to_field="nid",on_delete=models.CASCADE)


多对一

1。对于外键不需要唯一性，
2。不建立外键唯一（使用models.OneToOneField）建立外键


外键

1.完整版写法
authorDetail=models.ForeignKey(to="AuthorDetail",to_field="nid",on_delete=models.CASCADE) 2.id可以省略（自动连接另一个表的id字段（主键））
publishs=models.ForeignKey(to="Publish",on_delete=models.CASCADE,)
to=，to_field
#publishs是字段名
2.连接表的两种写法
第一种写法
to="加对应表名" 默认连接主键（id）
第二种写法
publishs=models.ForeignKey(to="Publish",on_delete=models.CASCADE,)
可以不写 直接写表名 但是如果加载在之后会报错因为没有预加载出来


admin使用超级管理员

1.连接数据库

注意要先连接数据库才能进入admin页面输入密码进行操作

创建与数据库之间的连接
1.在对应的app01 的models文件夹下创建好表，其中表包括（字段类型（约束大小限制）
1.2外键的创建#需要注意的是1.1默认创建 2.0版本需要手动添加
1.2.1 一对一创建外键约束 #属性名=OneToOneFlied(on_update=models.CASCADE)
一对多创建外键约束# 属性名=foreignKey()
也对就是对应的子程序的models
2.创建表记录
3.在对应子程序中把python默认支持的mysqldb 替换成pymysql
原因mysqldb不支持3.4以上版本


2.创建超级管理员

写法 createsuperuser
两种写法
1.pycharm的一个控制台
#1.manage.py@dbcont > createsuperuser#一开始显示这个
使用createsuperuser创建管理员2.python控制台
2.1python36 manage.py createsuperuser#创建超级管理员
2.2同理输入账号和密码 邮箱可以不用输入

创建数据（记录）

1.把models的表导入到admin
在对应app01（子程序中）的admin.py文件中
2.from django.contrib import admin
from app01 import models
admin.site.register(models.author)#格式 admin.site.reister(models.类名（表名）)


增删改查

在对应子程序的view视图里写增删改查

注意要先引用models模块（对应的models.py文件）

增加

一对一

# 一对一
# au_obj = models.AuthorDetail.objects.get(id=4)
查询出对应的models对象 存入表类中 models.Author.objects.create(
name='海狗',
age=59,
# 两种方式
au_id=4
# au=au_obj
#属性对应的值是对应的models对象
)

一对多

与一对一的区别

对于连接字段没有唯一的约束

pub_obj = models.Publish.objects.get(id=3) models.Book.objects.create(
title='xx2',
price=13,
publishDate='2011-11-12',
publishs=pub_obj,
#类属性作为关键字时,值为model对象
publishs_id=3
# 如果关键字为数据库字段名称,那么值为关联数据的值
)


多对多

多对多关系表记录的增加

ziwen = models.Author.objects.get(id=3)
haigou = models.Author.objects.get(id=5)new_obj = models.Book.objects.create(
title='海狗产后护理第二部',
price=0.5,
publishDate='2019-09-29',
publishs_id=2,
)
new_obj是一个对象
#第一种写法
new_obj.authors.add(对应外键字段的值)#对象.属性.方法名添加add
new_obj.authors.add(3,5) #*args **kwargs
#添加的多个值用逗号隔开
new_obj.authors.add(*[3,5]) # 用的最多,
用法：
1.select 下拉框 的值是一个列表 使用name属性 查看对应value的值
2.多选的value值 是提交到后端是一个列表
3.使用*[value]打散#*[3,5]#第二种写法 添加model对象
new_obj.authors.add(ziwen, haigou)
创建完字段之后要把对应的关系字段写到第三张表里


删除

一对一

models.AuthorDetail.objects.filter(id=3).delete()
models.Author.objects.filter(id=3).delete()


一对多

默认级联删除

关联的表是主表 主表删除子表的相对应的整条字段也被删除

models.Publish.objects.filter(id=3).delete()#Publish是主表
models.book.objects.filter(id=3).delete()


多对多

只操作对应第三张表
book_obj = models.Book.objects.get(id=2)
book_obj.authors.add() # 添加
book_obj.authors.remove(1) #删除括号里对应的外键关联的id
book_obj.authors.clear() # 清除,筛选出的所有的对应外键关系字段
book_obj.authors.set(['1','5']) # 先清除对应外键关系字段再添加,相当于修改
#易错点
不是在原位置修改是删除这条对应记录，再去添加新纪录


改

# 改
ret = models.Publish.objects.get(id=2)
models.Book.objects.filter(id=5).update(
title='华丽丽',
#publishs=ret,
publishs_id=1,
)
两种方式
publishs=ret#使用属性 对应的值是model对象
publishs_id=1#对应的id值


基于对象的跨表查询

obj=models.Author.objects.get(name='王洋')和filter用法一样出来的类型不一样
obj=models.Author.objects.filter(name='王洋').first()


get和filter的区别

1.filter筛选出来的是queryset对象需要转成model对象
1.2如果是多个值 需要for循环取值转换
写法
a=models.Author.objects.filter()[0]
a查询出来多个值 这样使用就只能查出一个
需要for 循环取值
2.get是对应的model对象 可以直接拿来用


反向查询和正向查询的区别

1.正向查询是创建外键关系的属性 在当前表中
用法
obj=models.Author.objects.get(name='王洋')
obj.对应的外键属性名.字段名2.反向查询是表中没有对应创建外键关系的属性
用法·
obj=models.Author.objects.get(name='王洋')
obj.小写表名.字段名 #obj，表名找到对应表
如果 查询东西多
1.需要用注意:正向查和反向查有一些区别,当正相查结果为多个时,直接obj.对应的外键属性名.all()既可以,但是反向查有一些不同obj.小写表名_set.all()属性名(字段)_set.all()
取值
2.使用 for循环列表进行对象取值
举例
obj=models.表名.objects.filter(name='子文')
ret=obj.book_set.all()#查询出来的是个列表s
for i in ret:
print(i.title)
#注意:正向查和反向查有一些区别,当正相查结果为多个时,直接obj.对应的外键属性名.all()既可以,但是反向查有一些不同obj.小写表名_set.all()


一对一

# 一对一
正向查询 对象.属性
obj = models.Author.objects.filter(name='王洋').first()
ph = obj.au.telephone
print(ph) # 查一下电话号码为120的作者姓名
# 反向查询 对象.小写的表名
obj = models.AuthorDetail.objects.filter(telephone=120).first()
ret = obj.author.name #陈硕
print(ret)


一对多

# 查询
# 一对多
# 查询一下 海狗的怂逼人生这本书是哪个出版社出版的 正向查询
obj = models.Book.objects.filter(title='海狗的怂逼人生').first()
ret = obj.publishs.name
print(ret) #24期出版社
# 查询一下 24期出版社出版过哪些书
obj = models.Publish.objects.filter(name='24期出版社').first() ret = obj.book_set.all() #<QuerySet [<Book: 母猪的产后护理>, <Book: 海狗的怂逼人生>]>
for i in ret:
print(i.title)

多对多

关于多对多正向反向查询的的解释

一句话概括
是两个的表的关系属性在哪个表里（类） 不是外键字段存在哪个表
解释
1.多对多需要建立在数据之上 因为没有数据的支持没办法建立外键，建立外键约束
2.多对多采用把关系存在第三张表里
3.基于对象的查询是根据属性查询
4.两个表的关系属性在哪个表里 哪个表就是正向查询


具体事例

# 多对多
如果post请求多个值使用getlist(字段)
写法
obj=request.POST.getlist("author_id")
#取得的是一个列表
# 海狗的怂逼人生 是哪些作者写的 -- 正向查询
obj = models.Book.objects.filter(title='海狗的怂逼人生').first()
ret = obj.authors.all()#可以直接查询到作者对应的名字 （直接查询到） print(ret) #<QuerySet [<Author: 王洋>, <Author: 海狗>]>
for i in ret:
print(i.name) # 查询一下海狗写了哪些书 -- 反向查询
obj = models.Author.objects.filter(name='海狗').first()
ret = obj.book_set.all()
print(ret)
for i in ret:
print(i.publishs.name)
print(i.title)
return HttpResponse('ok')


基于双下划线的跨表查询（join）

原生sql语句写法

select emp.name from emp inner join dep on dep.id=emp.id where emp.name='技术部';
select emp.name from dep inner join emp on dep.id=emp.id where emp.name='技术部';


在配置里面设置显示orm的操作的原生sql语句

注意

1.表的查询先后指定哪个表都可以
2.value里面是什么 查询出来字典的键就是什么，
3.可以查询出来多个不用.all()
4.属性__字段 小写表名__字段都是关联表字段


写法

表的查询先后指定哪个表都可以
#正向查询
写法
models.含有外键关联属性的表名.filter（本表字段=条件）.value( 属性_ _外键字段)
海狗的怂逼人生这本书是哪个出版社出版的#反向查询
写法
models.不含有外键关联属性的表名.filter(小写表名_ _字段).values('本表字段')
示例
海狗的怂逼人生这本书是哪个出版社出版的
ret = models.Publish.objects.filter(book__title='海狗的怂逼人生').values('name')
print(ret) #<QuerySet [{'name': '24期出版社'}]>

返回多个值

反向查询返回多个值
写法
models.不有外键关联属性的表名.filter（本表字段=条件）.value( 小写表名_ _字段)
示例
查询一下24期出版社出版了哪些书
#反向查询返回多个值
ret = models.Publish.objects.filter(name='24期出版社').values('book__title')
print(ret) #<QuerySet [{'book__title': '华丽的产后护理'}, {'book__title': '海狗的怂逼人生'}]>正向查询返回多个值
写法
models.含有外键关联属性的表名.filter(属性_ _字段).values('本表字段')
#示例
查询一下24期出版社出版了哪些书
#正向查询返回多个值
ret = models.Book.objects.filter(publishs__name='24期出版社').values('title')
print(ret) #<QuerySet [{'title': '华丽的产后护理'}, {'title': '海狗的怂逼人生'}]>

一对一

示例

# 查询一下王洋的电话号码
#正向
ret = models.Author.objects.filter(name='王洋').values('au__telephone')
#反向
ret = models.AuthorDetail.objects.filter(author__name='王洋').values('telephone')
# print(ret) #<QuerySet [{'au__telephone': '110'}]> #<QuerySet [{'telephone': '110'}]>


一对多

示例

海狗的怂逼人生这本书是哪个出版社出版的
#正向
ret = models.Book.objects.filter(title='海狗的怂逼人生').values('publishs__name')
print(ret) #<QuerySet [{'publishs__name': '24期出版社'}]>
#反向
ret = models.Publish.objects.filter(book__title='海狗的怂逼人生').values('name')
print(ret) #<QuerySet [{'name': '24期出版社'}]>#返回多个值
查询一下24期出版社出版了哪些书
#反向查询返回多个值
ret = models.Publish.objects.filter(name='24期出版社').values('book__title')
print(ret) #<QuerySet [{'book__title': '华丽的产后护理'}, {'book__title': '海狗的怂逼人生'}]>
#正向查询返回多个值ret = models.Book.objects.filter(publishs__name='24期出版社').values('title')
print(ret) #<QuerySet [{'title': '华丽的产后护理'}, {'title': '海狗的怂逼人生'}]>

多对多

示例

海狗的怂逼人生 是哪些作者写的
正向 返回多个值
authors__name 是属性__外键字段
ret = models.Book.objects.filter(title='海狗的怂逼人生').values('authors__name')
print(ret)反向 返回多个值
book__title 是小写表名__外键字段
ret = models.Author.objects.filter(book__title='海狗的怂逼人生').values('name')
print(ret) #<QuerySet [{'name': '王洋'}, {'name': '海狗'}]>


补充

related_name

写法

related_name==xxx 别名 注意用了必须用 以后就代指这个字段


查看原生sql语句的配置

聚合查询

arregate 聚合

不分组聚合只取一个最大的

注意

1.需要引用模块
2.聚合查询是orm结束符
3.查询出来的值是python的字典
4.不能再继续筛选


用法

from django.db.models import AVG,SUM,Max
arregate (*args,**kwargs)聚合
1.单个聚合函数
ret=models.表名.objects.all().arregate(AVG('字段名'))
2.多个聚合函数
ret=models.表名.objects.all().arregate(AVG('字段名'),Max('字段名'))


示例

# 计算所有图书的平均价格
from app01.models import Book
from django.db.models import Avg
models.Book.objects.all().aggregate(Avg('price'))
Book.objects.all().aggregate(Avg('price'))
#或者给它起名字(查询出来字典显示的键)：aggretate(a=Avg('price'))
{'price__avg': 34.35}


分组查询

annotate其实就是对分组结果的统计

分组执行的顺序

例如 models.Book.objects.annotate(max=Max('price')).arregate(Avg('max'))
#分组完进一步用聚合函数筛选
1.以book的id进行分组
2.annotate(max=Max('price'))#以最高的价钱进行统计起一个别名max
3.arregate(Avg('max')#把筛选完的表名 进一步进行筛选
4.arregate是orm的最后结束符


跨表分组查询本质就是将关联表join成一张表，再按单表的思路进行分组查询,，既然是join连表，就可以使用咱们的双下划线进行连表了。

注意

1.查询的平均值的字段必须要起别名 用values进行别名取值 vlues('别名')
2.values是分组的依据 可以属性可以字段
3.可以直接 model.表名.objects.annotate #默认依据表名的id主键进行分组


原生sql语句

#单表
select dep,Count(*) from emp group by dep;
#多表
select dep.name,Count(*) from emp left join dep on emp.dep_id=dep.id group by dep.id;


用法

两种写法
第一种 指定字段分组
models.分组的表名.objects.values('分组的字段').annotate(别名=聚合函数('字段名')).values('别名')
#别名取值
#示例
models.emp.objects.values("dep").annotate(c=Count("id")).values('c') #对象.values()
models.dep.objetcs.values("id").annotate(c=Count("emp")).values("name","c")
第二种 不指定values分组默认id进行分组
models.分组的表名.objects.annotate(别名=聚合函数('字段名')).values('别名')
# 示例
ret = models.Publish.objects.annotate(a=Avg('book__price')).values('a')
# print(ret) #<QuerySet [{'a': None}, {'a': 71.166667}, {'a': 6.0}]>


F查询

比较同一个 model (同一个表)实例中两个不同字段的值。

可以查询出来所有进行修改

用法

from django.db.models import Avg, Sum, Max, Min, Count,F
F('本表字段')#示例
from django.db.models import Avg, Sum, Max, Min, Count,F
#查询一下评论数大于点赞数的书
两个字段进行比较
ret = models.Book.objects.filter(comment__gt=F('good'))
print(ret)查询出所有本表字段进行修改
将所有书的价格上调100块
# models.Book.objects.all().update(
# price=F('price')+100
# )


Q查询

filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询（例如OR 语句），你可以使用Q 对象。

写法

或查询
q()
#注意
models.Book.objects.filter(Q(id=2),price=3)
不能写在Q()前面会报错


用法

或| 与& 非~
q()|q()
q()&q()
q()|~q()
1.单层
q('字段'__比较=值)|q('字段'__比较=值)
2.多层嵌套 关键字必须 写在q查询之后会报错 想要写之前就要用q()
#示例
ret = models.Book.objects.filter(Q(id=2)&Q(Q(price__gt=112)|~Q(comment__lte=200)))
print(ret)


orm执行原生sql语句

raw()# 取的是一个对象
写法
ret = models.Student.objects.raw('select * from app02_teacher', translations=d)
for i in ret:
print(i.id, i.sname, i.haha)
需要for 循环


自定义sql语句

django封装的

from django.db import connection, connections
cursor = connection.cursor() # cursor = connections['default'].cursor()
cursor.execute("""SELECT * from auth_user where id = %s""", [1])
ret = cursor.fetchone()


cookie

1.是保存在用户浏览器上的键值对，向服务端发送请求时会自动携带
2.cookie可以通过 浏览器进行cookie删除
max_age=None 多少秒之后自动失效
expires=None固定的时间
path="/"
domain 可以设置指定域名
http=true 就可以设置cookie 能不能修改


cookie的使用

通过js设置cookie

document.cookie="k1=wy222;path=/"#js写法
$.cookie("k1","wy222",{path:'/'})#jquery写法


path的作用

path默认所有域名"/"
1./ 根目录当前网站的所有的url都能读取到此值
2.""只能在当前页面访问的到此数据
3./index/，只能在/index/xxx的网页中查看后台默认在根目录也就是path=’/’
cookie修改需要指定根目录 "decument.cookie=121313 path= /"
不写默认path为""


不安全 可以使用浏览器进行修改可以获取到敏感数据

简单博客登陆

检查数据的库的密码是否正确

view.py写法
def login(requset):
if requset.method=='GET':
return render(requset,'login.html',{'age':18})
# 获取用户提交的用户名和密码
user = request.POST.get('user')#获取键对应的值
pwd = request.POST.get('pwd')#获取键对应的值
#判断用户名和密码
user_object=models.UserInfo.objects.filter(username=user,password=pwd).first()
if user_object:
# 用户登录成功
result = redirect('/index/')
#在写入一个cookie
result.set_cookie('xxxxxxxx',user)
return result # 用户名或密码输入错误
return render(request,'login.html',{'error':'用户名或密码错误'})def index(request):
"""
博客后台首页
:param request:
:return:
"""
#拿到存到浏览器的cookie
user = request.COOKIES.get('xxxxxxxx')
if not user:#如果没有获得
return redirect('/login/')#返回页面 return render(request,'index.html',{'user':user})


为防止通过url直接访问页面 使用cookie进行判断

应用场景

• 投票
• 每页默认显示数据
• 登陆认证

避免把敏感数据存储在浏览器使用到了session

session

依赖cookie

是一种存储数据的方式,依赖于cookie,实现本质:
用户（浏览器（向服务端发送请求,服务端做两件事:
1.生成随机字符串;
2.为此用户开辟一个独立的空间来存放当前用户独有的值（数据）.


在空间中如何想要设置值:

request.session['x1'] = 123
request.session['x2'] = 456
request.session['x2']如果不存在会报错keyerror错误#在空间中取值:
request.session.get('x2')
#视图函数中的业务操作处理完毕,给用户响应,在响应时会 将随机字符串存储到用户浏览器的cookie中


session中的数据是根据用户相互隔离每个都是独立的

session中的数据是根据用户相互隔离.
示例
def login(request):   # 获取用户提交的用户名和密码
user = request.POST.get('user')   request.session['user_name'] = user    
def index(request): print(request.session['user_name'])


应用场景

• 可以权限判断 放置权限
• 短信验证过期
• 登陆认证

session和cookie的区别

cookie是存储在客户端浏览器上的键值对，发送请求时浏览器会自动携带
session是一种存储数据方式 依赖cookie基于cookie实现，将数据存储在服务端 (django默认)

扩展 修改session默认存储位置

• - （默认在数据库）
- 小系统:默认放在数据库即可. 大系统:缓存(redis)


• 文件

• SESSION_ENGINE = 'django.contrib.sessions.backends.file' #引擎把session放入文件中
SESSION_FILE_PATH = '/ssss/' #在根目录的/ssss生成一个随机文件


• 缓存(内存)

• SESSION_ENGINE = 'django.contrib.sessions.backends.cache' SESSION_CACHE_ALIAS = 'default'
CACHES = {  
'default': {      
'BACKEND':'django.core.cache.backends.locmem.LocMem Cache',      
'LOCATION': 'unique-snowflake',  
}
}


• 缓存(redis)

• SESSION_ENGINE = 'django.contrib.sessions.backends.cache' SESSION_CACHE_ALIAS = 'default'
CACHES = {  
"default": {      
"BACKEND":"django_redis.cache.RedisCache",       "LOCATION": "redis://127.0.0.1:6379",       "OPTIONS": {          
"CLIENT_CLASS":"django_redis.client.DefaultClient",          
"CONNECTION_POOL_KWARGS": {
"max_connections": 100}           # "PASSWORD": "密码",       }   }
}

简单博客登陆（session）

检查数据的库的密码是否正确

from django.shortcuts import render,redirect
from app01 import modelsdef login(request):
"""
用户登录
:param request:
:return:
"""
if request.method == 'GET':
return render(request, 'login.html') # 获取用户提交的用户名和密码
user = request.POST.get('user')
pwd = request.POST.get('pwd')
print(user,pwd)
# 去数据库检查用户名密码是否正确
user_object = models.UserInfo.objects.filter(username=user, password=pwd).first() if user_object:
request.session['user_name']=user_object.username#名字存入session
request.session['user_id']=user_object.pk#id存入session
return redirect('/index/')#重定向页面 # 用户名或密码输入错误
return render(request,'login.html',{'error':'用户名或密码错误'})def index(request):
"""
博客后台首页
:param request:
:return:
"""
name=request.session.get("user_name")
if not name:
return redirect('/login/') return render(request,'index.html',{'user':name})··············································
简化版为了减少登陆验证的重复
··············································from django.shortcuts import render,redirect
from app01 import modelsdef login(request):
"""
用户登录
:param request:
:return:
"""
if request.method == 'GET':
return render(request, 'login.html') # 获取用户提交的用户名和密码
user = request.POST.get('user')
pwd = request.POST.get('pwd')
print(user,pwd)
# 去数据库检查用户名密码是否正确
user_object = models.UserInfo.objects.filter(username=user, password=pwd).first() if user_object:
request.session['user_name']=user_object.username#名字存入session
request.session['user_id']=user_object.pk#id存入session
return redirect('/index/')#重定向页面 # 用户名或密码输入错误
return render(request,'login.html',{'error':'用户名或密码错误'})def auth(func):#防止多次判断 简化判断 装饰器
@functools.wraps(func)
def inner( request,*args,**kwargs): name = request.session.get("user_name")
if not name:
return redirect('/login/')
return func(request,*args,**kwargs)
return inner
@auth
def index(request):
"""
博客后台首页
:param request:
:return:
""" return render(request,'index.html')


操作session

# 设置(添加&修改) request.session['x1'] = 123 request.session['x2'] = 456
# 读取
request.session['xx'] #读取不到会报key error错误
request.session.get('xx')#读取不到值返回none (不报错)
# 删除
del request.session['xx']
request.session.keys() #获取当前session的键
request.session.values() #获取当前session的值
request.session.items() #获取当前session的键值对
# 设置会话Session和Cookie的超时时间
request.session.set_expiry(value)
* 如果value是个整数，session会在些秒数后失效。
* 如果value是个datatime或timedelta，session就会在这个时间后失效。
* 如果value是0,用户关闭浏览器session就会失效。
* 如果value是None,session会依赖全局session失效策略。
request.session.session_key 获取sessionid（随机字符串）的值

扩展 django和session相关的配置

SESSION_COOKIE_NAME = "sessionid" # Session的cookie保存在浏览器上时的key可以修改，即： sessionid＝随机字符串
SESSION_COOKIE_DOMAIN = None #session的cookie保存的域名（都可以在那个域名，子域名下可用 所有的域名都可用读取到）
# api.baidu.com /www.baidu.com/ xxx.baidu.com
SESSION_COOKIE_PATH = "/" # Session的cookie 保存的路径
SESSION_COOKIE_HTTPONLY = True # 是否 Session的cookie只支持http传输 只能读不能修改
SESSION_COOKIE_AGE = 1209600 # Session的 cookie失效日期（2周）
SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否关闭浏览器使得Session过期
SESSION_SAVE_EVERY_REQUEST = False # 是否每 次请求都保存Session，默认修改之后才保存
request会刷新 ture 按照最后一次刷新时间 false 会在两周之后过期


django中的session如何设置过期时间?

SESSION_COOKIE_AGE = 1209600 # Session的 cookie失效日期（2周）