flask之请求上下文分析之导出项目依赖-函数和方法的区别-threading.local对象-偏函数-flask整个生命执行流程--wtforms
目录
flask之请求上下文分析之导出项目依赖-函数和方法的区别-threading.local对象-偏函数-flask整个生命执行流程--wtforms
今日内容详细
1 请求上下文分析(源码：request原理)
1.1 导出项目的依赖
# 之前 pip freeze > requirments.txt 把当前解释器环境下的所有第三方依赖都导出来
# 使用第三方模块 更精确的导出依赖 pipreqs
第一步：安装 pip install pipreqs
第二步：使用命令 导出项目依赖 pipreqs ./
win由于编码问题会出错：pipreqs ./ --encoding=utf8
mac linux没有问题
第三步：就会在项目根路径下生成：requirements.txt
'''
之前导出会把当前解释器环境下的所有第三方依赖都导出来
这个模块之导出我们在py文件中使用的
'''
1.2 函数和方法
# 只要会自动传值--->就是方法 函数--->有几个值就要传几个值 否则报错
# 函数：就是普通的函数 有几个参数就要传几个参数
# 方法：绑定给对象的方法 绑定给类的方法 绑定给谁的 由谁来调用 会自动把自身传入
# 类绑定的方法 对象可以来调用 会自动把类传入
# 对象绑定的方法 类可以来调用 但是它就变成了普通函数 有几个值就要传几个值 没有自动传值了
# MethodType检查一个对象 是不是方法
# FunctionType检查一个对象 是不是函数
# isinstance 判断一个对象 是不是一个类的对象
# issubclass 判断一个类 是不是另一个类的子类
from types import MethodType, FunctionType
class Foo(object):
def fetch(self):
pass
@classmethod
def test(cls):
pass
@staticmethod
def test1():
pass
a = Foo()
print(isinstance(a, Foo))
class Foo2(Foo):
pass
class Foo3():
pass
print(issubclass(Foo2, Foo))
print(issubclass(Foo3, Foo))
def add():
pass
print(isinstance(Foo.fetch, MethodType)) # False 类来调用对象的绑定方法 该方法就变成了普通函数
obj = Foo()
print(isinstance(obj.fetch, MethodType)) # True 对象来调用自己的绑定方法 fetch就是方法
print(isinstance(Foo.fetch, FunctionType)) # True 类来调用对象的绑定方法 该方法就变成了普通函数
print(isinstance(add, FunctionType)) # True 就是个普通函数
print(isinstance(add, MethodType)) # False
print(isinstance(Foo.test, MethodType)) # True test是绑定给类的方法 类来调用 就是方法
print(isinstance(obj.test, MethodType)) # True 对象调用类的绑定方法 还是方法
print(isinstance(Foo.test1, MethodType)) # False 是普通函数
print(isinstance(obj.test1, MethodType)) # False 是普通函数
print(isinstance(obj.test1, FunctionType)) # True 静态方法 就是普通函数 对象和类都可以调用 有几个值就传几个值
1.3 threading.local对象
# local 对象
# 并发编程时 多个线程操作同一个变量 会出现并发安全的问题 咱们需要加锁
# 使用local对象 多线程并发操作时 不需要加锁 不会出现数据错乱 threading.local
# 其他语言中也有这个东西ThreadLocal
# 本质原理：
多个线程修改同一个数据 复制多份变量给每个线程用 为每个线程开辟一块空间进行数据存储
每个线程操作自己的那部分数据
####1 数据错乱
# from threading import Thread,get_ident
# import time
# lqz = -1
# def task(arg):
# global lqz
# lqz = arg
# time.sleep(2) # 我们本意是想每个线程打印自己传入的arg，但是由于sleep了， 等cpu再调度该线程执行是，lqz被改成了 9 ，所有人打印出来都是9，数据错乱了
# print('线程id为：%s----->'%get_ident(),lqz)
#
# for i in range(10):
# t = Thread(target=task,args=(i,))
# t.start()
'''
数据错乱之后打印出来都是9
'''
# 使用互斥锁解决这个问题,解决并发安全的问题
# from threading import Thread,get_ident
# from threading import Lock
#
# import time
# lqz = -1
# l=Lock()
# def task(arg):
#
# # 1w行代码
# l.acquire()
# global lqz
# lqz = arg
# time.sleep(2) # 我们本意是想每个线程打印自己传入的arg，但是由于sleep了， 等cpu再调度该线程执行是，lqz被改成了 9 ，所有人打印出来都是9，数据错乱了
# print('线程id为：%s----->'%get_ident(),lqz)
# l.release()
# # 1w行代码
#
# for i in range(10):
# t = Thread(target=task,args=(i,))
# t.start()
'''
使用互斥锁能解决问题，效率低
'''
# 使用local对象，不会出现并发安全问题
# from threading import Thread
# from threading import local
# import time
# from threading import get_ident
#
# # 特殊的对象
# lqz = local()
#
#
# def task(arg):
# lqz.arg = arg
# time.sleep(2)
# print('线程id为：%s----->'%get_ident(),lqz.arg) # 虽然用的都是lqz这个变量，但是所有线程用的都是自己的那部分数据
#
#
# for i in range(10):
# t = Thread(target=task, args=(i,))
# t.start()
# flask中的request就是用了local 但是它只能区分线程 不能区分协程 flask自己写了个local 兼容线程和协程
# 本质是个{'线程id号': {arg:1}, '线程id号':{arg:2}, '线程id号':{arg:3}}
# {'协程id号':{arg:1},'协程id号':{arg:2},'协程id号':{arg:3}}
# 自己封装local 实现兼容线程和协程
# 尝试导入greenlet试一下 如果导入不进来 说明根本没有用greenlet 就没有用协程 没有用协程会报错 执行下面的代码 用了协程就不报错
try:
from greenlet import getcurrent as get_ident
except Exception as e:
from threading import get_ident
from threading import Thread
class Local(object):
def __init__(self):
object.__setattr__(self, 'storage', {}) # 这个不会触发setattr
# self.storage={} # 它会触发 __setattr__ 就会递归
def __setattr__(self, k, v):
ident = get_ident() # 如果用协程 这就是协程号 如果是线程 这就是线程号
if ident in self.storage: # {'协程id号':{arg:1},'协程id号':{arg:2},'协程id号':{arg:3}}
self.storage[ident][k] = v # 存在就修改值
else:
self.storage[ident] = {k: v} # 不存在就新增键值对
def __getattr__(self, k):
ident = get_ident()
return self.storage[ident][k]
lqz = Local()
def task(arg):
lqz.arg = arg
print(lqz.arg)
for i in range(10):
t = Thread(target=task, args=(i,))
t.start()
1.4 偏函数
# 偏函数作用：可以提前传值
from functools import partial
def add(a, b, c):
return a + b + c
print(add(3, 4, 5)) # 传少了报错
# 现在只有一个参数 后面的俩参数 需要过一会才知道
# 借助于偏函数 先提前给它把第一个参数传入 后面知道了后面俩参数 再传后面俩
add = partial(add, 3)
# 干了很多事
print(add(4, 5)) # 不会报错 提前传值
1.5 flask整个生命执行流程(1.1.4版本为例)
# 请求来了---> app()---> Flask.__call__---> self.wsgi_app(environ, start_response)--这个就是当次请求入口
def wsgi_app(self, environ, start_response):
# environ:http请求拆成了字典
# ctx对象：RequestContext类的对象 对象里有：当次的requests对象 app对象 session对象
ctx = self.request_context(environ)
error = None
try:
try:
# ctx RequestContext类 push方法
ctx.push()
# 匹配成路由后 执行视图函数
response = self.full_dispatch_request()
except Exception as e:
error = e
response = self.handle_exception(e)
except:
error = sys.exc_info()[1]
raise
return response(environ, start_response)
finally:
if self.should_ignore_error(error):
error = None
ctx.auto_pop(error)
# RequestContext：ctx.push
def push(self):
# 因为ctx = self.request_context(environ)
# _request_ctx_stack = LocalStack()---> push(ctx对象)---> ctx中有：request session app
_request_ctx_stack.push(self)
# 这下边是session相关 和request一样
if self.session is None:
session_interface = self.app.session_interface
self.session = session_interface.open_session(self.app, self.request)
if self.session is None:
self.session = session_interface.make_null_session(self.app)
# 路由匹配相关
if self.url_adapter is not None:
self.match_request()
# 点进LocalStack()---> 看到push---> obj是ctx对象
def push(self, obj):
# self._local _local就是咱们刚刚自己写的Local对象---> LocalStack的init初始化的_local---> self._local = local()---> Local对象可以根据线程协程区分数据
rv = getattr(self._local, "stack", None)
# 一开始没有值
if rv is None:
self._local.stack = rv = [] # self._local.stack 根据不同线程用的是自己的数据
rv.append(obj) # self._local.stack.append(obj)
# {'线程id号'：{stack：[ctx]},'线程id号2'：{stack：[ctx]}}
return rv
# 再往后执行 就会进入到路由匹配 执行视图函数
# request = LocalProxy(partial(_lookup_req_object, "request"))
# LocalProxy 代理类---> method---> 代理类去当前线程的stack取出ctx 取出当时放进去的request
视图函数中：print(request.method)
# print(request) 执行LocalProxy类的__str__方法
# request.method 执行LocalProxy类的__getattr__
def __getattr__(self, name): # name是method
# self._get_current_object() 就是当次请求的request
return getattr(self._get_current_object(), name)
# LocalProxy类的方法_get_current_object
def _get_current_object(self):
if not hasattr(self.__local, "__release_local__"):
return self.__local()
try:
return getattr(self.__local, self.__name__)
except AttributeError:
raise RuntimeError("no object bound to %s" % self.__name__)
# self.__local 是在 LocalProxy 类实例化的时候传入的local
# 在这里实例化的：request = LocalProxy(partial(_lookup_req_object, "request"))
# local 是 partial(_lookup_req_object, "request")
# _lookup_req_object name=request
def _lookup_req_object(name):
top = _request_ctx_stack.top # 取出了ctx 是当前线程的ctx
if top is None:
raise RuntimeError(_request_ctx_err_msg)
return getattr(top, name) # 从ctx中反射出request 当次请求的request
'''
结论：为什么request是全局的但是每个函数调用的都是自己
就是使用了thring.local每条线程都复制一份request 自己使用自己的 但是使用协程就出现了问题 因为协程是单线程实现并发
然后flask就做了操作---> 它生成了一个字典 字典键就是协程id或者线程id---> 无论是协程还是线程来了都是调用的自己(就是这个操作)
'''
请求上下文执行流程（ctx）：
-0 flask项目一启动，有6个全局变量
-_request_ctx_stack：LocalStack对象
-_app_ctx_stack ：LocalStack对象
-request ： LocalProxy对象
-session ： LocalProxy对象
-1 请求来了 app.__call__()---->内部执行：self.wsgi_app(environ, start_response)
-2 wsgi_app()
-2.1 执行：ctx = self.request_context(environ)：返回一个RequestContext对象，并且封装了request(当次请求的request对象)，session,flash,当前app对象
-2.2 执行： ctx.push()：RequestContext对象的push方法
-2.2.1 push方法中中间位置有：_request_ctx_stack.push(self)，self是ctx对象
-2.2.2 去_request_ctx_stack对象的类中找push方法（LocalStack中找push方法）
-2.2.3 push方法源码：
def push(self, obj):
#通过反射找self._local,在init实例化的时候生成的：self._local = Local()
#Local()，flask封装的支持线程和协程的local对象
# 一开始取不到stack，返回None
rv = getattr(self._local, "stack", None)
if rv is None:
#走到这，self._local.stack=[],rv=self._local.stack
self._local.stack = rv = []
# 把ctx放到了列表中
#self._local={'线程id1':{'stack':[ctx,]},'线程id2':{'stack':[ctx,]},'线程id3':{'stack':[ctx,]}}
rv.append(obj)
return rv
-3 如果在视图函数中使用request对象，比如：print(request)
-3.1 会调用request对象的__str__方法，request类是：LocalProxy
-3.2 LocalProxy中的__str__方法：lambda x: str(x._get_current_object())
-3.2.1 内部执行self._get_current_object()
-3.2.2 _get_current_object()方法的源码如下：
def _get_current_object(self):
if not hasattr(self.__local, "__release_local__"):
#self.__local() 在init的时候，实例化的，在init中：object.__setattr__(self, "_LocalProxy__local", local)
# 用了隐藏属性
#self.__local 实例化该类的时候传入的local（偏函数的内存地址：partial(_lookup_req_object, "request")）
#加括号返回，就会执行偏函数，也就是执行_lookup_req_object，不需要传参数了
#这个地方的返回值就是request对象(当此请求的request，没有乱)
return self.__local()
try:
return getattr(self.__local, self.__name__)
except AttributeError:
raise RuntimeError("no object bound to %s" % self.__name__)
-3.2.3 _lookup_req_object函数源码如下：
def _lookup_req_object(name):
#name是'request'字符串
#top方法是把第二步中放入的ctx取出来，因为都在一个线程内，当前取到的就是当次请求的ctx对象
top = _request_ctx_stack.top
if top is None:
raise RuntimeError(_request_ctx_err_msg)
#通过反射，去ctx中把request对象返回
return getattr(top, name)
-3.2.4 所以：print(request) 实质上是在打印当此请求的request对象的__str__
-4 如果在视图函数中使用request对象，比如：print(request.method):实质上是取到当次请求的reuquest对象的method属性
-5 最终，请求结束执行： ctx.auto_pop(error)，把ctx移除掉
其他的东西：
-session:
-请求来了opensession
-ctx.push()---->也就是RequestContext类的push方法的最后的地方：
if self.session is None:
#self是ctx，ctx中有个app就是flask对象， self.app.session_interface也就是它：SecureCookieSessionInterface()
session_interface = self.app.session_interface
self.session = session_interface.open_session(self.app, self.request)
if self.session is None:
#经过上面还是None的话，生成了个空session
self.session = session_interface.make_null_session(self.app)
-请求走了savesession
-response = self.full_dispatch_request() 方法内部：执行了before_first_request，before_request，视图函数，after_request，savesession
-self.full_dispatch_request()---->执行：self.finalize_request(rv)-----》self.process_response(response)----》最后：self.session_interface.save_session(self, ctx.session, response)
-请求扩展相关
before_first_request，before_request，after_request依次执行
-flask有一个请求上下文，一个应用上下文
-ctx:
-是：RequestContext对象:封装了request和session
-调用了：_request_ctx_stack.push(self)就是把：ctx放到了那个位置
-app_ctx:
-是：AppContext(self) 对象：封装了当前的app和g
-调用 _app_ctx_stack.push(self) 就是把：app_ctx放到了那个位置
-g是个什么鬼？
专门用来存储用户信息的g对象，g的全称的为global
g对象在一次请求中的所有的代码的地方，都是可以使用的
-代理模式
-request和session就是代理对象，用的就是代理模式
2 wtforms(了解)
# django 有forms组件
生成前端模板
校验数据
渲染错误信息
# flask 中使用第三方的wtforms 实现像django的forms一样的功能
第一步：导入 定义一个类 继承forms
第二步：模板中 for循环生成模板
第三步：视图函数中 使用form校验数据
from flask import Flask, request, render_template, redirect
from wtforms import Form, validators, widgets
from wtforms.fields import simple
app = Flask(__name__)
app.debug = True
class LoginForm(Form):
# 字段(内部包含正则表达式)
name = simple.StringField(
label='用户名',
validators=[
validators.DataRequired(message='用户名不能为空.'),
validators.length(min=6, max=18, message='用户名长度必须大于%(min)d且小于%(max)d')
],
widget=widgets.TextInput(), # 页面上显示的插件
render_kw={'class': 'form-control'}
)
# 字段(内部包含正则表达式)
pwd = simple.PasswordField(
label='密码',
validators=[
validators.DataRequired(message='密码不能为空.'),
validators.length(min=8, message='用户名长度必须大于%(min)d'),
validators.Regexp(regex="^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[$@$!%*?&])[A-Za-z\d$@$!%*?&]{8,}", message='密码至少8个字符，至少1个大写字母，1个小写字母，1个数字和1个特殊字符')
],
widget=widgets.PasswordInput(),
render_kw={'class': 'form-control'}
)
@app.route('/login', methods=['GET', 'POST'])
def login():
if request.method == 'GET':
form = LoginForm()
return render_template('login.html', form=form)
else:
form = LoginForm(formdata=request.form)
if form.validate():
print('用户提交数据通过格式验证 提交的值为：', form.data)
else:
print(form.errors)
return render_template('login.html', form=form)
if __name__ == '__main__':
app.run()
# templates内login.html代码
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>登录</h1>
<form method="post" novalidate>
<p>{{form.name.label}}： {{form.name}} {{form.name.errors[0] }}</p>
<p>{{form.pwd.label}} {{form.pwd}} {{form.pwd.errors[0] }}</p>
<input type="submit" value="提交">
</form>
</body>
</html>
补充
# 进程：进程是资源分配的最小单位 一个应用程序运行 至少会开启一个进程
# 线程：线程是cpu调度的最小单位 cpu执行的最小单位
# 协程：单线程下实现并发 代码层面遇到io 自己(程序方面)切换
