Django框架
1、什么是Django
是一个开源框架，2005年发布，采用Python语言开发的。早期Django是做新闻网站的。提供了非常强大的后台管理系统，采用
的是MTV的框架模式
2、Django的优缺点
1、优点
1、开源框架，有完美的文档支持
2、解决方案比较完整，内部功能也比较多
3、提供完整的路由系统，优雅的URL解析方式
4、自助式的后台管理
2、缺点
目标：高内聚，低耦合
耦合度偏高
3、Django的安装
1、Linux 中的安装
1、查看已安装的django
1、进入到虚拟环境中
2、进入到python的交互模式
3、在交互模式中输入
1、import django
2、django.VERSION
2、安装
1、在线安装 - 使用 pip
1、终端中输入
pip install django
(安装django的最高版本)
pip install django==1.11.8
虚拟环境中不用 sudo
2、离线安装
1、下载所需要的django包
https://www.djangoproject.com/
2、在 Linux 中解压 django
tar -xvf Django-1.11.8.tar.gz
3、进入到Django文件夹中
4、安装
python setup.py install
2、Windows 中的安装
1、在线安装
控制台中
pip3 install django==1.11.8
2、离线安装
1、下载django安装包
2、解压django包
3、进入到django包中
python setup.py install
使用Django
1、创建Django项目
直接使用 django-admin 去创建Django项目
1、找到项目文件夹(自定义)
2、使用 django-admin 指令
django-admin startproject 项目名称
2、启动Django项目
1、进入到项目文件夹中
2、通过 manage.py 启动项目
1、
python manage.py runserver
或
./manage.py runserver
只能在本机访问
http://localhost:8000
http://127.0.0.1:8000
2、
./manage.py runserver 0.0.0.0:8000
允许在局域网内访问，可以通过IP地址访问
ex:
1、启动服务
./manage.py runserver 0.0.0.0:8000
2、查看 虚拟机 IP地址
ifconfig
3、在windows中，打开chrome浏览器，通过IP地址访问django项目
Django结构介绍
1、manage.py
负责执行django中的各项操作的文件
命令脚本文件
如：
1、启动服务
2、创建应用
3、创建管理员、用户
... ...
2、主文件夹(名称与项目名称相同)
存放项目的最基础的配置文件
1、__init__.py
项目初始化文件，每当服务器启动的时候，会自动执行
如果有自定义的初始化操作，需要放在该文件中
2、urls.py
项目的基础url(路由)配置文件
路由：去哪找执行的程序
3、wsgi.py
配置应用服务器的文件，暂时不用
4、settings.py(重要)
项目的主设置文件：应用，模板，数据库，语言，时区，... ...
1、BASE_DIR ：项目所在的绝对路径
2、DEBUG ：调试模式
开发过程中，推荐使用 True
上线运行时，必须改为 False
3、ALLOWED_HOSTS
设置允许访问本地项目的地址列表，如果不设置的话，只有本机(localhost / 127.0.0.1访问)。推荐些 '*' ，表示任
何机器都允许访问当前项目
4、INSTALLED_APPS
指定已安装的应用，如果有自定义应用的话，需要在此注册
5、MIDDLEWARE ：注册中间件
6、ROOT_URLCONF ：指定项目的基础路由配置文件
7、TEMPLATES ：指定模板的信息
8、DATABASES ：指定数据库的信息
9、LANGUATE_CODE : 指定语言，允许修改为 zh-Hans
10、TIME_ZONE :指定时区，建议改为 Asia/Shanghai
settings的加载流程
1、先加载global_settings
位于：虚拟环境/lib/python3.5/site-packages/django/conf
2、再加载项目中的settings
注意：如果 global_settings中的内容与项目settings中的内容冲突的话，优先使用项目的settings中的内容
初识 django-admin 和 manage.py
1、终端中直接输入 django-admin
check
compilemessages
createcachetable
dbshell
diffsettings
dumpdata
flush
inspectdb
loaddata
makemessages
makemigrations
migrate
runserver
sendtestemail
shell
showmigrations
sqlflush
sqlmigrate
sqlsequencereset
squashmigrations
startapp
startproject #创建项目
test
testserver
2、进入到项目主文件夹，输入./manage.py
[auth]
changepassword #修改密码
createsuperuser #创建超级用户
[contenttypes]
remove_stale_contenttypes
[django]
check
compilemessages
createcachetable
dbshell #进入到Django数据shell交互模式
diffsettings
dumpdata
flush
inspectdb #将数据表直接导出为Models
loaddata
makemessages
makemigrations #创建数据库日志文件，记录Models的改动
migrate #将数据库日志文件同步到数据库中
sendtestemail
shell
showmigrations
sqlflush
sqlmigrate
sqlsequencereset
squashmigrations
startapp #创建应用
startproject
test
testserver
[sessions]
clearsessions
[staticfiles]
collectstatic
findstatic
runserver #启动服务
URL的使用
1、urls.py
默认在主文件夹中，包含所有的地址映射。
每当一个请求产生后，都会到urls.py中进行地址的匹配，匹配上后再找到对应的处理程序(View视图)去执行
2、测试
1、项目主文件夹中，创建 views.py
作用：包含所有定义好的视图(处理程序)
views.py :
from django.http import HttpResponse
def fun_views(request):
return HttpResponse('Hello Django')
2、在 urls.py 中追加
from .views import *
urlpatterns = [
url(r'^admin/',admin.site.urls),
url(r'^fun/$',fun_views),
]
3、url 函数
url函数的语法
url(regex,views,kwargs=None,name=None)
1、regex
正则表达式，匹配请求的 url
2、views
URL处理的视图函数，通常都是自定义的
3、kwargs
字典，用来向views传参的
4、name
字符串，给url()起一个别名，主要在模板中配合{%url%}一起使用
4、url 向 view 传参
1、使用正则表达式传参
使用正则表达式的子组传参,使用()
urlpatterns = [
#访问路径必须是 fun
url(r'^fun/$',fun_views),
#访问路径必须是 fun
url(r'^(fun)/$',fun_views),
url(r'^fun/(\d+)',fun_arg1_views),
]
注意：
1、在 url() 中，一个子组()表示一个参数
2、在views.py中，对应的处理函数要根据url()中子组的个数，相应的定义参数，定义的参数要位于 request之后
2、使用url()第三个参数，字典传参
urlpatterns = [
url(r'^showname/$',show_views,{'name':'zsf','age':'25'}),
]
views.py
def show_views(request,name,age):
resp = HttpResponse(name+":"+age)
return resp
注意：
1、视图处理函数中，必须声明参数
2、参数的名称 和 位置 必须要与字典中的名称和位置保持一致
Django 中的应用
1、什么是应用
应用是网站中的一个独立的模块，包含独立的显示信息。
在项目主文件夹中一般不处理其他的请求，主要就做初始化设置 以及 地址的分发
实际操作中，会将请求，交给不同的应用去处理
2、创建应用
1、命令
./manage.py startapp 应用名称
ex:
创建一个应用，名称为 index
2、在 settings.py中注册应用
在 INSTALLED_APPS 中追加应用名称即可
INSTALLED_APPS = [
'django.contrib.admin',
... ...,
'index',
]
3、应用的结构组成
1、migrations 目录
存放数据库日志文件，是一个django与数据库交互的中间文件
2、__init__.py
应用的初始化操作文件
3、admin.py
应用的后台管理配置文件
4、apps.py应用的属性设置文件，不需改动
5、models.py
Models模型文件
6、tests.py
测试模块，通常不用
7、views.py
定义视图的py文件
Django 模板(Template)
1、什么是模板
就是一个网页，可以被view响应给用户
目的是为了解决复杂的显示问题
2、模板的设置
1、BACKEND：指定模板的搜索引擎，不用改动
2、DIRS：指定模板所存放的目录
DIRS=['index.temp','music.temp']
但是，如果DIRS中为空的话，那么django会自动所有每个应用中的 templates 的文件夹作为模板管理目录
推荐：
1、DIRS 保持为空
2、在每个应用中，创建一个 templates 的文件夹
3、APP_DIRS
True:首先从DIRS中指定的文件夹中查找模板，如果没找到指定模板的话，则再搜索templates目录
3、模板的加载方式
1、使用 loader 获取模板，通过HttpResponse进行响应
from django.template import loader
def xxx(request):
t=loader.get_template('show.html')
html=t.render({})
return HttpResponse(html)
2、使用 render 直接加载
return render(request,'模板名称',{})
4、url() 的name参数
urlpatterns = [
url(regex,views,kwargs=None,name=None)
]
name : 定义当前url的别名，允许在Template中使用该别名来找到对应的 url
url(regex,views,name=None,name='别名')
在Django模板中使用 name 实现连接
{% url 'name值'%}
5、模板的语法
1、变量
作用：允许将后端的数据传递给模板(html),在模板中，会根据变量的实际值进行显示
在Django中允许传递给模板作为变量的数据类型
数字，字符串，列表，元组，字典，函数，对象
如何传递变量到模板中
1、render
dic = {
'变量1':'值1',
'变量2':'值2',
}
return render(request,'xx.html',dic)
2、loader
dic = {
'变量1':'值1',
'变量2':'值2',
}
t = loader.get_template('xx.html')
html=t.render(dic)
return HttpResponse(html)
在模板中，获取变量的值：
{{变量名}}
2、标签
1、什么是标签
允许嵌套一些服务器端的逻辑运算到模板中。
2、语法
{% ... %}
3、常用标签
1、{%if 条件%} ... {%endif%}
接受 ：not , and ,or
但是 ：and 和 or 不能同时出现
以下内容当成False处理：
空[]
空()
空{}
数字：0
空字符串
特殊对象：None
2、{%if 条件%} ... {%else%} ... {%endif%}
3、
{%ifequal 值1 值2%} ...{%endifequal%}
{%ifequal 值1 值2%} . {%else%} . {%endifequal%}
4、
{%for 变量 in 列表|元组|字典%}
{%endfor%}
允许使用的内置变量(免声明):
forloop
1、forloop.counter : 记录循环的次数
2、forloop.counter0: 同上，但从0开始
3、forloop.revcounter:记录未被遍历的数量
4、forloop.revcounter0:同上，从0开始
5、forloop.first : 布尔值，标记是否为第一个项目
6、forloop.last : 布尔值，标记是否为最后一个项目
3、过滤器
1、作用
在显示变量之前，允许对数据进行筛选或改变
2、过滤器的语法
{{var|过滤器}}
3、常用过滤器
1、{{var|upper}}
将var的数据变为大写
2、{{var|lower}}
将var的数据变为小写
3、{{var|add:num}}
4、{{var|floatformat:n}}
将var四舍五入到 n 位小数
4、静态文件的处理
1、什么是静态文件
模板中所用到的css,js,image,等一些资源文件都是静态文件
2、Django中静态文件的处理
需要在 settings.py中设置静态文件的访问路径 和 存储路径
1、STATIC_URL
指定静态资源的访问路径
STATIC_URL='/static/'
2、STATICFILES_DIRS
指定在开发阶段所有静态文件所在的根目录
STATICFILES_DIRS=(BASE_DIR,'static')
3、访问静态资源
1、<img src="/static/images/huiyuan.jpg">
2、使用 {%static %}访问静态资源
1、模板的最顶层增加
{%load static%}
2、使用静态资源文件时
<img src="{%static 'images/huiyuan.jpg' %}">
模板
模板的继承
1、什么是模板的继承
当多个模板(网页)具备大部分相同的内容时，就可以使用继承的方式，将相同的内容继承过来，再增加/修改属于自己的内
容即可
2、模板继承的语法
1、在父模板中
增加{%block 名称%}...{%endblock%}标签
2、在子模板中
1、在最顶层第一句话增加 ：
{%extends '父模板的名称'%}
2、增加 block 标记，编写属于自己的内容
{%block 名称%}
属于子模板中自己的内容
{%endblock%}
模型 - Models
1、什么是模型
模型，就是根据数据库中数据表的结构而创建出来的class。数据库中的每一张表到编程语言中就是一个class。数据库表中的一
个字段(列)可以被构建成class中的一个成员变量(属性)。并且在模型中，完成对数据的CRUD操作
C:Create
R:Retrieve
U:Update
D:Delete
2、创建 和 使用模型 - ORM
1、什么是ORM
ORM:Object Relational Mapping
简称：ORM，O/RM，O/R Mapping
中文为：对象关系映射
三大特征：
1、数据表 到 类(class) 的映射
允许将表自动生成 一个类
也允许将一个类自动生成一个表
2、数据类型的映射
允许将表中字段的类型自动生成到编程语言中对应的数据类型
也允许将编程语言中的数据类型生成数据库中对应的字段类型
3、关系映射
数据库中表的关联关系：
一对一，一对多(多对一)，多对多
将表中的关联关系也映射到编程语言的class中，通过创建对象的关系来完成映射
2、ORM的优点
1、提高了开发效率，能够自动完成实体类到数据表的映射，可以省略庞大的数据访问层
2、不用SQL编码，就能完成对数据的CRUD操作
3、创建 和 配置数据库
1、创建数据库(支持中文)
create database webdb default charset utf8 collate utf8_general_ci
2、Django中数据库的配置
settings.py 中配置数据库的信息
DATABASES = {
'default':{
'ENGINE':'...',
'NAME':'',
}
}
1、ENGINE ：引擎
django.db.backends.mysql
2、NAME：要连接到的数据库的名称
3、USER：用户名称，通常为 root
4、PASSWORD：密码，123456
5、HOST：连接的主机，本机的话 localhost / 127.0.0.1 / 不写
6、PORT：端口，3306
4、数据库的同步操作
1、./manage.py makemigrations
作用：将每个应用下的models.py文件映射成一个数据库日志文件，并存放在 migrations 文件夹中
2、./manage.py migrate
作用：将每个应用下的migrations文件夹中的日志文件同步到 数据库中
5、编写Models
1、注意
1、Models中的每个class都称之为 模型类(Model) 或 实体类(Entry)
2、Models中的每个实体类，必须继承自models.Model
2、ex
models.py
from django.db import models
class Publisher(models.Model):
name = models.CharField(max_length=30)
address = models.CharField(max_length=50)
city = models.CharFiled(max_length=20)
country = models.CharField(max_length=20)
website = models.URLField()
6、Django提供的数据字段 以及 字段选项
1、数据字段(Field Types)
1、BooleanField()
2、CharField()
3、DateField()
4、DateTimeField()
5、FloatField()
6、FileField()
7、EmailField()
8、IntegerField()
9、ImageField()
10、URLField()
11、DecimalField()
2、字段选项(Field Options)
1、null ：是否允许为空
name=models.CharField(max_length=30,null=True)
2、default ：为该列设置默认值
name=models.CharField(max_length=30,default='匿名')
7、数据的导入和导出(数据迁移) 以及 版本切换
1、版本切换
./manage.py migrate 应用名称 版本号
ex:
./manage.py migrate index 0001
2、数据库的导出
1、mysqldump -u root -p 数据库名 > 文件.sql
(导出所有的表结构 以及 数据)
2、mysqldump -u root -p -d 数据库名 > 文件.sql
(导出所有表结构，不导出数据)
3、数据库的导入
mysql -u root -p 数据库名 < 文件.sql
(要求数据库必须存在)
4、通过数据库自动导出Models
./manage.py inspectdb > 文件.py
实体：
数据表中的一行记录，就是一个实体
实体完整性：确保每张表中的数据不能有重复的。数据表中的主键，是实现实体完整性的方式之一
模型的数据库操作方法(CRUD)
1、通过视图向DB中增加数据
1、Entry.objects.create(属性=值,属性=值)
2、创建一个实体对象，并通过 save() 方法完成增加
obj = Entry(属性=值,属性=值)
obj.save()
3、通过字典创建实体对象，再调用 save()
dic = {
'name':'xx',
'age':33,
'email':''
}
obj = Author(**dic)
obj.save()
2、查询操作(重难点)
所有的查询都要在Entry.objects的基础上完成
1、基本查询操作
语法：all()
用法：Entry.objects.all()
返回：QuerySet
2、查询接口
1、all()
Entry.objects.all()
相当于：select * from ...
2、all().values('列名')
Entry.objects.all().values('name')
相当于：select name from ...
作用：查询所有记录的某一列的值
3、all().values('列1','列2')
Entry.objects.all().values('name','age')
相当于：select name,age from ...
4、get()
只查找一条记录时使用
也只能返回一条记录
如果查询返回多条记录的话，则报错
Entry.objects.get(id=4)
相当于：select * from ... where id=4
5、exclude()
作用：对给定条件取反
Entry.objects.exclude(id=3)
select * from .... where not id=3
Entry.objects.exclude(id=3,age=35)
select * from .... where not (id=3 and age=35)
6、order_by()
Entry.objects.order_by('列名1','-列名2')
指定按照字段们进行排序，如果是多个字段，中间,隔开。默认是按照升序排序，需要降序的话，只需要在列名前
加‘-’即可
7、filter()
根据自定义条件查询结果集，可以是一个，也可以是多个，多个的话，条件用 , 隔开。
如果是多个条件的话，其内部是使用 AND 来进行条件连接的
1、使用Entry的属性来作为filter()的条件
ex：
1、Author.objects.filter(id=1)
select * from author where id=1
2、Author.objects.filter(name='王宝强')
3、Author.objects.filter(id=1,name='王宝强')
select * from auther where id=1 and name='王宝强'
2、使用 Filed Lookups (查询谓词)
1、__exact
作用：等值判断
Author.objects.filter(id__exact=1)
SQL:
select * from auther where id=1
2、子查询
inner=Author.objects.filter(name__exact='贾乃亮').values('age')
authors=Author.objects.filter(age__gt=inner)
修改操作
1、修改单个对象
1、通过get()得到要修改的实体对象
2、通过实体对象修改属性值
3、再通过实体对象的save()函数，实现保存
auth=Author.objects.get(id=1)
auth.name='宝强.王'
auth.age=45
auth.save()
2、批量修改(修改查询结果集的值)
调用 update() 函数即可
Author.objects.all().update(属性=值,...)
删除操作
1、删除单个对象
obj=Author.objects.get(id=1)
obj.delete()
2、批量删除
Author.objects.filter(age__lt=50).delete()
F()操作 和 Q()操作
1、F()操作
update author set age=age+10
Author.objects.all().update(age=age+10)
作用：用于在执行中获取某列的值
语法：F('列名')
from django.db.models import F
Author.objects.all().update(age=F('age')+10)
2、Q()操作
AND:Author.objects.filter(id=1,age=35)
from django.db.models import Q
Author.objects.filter(
Q(id__exact=1)|Q(age=35),name='王'
)
select * from author where id=1 or age=35 and name='王'
原生的数据库操作方法
1、查询
函数:raw()
语法:Entry.objects.raw(sql)
2、增删改
def sql(request):
with connection.cursor() as cursor:
sql='delete from index_author;'
cursor.execute(sql)
return render(... ...)
静态文件css,js images的处理
2.在Django中的静态文件的处理
在 settings.py中设置有关静态文件的信息：
1.设置静态文件的访问路径
在浏览器中通过哪个地址能够找到静态文件
STATIC_URL='/static/'
如果访问路径是 http://localhost:8000/static/..一律都按照静态文件的方式去查找
2.设置静态文件的存储路径
指定静态文件要保存在服务器上哪个目录处
STATICFILES_DIRS=(os.path.join(BASE_DIR,'static'),)
静态文件目录的存放位置：
1.在项目的根目录处创建一个 static 目录，用于保存静态文件们
2.每个应用中也可以创建一个 static 目录，用于保存静态文件们
3.访问静态文件
1.直接使用静态文件访问路径进行访问
http://localhost:8000/static/...
ex:
<img src="http://localhost:8000/static/images/b04.jpg">
<img src="/static/images/b04.jpg">
2.使用 {% static %} 访问静态资源
1.在使用之前需要通过{% load static %} 加载 static
2.使用静态资源时
<img src="{% static 'images/b04.jpg' %}">
