目录
一、Flask 和pythonweb框架介绍
1.1python web框架介绍
同步web框架
- django：大而全，内置的app多，第三方app也多(通过uwsgi实现异步)
- Flask：小而精，没有过多的内置组件，只完成web框架最基本的功能，需要借助于第三方，完成更丰富的功能
- web.py:是一个小巧灵活的Python框架，它简单而且功能强大（国内几乎没有用的）
异步web框架
- fastapi：python的异步web框架，不少公司在用，https://fastapi.tiangolo.com/zh/
- sanic:python的异步web框架，供支持异步高并发请求的 web 服务
- tornado:异步框架，用的比较少了
同步框架和异步框架的区别
- django是同步框架还是异步框架，django 3.x以后支持异步
- 同步框架的意思：一个线程只处理一个请求
- 异步框架的意思：一个线程可以处理多个请求
- 异步框架可以很显著的提高并发量
下图就是展示django实现异步的流程图，django是通过uwsgi这样的web服务实现异步的，跟我们之前上线的时候一样，开启多个进程实现异步，当然这样的服务也有其他的，比如gunicom
1.2 flask介绍
Flask是一个基于Python开发并且依赖jinja2模板和Werkzeug WSGI服务的一个微型框架，对于Werkzeug本质是Socket服务端，其用于接收http请求并对请求进行预处理，然后触发Flask框架，开发人员基于Flask框架提供的功能对请求进行相应的处理，并返回给用户，如果要返回给用户复杂的内容时，需要借助jinja2模板来实现对模板的处理，即：将模板和数据进行渲染，将渲染后的字符串返回给用户浏览器。
“微”(micro) 并不表示你需要把整个 Web 应用塞进单个 Python 文件（虽然确实可以 ），也不意味着 Flask 在功能上有所欠缺。微框架中的“微”意味着 Flask 旨在保持核心简单而易于扩展。Flask 不会替你做出太多决策——比如使用何种数据库。而那些 Flask 所选择的——比如使用何种模板引擎——则很容易替换。除此之外的一切都由可由你掌握。如此，Flask 可以与您珠联璧合。
默认情况下，Flask 不包含数据库抽象层、表单验证，或是其它任何已有多种库可以胜任的功能。然而，Flask 支持用扩展来给应用添加这些功能，如同是 Flask 本身实现的一样。众多的扩展提供了数据库集成、表单验证、上传处理、各种各样的开放认证技术等功能。Flask 也许是“微小”的，但它已准备好在需求繁杂的生产环境中投入使用
一些注释：
-jinja2 模板语法，django的dtl，非常像
-Werkzeug WSGI 符合wsgi协议的web服务器，django使用的是wsgiref
1.3wsgiref
最简单的Web应用就是先把HTML用文件保存好，用一个现成的HTTP服务器软件，接收用户请求，从文件中读取HTML，返回。
如果要动态生成HTML，就需要把上述步骤自己来实现。不过，接受HTTP请求、解析HTTP请求、发送HTTP响应都是苦力活，如果我们自己来写这些底层代码，还没开始写动态HTML呢，就得花个把月去读HTTP规范。
正确的做法是底层代码由专门的服务器软件实现，我们用Python专注于生成HTML文档。因为我们不希望接触到TCP连接、HTTP原始请求和响应格式，所以，需要一个统一的接口协议来实现这样的服务器软件，让我们专心用Python编写Web业务。这个接口就是WSGI：Web Server Gateway Interface。而wsgiref模块就是python基于wsgi协议开发的服务模块
1.4用wsgirf和werkzeug写web
这里只需要了解，相当于刚学习django时，简易django框架的推导流程一样
#### wsgirf写web
from wsgiref.simple_server import make_server
# mya 就等同于django
def mya(environ, start_response):
#把environ包装成了request
print(environ)
start_response('200 OK', [('Content-Type', 'text/html')])
if environ.get('PATH_INFO') == '/index':
with open('index.html','rb') as f:
data=f.read()
elif environ.get('PATH_INFO') == '/login':
with open('login.html', 'rb') as f:
data = f.read()
else:
data=b'<h1>Hello, web!</h1>'
return [data] # 这里相当于把这个data做成了response
if __name__ == '__main__':
myserver = make_server('', 8008, mya)
print('监听8010')
myserver.serve_forever()
#### 使用werkzeug写web
from werkzeug.wrappers import Request, Response
@Request.application
def hello(request):
return Response('Hello World!')
if __name__ == '__main__':
from werkzeug.serving import run_simple
run_simple('localhost', 4000, hello)
django中的wsgirf分析
这里我们可以发现flask是可以用两种wsgi协议实现的，但是werkzeug用起来比较简洁
而我们回到django中，我们在django的asgi.py和wsgi.py中
可以看到他们的代码中都有一个application变量绑定的对象
application = get_wsgi_application()
application = get_asgi_application()
而我们查看这个方法的源码，可以看到他的源码就是返回了一个对象，而产生对象的这个类中，有双下call方法。当我们运行项目的时候，就是对象把application这个对象加括号进行调用，调用的时候就触发双下call方法内部的代码，我们可以发现request和response都是在这里产生的，虽然这里的代码看着不多，内部执行的代码却是非常多的。
def __call__(self, environ, start_response):
...
而在他的双下call方法中可以就可以看到environ, start_response两个参数，这里就可以跟我们上方的代码相对应
wsgirf和werkzeug的一些区别
在对比上方的两个web实现方式中，我们可以发现一下区别：
- 1、werkzeug把environ, start_response,[data]封装成了request和Response
- 2、werkzeug和wsgirf的启动参数都差不多，但是在启动后，werkzeug可以自动匹配路由
二、flask快速使用
步骤一
安装flask模块
pip install flask
他的依赖模块：MarkupSafe, Werkzeug, Jinja2, flask
ps：
-1.x 没有本质区别
-2.x 没有本质区别，不同于django，flask的版本更新是在源码上做了变动，用起来一样的
步骤二
创建flask项目
如果我们在创建项目的时候没有创建templates文件夹，我们可以手动创建，一些html文件照样还是放里面
from flask import Flask
app = Flask(__name__)
'约定俗成使用双下name'
# app=Flask('test')
'这里的app就是flask对象，而传给他的参数，没什么意义，只是一个名称，但是这个名称必须有，因为在他的源码中，别的参数都是有默认值的，就name的位置没有默认值，需要我们自己传值'
# 注册路由---->装饰器
@app.route('/index')
def index():
return 'hello web'
@app.route('/')
def home():
return 'hello home'
if __name__ == '__main__':
# app.run('127.0.0.1',5000)
app.run()
'这里就是启动flask，通过查看源码，我们可以发现我们不传值也是可以运行的，而他的前两个参数，分别对应ip和端口'
三、登录，显示用户信息小案例
实现的功能：让用户进行登陆，如果没有登陆的情况下访问别的页面，让他跳转回登陆页面，然后让他在登陆后可以查看用户信息，查看的时候是跳转到对应的信息详情页面
3.1 login.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<form method="post">
<p>用户名：<input type="text" name="username"></p>
<p>密码：<input type="password" name="password"></p>
<input type="submit" value="登录"> {{error}}
</form>
</body>
</html>
3.2 home.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>用户列表</h1>
<table>
{% for k,v in user_dict.items() %}
<tr>
<td>{{k}}</td>
<td>{{v.name}}</td>
<td>{{v['name']}}</td>
<td>{{v.get('name')}}</td>
<td><a href="/detail/{{k}}">查看详细</a></td>
</tr>
{% endfor %}
</table>
</body>
</html>
3.3 detail.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<p>名字是：{{user.name}}</p>
<p>年龄是：{{user['age']}}</p>
<p>性别是：{{user.get('gender')}}</p>
<p>{{user.text}}</p>
</body>
</html>
3.4 py文件
from flask import Flask, request, render_template, redirect, session,jsonify
app = Flask(__name__)
# 要使用session，必须设置秘钥，秘钥是配置信息
app.secret_key = 'asdfasdfa33aef3aefads'
USERS = {
1:{'name':'张三','age':18,'gender':'男','text':"道路千万条"},
2:{'name':'李四','age':28,'gender':'男','text':"安全第一条"},
3:{'name':'王五','age':18,'gender':'女','text':"行车不规范"},
}
# 1 创建templates文件夹，写login.html
@app.route('/login', methods=['GET', 'POST'])
def index():
# 没有request对象，使用全局的request
# get请求，返回模板
if request.method == 'GET':
return render_template('login.html') # 新手四件套之一：返回模板
else:
# post请求，校验数据
# 取出前端传入的用户名密码，校验
username = request.form.get('username') # 等同于django的的request.POST
password = request.form.get('password')
if username == 'lqz' and password == '123':
# 登录成功,保存登录状态 重定向到跟路径 新手四件套之一：重定向
# 保存到session中,session是全局的
session['name'] = username
return redirect('/')
else:
return render_template('login.html', error='用户名或密码错误') # 注意跟django的render区分，要模板渲染的数据，直接key=value传即可
@app.route('/')
def home():
# 校验，登录成功，才能过来，不登录，重定向到登录页面
if session.get('name'): # 有值说明登录了，没有值说明没有登录
return render_template('home.html',user_dict=USERS)
else:
return redirect('/login')
@app.route('/detail/<int:pk>')
def detail(pk):
if session.get('name'): # 有值说明登录了，没有值说明没有登录
user_detail = USERS.get(pk)
return render_template('detail.html', user=user_detail)
else:
return redirect('/login')
@app.route('/test')
def test():
return jsonify([{'name':'lqz','age':19}])
if __name__ == '__main__':
app.run()
3.5 知识点总结
1 注册路由 app.route(路径,methods=[请求方式get，post])
2 新手四件套：
-return render_template('login.html') 新手四件套之一：返回模板 跟django有区别
-return redirect('/') 新手四件套之一：重定向
-return 字符串 返回字符串
-return jsonify([{'name':'lqz','age':19}]) 返回json格式数据，比如字典和列表类型的数据
3 请求的request对象，是全局的，直接导入使用即可，在不同视图函数中不会混乱
request.method 请求方式
request.form post请求的body体的内容转成了字典
4 session 全局的，直接导入使用即可,一定要指定秘钥app.secret_key = 'asdfasdfa33aef3aefads'
放值：session['name']='lqz'
取值：session.get('name')
5 模板的渲染
-兼容django的dtl
-更强大，可以加括号，字典可以.get .values() .items()
-{% for %}
6 转换器@app.route('/detail/<int:pk>')
四、配置文件的使用方式
django有配置文件settings，flask 也有配置文件，但是他的使用方式是多种多样的。
1、设置方式一（测试中使用的多）
app.debug=True # 调试模式，提示信息更详细，修改代码不需要重启，自动重启
app.secret_key='dasdfasdfasd' # 秘钥，只能 放debug和secret_key
print(app.config)
PS： 由于Config对象本质上是字典，所以还可以使用app.config.update(...)
2、设置方式二
直接使用app.config设置
app.config['DEBUG']=True
app.config['SECRET_KEY']='sdfasdfasd'
3、设置方式三
使用py文件（不常用）
app.config.from_pyfile("settings.py")
print(app.config)
4、设置方式四（常用的）
使用类的方式（python类或类的路径）
app.config.from_object('settings.DevelopmentConfig')
app.config.from_object('settings.ProductionConfig')
print(app.config)
5、设置方式五
通过环境变量配置
app.config.from_envvar("环境变量名称")
环境变量的值为python文件名称名称，内部调用from_pyfile方法
6、设置方式六
使用json文件
app.config.from_json("json文件名称")
# JSON文件名称，必须是json格式，因为内部会执行json.loads
7、设置方式七
字典格式
这种方式可以使用配置中心来获取配置文件的内容，执行代码从配置中心获取字典格式的配置信息，然后使用字典方式读取配置信息到flask中
# app.config.from_mapping({'DEBUG': True})
8、配置的介绍
比较常用、重要的配置
# 内置的配置字段，其他可以写自己的，比如 redis的连接地址，mysql的连接地址
-DEBUG
是否开启debug模式
-SECRET_KEY
session的加密字符串
-SESSION_COOKIE_NAME
存在浏览器中的cookie的名称
-PERMANENT_SESSION_LIFETIME
设置cookie的过期时间
其他配置介绍
flask中的配置文件是一个flask.config.Config对象（继承字典）,默认配置为：
{
'DEBUG': get_debug_flag(default=False), 是否开启Debug模式
'TESTING': False, 是否开启测试模式
'PROPAGATE_EXCEPTIONS': None,
'PRESERVE_CONTEXT_ON_EXCEPTION': None,
'SECRET_KEY': None,
'PERMANENT_SESSION_LIFETIME': timedelta(days=31),
'USE_X_SENDFILE': False,
'LOGGER_NAME': None,
'LOGGER_HANDLER_POLICY': 'always',
'SERVER_NAME': None,
'APPLICATION_ROOT': None,
'SESSION_COOKIE_NAME': 'session',
'SESSION_COOKIE_DOMAIN': None,
'SESSION_COOKIE_PATH': None,
'SESSION_COOKIE_HTTPONLY': True,
'SESSION_COOKIE_SECURE': False,
'SESSION_REFRESH_EACH_REQUEST': True,
'MAX_CONTENT_LENGTH': None,
'SEND_FILE_MAX_AGE_DEFAULT': timedelta(hours=12),
'TRAP_BAD_REQUEST_ERRORS': False,
'TRAP_HTTP_EXCEPTIONS': False,
'EXPLAIN_TEMPLATE_LOADING': False,
'PREFERRED_URL_SCHEME': 'http',
'JSON_AS_ASCII': True,
'JSON_SORT_KEYS': True,
'JSONIFY_PRETTYPRINT_REGULAR': True,
'JSONIFY_MIMETYPE': 'application/json',
'TEMPLATES_AUTO_RELOAD': None,
}
五、路由系统
5.1 路由本质
django中配置路由 在urls.py 中，我们写path添加路由，写到路由配置的列表中
flask是基于装饰器的，大部分都用装饰器来做，少量可以抽取到一个urls.py中
路由的装饰器源码分析
# 咱们这样写
@app.route('/login')
def index():
pass
当我们用装饰器的方式去配置路由的时候，本质上是将函数名称当参数传入装饰器中去了（装饰器推导流程中的名称替换位置的知识点）
本质是---》index=app.route('/login')(index)
路由装饰器的源码
def route(self, rule: str, **options: t.Any) -> t.Callable[[T_route], T_route]:
def decorator(f: T_route) -> T_route:
endpoint = options.pop("endpoint", None)
self.add_url_rule(rule, endpoint, f, **options)
return f
return decorator
在贴出flask的路由装饰器后，我们继续分析
通过他的源码，我们可以得出他返回的结果时decorator
app.route('/login')的执行结果 decorator 函数
这里我们进行分析源码的参数，可以得知以下信息：
- 该方法把调用他的对象传到了方法中，而这里的对象就是flask创建的对象：app（核心，本质）
- rule是我们配置的路径
- 其他参数都给了options
因此
index=app.route('/login')(index)
相当于执行了
decorator(index)
因此decorator函数的参数就是index
目前没有用上endpoint，是None，所以这个变量的作用可以先不管
endpoint = options.pop("endpoint", None)
而add_url_rule方法，就是添加路由的方法，在添加了路由后，返回index方法出去
self.add_url_rule(rule, endpoint, f, **options)
return f
因此现在我们懂得了他的源码中代码的作用后，就可以不使用装饰器的方式去注册路由了，可以直接调用add_url_rule去注册
# 可以不使用装饰器的方式，注册路由
app.add_url_rule('/', endpoint=None, view_func=home, methods=['GET'])
flask路由的本质是app对象的add_url_rule完成路由的注册
5.2 路由方法add_url_rule参数
add_url_rule的代码如下
def add_url_rule(
self,
rule: str,
endpoint: t.Optional[str] = None,
view_func: t.Optional[ft.RouteCallable] = None,
provide_automatic_options: t.Optional[bool] = None,
**options: t.Any,
) -> None:
参数介绍
| 参数名称 | 介绍 |
|---|---|
| rule | URL规则 |
| view_func | 视图函数名称 |
| defaults = None | 默认值, 当URL中无参数，函数需要参数时，使用defaults = {'k': 'v'}为函数提供参数（函数需要设置形参来接收参数） |
| endpoint = None | 路径的别名，名称，用于反向解析URL，即： url_for('名称') |
| methods = None | 允许的请求方式，如：["GET", "POST"] |
| strict_slashes = None | 对URL最后的 / 符号是否严格要求 |
| redirect_to = None | 重定向到指定地址 |
| subdomain = None | 子域名访问 |
部分参数举例分析
对URL最后的 / 符号是否严格要求
strict_slashes = None
'''
@app.route('/index', strict_slashes=False)
#访问http://www.xx.com/index/ 或http://www.xx.com/index均可
@app.route('/index', strict_slashes=True)
#仅访问http://www.xx.com/index
'''
重定向到指定地址
redirect_to = None,
'''
@app.route('/index/<int:nid>', redirect_to='/home/<nid>')
'''
需要记住的参数
rule
view_func
defaults
endpoint
methods
5.3 转换器
DEFAULT_CONVERTERS = {
'default': UnicodeConverter,
'string': UnicodeConverter,
'any': AnyConverter,
'path': PathConverter,
'int': IntegerConverter,
'float': FloatConverter,
'uuid': UUIDConverter,
}
# 了解：路由也支持正则（忽略掉，用的不多）
六、作业
面试提
1、数据库三大范式是什么
参考：https://zhuanlan.zhihu.com/p/618012849
1、第一范式(1NF)是指数据库表的每一列都是不可分割的基本数据线；也就是说：每列的值具有原子性，不可再分割。
解释：
学籍信息可以继续分割，所以不符合1NF
2、第二范式(2NF)是在第一范式(1NF)的基础上建立起来得，满足第二范式(2NF)必须先满足第一范式(1NF)。如果表是单主键，那么主键以外的列必须完全依赖于主键；如果表是复合主键，那么主键以外的列必须完全依赖于主键，不能仅依赖主键的一部分。
解释：
学生id和课程id联合主键，非主键列【分数】完全依赖于主键【学生id和课程id】,学生id和课程id两个值才能决定score的值
但是【课程名字】只依赖于课程id，与学生id没有依赖关系，它不完全依赖于主键，只依赖于主键的一部分，不符合2NF
3、第三范式(3NF)是在第二范式的基础上建立起来的，即满足第三范式必须要先满足第二范式。第三范式(3NF)要求：表中的非主键列必须和主键直接相关而不能间接相关；也就是说：非主键列之间不能相关依赖。
解释：
表中【部门名称】依赖于【部门id】，而【部门id】依赖于【id主键】，从而推出【部门名称】依赖于id(主键)
【部门名称】不直接依赖于主键，而是通过依赖于非主键列而依赖于主键，属于传递依赖，不符合3NF
2、mysql有哪些索引类型，分别有什么作用
什么是索引？
索引是为了加速对表中数据行的检索而创建的一种分散的存储结构。
索引的作用
1）索引就好比一本书的目录，它能让你更快的找到自己想要的内容
2）让获取的数据更有目的性，从而提高数据库检索数据的性能
索引的本质:加快查询
mysql的索引类型
聚簇索引，聚集索引，主键索引，主键，如果不存在主键，隐藏一个主键，构建聚簇索引 primary(key)
辅助索引，普通索引 index
唯一索引 unique
联合索引,组合索引,多列索引：unique_together
3、事务的特性和隔离级别
事务的四大特性(ACID)
- A:原子性
指事务是一个不可再分割的工作单位，事务中的操作要么都发生，要么都不发生。
特点：
1、事务是一个完整的操作，事务的各元素是不可分的。
2、事务中的所有元素必须作为一个整体提交或回滚。
3、如果事务中的任何元素失败，则整个事务将失败。
举例：
比如转账的时候，如果对方接收失败了，钱应该退回自己的账户中。让双方的数据都回到转账前的状态。
- C:一致性
指在事务开始之前和事务结束以后，数据库的完整性约束没有被破坏。一致性与原子性是密切相关的。
特点：
1、当事务完成时，数据必须处于一致状态。
2、在事务开始前，数据库中存储的数据处于一致状态。
3、在正在进行的事务中，数据可能处于不一致的状态。
4、当事务成功完成时，数据必须再次回到已知的一致状态。
举例：
对银行转帐事务，不管事务成功还是失败，应该保证事务结束后表中A和B的存款总额跟事务执行前一致。
- I:隔离性
指在并发环境中，当不同的事务同时操纵相同的数据时，每个事务都有各自的完整数据空间（多个事务之间彼此不干扰）。
特点：
1、对数据进行修改的所有并发事务是彼此隔离的，表明事务必须是独立的，它不应以任何方式依赖于或影响其他事务。
2、修改数据的事务可在另一个使用相同数据的事务开始之前访问
3、这些数据，或者在另一个使用相同数据的事务结束之后访问这些数据
- D:持久性
持久性也称永久性，指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的，并不会被回滚。
特点：
1、指不管系统是否发生故障，事务处理的结果都是永久的。
2、一旦事务被提交，事务的效果会被永久地保留在数据库中。
事务的隔离级别
1.read uncommitted(未提交读)
事务中的修改即使没有提交，对其他事务也都是可见的，事务可以读取未提交的数据，这一现象也称之为"脏读"
2.read committed(提交读)
大多数数据库系统默认的隔离级别
一个事务从开始直到提交之前所作的任何修改对其他事务都是不可见的，这种级别也叫做"不可重复读"
3.repeatable read(可重复读) # MySQL默认隔离级别
能够解决"脏读"问题，但是无法解决"幻读"
所谓幻读指的是当某个事务在读取某个范围内的记录时另外一个事务又在该范围内插入了新的记录，当之前的事务再次读取该范围的记录会产生幻行，InnoDB和XtraDB通过多版本并发控制(MVCC)及间隙锁策略解决该问题
4.serializable(可串行读)
强制事务串行执行，很少使用该级别