2020-08-04  0aea0a39a8ea64777683e6402e39acc7 99+   1 小时   8.1 k  0次访问

python3之Django

一,Django基础

1.安装

通过pip安装Django。

在cmd命令行中输入下面代码，然后回车进行下载安装。

1
2
3
pip install Django==2.2.6  -i https://pypi.tuna.tsinghua.edu.cn/simple some-package
pip install Django  #默认是安装最新的
pip uninstall Django #卸载

其中2.2.6为版本号，-i和后面是表示使用国内镜像进行下载。

验证安装成功和查看版本

在cmd命令行中输入pip list

1
2
3
4
>>> import django
>>> django.get_version()
'3.0.6'
>>>

2，创建项目

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
在合适的地方创建目录我命名Django1， cmd进入该目录输入命令
django-admin startproject project   

D:\py_work\Django1>tree . /F  #查看目录层级

目录层级说明
	manage.py    
		一个命令行工具，可以使我们用多种方式对Django项目进行交互
	
	
	project目录	
		__init__.py  一个空文件，它告诉Python这个项目应该被看作是一个python包
		settings.py  项目的配置文件
		urls.py		 项目的url声明
		wsgi.py		 项目与WSGI兼容的web服务器入口

3，Django基本操作

基本操作

1、设计表结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
设计表结构

	班级表结构
		表名:
			Grades
		
		字段:
			班级名称 gname
			成立时间 gdate
			女生总数 ggirlnum
			男生总数 gboynum
			是否删除 isDelete
	
	
	表学生表结构
		表名： 
			students
		
		字段：
			学生姓名  sname
			学生性别  sgender
			学生年龄  sage
			学生简介  scontend
			所属班级  sgrade
			是否删除  isDelete

2、配置数据库

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
配置数据库
注意: Django默认使用SQLite数据
		在settings.py文件中。通过DATABASES选项进行数据库配置
	配置MySQL 
		python3.x安装的是PyMySQL
		在__init__.py写入两行代码
			import pymysql
			 pymysql.install_as_MySQLdb()
		
		配置mysql格式
			DATABASES = {
    			'default': {
        	'ENGINE': 'django.db.backends.mysql',
        	#'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
       	 	'NAME':"yichen",
        	'USER':"root",
        	'PASSWORD':'密码',
       	 	'HOST':"localhost",
       		 'PORT':"3308",
    		}
			}
			
	创建应用 
		在一个项目中可以创建多个应用，每个应用进行一种业务处理
		打开黑屏终端进入Django1\project目录
			执行 python manage.py startapp  myApp   #myApp是自定义的名称
			如果报错类似下面这个的文件出问题，就把确认版本的信息注释掉就可以了。							D:\Python\lib\site-packages\django\db\backends\mysql\base.py
		myApp目录说明
			admin.py    站点配置
			models.py   模型
			views.py    视图

image-20200604005145597

3，激活应用

1
2
3
4
5
6
7
8
9
10
11
12
13
激活应用
	在setting.py文件中，将myApp应用加入到INSTALLED_APPS选项中
		后面添加'myApp' 这个应用名称
		
		INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'myApp',
  ]

4.定义模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
概述: 有一个数据表，就对应有一个模型

在models.py文件定义模型
	引入包 from django.db import models  
	模型类要继承models.Mode类，所以要映入
	
from django.db import models

# Create your models here.
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.CharField(max_length=20)
    isDelete = models.BooleanField(default=False)
    
    #关联外键
    #sgrade = models.ForeignKey("Grades")
    sgrade = models.ForeignKey("Grades",on_delete=models.CASCADE)
	
说明: 不需要定义主键，在生成时自动添加，并且值为自动增加的

5.生数据库中生成表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
1、生成迁移文件 
	在project目录下执行命令
	 python manage.py makemigrations   在migrations目录下生成一个迁移文件，此时数据库中还没有生成数据表。
	 如果报错on_delete，就需要定义外键的时候加上on_delete=;
	 即：sgrade = models.ForeignKey("Grades",on_delete=models.CASCADE)

django 升级到2.0之后,表与表之间关联的时候,必须要写on_delete参数,否则会报异常:
TypeError: init() missing 1 required positional argument: ‘on_delete’

on_delete各个参数的含义如下：
on_delete=None,               # 删除关联表中的数据时,当前表与其关联的field的行为
	on_delete=models.CASCADE,     # 删除关联数据,与之关联也删除
	on_delete=models.DO_NOTHING,  # 删除关联数据,什么也不做
	on_delete=models.PROTECT,     # 删除关联数据,引发错误ProtectedError
	# models.ForeignKey('关联表', on_delete=models.SET_NULL, blank=True, null=True)
	on_delete=models.SET_NULL,    # 删除关联数据,与之关联的值设置为null（前提FK字段需要设置为可空,一对一同理）
	# models.ForeignKey('关联表', on_delete=models.SET_DEFAULT, default='默认值')
	on_delete=models.SET_DEFAULT, # 删除关联数据,与之关联的值设置为默认值（前提FK字段需要设置默认值,一对一同理）
	on_delete=models.SET,         # 删除关联数据,
	 a. 与之关联的值设置为指定值,设置：models.SET(值)
	 b. 与之关联的值设置为可执行对象的返回值,设置：models.SET(可执行对象)


2、执行迁移
	在project目录下执行命令
		python manage.py migrate
		相当于执行了sql语句创建数据库表

6.测试数据操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
进入到python shell ,执行下面命令进入
	python manage.py shell
	
引入包。 
	from myApp.models import Grades,Students
	from django.utils import timezone
	from datetime import *
	
查询所有数据
	类名.objects.all()
	Grades.objects.all()
	
添加数据
	本质: 创建一个模型类的对象实例
	 gradel = Grades()  #创建一个对象
>>> gradel.gname= "python04"
>>> gradel.gdate = datetime(year=2017,month=7,day=17)
>>> gradel.ggirlnum = 3
>>> gradel.gboynum = 70
>>> gradel.save()

查询某个对象
	类名.obgects.get(pk=id)
	Grades.objects.get(pk=2)
	
修改数据
	 grade2.save()
>>> grade2.gboynum = 60
>>> grade2.save()


删除数据
	模型对象.delete()
	grade2.delete()
	注意: 物理删除，数据库中的表里的数据被删除了
	
关联对象
>>> stu = Students()
>>> stu.sname="xueyanmei"
>>> stu.ggender=False
>>> stu.sage= 20
>>> stu.scontend="my name is xueyanmei"
>>> stu.sgrade = gradel
>>> stu.save()

	获得关联对象的集合
		需求: 获取python04班级的所有学生
		对象名.关联类名小写_set.all()
		stu.sgrade =gradel
		stu.save()
 		gradel.students_set.all()

7.启动服务器

1
2
3
4
5
6
7
8
格式:
	python manage.py runserver ip:port
	ip可以不写，不写的话代表本机ip
	端口号默认是8000
	python manage.py runserver
	
说明:
	这是一个纯python写的轻量级web服务器,仅仅在开发测试环境使用。

8.Admin站点管理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
概述:
	内容发布  负责添加、修改、删除内容
	公告访问
	
配置Admin应用
	在settings.py文件中INSTALLED_APPS中添加'django.contrib.admin'
	
创建管理员用户
	python manage.py  createsuperuser
	输入用户名，默认是administrator ,
	邮箱，密码123.shui 邮箱顺便乱写就可以。
	登录admin页面 http://127.0.0.1:8000/admin/

管理页面默认是英文界面，汉化。
	修改sttings.py文件里面的
	LANGUAGE_CODE = 'en-us' 把值改为zh-Hans
	TIME_ZONE = 'UTC' 		把值改为Asia/Shanghai
	然后直接刷新页面就可以，不用重启服务

image-20200604032034546

管理数据表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
修改admin.py文件
	from .models import Grades,Students
	#注册
	admin.site.register(Grades)
	admin.site.register(Students)

然后刷新页面，如果报错就重启服务器。
	就会有新增的两张表

自定义管理页面
	列表页属性
		list_display    显示字段 要显示什么字段，就写什么字段。
		list_filter		过滤字段
		search_fields	搜索字段
		list_per_page	分页
	
	添加、修改页属性
		fields		属性的先后顺序
		fieldsets	给属性分组 
		注意: fields 与 fieldsets不能同时使用。

admin.py详细内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
from django.contrib import admin

# Register your models here.
from .models import Grades,Students

#注册
class GradesAdmin(admin.ModelAdmin):
    #列表页属性
    list_display = ['pk','gname','gdate','ggirlnum','gboynum','isDelete']
    list_filter = ['gname']
    search_fields =['gname']
    list_per_page = 5


    #添加、修改页属性
    #fields = ['ggirlnum','gboynum','gname','gdate','isDelete']
    fieldsets = [
        ("num",{"fields":['ggirlnum','gboynum']}),
        ("base",{"fields":['gname','gdate','isDelete']}),
    ]

admin.site.register(Grades,GradesAdmin)

class StudentsAdmin(admin.ModelAdmin):
    list_display = ['pk','sname','sage','sgender','scontend','sgrade','isDelete']
    list_per_page = 2
    search_fields = ['sname']

admin.site.register(Students,StudentsAdmin)

关联对象

1
2
3
4
5
6
需求:
	创建一个班级是可以直接添加几个学生
	class STudentsInfo(admin.TabularInline) #StackedInline
		model = STudents
		extra =2
	class GradesAdmin(admin.ModelAdmin)

布尔值显示问题

1
2
3
4
5
6
7
8
9
10
11
12
class StudentsAdmin(admin.ModelAdmin):

    def gender(self):
        if self.sgender:
            return "男"
        else:
            return "女"
        #设置页面列的名称
    gender.short_description = "性别"
    list_display = ['pk','sname','sage',gender,'scontend','sgrade','isDelete']
    list_per_page = 2
    search_fields = ['sname']

执行动作的位置问题

1
2
3
#执行动作的位置
   actions_on_top = False
   actions_on_bottom = True

使用装饰器完成注册

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@admin.register(Students)
class StudentsAdmin(admin.ModelAdmin):

    def gender(self):
        if self.sgender:
            return "男"
        else:
            return "女"
        #设置页面列的名称
    gender.short_description = "性别"
    list_display = ['pk','sname','sage',gender,'scontend','sgrade','isDelete']
    list_per_page = 2
    search_fields = ['sname']
    #执行动作的位置
    actions_on_top = False
    actions_on_bottom = True

#admin.site.register(Students,StudentsAdmin)

3,Django视图的基本使用

1,概述

1
在django中，视图对web请求进行回应，视图就是一个python函数，在views.py文件中定义

2，定义视图

1
2
3
4
5
6
7
8
9
from django.shortcuts import render

# Create your views here.

from django.http import HttpResponse

def index(request):

    return HttpResponse("yichen is a good man")

3,配置url

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
修改project目录下的urls.py文件
from django.contrib import admin
from django.urls import path
from django.conf.urls import url,include

urlpatterns = [
    path('admin/', admin.site.urls),
    url(r'^',include('myApp.urls')),
]

在myApp目录下新建urls.py文件

from django.conf.urls import url

from . import views

urlpatterns = [
    url(r'^$',views.index), #执行views目录下的一个index函数。

]

4，模板的基本使用

1,概述

模板是HTML页面，可以根据视图中传递过来的数据进行填充

2,创建模板

1
创建templates目录，在目录下创建对应项目的模板目录(project/templates/myApp)

3,配置模板路径

1
2
3
4
5
6
7
修改settings文件下的TEMPLATES

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR,"templates")], #这里修改目录
        'APP_DIRS': True,

4，定义grades.html和students.html模板

1
2
3
模板语法
	{{输出值，可以是变量，一个可以是对象属性}}
	{%执行代码段%}

grades.html模板

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>班级信息</title>
</head>
<body>
<h1>班级信息表</h1>
<u1>

<!--    --[python04,python05,python06]-->
    {%for grade in grades%}
    <li>
        <a href="#">{{grade.gname}}</a>
    </li>
    {%endfor%}
</u1>

</body>
</html>

定义视图

1
2
3
4
5
6
7
from .models import Grades
def grades(request):
    #去模板里取数据
    gradesList = Grades.objects.all()

    #将数据传递给模板,模板在渲染页面，将渲染好的页面返回浏览器
    return render(request, "myApp/grades.html",{"grades":gradesList})

配置url

1
2
3
4
5
6
7
from . import views

urlpatterns = [
    url(r'^$',views.index), #执行views目录下的一个index函数。
    url(r'^(\d+)/(\d+)$',views.detail),
    url(r"^grades/$",views.grades),
]

二，Django模型

Django对各种数据库提供了很好的支持，Django为这些数据库提供了统一的API，可以根据不同的业务需求，选择不同的数据库

1，Django模型流程

1，配置数据库

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
1、修改工程目录下的__init__.py文件
	import pymysql

pymysql.install_as_MySQLdb()

2、在settings.py文件中。通过DATABASES选项进行数据库配置
	配置MySQL
DATABASES = {
    	'default': {
        'ENGINE': 'django.db.backends.mysql',
        #'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
       	'NAME':"yichen2",
        'USER':"root",
        'PASSWORD':'123.shui',
       	'HOST':"localhost",
       	'PORT':"3308",
    		}
			}

2，开发流程

1
2
3
4
5
6
7
8
9
10
1、配置数据库

2、定义模型类
	一个模型类都在数据库对应一张数据表

3、生成迁移文件
	python manage.py makemigrations
4、执行迁移生成数据表
	python manage.py migrate
5、使用模型进行增删改查(crud) 操作

3,ORM

1
2
3
4
5
6
7
8
9
10
概述 
	对象 关系 映射

任务 
	根据对象的类型生成表结构
	将对象、列表的操作转换为sql语句
	将sql语句查询到的结构转换为对象、列表

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

4，定义模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
1、模型、属性、表、字段间的关系
	一个模型类在数据库中对应一张表，在模型类中定义的属性，对应该模型对照表中的一个字段。
	
2、定义属性
概述:
	1、django根据属性的类型确定以下信息
		1，当前选择的数据库支持字段的类型
		2，渲染管理表单时使用的默认html控件
		3，在管理站点最低限度的验证
	
	2、django会为表增加自动增长的主键列，每个模型只能有一个主键列，如果使用选项设置某属性为主键列后，则django不会再生成默认的主键列
	
	3、属性命名限制
		1,不能是python的保留关键字，遵循标识符规则
		2,由于django的查询方式，不允许使用连续的下划线

库
	定义属性时，需要字段类型，字段类型被定义在django.db.models.fields目录下，为了方便使用，被导入到django.db.models中
	
	使用方式
		导入from django.db import models  
		通过models.Field创建字段类型的对象，赋值给属性
		
	4、逻辑删除
		对于重要数据都要做逻辑删除，不做物理删除，实现方法时定义isDelete属性，类型为BooleanField,默认值为False
		
	5、字段类型
		AutoField
			一个根据实际id自动增长的IntegerField,通常不指定，如果不指定一个主键字段将自动添加到模型中
		
		CharField(max_length=字段长度)
			字符串，默认的表单样式是 TextInput
		
		TextField
			大文本字段，一般超过4000使用，默认的表单控件是Textarea
			
		IntegerField
			整数
		
		DecimalField(max_digits=None,decimal_places=None)
			使用python的Decimal实例表示的十进制浮点数
			参数说明
				DecimalField.max_digits
					位数总数  			3.1415926 总数是8
				DecimalField.decimal_places
					小数点后的数字位数	 3.1415926 位数是7
					
		FloatField
        	用Python的float实例来表示的浮点数
        BooleanField
        	true/false 字段，此字段的默认表单控制是CheckboxInput
        
        NullBooleanField
        	支持null、true、false三种值
        	
        DateField([auto_now=False, auto_now_add=False])
        	使用Python的datetime.date实例表示的日期
        	参数说明
        		DateField.auto_now
        			每次保存对象时，自动设置改字段为当前时间，用于“最后一次修改” 的时间戳，它总是使用当前日期，默认为false
        		DateField.auto_now_add
        			当前对象第一次被创建时自动设置当前时间，用于创建的时间戳，它总是使用当前时间，默认为false
        	
         	说明
         		该字段默认对应的表单控件是一个TextInput,在管理站点添加了一个JavaScript写的日历控件，和一个"Today" 的快捷按钮。包含了一个额外的invalid_date错误消息键。
        	注意: 
        		auto_now_add, auto_now, add default 这些设置是相互排斥的，他们之间的任何组合将发生错误的结果
        		
        TimeField
        	使用Python的datetime.time的实例表示的时间，参数同DateField
        DateTimeField
        	使用Python的datetime
        	datetime实例表示的日期和时间，参数同DateField
        
        FileField
        	一个上传文件的字段
        
        ImageField
        	继承了FileField的所有属性和方法，但对上传的对象进行校验，
        	确保它是个有效的Image
        	
	7、字段选项
		概述:
			通过字段选项，可以实现对字段的约束
			在字段对象时通过关键字参数指定
			
		null
			如果为True, Django 将空值以NULL 存储到数据库中，默认值是 False
			
		blanke
			如果为True, 则该字段允许为空白，默认是False
		注意:
        	null是数据库范畴的概念，blank是表单验证范畴的概念
		
		db_column
			字段的名称，如果未指定，则使用属性的名称
		
		db_index
			若值为True, 则在表中会为此字段创建索引
		
		default
			默认值
		
		primary_key
			若为True, 则该字段会成为模型的主键字段
			
		unique
			如果为True,这个字段在表中必须有唯一值
			
	8、关系
		分类
			ForeignKey: 一对多，将字段定义在多的端中
			ManyToManyField:多对多，将字段定义在两端中，
			OneToOneField: 一对一，将字段定义在任意一端中
			
		用一访问多
			格式
				对象.模型类小写_et
			示例
				grade.students_set
				
		用一访问一
			格式
				对象.模型类小写 
			示例
				grade.students
		
		访问id
			格式
				对象.属性_id
			示例
				student.sgrade_id

创建模型类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
from django.db import models

# Create your models here.
class Grades(models.Model):
    gname =models.CharField(max_length=20)
    gdate = models.DateTimeField()
    ggirlnum = models.IntegerField()
    gboynum = models.IntegerField()
    isDelete= models.BooleanField(default=False)
    # def __str__(self):
    #     return "%s-%d-%d"%(self.gname,self.ggirlnum,self.gboynum)

    def __str__(self):
        return "%s"%(self.gname)
    class Meta:
        db_table ="grades"

class Students(models.Model):
    sname = models.CharField(max_length=20)
    sgender = models.BooleanField(default=True)
    sage = models.IntegerField(db_column="age")
    scontend = models.CharField(max_length=20)
    isDelete = models.BooleanField(default=False)

    #关联外键
    #sgrade = models.ForeignKey("Grades",on_delete=models.CASCADE)
    sgrade = models.ForeignKey("Grades",on_delete=models.DO_NOTHING )
    def __str__(self):
        return "%s"%(self.sage)
    lastTime = models.DateTimeField(auto_now=True)
    createTime = models.DateTimeField(auto_now_add=True)
    class Meta:
        db_table ="students"
        ordering=['id']

元选项

1
2
3
4
5
6
7
8
9
10
在模型类中定义Meta类，用于设置 元信息

db_table
	定义数据表名，推荐使用小写字母，数据表名默认为项目名小写_类名小写
	
ordering
	对象的默认字段排序，获取对象的列表时使用
	ordering[id]   升序
	ordering[-id]  降序
	注意: 排序会增加数据库的开销

模型成员

类属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
类属性
	objects  是Manager类型的一个对象，作用是与数据库进行交互
			当定义模型类是没有指定管理器，则Django为模型创建一个名为objects的管理器
	自定义管理器
		#自定义模型管理器
    	#当自定义管理器，objects就不存在了
    	stuObj = models.Manager()
		当为模型指定模型管理器，Django就不在为模型类生成objects模型管理器。
		
	自定义管理器Manager类
    	模型管理器是Django的模型进行与数据库进行交互的接口，一个模型可以有多个模型管理器
    	
    	作用
    		向管理器类中添加额外的方法
    		修改管理器返回的原始查询集 重新get_queryset()方法
    	
    	代码示例
    	class StudentsManager(models.Manager):
    def get_queryset(self):

        return super(StudentsManager,self).get_queryset().filter(isDelete=False)

class Students(models.Model):
    # 自定义模型管理器
    # 当自定义管理器，objects就不存在了
    stuObj = models.Manager()
    stuObj2 = StudentsManager()

创建对象

1
2
3
4
5
6
7
8
9
10
目的
	向数据库中添加数据
	
当创建对象时， django不会对数据库进行读写操作，当调用save()方式时才会与数据库交互，将对象保存到数据库中。

注意: __init__方法已经在父类models.Model中使用，在自定义的模式中无法使用。。

方法 
	在模型类中增加一个类方法
	在定义管理

模型查询

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
概述
	查询集表示从数据库获取的对象集合
	查询集可以有多个过滤器
	过滤器就是一个函数，基于所给的参数限制查询集结果
	从sql角度来说，查询集合select语句等价，过滤器就像where条件
	
查询集
	在管理器上调用过滤器方法返回查询集
	查询集经过过滤器诗选后返回新的查询集，所以科研写成链式调用
	情性执行， 创建查询集不会带来任何数据的访问，直接调用数据时，才会访问数据
	
	1、直接访问数据的情况
		迭代
		序列化
		与if合用
	2、返回查询集的方法称为过滤器
		all()      返回查询中的所有数据
		filter()   返回符合条件的数据
			filter(键=值 键=值)
			filter(键=值).(键=值)
		exclude()  过滤掉符合条件的数据
		order_by()  排序
		values() 	一个字典，返回一个列表
		
	3、返回单个数据
		get()  
			返回一个满足条件的对象，
			注意: 如果没有找到符合条件的对象，会引发模型类DoesNoteExist异常，如果找到多个对象，会引发模型类MultipleObjectsReturned at异常。
			
		count()		返回当前查询集中的对象个数
		first()		返回查询集中的第一个对象
		last()		返回查询集中的最后一个对象
		
		exists()   判断查询集中是否有数据，如果有数据返回True,没有数据返回false.
		
	4、限制查询集
		查询集返回列表。可以使用下标的方法进行限制，等同于sql中的limit语句
		studentList= Students.stuObj2.all()[0:5]
		注意: 下标不能是负数
		
	5、查询集的缓存
		概述: 
			每个查询集都包含一个缓存。来最小化的对数据库访问
			在新建的查询集中，缓存首次为空，第一次对查询集求值，会发生数据缓存。Django会将查询出来的数据做一个缓存，并返回查询结构，以后的查询直接使用查询缓存。
		
	6、字段查询
    	概述:
    		实现了sql中的where语句，作为方法filter(),exclude(),get()的参数
    		语法 属性名称__比较运算符=值
    		外键 属性名_id
    		转义 like语句中使用%是为了匹配占位。匹配数据中的%(where like \%)
    		
    	比较运算符:
    		exact
            	判断。大小写敏感
    			filter(isDelete=False)
    			
    		contains
    			是否包含，大小写敏感
    			ctudentSlist = Students.stuObj2.filter(sname__contains="sui")
    		startswith、endswith 
    			以value开头或结尾。大小写敏感
    		以上四个个在前面加上i,表示不区分大小写，iexact、icontains、istartswith、iendswith。
    			
    		isnull,isnotnull 是否为空
    		
    		in  是否包含在范围内
    			studentsList=Students.stuObj2.filter(pk__in=[2,4,6,8,10])
    			
    		gt		大于  studentsList=Students.stuObj2.filter(sage__gt=30)
    		gte		大于等于
    		lt		小于
    		lte		小于等于
    
    		year	年 studentsList=Students.stuObj2.filter(lastTime__year=2017)
    		month   月
    		day		天
    		week_day 周
    		hour	小时
    		minute	分钟
    		second	秒
    		
    		查询快键
    		  pk 代表主键
    		  
    	
	
		聚合函数
		 	Count
		 	Max
		 	Min
		 	Sum
		 
		 F对象
		 	可以使用模型的A属性与B属性进行比较
		 	支持F对象的算术运算。
		 	 
		
		Q对象
			概述。过滤器的方法中的关键字参数。条件为And模式
		    需求  进行or查询
            解决  使用Q对象
            
            studentsList = Students.stuObj2.filter(Q(pk__lte=3)|Q(sage__gt=50))
            studentsList = Students.stuObj2.filter(Q(pk__lte=3)) 只有一个Q对象，就是用于匹配的。

三、Django视图基础

概述

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1、作用： 视图接受web请求，并响应web请求
2、本质:  视图就是一个python中的函数

3、响应:
	1.网页
		 重定向
		 错误视图
				404
				500
				400
	2.JSON数据
4、过程
	1.用户在浏览器中输入网址
    2.Django获取网址信息，去除ip与端口，获取虚拟路径与文件名
    3.url管理器 逐个匹配urlconf 记录视图函数名
    4.视图管理器找到对应的视图去执行。返回给浏览器。

1、url配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
1、配置流程
	制定跟级url配置文件 在setting.py文件中的这里面。
	  		ROOT_URLCONF = 'project.urls'  默认已经配置好了。
	
	urlpatterns
			一个url实例的列表
			url对象。url(r'^students/$',views.students),
				正则表达式
				视图名称
				名称
				
	url匹配正则的注意事项
		如果想要从url中获取一个值。需要对正则加小阔号。
        匹配正则前方不需要加斜杠/
        正则前需要加r表示字符串不转义。

2、引入其他url配置
	在应用中创建urls.py文件，定义本应用的url配置，在工程中urls.py文件中使用include()方法
project/urls.py文件

from django.contrib import admin
from django.urls import path
from django.conf.urls import url,include


urlpatterns = [
    path('admin/', admin.site.urls),
    url(r'^', include(('myApp.urls','myApp'),namespace="myApp")),
]


myApp/urls.py文件。

from django.conf.urls import url,include
from . import views
urlpatterns = [

    url(r'^$', views.index,name="index"),

    url(r'^students/$',views.students),
    url(r'^addstudent/$',views.addstudent),
]

1.url的反向解析

1
2
3
4
5
6
7
概述
	如果在视图、模板中使用了硬编码连接。在url配置发生改变时。动态生成连接的地址
解决 
	在使用链接时，通过url配置的名称，动态生成url地址

作用
	 使用url模板

2，视图函数

1.定义视图

1
2
3
4
5
6
本质: 一个函数
视图参数:
	一个HttpRequest的实例
	通过正则表达式获取的参数
位置:
	 一般在views.py文件下定义

2.错误视图

1
2
3
4
5
6
7
8
9
10
11
12
13
404视图 
	找不到网页url匹配不成功的视图
	
	在templates目录下定义404.html
			request_path 导致错误的网址。
			
	配置settings.py文件	
    	DEBUG = False 如果为True永远不会调用404.html页面。 
    	ALLOWED_HOSTS = ["*"]
	
400视图 错误出现在客户的操作
	
500视图 在视图代码中出现错误(服务器代码)

3，HttpRequest对象

概述

1
2
3
服务器接收http请求后，会根据报文创建httpRequest对象
视图的第一个参数就是httpRequest对象。
django创建的。之后调用视图时传递给视图

属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
path
	请求的完整路径(不包括域名和端口)

method
	表示请求的方式，常用的有get、post
	
encoding 
	表示浏览器提交的数据的编码方式 一般为utf-8,

GET
	类似字典的对象，包含了get请求的所有参数

POST
	类似字典的对象，包含了post请求的所有参数
	
FILES
	类似字典的对象，包含了所有上传额文件

COOKIES
	字典，包含了所有的cookie
	
session
	类似字典的对象，表示当前会话。

方法

1
2
is_ajax()
	如果是通过XMHttpReauest发起的，返回True

QueryDict对象

1
2
3
4
5
6
7
8
9
request对象中的GET、POST都属于QueryDict对象

方法
	get()
		作用：根据键获取值
		只能获取一个值
	getlist()
		将键的值以列表的形式返回
		只能获取一个值

get属性

1
2
http://127.0.0.1:8000/get1?a=1&b=2c=3
http://127.0.0.1:8000/get2?a=1&b=2c=3

post属性

1
使用表单实现post请求。

HttpResponse对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
概述
  作用: 给浏览器返回数据
  HttpRequest对象时有Django创建，HttpResponse对象有程序员创建。
 
返回用法:
   不调用模板，
   def index(request):
    return HttpResponse("yichen2 is a good man")
    
    调用模板
    
    使用render方法。
    	原型 render(request, templateName[context])
    	作用 结合页面数据和模板，返回完整的HTML页面
    	
    	参数
    		request  请求体对象
    		templateName  模板路径
    		context   传递给需要渲染在模型上的数据。
    
属性
	content  		表示返回的内容
	charset  		编码格式
	status_code		响应的状态码 200 304 404 等等
	content-type	指定输出的mimr类型
	
	
方法
	init  			使用页面的内容实例化HttpReponse对象
	
	write(content)	以文本的形式写入。
	
	flush()    		以文本的形式输出缓冲区
	set_cookie(key,value="",max_age=None,exprise=None)
	
	delete_cookie(key)  删除cookie  
		注意: 如果删除一个不存在的key,就当什么都没有发生
	
	子类HttpResponseRedirect
		功能，重定向 ，服务器端跳转。
		简写： 
		
	子类JsonResponse
		返回json数据，一般用于异步请求

状态保持

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
http协议是无状态的，每次请求都是一次新的请求。不记得以前的请求
客户端与服务端的一次通信就是一次会话
实现状态保持，在客户端或者服务端存储有关会话的数据

存储方式
	cookie
		所有的数据存储在客户端，不要存敏感的数据
	
	seesion
		所有的数据存储在服务端，在客户端用cookie存储在session_id

状态保持的目的
	在一段时间内跟踪请求者的状态，可以实现跨页面访问当前的请求者的数据
	注意: 不同的请求者之间不会共享这个数据，与请求一一对应的。

启用seesion
	settings文件中。  
		INSTALLED_APPS
			 'django.contrib.sessions', 默认是启用的
		MIDDLEWARE
			'django.contrib.sessions.middleware.SessionMiddleware',默认是启用的。
		
使用session
	启用session后，每个HttpRequest对象都有一个session属性，就是一个类似字典的
	get(key,default=None) 根据键获取session值。
	clear() 清空所有的会话
	flush() 删除当前的会话并删除会话的cookie
	
设置过期时间
	set_expity(value)
	如果不设置，两个星期过期 
	request.session.get_expiry(10) #表示10秒后过期
	时间对象
	0 关闭浏览器时失效。
	None 永不过期。  

存储session的位置
	数据库: 默认存储在数据库中  django_session;
		SESSION_ENGINE='django.contrib.session.backends.'
	缓存: 只存储在本地内存中，如果丢失不能找回，比数据库快
		SESSION_ENGINE='django.contrib.session.backends.cache'
    数据库和缓存: 	优先从本地存储中读取，读取不到再去数据库中获取。
    	SESSION_ENGINE='django.contrib.session.backends.cached_db'
    
使用redis缓存session     
  pip install django-redis-sessions
  
 SESSION_ENGINE='redis_sessions.session'
 SESSION_REDIS_HOST='localhost'
 SESSION_REDIS_PORT=6379
 SESSION_REDIS_DB=0
 SESSION_REDIS_PASSWORD='123.yichen'
 SESSION_REDIS_PREFIX='session'

四、Django中的模板

templates

1,定义模板

1，变量

1
2
3
4
5
6
7
8
9
变量
	视图传递给模板的数据
	要遵循标识符规则
	语法  {{var}}
	注意:如果使用的变量不存在，则插入的是空字符串。
	在模板使用点语法
		字典查询  属性或者方法  数字索引
	在模板中调用对象的方法。
		注意: 在模板中不能传递参数。

2,标签

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
标签
	语法: {%tag%}
	作用: 在输出中创建文本  控制逻辑和循环  
	if: 格式 {% if 表达式 %}
		语句
		{%endif %}
		{%if 表达式1%}
		语句1
        {%else%}
        语句2
        {%endif%}
        
        {%if 表达式1%}
		语句1
        {%elif 表达式2%}
        语句2
        {%elif 表达式n %}
        语句n
        {%else%}
        语句e
        {%endif%}
       示例
       	{%if num %}
       	<h1>yichen is a good man</h1>
       	{%endif%}
	
	for:
		格式 {%for 变量 in 列表%}
		语句
		{% endfor%}
		
		格式2 {%for 变量 in 列表%}
		语句1
		{% empty%}
		语句2
		{% endfor%}  注意: 列表为空或者不存在时执行语句2
		
		{{forloop.counter}} ,表示当前是第几次循环。
		
		
	comment: 注释多行
			{%comment%}
			注释的内容
			{%endcomment%}
			
	
	ifequal、ifnotequal: 判断是否相等或者不相等
		格式:  {%ifequal 值1 值2 %}
				语句 如果值相等，则执行里面的内容
				{% endifequal%}
				
	
	
	include:  作用  加载模板并以标签内的参数渲染
			格式: {% include 模板目录 参数1  参数2 %}
	
	url:  作用: 反向解析
			格式: {%url 'namespace:name' p1 p2%}
			
	
	csrf_token: 作用:
    				用于跨站请求伪造保护
    				
    			
				格式:{% csrf_token%}
	
	block、extends: 作用 用于模板的继承
	
	autoescape:  作用  用于HTML转义

3,过滤器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
过滤器 
	语法 {{var|过滤器}}
	作用， 在变量被显示之前修改它。
	lower 	小写
	upper	大写
	过滤器可以传递参数，参数用引号引起来 join 
	格式      列表|join:'#'
	示例  <h1>{{list|join:'#'}}</h1>
	如果一个变量没有被提供，或者值为false,空、可以使用默认值
	default 
	格式 {{var|default:'good'}}
	示例  <h1>{{test|default:'没有'}}</h1>
	
	根据给定格式转换日期为字符串
	date
		格式: {{dateval|date:'y-m-d'}}
		
	HTML转义   escape
	
	加减乘除  
	示例:
<h1>num ={{num}}</h1>
<h1>{{num|add:10}}</h1>
<h1>{{num|add:-5}}</h1>

<!--num/1*5-->
<!--num * 5-->
<h1>{% widthratio num 1 5 %}</h1>
<!--num /5 -->
<h1>{% widthratio num 5 1 %}</h1>

4,注释

1
2
3
4
5
6
7
8
9
注释 
	单行注释 
		语法 {# 注释内容 #}
		
	多行注释
	comment: 注释多行
			{%comment%}
			注释的内容
			{%endcomment%}

5，反向解析

1
2
3
4
5
6
7
8
9
10
11
url:  作用: 反向解析
			格式: {%url 'namespace:name' p1 p2%}

project\urls.py文件
url(r'^',include('myApp.urls',namespace='app'))

project\myApp\urls.py 文件
url(r'^good/(\d+)/$', views.good,name="good"),

index.html代码文件
<a href="{% url 'app:good' 1 %}">链接</a>

6,模板继承

1
2
3
4
5
6
7
8
9
10
11
12
13
作用 
	模板继承可以减少页面的内容的重复定义，实现页面的重用
	
block标签
	在父模板中预留区域，子模板去填充
	语法:
		{% block 标签名 %}
		{% endblock 标签名 %}

extends标签
	继承模板，需要写在模板文件的第一行
	语法: 
		{% extends '父模板路径' %}

7，HTML转义

1
2
3
4
5
6
7
8

{{code}}
将接收到的code当成普通字符串渲染

将接收到的字符串当成HTML代码渲染
{% autoescape off %} on 就是当成普通字符串了
{{code}}
{% endautoescape %}

8，CSRF

1
2
3
4
5
6
跨站请求伪造 
	某些恶意网站包含链接、表单、按钮、js，利用登录用户在浏览器中认证，从而攻击服务。
	
防止CSRF
	1、在settings.py文件中的MIDDLEWARE增加'django.middleware.csrf.CsrfViewMiddleware',
	2、{% csrf_token %}  在html代码中加上验证。

9，验证码

1
2
3
4
作用: 在用户注册、登陆页面的时候使用，为了防止暴力请求，减轻服务器的压力。
防止csrf一种方式

pip install Pillow

五，Django高级扩展

1,静态文件

css、js、图片、json文件、字体文件等

1
2
3
4
5
6
配置 settings.py

STATICFILES_DIRS=[
os.path.join(BASE_DIR,'static')

]

2，中间件

1
2
3
4
5
6
7
8
9
一个轻量级、底层插件。可以介入Django的请求和响应
本质   一个Python类

方法:
__init__  不需要传参数，服务器响应第一个请求的时候自动调用，用于确定是否启用该中间件

执行的位置

自定义中间件

3，上传图片

1
2
3
4
5
6
7
8
概述:
 文件上传时，文件数据存储在request.FILES属性中。
   注意: form表单要上传文件是需要加enctype='multipart/form-data'
   注意: 上传文件必须是post请求。
存储路径
	在static目录下创建upfile目录用于存储文件
	配置settings.py文件
	MDEIA_ROOT=os.path.join(BASE_DIR,r'static\upfile')

4，分页

1
2


喜欢这篇文章？打赏一下作者吧

评论

目录

关注我

:D 一言句子获取中...

最新评论

加载中，最新评论有1分钟缓存...

最新文章

分类

归档

标签

linux18
docker16
Prometheus14
html14
python12
web12
nginx9
mysql7
容器7
数据库7
科学上网6
work5
自动化5
博客4
工作4
工具4
ssl3
文件系统3
日志3
日志加密3
查看全部>>

订阅更新

输入邮箱开始订阅，更博后邮件通知！