目录
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 models
def 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 models
def 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周）