Django框架部分笔记

一、框架基础
1.环境配置
进入虚拟环境

workon

创建虚拟环境

mkvirtualenv -p /usr/bin/python[版本号] [名称]

删除虚拟环境

rmvirtualenv djangoapp

退出虚拟环境

deactivate

建议在虚拟环境下工作 避免污染 安装模块一定要在对应的虚拟环境下安装

2.端口映射

3.基本认知
django----->web应用框架------>工作原理

1.django：全能型的web框架

2.tornado：异步的web框架

4.设计模式
1.mtv
-m models 模型：负责业务数据对象和数据库对象 （models.py)

-t template 模板：负责如何把页面展示给用户（html）

-v view 视图：存取模型及调取恰当的模板,模板和模型的桥梁 （view.py）

2.mvc
-m models 模型：负责业务数据对象和数据库对象 (models.py)

-v view 视图：页面

-c controller 控制器：调用模型和视图完成用户的请求

5.操作命令
1.创建项目
进入放置项目的目录下，命名遵循命名规则

django-admin startproject [名称]（Customer Relationship Management）

2.启动项目
进入当前manage.py所在的位置

python manage.py runserver 0:8000 (0表示0.0.0.0 可接收所有ip)

3.修改配置文件
ALLOWED_HOSTS = [’ * ']

4.操作图片步骤

5.创建App
进入当前manage.py所在位置

python manage.py startapp [app名称]

二、路由器分配及模板渲染
1.基本概念：
网址，全球统一资源定位符，作用：用来标识互联网上资源的地址。

1.格式

2.django的路由系统
URLconf（URL配置)

路径报错信息查看

3.相关模块
1.path

path(route, views, kwargs=None, name=None)
1.path(‘detail//’, views.detail) url中传递参数
2.路径转换器：<转换器：变量名>
3.path(‘detail/int:year-int:month-int:id/’, views.detail),
path(‘detail/int:year/int:month/int:id/’, views.detail),
2. re_path

re_path(route, views, kwargs=None, name=None)
re_path(r’student/(?P\d{4})-(?P\d[0-9]|1[0-2])-(?P\d+)/’, views.student),
3. include

要实现访问app

CRM/urls.py

path(‘teacher/’, include(‘teacher.urls’)),
4. kwargs

path(‘teacher//’, views.teacher, kwargs={‘name’: ‘飞’}),
当变量名相同时，kwargs生效
5. name

return redirect(reverse(‘index’)) # 动态解析url路径
6.app_name

return redirect(reverse(‘teacher:index’)) # app_name:name
2.路由系统原理
1.根URLconf,从上往下找，第一个匹配到的路径，映射到对应的视图函数

2.根URLconf，include到app的URLconf，从上往下找，第一个匹配到的路径，映射到对应的视图函数

3.都找不到，返回页面404

3.模板路径配置

TEMPLATES = [
{
‘BACKEND’: ‘django.template.backends.django.DjangoTemplates’,
‘DIRS’: [os.path.join(BASE_DIR, ‘templates’)],
‘APP_DIRS’: True,
‘OPTIONS’: {
‘context_processors’: [
‘django.template.context_processors.debug’,
‘django.template.context_processors.request’,
‘django.contrib.auth.context_processors.auth’,
‘django.contrib.messages.context_processors.messages’,
],
},
},
]
4.模板渲染方式

return render(request, ‘teacher/index.html’)
三、模板变量及模板过滤器
1.模板配置
2. app下

INSTALLED_APPS = [
‘django.contrib.admin’,
‘django.contrib.auth’,
‘django.contrib.contenttypes’,
‘django.contrib.sessions’,
‘django.contrib.messages’,
‘django.contrib.staticfiles’,
‘[app名称]’,
]
3. templates的选择
a. templates放置在根目录时：settings TEMPLATES里的DIRS的路径

b.settings TEMPLATES里的'APP_DIRS': True,才会去app目录下找。

c.templates放置在app目录下：settings INSTALLED_APPS里添加

一般选择根目录下创建，如果我们要编写可以重复使用的app时，选择将模板放置在APP目录下
2.模板变量
1.静态页面和动态页面
判断标准：是否有交互

2. 模板变量语法

{{ 变量名 }}
TIME_ZONE = ‘Asia/Shanghai’

当前时间：{{ now }}

列表：{{ L }}

列表的第一个值：{{ L.0 }}

字典：{{ D }}

取字典中key为name的值：{{ D.name }}

取字典中items：{{ D.items }}

函数返回值：{{ func }}

3.常用过滤器：
https://docs.djangoproject.com/en/2.1/ref/templates/builtins/#date

可以利用过滤器直接对模板变量进行再次的处理

注意

语法：{{ 变量名|过滤器[:字符串参数] }}
​
1.变量名的命名规则
2.冒号：前后不能空格
3.可以链式调用eg：

列表的第一个值：{{ L|first|add:‘2’ }}

4.字符串参数可以通过模板变量传入
补充：xss（跨域脚本攻击）

{{ html|safe }}

4.静态文件的引用(css, js, img)

一般项目根目录，也可以放在app目录
1.路径设置

项目根目录时

STATIC_URL = ‘/static/’
STATICFILES_DIRS = [os.path.join(BASE_DIR, ‘static’)]

{% load static %}
。。。。

Bootstrp网址：https://v3.bootcss.com/getting-started/

怎样获取css文件：

{{ 变量 }}

{% 标签 %}
四、模板标签
1.常用标签
模板标签的作用：在模板中进行各种逻辑操作，比如循环，判断等

模板标签的基本语法：{% tag %}{% endtag %}

1.{% load static %}
2.{% for stu in sts %}{% endfor %}
3.{{forloop.counter }}
4.{{ url ‘app_name:name’ 参数}}
5.{% if 条件1 %}
满足条件1进行的处理
{% elif 条件2 %}
满足条件2进行的处理
{% else %}
以上条件都不满足时进行的处理
{% endif %}
2.模板的引用 include
作用：实现一个模板，在特定的位置引入另一个模板的内容

{% include ‘teacher/ad.html’ %}
3.模板的继承 extends
作用：将模板中共同的部分抽离出来，独立的作为一个部分，（base.html)

{% extends ‘teacher/base.html’ %} # 放在html最前面
此时，页面只有继承的base.html的效果

4.block
作用：扩展

{% block 名称 %}内容{% endblock %}
五、自定义过滤器
本质：python函数，它有一个或者两个参数

第一个参数 是传进来的模板变量，不一定是字符串

第二个参数 是一个普通参数，可以是默认参数，也可以不要这个参数

前提：设置数据时，性别0代表女，1代表男

		展示数据时，页面显示为中文或者英文

解决方法，自定义过滤器

步骤：

a.app下

INSTALLED_APPS = [
‘django.contrib.admin’,
‘django.contrib.auth’,
‘django.contrib.contenttypes’,
‘django.contrib.sessions’,
‘django.contrib.messages’,
‘django.contrib.staticfiles’,
‘student’,
‘teacher’,
]
b.设置过滤器

def to_sex(value, arg=‘zh’): # value：0、1
change = {
‘zh’: (‘女’, ‘男’),
‘en’: (‘Female’, ‘Male’),
}
return change[arg][value]
c.注册

django.template.Library实例化register，通过filter方法，实现自定义过滤器的注册

from django import template
register = template.Library()
​
​
def to_sex(value, arg=‘zh’): # value：0、1
change = {
‘zh’: (‘女’, ‘男’),
‘en’: (‘Female’, ‘Male’),
}
return change[arg][value]
​
​
register.filter(‘to_sex’, to_sex) # 参数一：过滤器名字， 二：函数名
d.导入
{% load customer_filters %}

六、模型基础（一）
1.数据库连接配置

1.安装pymysql，注意：一定要在项目环境下安装
pip install pymysql
2.创建数据库
-创建数据库用户(已经完成，操作见ppt)
-创建数据库create database CRM;
3.配置
DATABASES = {
‘default’: {
‘ENGINE’: ‘django.db.backends.mysql’,
‘NAME’: ‘CRM’,
‘USER’: ‘root’,
‘PASSWORD’: ‘qwe123’,
‘HOST’: ‘127.0.0.1’,
‘PORT’: ‘3306’,
}
}
4.导入
关闭项目，在项目根目录下__init__.py文件下
import pymysql
​
pymysql.install_as_MySQLdb()
2.Django的ORM简介
ORM：对象关系映射（Object Relational Mapping）简单来说，就会用面向对象的方式，达到不用编写sql语句就能对数据库进行操作（描述数据库，增删改查操作数据库）

数据库----------------->Django

表 ----------------->类

字段 ----------------->类属性

一行数据 ----------------->一个实例

3.模型的创建和映射

1. 创建模型：models.py
   我们创建的每一个类都是models.Model的子类

from django.db import models
​
​

Create your models here.

class Student(models.Model):
name = models.CharField(max_length=20)
age = models.SmallIntegerField()
sex = models.SmallIntegerField(default=1) # 设置默认值
qq = models.CharField(max_length=20)
phone = models.CharField(max_length=20)
c_time = models.DateTimeField(verbose_name=‘创建时间’, auto_now_add=True) # auto_now_add=True自动填充当前时间，verbose_name='创建时间’定义一个人类可读的名称
2. 激活模型

1.注册
models所在的app名添加到settings.py下的INSTALLED_APPS
2.迁移
python manage.py makemigrations # 全部模型都进行迁移
python manage.py makemigrations app名 # 指定app下模型进行迁移
迁移：是django对模型的更改方式，它是一个文件，这步操作，把我们设置的东西保存下来了，但是操作还没生效。
​
python manage.py sqlmigrate teacher 0001 # 查看原生sql语句

3.迁移生效
python manage.py migrate
表名：appname_模型name.low()
总结：<模型更改三步指南>

1.更改模型（models.py)
2.生成迁移python manage.py makemigrations
3.迁移生效python manage.py migrate
4.数据的增删改查
1.准备工作

1.pip install ipython
2.进入交互模式 python manage.py shell
2.增

from teacher.models import Student # 导入模型
Student.objects # 模型下对象的地址
Student.objects.all() # 查看模型下的数据
第一种

第二种

第三种

第四种

先查找，没有就创建，返回值第二参数是True，如果是有，返回值第二参数是false

3.查 all，get，filter

4. 删 delete

5.改

七、模型基础（二）
1.常用模型字段类型
参考ppt

AutoFeild

2.字段的常用参数

primary_key: 指定是否为主键。
unique: 指定是否唯一。
null: 指定是否为空，默认为False。
blank: 等于True时form表单验证时可以为空，默认为False。
default: 设置默认值。
DateField.auto_now: 每次修改都会将当前时间更新进去，只有调用，QuerySet.update方法将不会调用。这个参数只是Date和DateTime以及TimModel.save()方法才会调用e类才有的。
DateField.auto_now_add: 第一次添加进去，都会将当前时间设置进去。以后修改，不会修改这个值
自定义主键

id = models.AutoField(primary_key=True)
3.常用查询
1.查询方法

每个django模型类，都有一个默认的管理器：objects

普通查询
all/get/filter
res = Student.objects.first() # 返回对象
res = Student.objects.last() # 返回对象
res = Student.objects.exclude(sex=1,age=18) # 排除，和filter相反

指定字段查询
res = Student.objects.values(‘name’,‘age’) # 指定字段查询，仅能拿到指定的查询字段值，其他字段值是无法拿到的res[2][‘name’]
res = Student.objects.only(‘name’,‘age’) # 指定字段查询，但可以拿到所有的字段值res[1].sex
res = Student.objects.defer(‘c_time’,‘qq’,‘phone’) # 和only相反

其他：
res = Student.objects.order_by(‘age’) # 正序
res = Student.objects.order_by(’-age’) # 反序
res = Student.objects.all()[:2] # 切片
#多条件OR查询
from django.db.models import Q Student.objects.filter(
…: Q(sex=1),
…: Q(age=18)|Q(age=70)
…: )
2.条件查询

res = Student.objects.filter(name__exact=‘Lucy’) # 准确匹配
res = Student.objects.filter(name__iexact=‘lucy’) # 忽略大小写的匹配
res = Student.objects.filter(name__contains=‘l’) # 包含
res = Student.objects.filter(name__icontains=‘l’) # 忽略大小写的包含

in指定值查询，值可以是可迭代对象

res = Student.objects.filter(id__in=[1,3,5])
res = Student.objects.filter(sex__in=‘01’)

gt，gte，lt，lte大于等

res = Student.objects.filter(id__gt=2)

指定范围range

res = Student.objects.filter(age__range=(15,18))
3.聚合分组（aggregate、annotate）

1.统计数量
res = Student.objects.filter(sex=1).count()
2.平均值，最大值，最小值，求和
In [83]: from django.db.models import Avg,Max,Min,Sum
In [84]: Student.objects.aggregate(Avg(‘age’))
Out[84]: {‘age__avg’: 25.6667}
In [85]: Student.objects.aggregate(Max(‘age’))
Out[85]: {‘age__max’: 70}
​
In [86]: Student.objects.aggregate(Min(‘age’))
Out[86]: {‘age__min’: 15}
​
In [87]: Student.objects.aggregate(Sum(‘age’))
Out[87]: {‘age__sum’: 154}
​

In [88]: from django.db.models import Count
​
In [89]: res = Student.objects.values(‘sex’).annotate(num=Count(‘sex’))
4. 表关系的实现

class Student(models.Model):
name = models.CharField(max_length=20)
age = models.SmallIntegerField(null=True)
sex = models.SmallIntegerField(default=1) # 设置默认值
qq = models.CharField(max_length=20, null=True)
phone = models.CharField(max_length=20, null=True)
c_time = models.DateTimeField(verbose_name=‘创建时间’, auto_now_add=True)
# auto_now_add=True自动填充当前时间，verbose_name='创建时间’定义一个人类可读的名称
# detail = models.OneToOneField(‘StudentDetail’, on_delete=models.SET_NULL, null=True)
grade = models.ForeignKey(‘Grade’, on_delete=models.SET_NULL, null=True)

on_delete=models.SET_NULL代表参考表删除，相应的字段设置为null，所以一定要记得null=True

1. OneToOne 一对一

class StudentDetail(models.Model):
college = models.CharField(max_length=20, default="") # 学校
student = models.OneToOneField(‘Student’, on_delete=models.CASCADE) # on_delete=models.CASCADE，集联删除，为了保持数据一致性，参考表删除，对应的相关对象也删除
2. OneToMany 一对多

class Grade(models.Model):
name = models.CharField(‘班级名称’, max_length=20)
num = models.CharField(‘班期’, max_length=20)
3. ManyToMany 多对多

1.自动生成第三张表
class Course(models.Model):
name = models.CharField(‘课程名称’, max_length=20)
student = models.ManyToManyField(‘Student’)

2.自定义第三张表
回滚：python manage.py migrate teacher 0002
删除最后一次迁移文件
class Course(models.Model):
name = models.CharField(‘课程名称’, max_length=20)
student = models.ManyToManyField(‘Student’, through=‘Enroll’) # through=‘Enroll’
​
​
class Enroll(models.Model):
student = models.ForeignKey(‘Student’, on_delete=models.CASCADE)
course = models.ForeignKey(‘Course’, on_delete=models.CASCADE)
c_time = models.DateTimeField(‘报名时间’, auto_now_add=True)
pay = models.FloatField(‘缴费金额’, default=0)
总结

1.创建迁移：python manage.py makemigrations
​
2.查看迁移sql语句：python manage.py sqlmigrate 迁移序号
​
3.应用迁移：python manage.py migrate
​
4.回滚回指定迁移：python manage.py migrate teacher 迁移序号
​
八、模型基础（三）
1.关联表的数据操作
1.OneToMany(增删改查)

正向：一个模型如果有外键字段，通过这个模型对外键进行操作叫做正向（eg：student模型有grade外键字段）
反向：一个模型如果被另一个模型外键关联，通过这个模型对关联它的模型进行操作叫做反向（eg：grade模型被student模型的grade外键关联，通过grade对student进行操作）
a.正向增删改查

1.增，改

通过属性赋值的方式

In [12]: s1.grade = g1
In [13]: s1.save()

通过主键的方式

In [21]: s2.grade_id = g2.id
In [22]: s2.save()
​
2.查
In [3]: s1.grade
Out[3]: <Grade: django框架-8>
​
In [4]: s1.grade.name
Out[4]: ‘django框架’
​
In [5]: Student.objects.filter(grade__name=‘django框架’)

外键字段对象的属性可以通过两个下划线来获取

​
3.删
In [7]: s1.grade = None
In [8]: s1.save()
b.反向增删改查

管理器：g2.student_set.all()
实际访问情况：如果一个模型有外键（eg：student模型），那么这个外键模型的实例(eg：grade模型的实例g2)将可以通过一个管理器（返回的是Student模型的所有实例的管理器），默认情况下管理名为（student_set),其中student是源模型名，小写。
1.增
new_student = g2.student_set.create(name=‘肖扬’,age=15)
​
In [18]: s1,s2,s3 = Student.objects.filter(id__lte=3)
In [19]: g1.student_set.add(s1,s2,s3)
2.删
In [20]: g1.student_set.remove(s1)
In [21]: g1.student_set.clear()
3.改
g2.student_set.set([s4,s5]) # 替换
​
4.查
In [29]: g2.student_set.all()
In [30]: g1.student_set.filter(sex=0)
==可以通过字段参数related_name=‘student’来替代上面的管理器名（‘student_set’)

grade = models.ForeignKey(‘Grade’, on_delete=models.SET_NULL, null=True, related_name=‘student’)
2. ManyToMany
正向

（eg：course里面有ManyToManyField字段，模型使用该字段本身的属性名student）

c1.student.all()
反向

（原始蘑菇型的小写模型名，加上_set—>course_set)

s1.course_set.all()
3. OneToOne
正向—>属性

In [17]: d1 = StudentDetail(college = ‘潭州大学’)
​
In [18]: d1.student = s1
​
In [19]: d1.save()
反向—>原始模型的小写模型名

s4.studentdetail = d2
4.跨表查询

StudentDetail.objects.values(‘college’,‘student__name’,‘student__sex’)
Student.objects.values(‘name’,‘sex’,‘studentdetail__college’)

Course.objects.filter(student__sex=1) # 男生报了什么课程
Student.objects.filter(course__name=‘python’) # 报了’python‘的学生
Student.objects.filter(course__name=‘python’,grade__num=‘8’) # 所有报了python，8期的学员
Student.objects.filter(enroll__pay__lt=3000) # 缴费小于3000的学员
Grade.objects.filter(student__course__name = ‘python’).distinct() # 学员报名Python课程的班级有哪些。distinct()去重
九、请求与响应

1. HttpRequest对象

django框架—>web应用框架
请求和响应就是框架中的数据流
2. GET和POST请求

action属性：如果不写或为空，表示当前页
request.GET.get(‘hobby’) # 一个值
request.GET.getlist(‘hobby’) # 所有值

前后台交互流程：输入url，get请求，服务器响应，返回登录页面。输入用户名，密码，提交按钮，发送post请求，提交数据，通过验证，跳转到主页。

总结：
1.GET，是从服务器获取数据，携带参数会直接显示在url中，不会更改服务器的数据
2.POST，向服务器发送数据，一般会更改服务器的数据，参数不会显示在url中
3.{% crsf_token %}
3. 文件上传

1.设置文件的存储路径
a.在项目根目录下static文件夹中创建media文件夹
b.配置：settings.py文件中添加
MEDIA_ROOT = os.path.join(BASE_DIR, ‘static/media’)

第二种使用方法

a.在项目根目录下创建一个新的文件夹(upload)
b.配置：settings.py文件中添加
UPLOAD_ROOT = os.path.join(BASE_DIR, ‘upload’)
4. HttpResponse对象

HttpRequest对象是django自动创建，HttpResponse对象需要手动创建。
5. Cookie

def index(request):
num = request.COOKIES.get(‘num’)
if num:
num = int(num) + 1
else:
num = 1
​
response = render(request, ‘teacher/index.html’, context={‘num’: num})
response.set_cookie(‘num’, num)
return response