**python web框架
flask 轻量级 web框架
AJAX 在WEB中完成 异步请求和响应
Django 重量级web框架
1.静态网页 和 动态网页的
静态网页: 无法与服务器做动态交互的网页
动态网页：允许与服务器做动态交互的网页
2.web与服务器
1.web:网页(HTML,css,js)
2.服务器
能够给用户提供服务的机器
1.硬件 与 软件
硬件：一台计算机
软件：一个能够接受用户请求并给出响应的程序
1.APACHE
2.TOMCAT
3.IIS(internet information service)
4.Nginx
2.服务器的作用：
1.存储web上的信息
2.能够处理用户的请求(request)并给出响应(response)
3.执行服务器端的程序
4.具备一定的安全功能
3.框架
1.什么是框架
框架是一个为了解决开放性问题而存在的一种结构
框架本身会提供一些基础的功能
我们只需要在基础功能之上搭建自己的操作即可
2.python web框架
1.flask-轻量级
2.webpy-轻量级
3.tornado-异步框架
4.Django-重量级web框架
3.框架模式
1.MTV
M：Models：模型层，主要负责根据数据库建模
T：templates,模板层，处理用户的显示内容的，如html
V： Views,视图，处理与用户交互的内容(请求和响应)
2.MVC
M:Models：模型层，主要负责根据数据库建模
V:Views,视图层，处理用户的显示的内容的，如：html
C:controller,控制器，处理与用户交互的内容(请求和响应)
M ----> M
T ----> V
V` ----> c
4.flask框架
1，什么是flask
flask是一个基于python并且依赖于jinja2模板引擎和werkzeug WSGI服务的一个微型框架
flask中包含一个轻量级的web服务器主要用于在开发节点测试使用
WSGI ： WEB server Gatway Inerface(WEB服务网关接口)
2.安装flask
1.查看已安装的flask及其版本
在python的交互模式中
1.import flask
没报错：已安装，可查看版本
报错：没安装
2,安装Flask
sudo pip3 install flask
pipe download flask
5.flask-路由
1.什么是路由
客户端发送请求给服务器，服务器需要将请求发送给flask程序实例
城西实力需要知道每个url请求对应的吹代码是谁，所以程序中必须要有一个url请求地址到ptyhon
运行函数的一个映射，处理url和函数之间的关系的程序就是“路由”
2.路由的体现
在Flask中，路由是通过@app.route()装饰器来表示的
1.路由的基本表示
@app.route(’/’)
def index():
return “xxx”
2.带参数的路由
路由中可以携带参数来表示要传递到视图中的数据
http://localhost:5000/show/laowang
http://localhost:5000/show/wangwc
1.基本带参的路由
#app.route("/show/")
def show1(name);
name:表示地址栏上传递的数据
pass
2.指定参数类型的路由
允许在声明路由时指定参数的类型，避免了在程序中在转换
@app.route(’./show//int:age’)
def show(name,age):
name:字符串
age:整数
int:类型转换器
flask中所支持的类型转换器
类型转换器 作用
缺省 字符串，中间不能有斜杠（/）
int 整型
float 浮点型
path 字符串，可以有‘/’
3.多URL的路由匹配
为多个url访问地址匹配同一个视图函数
localhost：5000/
localhost：5000/index
@app.route(’/地址1’)
@app.route(’/地址2’)
…
pass
将程序交给index（）视图处理函数
遇到进程被占用的情况，在终端中
netstat -lptu localhost:5000----pid
sudo kill -9 进程ID
换端口 app.run(debug=True,port=5555),建议使用5000之后的数字
3.路由中设置HTTP请求方法
在flask中默认只能接受get请求，无法接受post请求
get向服务器要数据，例如搜索栏
post向服务器传递数据，如果数据不安全，则会将一些垃圾信息传入服务器
在flask中允许设定可以接受的请求方式，如果请求方式不匹配的话，会响应405(Method Not Allowed)
@app.route("/xxx",method=[“POST”,“GET”]),用字符串的方式显示除可以接受的请求，
如果没有写在method中认为不能接受的请求，当前写法认为：该函数技能接受post请求也能接受get请求
4.url反向解析
正向解析：程序自动解析，根据@app.route()中的访问路径，来匹配处理函数
反向解析：通过视图处理函数的名称自动生成对应的访问路径
在flask中要实现反向解析：
url_for(funName,args)
funName:要生成 地址的函数名
args：改地址中需要的参数
6.模板-templates
1.什么事模板
模板，在flask中就是允许响应给用户看的网页
在模板中，允许前嵌入动态的内容
模板最终也会被解析成字符串在响应给客户端，这一过程成为“渲染”
Flask中，模板是依赖于jinja2的模板系统http://jinja.pocoo.org/
2.模板的设置
默认情况下，flask会在程序目录中收一个templates的目录，作为模板的存放目录
3.模板的渲染
作用：在视图中，将模板文件(xx.html)渲染成字符串之后，在响应给浏览器
语法：
import flask import render_template
render_template(‘xxx.html’)
参数：要渲染的模板
返回值：该模板中的字符串内容
传递变量到模板中
render_template(‘xxx.html’,变量=值，变量=值，…)
在模板中获取变量的值
{{变量名}}
1.模板 - Templates
1.变量
能够作为变量的数据类型
字符串,整数,小数,列表,元祖,字典,对象
2.过滤器
1.什么是过滤器
过滤器是允许在变量输出之前按一定的规则改变变量的值
2.语法：
{{变量|过滤器}}
jinja2模板中常见过滤器
过滤器名 说明
capitalize 首字符变大写，其他字符变小写
lower 将值转换为小写字符
upper 将值转换为大写字符
title 将值中的每个单词的首字符变大写
trim 去掉值两端的空格
3.标签
1.什么是标签
每个标签标示的是不同的服务器端的功能
2.常用标签
1.if 标签
1.基本的if结构
{% if 条件 %}
满足条件要执行的内容
{% endif %}
2. if else结构
{% if 条件 %}
满足条件要执行的内容
{% else %}
不满足条件要执行的内容
{% endif %}
3.if elif else结构
{% if 条件 %}
满足条件要执行的内容
{% elif 条件2 %}
满足条件2要执行的内容
{% elif 条件3 %}
满足条件2要执行的内容
{% else %}
不满足条件要执行的内容
{% endif %}
2.for结构
{% for 变量 in 列表|元组|字典 %}
{% endfor %}
内置变量：loop
1.只能在for循环标签中使用
2.不用声明直接使用
作用：记录本次循环的一些信息
loop 中常用的属性
1，index
作用：记录当前循环的次数，从1开始计算
2.index0
作用：记录当前循环的次数，从0开始计算
3.first
作用：表示当前的循环是否为第一次星环
True：表示为第一次循环
False：表示不是第一次循环
4.last
作用：表示当前循环是否为最后一次循环
True：表示为最后一次循环
False：表示不是最后一次循环
3.macro 标签（宏）
1.作用
相当于是在模板中声明函数
2.语法
使用{% macro %}…{% endmacro %}
声明宏：
{% macro 名称(参数列表) %}
…
…
{% endmacro %}
使用宏：
{{宏名称(参数列表)}}
3.在独立的模板文件中声明所有的宏
1.创建macro.html模板文件
作用：定义项目中要用到的所有的宏
2.在使用宏的模板上，导入 macro.html
{% import ‘macro.html’ as macro %}
4.静态文件的处理
1.什么是静态文件
在flask中不能与服务器动态交互的文件都是静态文件
2.在flask中处理静态文件
1.所有的静态文件要放在static目录中
static目录要位于项目的根目录内
2.所有的静态文件必须通过/static/路径访问
/static 表示的要到静态资源目录中继续搜索
1.模板
1.模板的继承
模板的继承类似于类的继承
如果一个模板出现大量的内容与另一个模板相同的话
那么就可以使用继承的方式来简化模板开发
2.语法：
1.父模板中
需要在父模板中定义出哪些内容可以被重写的
{% block 块名 %}
{% endblock %}
block定义允许在子模板中被修改的内容
1.在父模板中正常显示，没有任何影响
2.在子模板中可以被重写
2.子模板中
1.使用{% extends ‘父模板名称’ %}
2.使用{% block 块名%}来重写父模板中同名块的内容
{% block 块名%}
会改掉父模板中的同名函数
{% endblock %}
2.自定义错误页面
404：found
500:server internerl error
1…404错误处理
@app.errorhandler(404)
def page_not_found(e)
return render_template(‘500.html’),404
2.500错误处理
@app.errorhandler(500)
def page_not_found(e)
return render_template(‘500.html’),500
404.html 和 500.html 需要自定义
3.修改配置
app = Flask(name,template_folder=“muban”,static_folder=“stc”，static_url_path=“路径”)
1.template_folder
指定保存模板文件夹的名称
2.static_folder
指定保存静态文件的文件夹的名称
3.static_url_path
指定访问静态文件的路径
4.请求(request) 和响应(response)
1.http协议
Request：请求消息
请求起始行
请求方式
请求路径
协议及版本号
请求消息头
key:value
Referer:http://www.tmooc.cn
Referer请求消息头：用于记录请求源地址
请求主体
由客户端浏览器带给服务器的数据或信息
只有post和put请求 才有请求主体
response：响应消息
响应起始行
协议和版本号
响应状态码
原因短句
响应消息头
key：value
content-type:image/png:告诉浏览器响应回来的内容是什么类型的
响应主体
Response / Preview
2.请求对象 - request
1.什么事请求对象
request - 请求对象，封装了所有与请求相关的信息
在 flask 中可以通过 request 对象来获取请求信息
from flask import request
2.request中常用的成员
1.scheme:获取请求方案(协议)
2.method：获取请求方式(重点，取值为 post 或get)
3.rgs：获取使用get请求方式提交过来的数据(重点)
4.form：获取使用post请求方式提交过来的数据(重点)
5.cookies：获取cookies中的相关信息
6.headers：获取请求消息头的相关信息
7.files：获取上传的文件
8.path：获取请求的资源的具体路径(不带参数)
9.full_path:获取完整的请求资源的具体路径(带参数)
10.url:获取完整的请求地址，从协议开始
3.获取使用get请求方式提交过来的数据
1.get请求方式
1.表单允许实现get请求
姓名：
2.在请求地址后拼查询字符串(提交的参数)
2.post请求方式
只有在表单提交时才可以触发post请求
request.form 获取提交的数据
3.响应对象 - response
am
1.响应
1.什么是响应
响应是有服务器端带给客户端的内容
响应内容可以是字符串，模板，重定向
2.响应字符串 或 模板
1.响应字符串
return ‘普通字符串’
2.响应模板
return render_template(‘xxx.html’)
其本质还是响应字符串
3.响应对象
响应对象：将响应内容封装到一个对象中，以便完成更多的响应行为
在Flask中，使用 make_response() 构建响应对象
from flask import make_response
@app.route(’/xxx’)
def xxx():
resp = make_response(‘响应内容’)
resp = make_response(render_template(‘XXX.html’))
#允许调用resp中的属性或方法们以便完成更多的响应行为
return resp
4.重定向
1.什么是重定向
由服务器端通知客户端重新向新的地址发送请求
2.语法
from flask import redirect
@app.route(’/xxxx’)
def xxx():
xxxx xxxx
return redirect(‘重定向地址’)
2.文件上传
1.注意问题
表单中如果有文件上传的话，必须遵循以下两个要求
1.表单的提交方式method必须为post
2.表单的 enctype 属性的值必须为multipart / form-data
2.服务器端
1.获取上传的文件
语法：request。files
作用：获取上传的所有文件
f == request.files[‘uimg’]
从上传的文件中，将名称俄日uimg 的文件获取出来并保存在f中
2.将文件保存到指定的目录处
语法：f.save(‘保存路径’)
作用：将文件保存到指定目录处
注意：
1.保存路径可以是相对路径也可以是绝对路径
2.保存路径要精确到文件名称
3.保存的目录必须是已存在的
ex：
f.save(‘static/’+f.filename)
f.filename:能够获取处文件名
3.模型 - Models
1.什么是模型
模型，是根据数据库中表结构而创建出来的class
模型其实就是将数据表进行‘类化’，以类(对象)的方式来操作数据表(数据)
数据库中的每一张表到编程语言中，就是一个class
表中的每一个列对应到编程语言中就是class中的一个属性
表中的每一条数据对应到的编程语言中就是class的一个对象
模型：可以被称为"模型类"或"实体类"
2.模型的框架 - ORM
1.什么是ORM
ORM：object Relational Mapping
简称：ORM ， O/RM , O/R Mapping
中文：对象关系映射
2.ORM框架的三大特征
1.数据表(Table)到编程类(Class)的映射
数据库中每一张表对应到编程语言中都有一个类
在ORM中：
允许将数据表 自动 生成一个类
允许将类 自动生成一张数据表
2.数据类型的映射
数据表中的字段以及数据类型对应到 编程语言中有对应的属性和类型
3.关系映射
将数据库中表与表之间的关系，对应到编程语言中类与类之间的关系
数据库中表与表之间的关系
1.一对一
A表中的一条记录能够与B表中的一条记录向关联
B表中的一条记录能够与A表中的一条记录相关联
主键，外键，唯一约束
2.一对多
A表中的一条记录能够与B表中的多条记录相关联
B表中的一条记录只能与A表中的一条记录相关联
3.多对多
A表中的一条记录能够与B表中的多条记录相关联
B表中的一条记录能够与A表中的多条记录相关联
实现方式：
增加第三张关联表来实现多对多
3.ORM的优点
1.风主干了数据库中所有的操作，大大的提高了开发效率
2.可以是省略胖胖哒的数据访问层，几遍不用SQL编码也能完成对数据的CRUD操作
3.Flask中的ORM框架
1,。python中的ORM
比较常用的ORM框架 - SQLAIchemy
安装 :sudo pip3 install sqlalchemy
2.在Flask中
5.在Flask中配置数据库
1.通过app(Flask应用实例)构建配置信息
app.config['SQLAICHEMY_DATABASE_URI']="mysql://用户名：密码@主机：端口/数据库"
2.创建数据库应用实例
from flask_sqlalchemy import SQLAIchemy
db.SQLAIchemy(app)
6.语法：
class MODELNAME(db.Model):
__tablename__ = "TABLENAME"
COLUMN_NAME=db.Column(db.TYPE,OPTIONS)
1.MODELNAME:定义的模型类的类名，通常都参考表名
2.TABLENAME：映射到数据库中表的名称
3.COLUMN_NAME：属性名，映射到数据表中就是列名
4.TYPE:映射到列的数据类型
5.OPTIONS：列选项
db.TYPE 列的数据类型：
类型名 python类型 说明
Integer Int 普通整数，32位
SmallIntager int 小范围整数，16位
BigInteger long 不限精度的整数
Float float 浮点类型
Numeric decimal.decimal 定点类型
String str 变长字符串
Text str 变长字符串
Boolean bool 布尔值
Date datetime.data 日期
Time datetime.time 时间
DateTime datetime.datetime 日期和时间
OPTIONS 列选项
选项名 说明
primary_key 如果设置为True表示该列为主键
unique 如果设置为True表示该列的值唯一
index 如果设置为True表示该列要创建索引
nullable 如果设置为True表示该列允许为空，默认允许为空
default 指定该列的默认值**
1.数据库操作
1.插入
1.创建实体类的对象
1.完成插入
db.session.add(实体对象)
db.session.commit()
2.查询
1.基于 db.session 进行查询
1.db.session.query(Models1,Models2,…)
参数：要查询的实体类(表)，如果是多个实体类的话，相当于要做多表连接查询
返回：对应的类的一个查询对象
2.查询执行函数
目的：在query()的基础上得到最终的数据
语法：db.session.query(Models).查询执行函数
1.all() : 以列表的形式返回query()对象中所有的查询数据
2.first() : 返回query对象中的第一个查询结果，如果没有结果，返回None
3.first_or_404() : 返回query对象中的第一个查询结果，如果没有结果的话则终止程序并响应404
4.count(): 返回query对象中的查询结果的数量
3.查询过滤器函数
作用：专门对数据进行筛选，返回部分行数据
1.filter() 按照指定条件进行过滤(单表，多表，定值，不定值)
2.filter_by() 按等值条件进行过滤
3.limit() 按限制行数量获取结果
4.order_by() 按指定列进行排序
5.group_by() 按指定条件进行分组
语法：
db.session.query().过滤器函数().执行函数()
过滤器函数详解：
1.filter()
注意：条件必须由 实体类.属性 组成
1.查询年龄大于30的人的信息
db.session.query(Users).filter(Users.age>30).all()
2.查询id为1的人的信息
db.session.query(Users).filter_by(Users.id == 1).all()
3.查询年龄30并且id大于1的用户的信息
db.session.query(Users).filter(Users.age>30,Users.id>1).all()
4.查询年龄大于30或者id为1的用户信息
from sqlalchemy import or_
db.session.query(Users).filter(or_(条件1，条件2)).all()
5.查询email中包含“W” Users的信息
db.session.query(Users).filter(Users.email.like('%w%')).all()
6.查询id在[2,4] 列表中的Users的信息
db.session.query(Users).filter(Users.id.in_([2,4])).all()
2.filter_by()
注意：只能做等值判断，不能做不等值
查询id为1的users的信息
db.session.query(Users).filter(id=1)
3.limit()
1.获取users表中的前2条数据
db.session.query(Users).limit(2).all()
select * from Users limit 2
2.获取users过滤前两条数据后剩余的前两条数据
select * from Users limit 3,2
db.session.query(Users).limit(2).offset(3).all()
4.order_by()
按照id倒序排序
select * from Users order by id desc;
先按照年龄倒序排序，在按照id升序排序
select * from Users order by age dedc,id asc
db.session.query(Users).order_by("age desc,id asc").all()
5.group_by()
1.将users表中的数据按照age进行分组
db.session.query(Users).group_by("age").all
6.聚合函数
1.查询users表中所有人的平均年龄
select avg(age) from Users;
from sqlalchemy import func
db.session.query(func.avg(Users.age).label('avgAVG')).all()
2.Users表中，按年龄分组，再查每组的年龄平均值
select age,avg(age) from Users group by age;
db.session.query(func.avg(Users.age)).group_by('age').all()
聚合函数
1.func.avg() 平均值
2.func.sum() 求和
3.func.max() 求最大值
4.func.min() 求最小值
5.func.count() 求不为空的数量
2.基于 Models 类进行查询
Models.query.查询过滤器函数.执行函数
1.ORM操作
1.插入(略)
2.查询(略)
3.修改
例：将users表中id为1的人的年龄更改为60岁
1.查
user = Users.query.filter_by(id = 1).first()
2.改
user.age = 60
3.保存
db.session.add(user)
db.session.commit()
4.删除
1.查
2.删除
db.session.delete(实体对象)
2.关系映射
1.一对多关系映射
一对多在数据库中的实现方式：主外键关系
在 多 表表中增加一个列，作为外键，引用在 一 表的主键
语法：
1.在 多 实体类中
增加一个属性，引用自“一”表(实体类)的主键列(属性)
外键列名 = db.Column(db.Integer,db.ForeignKey(“主表.外键”))
2.在 一 实体类中
增加关联属性一级反向引用关系
在course对象中，通过一个属性能够得到对应的所有的teacher们
关联属性，是应该加载course的实体类中
反向引用
在teacher 对象中，通过一个属性能够得到对应的course
反向引用属性，是应该加载Teacher的实体类中
增加关联属性和反向引用关系：
在 一 的实体类中增加
属性名 = db.relationship("多表实体类名",关系选项)
关系选项：
-------------------------------------------------------------------------------------------------------------
选项名： | 说明
-------------------------------------------------------------------------------------------------------------
backref | 在关系的另一个模型中添加的反向应用属性名(准备在‘多’的实体中增加对 一 的实体引用属性名)
|
-------------------------------------------------------------------------------------------------------------
lazy | 指定如何加载当前的相关记录(延迟加载模式)
| select：首次访问是加载所有的记录
| immediate：原对象只要加载就马上加载相关记录
| subquery:效果同上，使用子查询的方式 加载记录
| noload：用不加载相关记录
| dynamic:默认也不加载相关记录，但提供记录的查询
|
-------------------------------------------------------------------------------------------------------------
uselist | 如果设置为False，表示不适用列表相关数据而使用标量(一对一的时候使用)
-------------------------------------------------------------------------------------------------------------
secondary | 指定多堆多关系中关联表的名字
-------------------------------------------------------------------------------------------------------------
2.一对一
1.在SQLAlchemy中的体现
1.在任意一个实体类中 增加对另一个实体的引用
外键的列名 = db.Column(db.Integer,db.ForeignKey("主键表.主键列"))
2.反向引用
在另一个表中添加关联属性和反向引用关系
属性=db.relationship('关联的实体类'，backref='反向引用属性名'，uselist=False)
uselist
指定关联数据
1.为wife
1.多对多的实现
1.什么是多堆多
A 表中的一条数据可以与 B 表中的任意多条数据相关联
A:B 1:M
B 表中的一条数据可以与 A 表中的任意多条数据相关联
B:A 1:M
2.在数据库中的实现
依托于第三张关联表来实现的
3.SQLAlchemy
2.cookies
1.什么是cookies
cookies是一种数据存储手段
将一段文本内容保存在客户端(浏览器)中的一种手段，并且可以长时间保存
2.cookies使用场合
1.记住密码
2.记住搜索文本
3.flask 中使用 cookies
1.保存cookies到客户端
使用响应对象，将数据保存进客户端(浏览器)
1.resp = make_response("")
2.resp = redirect(’/xxxx’)
cookies的语法：
响应对象.set_cookie(key,value,max_age)
key:字符串，要保存的cookies的名称
value：字符串，要保存的cookie的值
max_age:最大的保存时间，取值数字，以s为单位
2.在服务器端获取cookies的值
每次向服务器发送请求时，浏览器会将cookies中所有的数据封装到request中并带到服务器
request.cookies获取所有的cookies的值
3.删除cookies内容
响应对象.delete_cookie('key')
3.session - 会话
1.什么是session - 会话
session是保存在服务器上，为每个浏览器锁开辟的一段空间
目的：保存浏览器与服务器的一些交互状态(数据)
2.session 在Flask中的实现
1.配置 SECRET_KEY
app.config[‘SECRET_KEY’]=“aixieshaxiesha”
2.使用session
from flask import session
1.向session保存数据
session[‘key’]=value(字符串)
2.从session中获取数据
value = session[‘key’]
value = session.get(‘key’)
3.删除session中的数据
del session[‘key’]
3.保存进session的内容
多次与服务器交互时要用到的数据需要保存进session
如：登陆信息
1717
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
