目录html
对象是指 orm的models类名实例化的对象前端
关系是指 orm中的数据模型和数据库的关系python
类----------------》表 #models.py中的类对应数据库中的表 对象--------------》记录(数据行) #obj=models.User.objects.get(id=1) obj对应数据库表中的行数据 属性--------------》字段 #models.py类中的属性对应数据库表中的字段
映射 orm其实就是将models.类名.object.filter类对象的语法经过orm翻译翻译成sql语句的一个引擎mysql
''' <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,它实现了数据模型与数据库的解耦,即数据模型的设计不须要依赖于特定的数据库,经过简单的配置就能够轻松更换数据库,这极大的减轻了开发人员的工做量jquery
2.ORM是“对象-关系-映射”的简称。git
3.执行流程正则表达式
类对象--->sql--->pymysql--->mysql服务端--->磁盘redis
orm其实就是将类对象的语法翻译成sql语句的一个引擎sql
orm语句 -- sql -- 调用pymysql客户端发送sql -- mysql服务端接收到指令并执行数据库
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', # 引擎 'NAME': 'day53', # 数据库名称 'HOST': '127.0.0.1', # IP 'PORT': 3306, # 端口号 'USER': 'root', # 用户名 'PASSWORD': '123' # 密码 } }
做用:用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()
#引用一个模块 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...))
添加字段的时候别忘了,该字段不能为空,全部要么给默认值,要么设置它容许为空 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
(实例一个对象,调用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')
经过选项实现对字段的约束,选项以下: 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特殊说明
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)
步骤 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) #批量建立
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#经过打散把键和值转换成以上数据 )
筛选基本都是queryset类型
reservse 必需要排序才能反转
查询对应表名的全部对象,结果是对象列表
结果为queryset类型
写法 models.表名.object.all() 例如 all_books = models.Book.objects.all() 数量过多会自动截断
过滤出符合条件的数据
filter 条件查询 ret = models.Book.objects.filter(title='金瓶7',publish='24期出版社') #至关于mysql数据库中and多条件查询 查询条件不能匹配到数据时,不会报错,返回一个空的queryset,<QuerySet []>,若是没有写查询条件会获取全部数据,queryset类型的数据还可以继续调用fitler方法
获得一个知足条件的model对象 有且只有一个
ret = models.Book.objects.get() #获得的是一个model对象,有且只能有一个 1. 查不到数据会报错 :Book matching query does not exist. 2. 超过一个就报错 :returned more than one Book -- it returned 13!
#除了这个以外 models.BOOK.objects.exclude(title__startswith=('金瓶')) #model类型不能使用这个方法 1.object可以调用,models.Book.objects.exclude(title__startswith='金瓶') 2.queryset类型数据可以调用, models.Book.objects.all().exclude(title__startswith='金瓶')
models.Book.objects.all().order_by('-price','id') #sql语句写法 orderby price desc,id asc; models类型不能使用 排序order by 加上-字段名 不加是升序
models.Book.objects.all().order_by('id').reverse() #数据排序以后才能反转
计数,统计返回结果的数量
models.Book.objects.all().count() sql语句 聚合函数
相似于models.类名(表名).objects.filter(条件判断)[0] models.类名(表名).objects.filter(条件判断).first() #返回知足条件的第一条数据
返回第一条数据,结果是model对象类型
返回最后一条数据,结果是model对象类型
ret = models.Book.objects.all().first() ret = models.Book.objects.all().last()
判断返回结果集是否是有数据
models.Book.objects.filter(id=9999).exists() #有结果就是True,没有结果就是False
(返回的queryset类型,里面是字典类型数据)
(返回的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控制器,那么返回全部数据
去重,配置values和values_list来使用,不能带有id 由于id默认惟一
models.Book.objects.all().values('publish').distinct()
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.在对应的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以上版本
写法 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()
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')
原生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==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主键进行分组
#单表 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}]>
比较同一个 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 # )
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)
raw()# 取的是一个对象 写法 ret = models.Student.objects.raw('select * from app02_teacher', translations=d) for i in ret: print(i.id, i.sname, i.haha) 须要for 循环
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()
1.是保存在用户浏览器上的键值对,向服务端发送请求时会自动携带 2.cookie能够经过 浏览器进行cookie删除 max_age=None 多少秒以后自动失效 expires=None固定的时间 path="/" domain 能够设置指定域名 http=true 就能够设置cookie 能不能修改
document.cookie="k1=wy222;path=/"#js写法 $.cookie("k1","wy222",{path:'/'})#jquery写法
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
是一种存储数据的方式,依赖于cookie,实现本质: 用户(浏览器(向服务端发送请求,服务端作两件事: 1.生成随机字符串; 2.为此用户开辟一个独立的空间来存放当前用户独有的值(数据).
request.session['x1'] = 123 request.session['x2'] = 456 request.session['x2']若是不存在会报错keyerror错误#在空间中取值: request.session.get('x2') #视图函数中的业务操做处理完毕,给用户响应,在响应时会 将随机字符串存储到用户浏览器的cookie中
session中的数据是根据用户相互隔离. 示例 def login(request): # 获取用户提交的用户名和密码 user = request.POST.get('user') request.session['user_name'] = user def index(request): print(request.session['user_name'])
cookie是存储在客户端浏览器上的键值对,发送请求时浏览器会自动携带 session是一种存储数据方式 依赖cookie基于cookie实现,将数据存储在服务端 (django默认)
- (默认在数据库) - 小系统:默认放在数据库便可. 大系统:缓存(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', } }
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": "密码", } } }
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')
# 设置(添加&修改) 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(随机字符串)的值
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 会在两周以后过时
SESSION_COOKIE_AGE = 1209600 # Session的 cookie失效日期(2周)