• orm（对象关系映射）
  • • 字段介绍
    • 属性介绍
  • django 连接mysql顺序
    • 1 settings配置文件中
    • 2 项目文件夹下的init文件中写上下面内容，
    • 补充
    • 3 models文件中创建一个类（类名就是表名）
    • 4.执行数据库同步指令,
    • 5 创建记录
    • 6.字段约束
  • 数据库的操作（django）
    • 增:
    • 时间问题
    • 删
    • 改
    • 批量插入(bulk_create)
    • form表单提交之字典
    • 查询api
      • 1.all()
      • 2.filter条件查询
      • 3.get()
      • 4.exclude()#排除
      • 5.order by()排序
      • 6.reverse() 反转
      • 7.count()
      • 8.first()
      • 9.last()
      • 10.exists()
      • 11.values
      • 12.values_list
      • 13.distinct()
    • filter双下划线查询
  • 多表查询
    • 表结构
    • 注意事项
    • 多对多关系
    • 一对一关系
    • 多对一
    • 外键
  • admin使用超级管理员
    • 1.连接数据库
    • 2.创建超级管理员
    • 增删改查
    • 增加
      • 一对一
      • 一对多
      • 多对多
    • 删除
      • 一对一
      • 一对多
      • 多对多
    • 改
    • 基于对象的跨表查询
      • get和filter的区别
      • 反向查询和正向查询的区别
    • 一对一
    • 一对多
    • 多对多
      • 关于多对多正向反向查询的的解释
      • 具体事例
  • 基于双下划线的跨表查询（join）
    • 写法
      • 返回多个值
    • 一对一
    • 一对多
    • 多对多
  • related_name
  • 聚合查询
    • 注意
    • 用法
    • 示例
  • 分组查询
    • 原生sql语句
    • 用法
  • F查询
    • 用法
  • Q查询
    • 写法
    • 用法
  • orm执行原生sql语句
    • 自定义sql语句
• cookie
  • cookie的使用
    • 通过js设置cookie
    • path的作用
  • 简单博客登陆
  • 检查数据的库的密码是否正确
  • 应用场景
• session
  • • 依赖cookie
  • 在空间中如何想要设置值:
    • session中的数据是根据用户相互隔离每个都是独立的
  • 应用场景
  • session和cookie的区别
  • 扩展 修改session默认存储位置
    • • 文件
      • 缓存(内存)
    • 缓存(redis)
  • 简单博客登陆（session）
    • 检查数据的库的密码是否正确
  • 操作session
    • 扩展 django和session相关的配置
    • django中的session如何设置过期时间?

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 用一个文本框()表示该字段保存的数据.
 
<4> AutoField
        一个 IntegerField, 添加记录时它会自动增长. 你通常不需要直接使用这个字段;
        自定义一个主键：my_id=models.AutoField(primary_key=True)
        如果你不指定主键的话,系统会自动添加一个主键字段到你的 model.
 
<5> BooleanField
        A true/false field. admin 用 checkbox 来表示此类字段.
 
<6> TextField
        一个容量很大的文本字段.
        admin 用一个  (文本区域)表示该字段数据.(一个多行编辑框).
 
<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参数.
 
 
 
'''
</code></pre>
<h3 id="属性介绍">属性介绍</h3>
<pre><code class="language-python">(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，每次更新数据记录的时候会更新该字段，标识这条记录最后一次的修改时间。
</code></pre>
<p>1.MVC或者MVC框架中包括一个重要的部分，就是ORM，它实现了数据模型与数据库的解耦，即数据模型的设计不需要依赖于特定的数据库，通过简单的配置就可以轻松更换数据库，这极大的减轻了开发人员的工作量</p>
<p>2.ORM是“对象-关系-映射”的简称。</p>
<p>3.执行流程</p>
<p>?	类对象--->sql--->pymysql--->mysql服务端--->磁盘</p>
<p>?	orm其实就是将类对象的语法翻译成sql语句的一个引擎</p>
<p>?	orm语句 -- sql -- 调用pymysql客户端发送sql -- mysql服务端接收到指令并执行</p>
<p></p>
<h2 id="django-连接mysql顺序">django 连接mysql顺序</h2>
<h3 id="1-settings配置文件中">1 settings配置文件中</h3>
<pre><code class="language-sql">DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',   # 引擎
        'NAME': 'day53',			# 数据库名称
        'HOST': '127.0.0.1',		# IP
        'PORT': 3306,				# 端口号
        'USER': 'root',			# 用户名
        'PASSWORD': '123'			# 密码
    }
}
</code></pre>
<h3 id="2-项目文件夹下的init文件中写上下面内容">2 项目文件夹下的init文件中写上下面内容，</h3>
<p>?	作用：用pymysql替换mysqldb（djnago自带的）</p>
<p>mysqldb 不能python3.4以上的版本</p>
<p>需要使用第三方模块pymysql进行替换</p>
<p><strong>app01</strong>中的--init--文件</p>
<h3 id="补充">补充</h3>
<pre><code class="language-python">MySQLdb的是一个接口连接到MySQL数据库服务器从Python
MySQLdb并不支持Python3.4之后版本
</code></pre>
<pre><code class="language-python">原因：
#python默认连接的MySQLdb并不支持Python3.4之后版本
解决办法：
#12使用第三方模块pymysql进行替换
import pymysql
pymysql.install_as_MySQLdb()

</code></pre>
<h3 id="3-models文件中创建一个类类名就是表名">3 models文件中创建一个类（类名就是表名）</h3>
<pre><code class="language-python">#引用一个模块 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...))
</code></pre>
<h3 id="4执行数据库同步指令">4.执行数据库同步指令,</h3>
<p>添加字段的时候别忘了,该字段不能为空,所有要么给默认值,要么设置它允许为空 null=True</p>
<pre><code class="language-python"> #注意在每次增加字段时候都需要执行一遍这个方法
 python manage.py makemigrations#创建一个表记录
python版本号
 python manage.py migrate 执行记录
</code></pre>
<p><strong>数据库问题mysql 更改时区和改变版本号mysql for 5.1</strong><br>
</p>
<p>更改时区连接 </p>
<h3 id="5-创建记录">5 创建记录</h3>
<p>(实例一个对象,调用save方法)</p>
<p>models.py</p>
<pre><code class="language-mysql">#创建一条记录,增
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')
</code></pre>
<h3 id="6字段约束">6.字段约束</h3>
<pre><code class="language-sql">通过选项实现对字段的约束，选项如下：

null：如果为True，表示允许为空，默认值是False。
blank：如果为True，则该字段允许为空白，默认值是False。
对比：null是数据库范畴的概念，blank是表单验证证范畴的。
db_column：字段的名称，如果未指定，则使用属性的名称。
db_index：若值为True, 则在表中会为此字段创建索引，默认值是False。
default：默认值。
primary_key：若为True，则该字段会成为模型的主键字段，默认值是False，一般作为AutoField的选项使用。
unique：如果为True, 这个字段在表中必须有唯一值，默认值是False。
</code></pre>
<p>配置数据库</p>
<pre><code class="language-sql">python3 manage.py makemigrations   创建脚本
python3 manage.py migrate   迁移
</code></pre>
<p>创建app01中的--init--文件</p>
<pre><code class="language-python">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位，保留两位小数
</code></pre>
<p>替换数据库的时候需要重新创建表记录</p>
<p>更改字段时候也需要</p>
<pre><code class="language-python">python36 manage.py makemigrations   创建脚本
python36 manage.py migrate  迁移
</code></pre>
<h2 id="数据库的操作django">数据库的操作（django）</h2>
<p>创建字段django特殊说明</p>
<pre><code class="language-python">1.字段的值默认是不为空的 需要手动设置 不然会报错

2.主键无需手动添加 自动生成id字段（主键）
3.引用模块from django.db import models
</code></pre>
<p>获取id字段的两种方式</p>
<pre><code class="language-python">1.表名.id
例
book.id
2.表名.pk
例
book.pk
</code></pre>
<h3 id="增">增:</h3>
<pre><code class="language-mysql">方式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
</code></pre>
<h3 id="时间问题">时间问题</h3>
<pre><code class="language-mysql">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的数据库客户端的时候,时区问题要注意
</code></pre>
<h3 id="删">删</h3>
<pre><code class="language-mysql">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对象调用
</code></pre>
<h3 id="改">改</h3>
<pre><code class="language-mysql">方式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)
</code></pre>
<h3 id="批量插入bulk_create">批量插入(bulk_create)</h3>
<pre><code class="language-python">步骤
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)  #批量创建
</code></pre>
<h3 id="form表单提交之字典">form表单提交之字典</h3>
<pre><code class="language-python">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#通过打散把键和值转换成以上数据
        )
</code></pre>
<h3 id="查询api">查询api</h3>
<p><strong>筛选基本都是queryset类型</strong></p>
<p>reservse 必须要排序才能反转</p>
<h4 id="1all">1.all()</h4>
<p>查询对应表名的所有对象,结果是对象列表</p>
<p>结果为queryset类型</p>
<pre><code class="language-python">写法
models.表名.object.all()
例如
all_books = models.Book.objects.all()
数量过多会自动截断
</code></pre>
<h4 id="2filter条件查询">2.filter条件查询</h4>
<p>过滤出符合条件的数据</p>
<pre><code class="language-python">filter 条件查询
	ret = models.Book.objects.filter(title='金瓶7',publish='24期出版社') #相当于mysql数据库中and多条件查询
	查询条件不能匹配到数据时,不会报错,返回一个空的queryset,<QuerySet []>,如果没有写查询条件会获取所有数据,queryset类型的数据还能够继续调用fitler方法
</code></pre>
<h4 id="3get">3.get()</h4>
<p>得到一个满足条件的model对象 有且只有一个</p>
<pre><code class="language-python">ret = models.Book.objects.get() #得到的是一个model对象,有且只能有一个
	1. 查不到数据会报错 :Book matching query does not exist.
	2. 超过一个就报错 :returned more than one Book -- it returned 13!
</code></pre>
<h4 id="4exclude排除">4.exclude()#排除</h4>
<pre><code class="language-python">#除了这个之外
models.BOOK.objects.exclude(title__startswith=('金瓶'))
#model类型不能使用这个方法
1.object能够调用,models.Book.objects.exclude(title__startswith='金瓶')	
2.queryset类型数据能够调用, 	models.Book.objects.all().exclude(title__startswith='金瓶')

</code></pre>
<h4 id="5order-by排序">5.order by()排序</h4>
<pre><code class="language-python">models.Book.objects.all().order_by('-price','id')  
#sql语句写法 orderby price desc,id asc;
models类型不能使用
排序order by 加上-字段名 不加是升序
</code></pre>
<h4 id="6reverse-反转">6.reverse() 反转</h4>
<pre><code class="language-python">models.Book.objects.all().order_by('id').reverse()  #数据排序之后才能反转
</code></pre>
<h4 id="7count">7.count()</h4>
<p>计数,统计返回结果的数量</p>
<pre><code class="language-python">models.Book.objects.all().count() 
sql语句 聚合函数
</code></pre>
<h4 id="8first">8.first()</h4>
<pre><code class="language-python">类似于models.类名(表名).objects.filter(条件判断)[0]
models.类名(表名).objects.filter(条件判断).first()
#返回满足条件的第一条数据
</code></pre>
<p>返回第一条数据,结果是model对象类型</p>
<h4 id="9last">9.last()</h4>
<p>返回最后一条数据,结果是model对象类型</p>
<pre><code class="language-python">ret = models.Book.objects.all().first()
ret = models.Book.objects.all().last()
</code></pre>
<h4 id="10exists">10.exists()</h4>
<p>判断返回结果集是不是有数据</p>
<pre><code class="language-python">models.Book.objects.filter(id=9999).exists() 
#有结果就是True,没有结果就是False
</code></pre>
<h4 id="11values">11.values</h4>
<p>(返回的queryset类型,里面是字典类型数据)</p>
<h4 id="12values_list">12.values_list</h4>
<p>(返回的queryset类型,里面是数组类型数据)</p>
<pre><code class="language-python">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控制器,那么返回所有数据 
</code></pre>
<h4 id="13distinct">13.distinct()</h4>
<p>去重,配置values和values_list来使用,不能带有id 因为id默认唯一</p>
<pre><code class="language-python">models.Book.objects.all().values('publish').distinct()
</code></pre>
<h3 id="filter双下划线查询">filter双下划线查询</h3>
<p>queryset类型 筛选出来的是queryset类型</p>
<p>get筛选出来一个是model对象</p>
<p><strong>queryset 类型的方法可以多次调用使用</strong></p>
<p>13个api能调用的函数和方法（重点）</p>
<pre><code class="language-python">    # 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) #这个字段值为空的那些数据
</code></pre>
<h2 id="多表查询">多表查询</h2>
<p>多表是会为减少数据的冗余 加速查询的效率</p>
<p>models.字段类型（）</p>
<h3 id="表结构">表结构</h3>
<pre><code class="language-python">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',)

</code></pre>
<h3 id="注意事项">注意事项</h3>
<pre><code class="language-python">#重中之重 不要把表名和库名设置成一样的
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 去除强制约束效果
</code></pre>
<h3 id="多对多关系">多对多关系</h3>
<pre><code class="language-python"># 多对多没办法使用一个表的外键去设置
#多对多关系用第三张表存储关系
优点
存入字段数据少 数据库小 增加执行效率
1.manytomany #authors=models.ManyToManyField('Author',)

ManyToManyField不会加字段
book——author 一个表-另一个表
1.会生成一个表 字段会自己建立
2。一个字段是表名——id
3.下一个字段是另一个表——id
会自动创建 对应id字段，存入到一个属性中
使用方法
4.类名或者实例化对象（表名）去调用这个属性
</code></pre>
<h3 id="一对一关系">一对一关系</h3>
<pre><code class="language-python">#注意事项
1.如果两张表数据不统一 是表数据少的去连接数据多的（数据多的是主表）
2.如果数据统一 建哪个东西
sql语句 把外键变成unique（唯一）格式一样
authorDetail=models.OneToOneField(to="AuthorDetail",to_field="nid",on_delete=models.CASCADE)  
</code></pre>
<h3 id="多对一">多对一</h3>
<pre><code class="language-python">1。对于外键不需要唯一性， 
2。不建立外键唯一（使用models.OneToOneField）建立外键
</code></pre>
<h3 id="外键">外键</h3>
<pre><code class="language-python">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,)
可以不写 直接写表名 但是如果加载在之后会报错因为没有预加载出来
</code></pre>
<h2 id="admin使用超级管理员">admin使用超级管理员</h2>
<h3 id="1连接数据库">1.连接数据库</h3>
<p><strong>注意</strong>要先连接数据库才能进入admin页面输入密码进行操作</p>
<pre><code class="language-python">创建与数据库之间的连接
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以上版本
</code></pre>
<h3 id="2创建超级管理员">2.创建超级管理员</h3>
<pre><code class="language-python">写法 createsuperuser
两种写法
1.pycharm的一个控制台 
#1.manage.py@dbcont > createsuperuser#一开始显示这个 
使用createsuperuser创建管理员

2.python控制台
2.1python36 manage.py createsuperuser#创建超级管理员
2.2同理输入账号和密码 邮箱可以不用输入

</code></pre>
<p><strong>创建数据（记录）</strong></p>
<pre><code class="language-python">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.类名（表名）)
</code></pre>
<h3 id="增删改查">增删改查</h3>
<p>在对应子程序的view视图里写增删改查</p>
<p>注意要先引用models模块（对应的models.py文件）</p>
<h3 id="增加">增加</h3>
<h4 id="一对一">一对一</h4>
<pre><code class="language-python"># 一对一
    # au_obj = models.AuthorDetail.objects.get(id=4)
    查询出对应的models对象 存入表类中


    models.Author.objects.create(
        name='海狗',
        age=59,
        # 两种方式
        au_id=4
        # au=au_obj
        #属性对应的值是对应的models对象
    )

</code></pre>
<h4 id="一对多">一对多</h4>
<p>与一对一的区别</p>
<p>对于连接字段没有唯一的约束</p>
<pre><code class="language-python">     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  
         # 如果关键字为数据库字段名称,那么值为关联数据的值
     )
</code></pre>
<h4 id="多对多">多对多</h4>
<p>多对多关系表记录的增加</p>
<pre><code class="language-python"> 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)
创建完字段之后要把对应的关系字段写到第三张表里
</code></pre>
<h3 id="删除">删除</h3>
<h4 id="一对一-1">一对一</h4>
<pre><code class="language-python">models.AuthorDetail.objects.filter(id=3).delete()
models.Author.objects.filter(id=3).delete()
</code></pre>
<h4 id="一对多-1">一对多</h4>
<p>默认级联删除</p>
<p><strong>关联的表是主表 主表删除子表的相对应的整条字段也被删除</strong></p>
<pre><code class="language-python">models.Publish.objects.filter(id=3).delete()#Publish是主表
models.book.objects.filter(id=3).delete()
</code></pre>
<h4 id="多对多-1">多对多</h4>
<pre><code class="language-python">只操作对应第三张表
    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'])  # 先清除对应外键关系字段再添加,相当于修改
    #易错点
    不是在原位置修改是删除这条对应记录，再去添加新纪录
</code></pre>
<h3 id="改-1">改</h3>
<pre><code class="language-python">    # 改
    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值
</code></pre>
<h3 id="基于对象的跨表查询">基于对象的跨表查询</h3>
<pre><code class="language-python">obj=models.Author.objects.get(name='王洋')和filter用法一样出来的类型不一样
obj=models.Author.objects.filter(name='王洋').first()
</code></pre>
<hr>
<h4 id="get和filter的区别">get和filter的区别</h4>
<pre><code class="language-python">    1.filter筛选出来的是queryset对象需要转成model对象
    1.2如果是多个值 需要for循环取值转换
    写法
   a=models.Author.objects.filter()[0]
    a查询出来多个值 这样使用就只能查出一个
    需要for 循环取值
    2.get是对应的model对象 可以直接拿来用
</code></pre>
<h4 id="反向查询和正向查询的区别">反向查询和正向查询的区别</h4>
<pre><code class="language-python">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()
</code></pre>
<hr>
<h3 id="一对一-2">一对一</h3>
<pre><code class="language-python"># 一对一
     正向查询  对象.属性
     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)
</code></pre>
<hr>
<h3 id="一对多-2">一对多</h3>
<pre><code class="language-python">  
  
    # 查询
    # 一对多
    # 查询一下 海狗的怂逼人生这本书是哪个出版社出版的  正向查询
     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)

    
</code></pre>
<h3 id="多对多-2">多对多</h3>
<h4 id="关于多对多正向反向查询的的解释">关于多对多正向反向查询的的解释</h4>
<pre><code class="language-python">一句话概括
	是两个的表的关系属性在哪个表里（类） 不是外键字段存在哪个表
解释
    1.多对多需要建立在数据之上 因为没有数据的支持没办法建立外键，建立外键约束
    2.多对多采用把关系存在第三张表里
    3.基于对象的查询是根据属性查询 
    4.两个表的关系属性在哪个表里 哪个表就是正向查询
</code></pre>
<h4 id="具体事例">具体事例</h4>
<pre><code class="language-python"># 多对多
如果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')
</code></pre>
<h2 id="基于双下划线的跨表查询join">基于双下划线的跨表查询（join）</h2>
<p>原生sql<strong>语句写法</strong></p>
<pre><code class="language-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='技术部';
</code></pre>
<p>在配置里面设置显示orm的操作的原生sql语句</p>
<p><strong>注意</strong></p>
<pre><code class="language-python">1.表的查询先后指定哪个表都可以 
2.value里面是什么 查询出来字典的键就是什么，
3.可以查询出来多个不用.all()
4.属性__字段 小写表名__字段都是关联表字段
</code></pre>
<h3 id="写法">写法</h3>
<pre><code class="language-python">表的查询先后指定哪个表都可以  
#正向查询
写法
models.含有外键关联属性的表名.filter（本表字段=条件）.value( 属性_ _外键字段)
海狗的怂逼人生这本书是哪个出版社出版的


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


</code></pre>
<h4 id="返回多个值">返回多个值</h4>
<pre><code class="language-python">反向查询返回多个值 
写法
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': '海狗的怂逼人生'}]>


</code></pre>
<h3 id="一对一-3">一对一</h3>
<p><strong>示例</strong></p>
<pre><code class="language-python"># 查询一下王洋的电话号码
#正向
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'}]>
</code></pre>
<h3 id="一对多-3">一对多</h3>
<p><strong>示例</strong></p>
<pre><code class="language-python">海狗的怂逼人生这本书是哪个出版社出版的
#正向
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': '海狗的怂逼人生'}]>


</code></pre>
<h3 id="多对多-3">多对多</h3>
<p><strong>示例</strong></p>
<pre><code class="language-python">海狗的怂逼人生 是哪些作者写的
正向 返回多个值
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': '海狗'}]>
</code></pre>
<p><strong>补充</strong></p>
<h2 id="related_name">related_name</h2>
<p>写法</p>
<pre><code class="language-sql">related_name==xxx 别名 注意用了必须用 以后就代指这个字段
</code></pre>
<p>查看原生sql语句的配置</p>
<h2 id="聚合查询">聚合查询</h2>
<p>arregate 聚合</p>
<p>不分组聚合只取一个最大的</p>
<h3 id="注意">注意</h3>
<pre><code class="language-python">1.需要引用模块
2.聚合查询是orm结束符 
3.查询出来的值是python的字典 
4.不能再继续筛选
</code></pre>
<h3 id="用法">用法</h3>
<pre><code class="language-python">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('字段名'))
</code></pre>
<h3 id="示例"><strong>示例</strong></h3>
<pre><code class="language-python"># 计算所有图书的平均价格
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}
</code></pre>
<hr>
<h2 id="分组查询">分组查询</h2>
<p>annotate其实就是对分组结果的统计</p>
<p>分组执行的顺序</p>
<pre><code class="language-python">例如 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的最后结束符
</code></pre>
<p><strong>跨表分组查询本质就是将关联表join成一张表，再按单表的思路进行分组查询,，既然是join连表，就可以使用咱们的双下划线进行连表了。</strong></p>
<p><strong>注意</strong></p>
<pre><code class="language-python">1.查询的平均值的字段必须要起别名 用values进行别名取值  vlues('别名')
2.values是分组的依据 可以属性可以字段 
3.可以直接 model.表名.objects.annotate #默认依据表名的id主键进行分组
</code></pre>
<h3 id="原生sql语句">原生sql语句</h3>
<pre><code class="language-python">#单表
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;
</code></pre>
<h3 id="用法-1">用法</h3>
<pre><code class="language-python">两种写法
第一种 指定字段分组
	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}]>
</code></pre>
<h2 id="f查询">F查询</h2>
<p>比较同一个 model (同一个表)实例中两个不同字段的值。</p>
<p>可以查询出来所有进行修改</p>
<h3 id="用法-2">用法</h3>
<pre><code class="language-python">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
# )
</code></pre>
<h2 id="q查询">Q查询</h2>
<p><code>filter()</code> 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询（例如<code>OR</code> 语句），你可以使用<code>Q 对象</code>。</p>
<h3 id="写法-1">写法</h3>
<pre><code class="language-python">或查询
q()
#注意 
models.Book.objects.filter(Q(id=2),price=3)
不能写在Q()前面会报错
</code></pre>
<h3 id="用法-3">用法</h3>
<pre><code class="language-python">或| 与& 非~
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)
</code></pre>
<h2 id="orm执行原生sql语句">orm执行原生sql语句</h2>
<pre><code class="language-python">raw()# 取的是一个对象
写法
    ret = models.Student.objects.raw('select * from app02_teacher', translations=d)
    for i in ret:
        print(i.id, i.sname, i.haha)
需要for 循环
</code></pre>
<h3 id="自定义sql语句">自定义sql语句</h3>
<p>django封装的</p>
<pre><code class="language-python">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()
</code></pre>
<h1 id="cookie">cookie</h1>
<pre><code class="language-python">1.是保存在用户浏览器上的键值对，向服务端发送请求时会自动携带
2.cookie可以通过 浏览器进行cookie删除
max_age=None 多少秒之后自动失效
expires=None固定的时间
path="/"
domain 可以设置指定域名
http=true 就可以设置cookie 能不能修改
</code></pre>
<h2 id="cookie的使用">cookie的使用</h2>
<h3 id="通过js设置cookie">通过js设置cookie</h3>
<pre><code class="language-js">document.cookie="k1=wy222;path=/"#js写法
$.cookie("k1","wy222",{path:'/'})#jquery写法
</code></pre>
<h3 id="path的作用">path的作用</h3>
<pre><code class="language-python">path默认所有域名"/"
1./ 根目录当前网站的所有的url都能读取到此值
2.""只能在当前页面访问的到此数据
3./index/，只能在/index/xxx的网页中查看

后台默认在根目录也就是path=’/’
cookie修改需要指定根目录 "decument.cookie=121313 path= /"
不写默认path为""
</code></pre>
<p>不安全 可以使用浏览器进行修改可以获取到敏感数据</p>
<h2 id="简单博客登陆">简单博客登陆</h2>
<h2 id="检查数据的库的密码是否正确">检查数据的库的密码是否正确</h2>
<pre><code class="language-python">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})
</code></pre>
<p><strong>为防止通过url直接访问页面 使用cookie进行判断</strong></p>
<h2 id="应用场景">应用场景</h2>
<ul>
<li>投票</li>
<li>每页默认显示数据</li>
<li>登陆认证</li>
</ul>
<p>避免把敏感数据存储在浏览器使用到了session</p>
<h1 id="session">session</h1>
<h3 id="依赖cookie">依赖cookie</h3>
<pre><code class="language-python">是一种存储数据的方式,依赖于cookie,实现本质:    
    用户（浏览器（向服务端发送请求,服务端做两件事:
      1.生成随机字符串;
      2.为此用户开辟一个独立的空间来存放当前用户独有的值（数据）.  
</code></pre>
<h2 id="在空间中如何想要设置值">在空间中如何想要设置值:</h2>
<pre><code class="language-python">  request.session['x1'] = 123        
  request.session['x2'] = 456    
 request.session['x2']如果不存在会报错keyerror错误#在空间中取值:  
request.session.get('x2')    
#视图函数中的业务操作处理完毕,给用户响应,在响应时会 将随机字符串存储到用户浏览器的cookie中
</code></pre>
<h3 id="session中的数据是根据用户相互隔离每个都是独立的">session<strong>中的数据是根据用户相互隔离每个都是独立的</strong></h3>
<pre><code class="language-python">session中的数据是根据用户相互隔离.
示例 
def login(request):    # 获取用户提交的用户名和密码
    user = request.POST.get('user')    				request.session['user_name'] = user     
def index(request):    								print(request.session['user_name'])
</code></pre>
<h2 id="应用场景-1">应用场景</h2>
<ul>
<li>可以权限判断 放置权限</li>
<li>短信验证过期</li>
<li>登陆认证</li>
</ul>
<h2 id="session和cookie的区别">session和cookie的区别</h2>
<pre><code class="language-python">cookie是存储在客户端浏览器上的键值对，发送请求时浏览器会自动携带 
session是一种存储数据方式 依赖cookie基于cookie实现，将数据存储在服务端 (django默认)

</code></pre>
<h2 id="扩展-修改session默认存储位置">扩展 修改session默认存储位置</h2>
<ul>
<li>
<pre><code class="language-python">- （默认在数据库）
- 小系统:默认放在数据库即可. 大系统:缓存(redis)
</code></pre>
</li>
<li></li>
<li>
<h4 id="文件">文件</h4>
</li>
<li>
<pre><code class="language-python">SESSION_ENGINE = 'django.contrib.sessions.backends.file' #引擎把session放入文件中
SESSION_FILE_PATH = '/ssss/' #在根目录的/ssss生成一个随机文件
</code></pre>
</li>
<li>
<h4 id="缓存内存">缓存(内存)</h4>
</li>
<li>
<pre><code class="language-python">SESSION_ENGINE = 'django.contrib.sessions.backends.cache' SESSION_CACHE_ALIAS = 'default'
CACHES = {    
    'default': {        
'BACKEND':'django.core.cache.backends.locmem.LocMem Cache',        
        'LOCATION': 'unique-snowflake',   
 } 
}
</code></pre>
</li>
<li>
<h3 id="缓存redis">缓存(redis)</h3>
</li>
<li>
<pre><code class="language-python">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": "密码",        }    } 
      }

</code></pre>
</li>
<li></li>
</ul>
<h2 id="简单博客登陆session">简单博客登陆（session）</h2>
<h3 id="检查数据的库的密码是否正确-1">检查数据的库的密码是否正确</h3>
<pre><code class="language-python">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')
</code></pre>
<h2 id="操作session">操作session</h2>
<pre><code class="language-python"># 设置(添加&修改) 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（随机字符串）的值

</code></pre>
<h3 id="扩展-django和session相关的配置">扩展 django和session相关的配置</h3>
<pre><code class="language-python">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 会在两周之后过期
</code></pre>
<h3 id="django中的session如何设置过期时间">django中的session如何设置过期时间?</h3>
<pre><code class="language-python">SESSION_COOKIE_AGE = 1209600  # Session的 cookie失效日期（2周）
</code></pre>
						  
					  </div>
						<!--conend-->
							<div class="p-2"></div>

						<div class="arcinfo my-3 fs-7 text-center">
							
							
			<a href='/t/etagid607-0.html' class='tagbtn' target='_blank'>Django</a>							
						



						</div>
						
						<div class="p-2"></div>

						

						
					</div>
					<div class="p-2"></div>
					<!--xg-->
					<div class="lbox p-4 shadow-sm rounded-3">
						<div class="boxtitle"><h2 class="fs-4">相关</h2></div>
						
<hr>				
						
			<div class="row g-0 py-2 border-bottom align-items-center">
																
								<div class="col-7 col-lg-11 border-lg-end">
										<h3 class="fs-6 mb-0 mb-lg-2"><a href="/a/1-565333.html">Django  url路由分配</a></h3>
									
									<div class="ltag fs-8 d-none d-lg-block">
								 

        </div>
								</div>
							
							</div><div class="row g-0 py-2 border-bottom align-items-center">
																
								<div class="col-7 col-lg-11 border-lg-end">
										<h3 class="fs-6 mb-0 mb-lg-2"><a href="/a/1-564431.html">【Mysql学习】django.db.utils.OperationalError: (1045:Access denied for user 'roo</a></h3>
									
									<div class="ltag fs-8 d-none d-lg-block">
								 

        </div>
								</div>
							
							</div><div class="row g-0 py-2 border-bottom align-items-center">
																
								<div class="col-7 col-lg-11 border-lg-end">
										<h3 class="fs-6 mb-0 mb-lg-2"><a href="/a/1-563842.html">web框架们~Django~Flask~Tornado</a></h3>
									
									<div class="ltag fs-8 d-none d-lg-block">
								 

        </div>
								</div>
							
							</div><div class="row g-0 py-2 border-bottom align-items-center">
																
								<div class="col-7 col-lg-11 border-lg-end">
										<h3 class="fs-6 mb-0 mb-lg-2"><a href="/a/1-562875.html">Django Rest Framework的使用</a></h3>
									
									<div class="ltag fs-8 d-none d-lg-block">
								 

        </div>
								</div>
							
							</div><div class="row g-0 py-2 border-bottom align-items-center">
																
								<div class="col-7 col-lg-11 border-lg-end">
										<h3 class="fs-6 mb-0 mb-lg-2"><a href="/a/1-560952.html">Django Admin管理后台详解2(转）</a></h3>
									
									<div class="ltag fs-8 d-none d-lg-block">
								 

        </div>
								</div>
							
							</div><div class="row g-0 py-2 border-bottom align-items-center">
																
								<div class="col-7 col-lg-11 border-lg-end">
										<h3 class="fs-6 mb-0 mb-lg-2"><a href="/a/1-560149.html">【Python之路Day18】Python Web框架之 Django 进阶操作</a></h3>
									
									<div class="ltag fs-8 d-none d-lg-block">
								 

        </div>
								</div>
							
							</div><div class="row g-0 py-2 border-bottom align-items-center">
																
								<div class="col-7 col-lg-11 border-lg-end">
										<h3 class="fs-6 mb-0 mb-lg-2"><a href="/a/1-558547.html">django，inspectdb，操作已经存在的表</a></h3>
									
									<div class="ltag fs-8 d-none d-lg-block">
								 

        </div>
								</div>
							
							</div><div class="row g-0 py-2 border-bottom align-items-center">
																
								<div class="col-7 col-lg-11 border-lg-end">
										<h3 class="fs-6 mb-0 mb-lg-2"><a href="/a/1-555754.html">django rest framework</a></h3>
									
									<div class="ltag fs-8 d-none d-lg-block">
								 

        </div>
								</div>
							
							</div><div class="row g-0 py-2 border-bottom align-items-center">
																
								<div class="col-7 col-lg-11 border-lg-end">
										<h3 class="fs-6 mb-0 mb-lg-2"><a href="/a/1-552070.html">Django Model模型</a></h3>
									
									<div class="ltag fs-8 d-none d-lg-block">
								 

        </div>
								</div>
							
							</div><div class="row g-0 py-2 border-bottom align-items-center">
																
								<div class="col-7 col-lg-11 border-lg-end">
										<h3 class="fs-6 mb-0 mb-lg-2"><a href="/a/1-552041.html">Django基础</a></h3>
									
									<div class="ltag fs-8 d-none d-lg-block">
								 

        </div>
								</div>
							
							</div><div class="row g-0 py-2 border-bottom align-items-center">
																
								<div class="col-7 col-lg-11 border-lg-end">
										<h3 class="fs-6 mb-0 mb-lg-2"><a href="/a/1-550075.html">Django 小实例S1 简易学生选课管理系统 11 学生课程业务实现</a></h3>
									
									<div class="ltag fs-8 d-none d-lg-block">
								 

        </div>
								</div>
							
							</div><div class="row g-0 py-2 border-bottom align-items-center">
																
								<div class="col-7 col-lg-11 border-lg-end">
										<h3 class="fs-6 mb-0 mb-lg-2"><a href="/a/1-550053.html">Django 小实例S1 简易学生选课管理系统 3 创建用户模型(model)</a></h3>
									
									<div class="ltag fs-8 d-none d-lg-block">
								 

        </div>
								</div>
							
							</div>            
            
            <!---->
                                    
           <!---->
  			
						

					</div>
					<!--xgend-->
				</div>

				<div class="col-lg-3 col-12 p-0 ps-lg-2">
					<!--box-->									
					<!--boxend-->
					<!--<div class="p-2"></div>-->

					<!--box-->
									<div class="lbox p-4 shadow-sm rounded-3">
					
									   <div class="boxtitle pb-2"><h2 class="fs-4"><a href="#">标签</a></h2></div>
										<div class="clearfix"></div>
										<ul class="m-0 p-0 fs-7 r-tag">
										</ul>
									

										
										<div class="clearfix"></div>
									</div>
					<!--box end-->

					
				</div>

			</div>
		
		
		
		</div>	

</main>
						<div class="p-2"></div>
<footer>
<div class="container-fluid p-0 bg-black">
	<div class="container p-0  fs-8">
	<p class="text-center m-0 py-2 text-white-50">一品网 <a class="text-white-50" href="https://beian.miit.gov.cn/" target="_blank">冀ICP备14022925号-6</a></p>
	</div>	
</div>
<script>
var _hmt = _hmt || [];
(function() {
  var hm = document.createElement("script");
  hm.src = "https://hm.baidu.com/hm.js?6e3dd49b5f14d985cc4c6bdb9248f52b";
  var s = document.getElementsByTagName("script")[0]; 
  s.parentNode.insertBefore(hm, s);
})();
</script>
</footer>
		
<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.8/dist/js/bootstrap.min.js"></script>

</body>
</html>