DJango学习

DJango

MTV：本质上和MVC没有差别
Model:负责业务对象和数据库对象

Template：负责如何把页面展示给用户 （html页面，相当于MVC里面的View）

View：负责业务逻辑，并在适当的时候调用Model和Template （类似于MVC里面的controller）

【注】DJango还有一个url分发器，它的作用是将一个个url的页面请求分发给不同的view处理，view再调用相应的Model和Template

创建项目:
1.在合适位置创建一个目录
2.打开终端进入到上一步创建的目录下
3、输入 djproject是文件名
4.目录层级说明：
manage.py
一个命令行工具，可以使我们用多种方式对Django项目进行交互

djproject文件夹目录下
init.py 一个空文件，它告诉python这个目录应该被看做一个python包
settings.py 项目配置文件
urls.py 项目的url声明
wsgi.py 项目与WSGI兼容的web服务器入口

启动MYSQL服务：C盘->users->system32->搜索中输入cmd，以管理员身份运行，输入net start mysql56 (56是版本号)

Django学习笔记：
https://blog.csdn.net/u012563006/article/details/82194764

配置数据库:
注意：DJango默认使用SQLite数据库
在setting.py文件中，通过DATABASES选项进行数据库配置

配置MySql

1 安装Django
1.1 Django版本与Python版本对应关系
1.2 安装Django
1.3 安装验证
2 创建项目
3 基本操作
3.1 设计表结构
3.2 配置数据库
3.3 创建应用
3.4 激活应用
3.5 定义模型
3.6 在数据库中生成数据表
3.7 测试数据操作
3.8 启动服务器
3.9 admin站点管理
4 视图的基本使用
4.1 概述
4.2 定义视图
4.3 配置url
5 模板的基本使用
5.1 概述
5.2 创建模板
5.3 配置模板路径
5.4 定义模板
1 安装Django
1.1 Django版本与Python版本对应关系

Django	Python
1.8	2.7, 3.2 (until the end of 2016), 3.3, 3.4, 3.5
1.9, 1.10	2.7, 3.4, 3.5
1.11	2.7, 3.4, 3.5, 3.6
2.0	3.4, 3.5, 3.6
2.1	3.5, 3.6, 3.7

1.2 安装Django
开发环境：pyhton 3.6.4，windows10, Pycharm2018.1

安装
pip install django==1.11.4

卸载
pip uninstall django

1.3 安装验证
python

import django
django.get_version()

2 创建项目
在一个合适的位置创建目录

使用终端进入上一步创建的目录下

执行： django-admin startproject [project_name]

目录层级说明：
project
manage.py 一个命令行工具，可以让我我们使用多种方式对Django项目进行操作

    project目录
        __init__.py     一个空文件，告诉Python这个目录应该被看做一个Python包
        settings.py     项目的配置文件
        urls.py         项目的URL声明，匹配view
        wsgi.py         项目与WSGI兼容的Web服务器入口

3 基本操作
3.1 设计表结构
学生库
班级表结构
表名 grade
字段
班级名称 gname
成立时间 gdate
女生总数 ggirlnum
男生总数 gboynum
是否删除 isDelete
学生表结构
表名 students
字段
学生姓名 sname
学生性别 sgender
学生年龄 sage
学生简介 scontend
所属班级 sgrade
是否删除 isDelete

3.2 配置数据库
注意：Django 默认使用sqlite3

在settings.py文件中，通过DATABASES进行数据库配置

配置MySQL
python3.x 安装的是PyMySQL； python2.x 安装的是mysql-python

    在__init__.py写入两行代码
        import pymysql
        pymysql.install_as_MySQLdb()

    配置 settings.py
        DATABASES = {
            'default': {
               'ENGINE': 'django.db.backends.mysql',
               	      'NAME': 'kaige',
                         "USER":'root',
                         'HOST':'localhost',
                         'PASSWORD':'123456',
                        'PORT':'3306',
            }
        }

3.3 创建应用
在每个项目中可以创建多个应用，每个应用进行一种业务处理；

打开终端，进入项目目录下；(E:\python文件\Django study\djproject)

执行： python manage.py startapp myApp

【注】Traceback (most recent call last):
File “manage.py”, line 8, in
from django.core.management import execute_from_command_line
ImportError: No module named ‘django’

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
File “manage.py”, line 14, in
import django
ImportError: No module named ‘django’

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
File “manage.py”, line 17, in
"Couldn’t import Django. Are you sure it’s installed and "
ImportError: Couldn’t import Django. Are you sure it’s installed and available on your PYTHONPATH environment variable? Did you forget to activate a virtual environment?

当报这个错误的时候，需要在使用的项目目录下的project目录下再安装一下Django包 (pip install django)

myapp 目录说明：
admin.py 站点配置
models.py 模型
views.py 视图

3.4 激活应用
在 settings.py 文件中，将myapp应用加入到 INSTALLED_APPS 中；

INSTALLED_APPS = [
‘django.contrib.admin’,
‘django.contrib.auth’,
‘django.contrib.contenttypes’,
‘django.contrib.sessions’,
‘django.contrib.messages’,
‘django.contrib.staticfiles’,
‘myapp’
]

3.5 定义模型
概述： 有一个数据表，就对应一个模型；

在 models.py 文件中定义模型：
引入 from django.db import models

    模型要继承 models.Model 类    (类里面的属性就对应数据库表中的字段)

            class Grades(models.Model):
                gname = models.CharField(max_length=20)
                gdate = models.DateTimeField()
                ggirlnum = models.IntegerField()
                gboynum = models.IntegerField()
                isDelete = models.BooleanField(default=False)

            class Students(models.Model):
                sname = models.CharField(max_length=20)
                sgender = models.BooleanField(default=True)
                sage = models.IntegerField()
                scontend = models.TextField()
                isDelete = models.BooleanField(default=False)
                # 关联外键
                sgrade = models.ForeignKey('Grades',on_delete=models.CASCADE)

说明：
不需要定义主键，在生成表时自动添加，并且值为自动增加；
一个表对应一个模型类
一个类属性对应标的一个字段

3.6 在数据库中生成数据表
1.生成迁移文件
在项目文件下的project文件下打开shell命令窗口执行： python manage.py makemigrations
迁移文件在：myapp/migrations/0001_inital.py
此时数据库中还没有生成数据表

2.执行迁移：
执行： python manage.py migrate
相当于执行 sql 语句创建数据表

备注：
带上appname只会生成对应app的数据表；
不带，则会生成全部的数据表，包括一些系统的默认表；

3.7 测试数据操作
进入python shell(还是上面的终端环境)，执行： python manage.py shell

引入一些包(还是上面的终端环境)
from myApp.models import Grades, Students
from django.utils import timezone
from datatime import *

查询所有数据
类名.objects.all()
Grades.objects.all() #查看所有数据，结果现在为空

    重写 __str__方法，可以看到对象的值：
        def __str__(self):
            return '%s | %s | %s' % (self.gname, self.gdate, self.gnum)

添加数据
本质： 创建一个模型类的对象实例；（在终端中输入）
grade1 = Grades()
grade1.gname = ‘python’
grade1.gdate = datetime(year=2018, month=2, day=14)
grade1.ggirlnum=3
grade1.gboynum=2
grade1.save() #保存后数据表中才有数据

查看某个对象
类名.objects.get(pk=2) pk == primary_key #（Grades.objects.get(pk=2)）还是在终端操作

修改数据
grade2 = Grades.objects.get(pk=2)
grade2.ggirlnum = 20
grade2.save()

删除数据
grade2.delete()
注意：是物理删除，数据库中的表里的数据被删除了；

如果关了shell命令窗口，需要重新导入包：
引入一些包(还是上面的终端环境)
from myApp.models import Grades, Students
from django.utils import timezone
from datatime import *

关联对象
grade1 = Grades.objects.get(pk=1) 此处相当于设置了外键，外键是Grades表中第一行的id
stu = Students()
stu.sname = ‘jane’
stu.sgender=False
stu.sage=18
stu.scontend= “i am jane.”
stu.sgrade = grade1
stu.save() #如果保存不成功可能是编码格式错误，可以设置表格的sname和scontent为utf8

    获取关联对象的集合
            需求：获取 python 04班所有学生
                    对象名.关联的类名小写_set.all()
                        grade1.students_set.all() 找到grade1班所有的学生，grade1.students_set调用all()方法


            需求：给 python04 班创建allen
                        stu3 = grade1.students_set.create(sname='allen', sgender=True, sage=30, scontend='i am allen.')
                    注意：直接添加到数据库中，不用调用save方法

3.8 启动服务器
格式：
执行：python manage.py runserver ip:port
ip 可以不写，不写代表localhost
port默认8000
执行：python manage.py runserver

说明：
这是纯python写的轻量级web服务器，只在测试开发时使用；
浏览器输127.0.0.1:8000/

3.9 admin站点管理（让我们有一个可视化界面来管理数据）
概述：
内容发布：
负责添加、修改、删除内容（数据库中数据）
公告访问

配置admin应用：
在 setting.py 文件的 INSTALLED_APPS 中添加 django.contrib.admin(默认自动配置好了，不用自己写 )

创建管理员用户：（重新打开shell窗口,原窗口不能关闭，否则服务器中断）
执行：python manage.py createsuperuser
一次输入 用户名、邮箱、密码(8位，非字典密码) （username:sunck password:1234567890a）
访问：127.0.0.1:8000/admin登录管理界面

汉化（给admin页面汉化）：
修改 settings.py
LANGUAGE_CODE = ‘zh-Hans’
TIME_ZONE = ‘Asia/Shanghai’

管理数据表：
修改 myApp包下 admin.py：
from .models import Grades, Students
# 注册
admin.site.register(Grades)
admin.site.register(Students)

    自定义管理页面：(上面的注册抛掉)
            class GradesAdmin(admin.ModelAdmin):#ModelAdmin默认的界面

            # 列表页属性
                list_display = ['pk', 'gname', 'gdate', 'gbnum', 'ggnum']       # 显示表的字段(pk 是主键，也可以用字段名id)
                list_filter = ['gname']             # 右侧添加过滤字段栏，使用字段以及字段值来过滤数据
                search_fields = ['gdate']           # 增加搜索框，定义哪些字段的值能够搜索
                list_per_page = 5                   # 分页，每页显示的数据数量

            # 添加、修改页的属性 (注意 fields 和 fieldsets 不能同时使用)
                fields = ['gname', 'gbnum', 'ggnum', 'gdate', 'isDelete']         # 属性的先后顺序：修改表单的显示顺序

                fieldsets = [                                           # 给属性分组
                    ('Base', {"fields": ['sname', 'sgender', 'sage']}),# 分为 Base和Other分组，Base有sname,sgender,sage属性，顺序是由fields规定的
                    ('Other', {"fields": ['sgrade', 'scontend'， 'isDelete']})
                ]

            admin.site.register(Grades, GradesAdmin)#加在注册里面才能用到里面属性


    关联对象：
            需求：在创建一个班级时，可以直接添加几个学生；
                    class StudentsInfo(admin.TabularInline):
                        model = Students        # 和 Students 模型关联
                        extra = 2               # 创建班级时，添加两个学生
                    # 注册
                    class GradesAdmin(admin.ModelAdmin):
                        inlines = [StudentsInfo]   #意思是加两行
            备注：
                    admin.TabularInline     把需要填写的表单，放在一行显示
                    admin.StackedInline     把需要填写的表单，逐行显示


    boole值显示问题：
            class StudentsAdmin(admin.ModelAdmin):
                def gender(self):   #封装一个函数
                    if self.sgender:
                        return '男'
                    else:
                        return '女'
            # 设置页面列的名称
                gender.short_description = '性别'
                list_display = ['id', 'sname', 'sage', gender, 'scontend', 'sgrade']


    列表标题显示问题：
            age = lambda self: self.sage
            age.short_description = '年龄'
            list_display = ['id', 'sname', age, gender, 'scontend', 'sgrade']


    执行动作操作框位置：
        actions_on_bottom = True
        actions_on_top = False      # 默认是 True


    使用装饰器完成注册
        @ admin.register(Students)
        class StudentsAdmin(admin.ModelAdmin):
        ...
        ...
        # admin.site.register(Students, StudentsAdmin)

4 视图的基本使用
4.1 概述
在 Django 中，视图对web请求进行回应；
视图就是一个 python 函数，在 views.py 中定义；

4.2 定义视图
from django.shortcuts import render

Create your views here.

from django.http import HttpResponse
def index(request):
return HttpResponse(‘Python is Best!’)

4.3 配置url
修改 class(工程) 目录下的 urls.py 文件
from django.conf.urls import url,include
from django.contrib import admin
urlpatterns = [
url(r’^admin/’, admin.site.urls),
url(r’^’, include(‘myapp.urls’)), #相当于会调用myapp下的urls.py里面的网址
]

在myapp应用目录下创建一个 urls.py
from django.conf.urls import url
from . import views
urlpatterns = [
url(r’^KaTeX parse error: Undefined control sequence: \d at position 37: … url(r'^(\̲d̲+)/(\d+)’,views.detail),#加（）在正则中表示组的概念,正则匹配url中输入的数字此时输入网址http://127.0.0.1:8000/2/100，出现页面

]

修改在myapp应用目录下view.py，（view.py文件显示页面的内容）
from django.shortcuts import render

Create your views here.

from django.http import HttpResponse

def index(request):
return HttpResponse(“sunck is a good man”)

def detail(request,num,num2):
return HttpResponse(“detail-%s-%s”%(num,num2))

5 模板的基本使用
5.1 概述
模板是HTML页面，可以根据视图传递过来的数据进行填充；

5.2 创建模板
创建 templates 目录（目录与myApp和project下的project同级），在目录下创建对应模板目录 project/templates/myapp

5.3 配置模板路径
修改 settings.py 文件下 TEMPLATES, 把templates添加到DIRS中：
TEMPLATES = [
{
‘BACKEND’: ‘django.template.backends.django.DjangoTemplates’,
‘DIRS’: [os.path.join(BASE_DIR, ‘templates’)]，
‘APP_DIRS’: True,

5.4 定义模板
在 class/templates/myapp 下创建 grades.py 和 students.py
模板语法：
{{输出值，可以是变量，也可以是对象.属性}}
{%执行代码段%}

    需求：http://127.0.0.1:8000/grades

           1. 编辑 grades.html 模板:
                    
班级信息列表
                    

                        {% for grade in grages %}
                        

                            {{ grade.gname }}
                        
                        {% endfor %}
                    


            2.定义视图view.py：
                    from .models import Grades
                    def grades(requests):
                        # 去model取数据
                        gradesList= Grades.objects.all()
                        # 将数据传递给模板，再渲染页面，将渲染好的页面返回给浏览器
                        return render(requests, 'myapp/grades.html', {'grades': gradesList})
                        #            request参数     模板路径      模板中接收的参数名: 传递的数据

           3. 配置url:
                    url(r'^grades/$', views.grades),


    需求：http://127.0.0.1:8000/students
            编辑 students.html 模板：
                    
学生信息表
                    

                        {% for studentInfo in student %}
                        

                            {{ studentInfo.id }}-{{ studentInfo.sname }}-{{ studentInfo.sage }}-{{ studentInfo.scontend }}
                        
                        {% endfor %}
                    

            定义视图：
                    def student(request):
                        studentList = Student.objects.all()
                        return render(request, 'myapp/student.html', {'student': studentList})

            配置url：
                    url(r'^student/$', views.student),


    需求：点击班级显示对应学生信息
            复用 students.html 模板

            修改 grades.html 让URL传参：
                    {{ gradeInfo.gname }}

            定义视图：
                    def gradeStudent(request, num):
                        grade = Grade.objects.get(pk=num)
                        studentList = grade.student_set.all()  #班级里把所有学生信息拿出来
                        return render(request, 'myapp/student.html', {'student': studentList})

            配置url：
                    url(r'^grade/(\d+)$', views.gradeStudent),

如果需要新添表格，则需要重新添加model,重新生成迁移文件，重新迁移，
如果需要修改表中的字段，则直接删除之前数据库和迁移文件，重新生成数据库。

    需求：通过主页分别访问 grades students admin
            编辑 index.html 模板：
                    
admin
                    
Grade
                    
Student

            修改视图：
                    def index(request):
                        return render(request, 'myapp/index.html')

            配置url：
                    url(r'^$', views.index),

---

模型：
Django对各种数据库提供了很好的支持，Django为这些数据库提供了统一的调用API，可以根据不同的也无需求选择数据库

配置数据库：
1.修改工程目录下的_init_.py文件
import pymysql
pymysql.install_as_MySQLdb()

2.修改settings.py文件
DATABASES = {
‘default’: {
‘ENGINE’: ‘django.db.backends.mysql’,
‘NAME’: “sunck”,
“USER”:‘root’,
‘HOST’:‘localhost’,
‘PASSWORD’:‘123456’,
‘PORT’:‘3306’,
}
}
开发流程：
配置数据库：
定义模型类：一个模型类都在数据库中对应一张数据表
生成迁移文件
执行迁移生成数据表
使用模型类进行增删改查（crud）操作

ORM
对象-关系-映射

任务：
1.根据对象的类型生成表结构
2.将对象，列表的操作转换为sql语句
3.将sql语句查询到的结果转换为对象，列表

优点：极大地减轻了开发人员的工作量，不需要面对因数据库的改变而修改代码

定义模型：模型，属性，表字段间的关系:一个模型类在数据库中对应一张表，在模型类中定义的属性，对应该模型对照表中的字段

定义属性：
Django根据属性的类型确定以下信息
。当前选择的数据库支持字段的类型
。渲染管理表单时使用的默认html控件
。在管理站点最低限度的验证
Django会为表增加自动增长的主键列，每个模型只能有一个主键列：如果使用选项设置某属性为主键列后，则Django不会再生成默认的主键列
属性命名限制
遵循标识符规则
由于Django的查询方式，不允许使用连续的下划线

库
。定义属性时，需要字段类型，字段类型被定义在django.db.models.fields目录下，为了方便使用，被导入到django.db.models中

使用方式
。导入from django.db import models
。通过models.Field创建字段类型的对象，赋值给属性
逻辑删除
。对于重要数据都做逻辑删除，不做物理删除，实现方法是定义isDelete属性，类型为BooleanField,默认值为False
字段类型
AutoField
一个根据实际ID自动增长的IntegerField，通常不指定如果不指定，一个主键字段将自动添加到模型中

CharField(max_length=字符长度)
字符串，默认表单样式是TextInput
TextField
大文本字段，一般超过4000使用，默认表单控件是Textarea

IntegerField
整数
DecimalField(max_digits=None,decimal_places=None)
使用python的Decimal实例表示十进制浮点数
max_digits位数总数
decimal_places小数点后的数字位数
FloatField
用python的float实例来表示浮点数
BooleanField
true/flase字段，默认表单控制是CheckBoxInput

NullBooleanField
支持null,true,false三种值
DataField([auto_now=False,auto_now_add=False])#参数可加可不加，
DataField.auto_now
每次保存对象时，自动设置该字段为当前时间，用于“最后一次修改”的时间戳，它总是使用当前日期，默认为false
auto_now_add
当对象第一次被创建时自动设置当前时间，用于创建的时间戳，它总是使用当前时间，默认为false
TimeField
DataTimeField
使用python的datatime
datatime实例表示的日期和时间，参数同DateField
这两个设置和default是相互排斥的，他们之间的任何组合将会发生错误的结果
属性设置：g.gdate=datetime(year=2017,month=7,day=17)
FileField
一个上传文件的字段
ImageField
继承了FileFieldde的所有属性和方法，但对上传的对象进行校验，确保它是个有效的image

字段选项
概述
通过字段选项，可以实现对字段的约束
在字段对象时通过关键字参数指定
null
如果为True,Django将空值以NULl存储到数据库中，默认值为False
blanke
如果为True,则该字段允许为空白，默认值是False
注意：
null是数据库范畴的概念，blank是表单验证范畴的

db_column
字段的名称，如果未指定，则使用属性名称
sage=models.IntegerField(db_column=“age”)在数据库中的列名是age,不写的话默认sage
db_index
若值为True，则在表中会为此字段创建索引
default
默认值
primary_key
若为True,则字段会成为模型的主键字段
unique
如果为True,这个字段在表中必须有唯一值

关系：
分类
ForeignKey:一对多，将字段定义在多的端中
ManyToMainField:多对多，将字段定义在两端中
OneToOneField:一对一，将字段定义在任意一端中

用一访问多：
格式
对象.模型类小写_set
示例
grade.student._set

元选项：
在模型类中定义Meta类，用于设置元信息

db_table定义数据表名，推荐使用小写字母，数据表名默认为项目名小写，类名小写，是在每个定义的model类内部定义一个class Meta:
ordering:对象的默认排序字段，获取对象的列表时使用
ordering=[‘id’]升序
ordering=[’-id’]降序

注：排序会增加数据库的开销
class Student(models.Model):
sname=models.CharField(max_length=20)
sgender=models.BooleanField(default=True)
sage=models.IntegerField(db_column=“age”)#数据库列名设置为age
scontend=models.CharField(max_length=20)
isDelete=models.BooleanField(default=False)
#关联外键
sgrade=models.ForeignKey(‘Grades’,on_delete=models.CASCADE)
def str(self):
return self.sname
lastTime=models.DateTimeField(auto_now=True)
createTime=models.DateTimeField(auto_now_add=True)
class Meta:
db_table=“students”
ordering=[“id”]

模型成员：
类属性：objects是Manager类型的一个对象，作用是与数据库进行交互
当定义模型类时没有指定管理器，则Django为模型创建一个名为objects的管理器

自定义管理器：当为模型指定模型管理器，Django就不在为模型类生成objects模型管理器
class Student(models.Model):
#自定义模型管理器
#当自定义模型管理器，objects就不存在了
stuObj=models.Manager()
自定义管理器Manager类:模型管理器是Django的模型与数据库进行交互的接口，一个模型类可以有多个模型管理器
作用：向管理器类中添加额外的方法
修改管理器返回的原始查询集------重写get-queryset()方法
class StudentManager(models.Manager):
def get_queryset(self):#重写get_queryset方法
return super(StudentManager,self).get_queryset().filter(isDelete=False)
class Student(models.Model):
#自定义模型管理器
#当自定义模型管理器，objects就不存在了
stuObj=models.Manager()
stuObj2=StudentManager()

创建对象：
目的;向数据库中添加数据
当创建对象时，Django不会对数据库进行读写操作，当调用save()方法时，才与数据库进行交互，将对象保存到数据库表中
注意：__init__方法已经在父类models.Model中使用，在自定义的模型中无法使用

方法：
1.在模型类中增加一个方法
model.py:
class Student(models.Model):
#自定义模型管理器
#当自定义模型管理器，objects就不存在了
stuObj=models.Manager()
stuObj2=StudentManager()

sname=models.CharField(max_length=20)
sgender=models.BooleanField(default=True)
sage=models.IntegerField()
scontend=models.CharField(max_length=20)
isDelete=models.BooleanField(default=False)
#关联外键
sgrade=models.ForeignKey('Grades',on_delete=models.CASCADE)
def __str__(self):
    return self.sname

#定义一个类方法创建对象
@classmethod
#cls就代表Students类
def createStudent(cls,name,age,gender,contend,sgra,isD=False):
    stu=cls(sname=name,sage=age,sgender=gender,scontend=contend,isDelete=isD,sgrade=sgra)
    return stu

url.py:
url(r’^addstudent/$’,views.addstudent),
Views.py:
def addstudent(request):
stu=Student.createStudent(‘liudehua’,34,True,“I am liudehua”,“python04”)
stu.save()
return HttpResponse(“aaaaa”)

2. 在定义管理器中添加一个方法(对应了模型管理器的作用：向管理器类添加额外的方法)

models.py:
class StudentManager(models.Manager):
def get_queryset(self):
return super(StudentManager,self).get_queryset().filter(isDelete=False)

def createStudent(self,name,age,gender,contend,sgra,isD=False):
    stu=self.model()
    stu.sname=name
    stu.sage=age
    stu.sgender=gender
    stu.contend=contend
    stu.sgrade=sgra
    return stu

view.py:
def addstudent2(request):
grade = Grades.objects.get(pk=1)
stu=Student.stuObj2.createStudent(‘zhangxueyou’,34,True,“I am zhangxueyou”,grade)
stu.save()
return HttpResponse(“aaaaa”)

---

模型查询：
概述：
查询集表示从数据库获取的对象集合:
查询集有多个过滤器
过滤器就是一个函数，基于所给的参数限制查询集结果
从sql角度来说，查询集合select语句等价，过滤器就像where条件

查询集：
在管理器上调用过滤器方法返回查询集
查询集经过过滤器筛选后返回新的查询集，所有可以写成链式调用
惰性执行：创建查询集不会带来任何数据的访问，直到调用数据时，才会访问数据
直接访问数据的情况：
迭代：
序列化:
与if合用:
返回查询集的方法称为过滤器：
all()返回查询集中的所以数据
filter 保留符合条件的数据
filter(键=值)
filter(键=值，键=值)
filter(键=值).filter(键=值)
exclude()过滤掉符合条件的数据
order_by()排序
values() 一条数据就是一个对象（字典），返回一个列表
返回单个数据：
get()------返回一个满足条件的对象
-------注意：如果没有找到符合条件的对象，会引发“模型类.DoesNotExist“异常
---------如果找到多个对象，会引发“模型类.MultipleObjectsReturned”异常

count()------返回当前查询集中的对象个数
first()------返回查询集中的第一个对象
last()------返回查询集中的最后一个对象
exists()--------判断查询集中是否有数据，如果有数据返回True

限制查询集：
查询集返回列表，可以使用下标的方法进行限制，等同于sql中的limit语句
studentsList=Student.objects.all()[0,5]
注意：下标不能是负数
#分页显示学生
def stupage(request,page):
#0-5 5-10 10-15
# 1 2 3
#page*5
page=int(page)
studentsList = Student.objects.all()[(page-1)5:page5]
return render(request, ‘myApp/students.html’, {“student”: studentsList})
查询集的缓存：
概述：每个查询集都包含一个缓存，来最小化的对数据库访问
在新建的查询集中，缓存首次为空，第一次对查询集求值，会发生数据缓存，Django会将查询出来的数据做一个缓存，并返回查询结构，以后查询直接使用查询集的缓存

字段查询：概述：实现了sql中的where语句，作为方法filter(),exclude(),get()的参数

                      比较运算符	。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
                                         eq相等   ne、neq不相等，   gt大于， lt小于 gte、ge大于等于   lte、le 小于等于   not非   mod求模
   # studentsList=Student.stuObj2.filter(sname_contains="sun")
                                                    # return render(request,'myApp/students.html',{"student":studentsList})
							# studentsList = Student.stuObj2.filter(sname_startswith="sun")
						#studentsList = Student.stuObj2.filter(pk__in=[2,4,6,8,10])
						#studentsList = Student.stuObj2.filter(sage__gt=30)
						#studentsList = Student.stuObj2.filter(lastTime__year=2017)
						 studentsList = Student.stuObj2.filter(sname__=2017)

跨关联查询：处理join查询-----语法：模型类名__属性名__比较运算符（必须使用外键作为查询条件）
查询快捷：pk:代表主键

 聚合函数：使用aggregate()函数返回聚合函数的值

from django.db.models import Max
#调用之前需要先导入这个函数的包
maxAge=Student.stuObj2.aggregate(Max(“sage”))
Avg
Count
Max
Min
Sum
F对象：可以使用模型A属性与b属性进行比较（班级表中的那是数目和女生数目）(同一条数据的两个字段进行比较)

from django.db.models import F,Q
def grades(request):
Grades.objects.filter(ggirlnum__gt=F(‘gbounum’))
#gt表示大于
print(g)
return HttpResponse(“qqqqqqqq”)
支持F对象的算术运算：
Grades.objects.filter(ggirlnum__gt=F(‘gbounum’)+20)

Q对象： 概述：过滤器的方法中的关键字参数，条件为And模式
需求：进行or查询
解决:使用Q对象（实现或的关系或者实现非的关系）
studentList=Students.stuObj2.filter(Q(pk__lte=3) | Q(sage__lte=80))
studentList=Students.stuObj2.filter(pk__lte=3)
studentList=Students.stuObj2.filter(~Q(pk__lte=3)) 取反

---

视图：
概述：
作用：视图接受web请求，并响应web请求
本质：视图就是一个python中的一个函数
响应：
网页：重定向
错误视图：404
500(服务器内部错误)

JSON数据（网页里面发生AJAX请求）

过程：用户在浏览器输入一个网址，-----网址-----> Django获取网址信息（去除IP和端口），-------虚拟路径与文件名------>URL管理器（逐个匹配urlconf，记录视图函数名）-----------视图函数名---------->视图管理器（找到对应的视图去执行，返回结果给浏览器）----------响应的数据------------>用户浏览器

url配置：配置流程—制定根级url配置文件-----settings.py文件中的 ROOT_URLCONF
----------ROOT_URLCONF = ‘djproject.urls’(默认实现了)
url.py文件中：urlpatterns：一个url实例的列表
url对象----正则表达式
-----视图名称
名称
url匹配正则的注意事项：如果想要从url中获取一个值，需要对正则加小括号
匹配正则前方不需要加反斜杠/
正则前需要加r表示字符串不转义

引用其他url配置-----在应用中创建urls.py文件，定义本应用的url配置，在工程urls.py文件中使用include()方法
from django.contrib import admin
from django.urls import path,include
from django.conf.urls import url,include
urlpatterns = [
path(‘admin/’, admin.site.urls),
url(r’^’,include(‘myApp.urls’,namespace=“myApp”)),

匹配过程：

url反向解析：概述：如果在视图，模板中使用了硬编码的链接，在url配置发生改变时，动态生成链接的地址

解决：在使用链接时，通过url配置的名称，动态生成url地址

作用：使用url模板的时候
urlpatterns = [
url(r’^KaTeX parse error: Undefined control sequence: \d at position 42: …), url(r'^(\̲d̲+)/(\d+)’,views.detail),#加（）在正则中表示组的概念

url(r'^grades/$',views.grades),
url(r'^student/$',views.students),
url(r'^student3/$',views.students3),
url(r'^stu/(\d+)/$',views.stupage),
url(r'^grades/(\d+)$',views.gradesStudents),
url(r'^addstudent/$',views.addstudent),
url(r'^addstudent2/$',views.addstudent2),
url(r'^studentssearch/$',views.studentssearch),
url(r'^grades/$',views.grades),

]

视图函数-----定义视图：本质：一个函数
视图参数：request（一个HttpRequest的实例，是浏览器发过来的内容）
通过正则表达式获取的参数
位置：一般在views.py文件下定义

错误视图：404视图：找不到网页（url匹配不成功）时返回
在Template目录下定义404.html（命名必须是404）----------------------request.path导致错误的网址
配置settings.py------ DEBUG 如果为True永远不会调用404.html
ALLOWED_HOSTS=[’*’]

404页面

页面丢失

{{request_path}}

     500视图：在视图代码中出现错误（服务器代码）
    400视图：错误出现在客户操作

HttpRequest对象：概述：服务器接收http请求后，会根据报文创建HttpRequest对象
视图的第一个参数就是HttpRequest对象
Django创建的，之后调用视图时传递给视图

属性：path:请求的完整路径，不包括域名和端口
method：表示请求的方式，常用的有，get,post
encoding:表示浏览器提交的数据的编码方式，一般为utf-8
GET：类似于字典的对象，包含get请求的所有参数
POST:类似于字典的对象，包含了post请求的所以参数
FILES:类似于字典的对象，包含了所以长传的文件
COOKIES:字典，包含所以得cookie
session:类似字典的对象，表示当前会话

方法：is_ajax()--------如果是通过XMLHttpRequest发起的，返回True

QuertDict对象------------request对象中的GET,POST都属于QueryDict
方法-------get() 作用：根据键获取值（只能获取一个值）www.sunck.wang/abc?a=1&b=2&c=3

                                                 getlist()   将键的值以列表的形式返回（可以获取多个值）www.sunck.wang/abc?a=1&a=2&c=3

Get属性（获取浏览器传递过来给服务器的数据）-----
http://127.0.0.1:8000/sunck/get1?a=1&b=2&c=3(在浏览器中输入这个网址，)
urls.py:
url(r’^get1’,views.get1),
views.py:
def get1(request):
a = request.GET.get(‘a’)
b = request.GET.get(‘b’)
c = request.GET.get(‘c’)
return HttpResponse(a + " "+ b + “” +c) #网址上出现1 2 3即获取到网址携带的参数

     http://127.0.0.1:8000/sunck/get1?a=1&a=2&c=3   （a有多个value的时候）
     url(r'^get2', views.get1),

def get2(request):
a=request.GET.getlist(‘a’)
a1=a[0]
a2=a[1]
c=request.GET.get(‘c’)
return HttpResponse(a1 + " "+ a2 + “” +c)

Post属性：使用表单提交实现Post请求

def showregister(request):
return render(request,‘myApp/regist.html’)
def register(request): #获取的信息可以，用模型类创建一个对象，将信息存储到数据库表中
name=request.POST.get(“name”)
gender=request.POST.get(“gender”)
age = request.POST.get(“age”)
hobby=request.POST.getlist(“hobby”)
print(name)
print(gender)
print(age)
print(hobby)
return HttpResponse(“aaaa”)
注册页面：

注册 姓名:

---

性别：男女

---

年龄:

---

爱好:权利金钱男孩女孩

---

如果出现CSRF错误； 在settings.py中注释 MIDDLEWARE = [ 'django.middleware.security.SecurityMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', #'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware',

HttpResponse对象：概念：作用：给浏览器返回数据
HttpRequest对象是由Django创建的，HttpResponse对象是由程序员创建的
用法：不调用模板： def addstudent2(request):
grade = Grades.objects.get(pk=1)
stu=Student.stuObj2.createStudent(‘zhangxueyou’,34,True,“I am zhangxueyou”,grade)
stu.save()
return HttpResponse(“aaaaa”)

       调用模板:使用render方法：原型：render(request,templateName[,context])
                                  作用:结合数据和模板，返回完整的HTML页面
                    参数：request：请求体对象
                                                  templateName:模板路径
                                                   Context:传递给需要渲染在模板上的数据
                    
                                  示例：def gradesStudents(request,num):
                                #获得对应班级对象
                                           grade=Grades.objects.get(pk=num)
                                           studentsList=grade.student_set.all()#获得班级下所有学生对象列表
                                            return render(request,'myApp/students.html',{"student":studentsList})

HttpResponse对象：属性：content：表示返回的内容
charset:编码格式
status_code：响应状态码：200，304，404
content-type:指定输出的MIME类型

                            方法：init:使用页面内容实例化HttpResponse对象

write()：以文件的形式写入 def cookietest(request):
res=HttpResponse()
cookie=res.set_cookie(“sunck”,“good”)#此时cookie的值就存进去了
return res
set_cookie(key,value=’ ’ ,max_age=None,exprise=None)
flush():以文件的形式输出缓冲区
delete_cookie(key):删除cookie
注：如果删除一个不存在的key,就当什么都没发生

                     子类HttpResponseRedirect：功能------------重定向（服务器端跳转）：输入一个网址通过View.py跳转到另外一个网址页面
                                                                                                                简写--------redirect(to)
                                                                                                                 to推荐使用反向解析

from django.http import HttpResponseRedirect
from django.shortcuts import redirect
def redirect1(request):
return HttpResponseRedirect(’/sunck/redirect2’)
return redirect(’/sunck/redirect2’)
def redirect2(request):
return HttpResponse(“我是重定向后的视图”)

                                   子类JsonResponse-----返回json数据，一般用于异步请求
                                              __init__(self,data)
                                   data---字典对象
                                   注意----------Content-type类型为application/json

状态保持：
概述：http协议是无状态的，每次请求都是一次新的请求，不记得以前的请求
客户端与服务端的一次通信就是一次会话
实现状态保持，在客户端或者服务端存储有关会话的数据

                       存储的方式：cookie----所以得数据都存在客户端，不要存放敏感的数据
    session------所以得数据存储在服务端，在客户端用cookie存储session_id
 状态保持的目的：在一段时间内跟踪请求者的状态，可以实现跨页面访问当前的请求者的数据
 
  注意：不同的请求者之间不会共享数据，与请求者是一一对应的。


        启用session:settings文件中-----INSTALL_APPS    'django.contrib.sessions',
                                                                           MIDDLEWARE      'django.contrib.sessions.middleware.SessionMiddleware',


        使用session：每个HttpRequest对象都有一个session属性，就是一个类似字典的对象
    get(key,dafault=None) 根据键获取session值

main.html:

我的

欢迎:{{username}}

登录> login.html 登录

Views.py

#session
def main(request):
#取session
username=request.session.get(‘name’,“游客”) #根据键取值，如果没取到，就取后面这个值（游客）
return render(request,‘myApp/main.html’,{‘username’:username})

def login(request):
return render(request,‘myapp/login.html’)

def showmain(request):
username=request.POST.get(‘username’) #游客登录为注册用户时（login.html）获取登录名
#存储session,session是一个键值对
request.session[‘name’]=username
return redirect(’/sunck/main/’) #重定向

urls.py:
url(r’^main/${}^{\prime },views.main),url(r^{\prime l}ogin/$’,views.login),
url(r’^showmain/$’,views.showmain),
clear()清空所以得会话
flush()删除当前的会话并删除会话的cookie