目录
一、请求上下文分析（源码：request原理）
1.1 导出项目的依赖（pipreqs模块）
之前我们是用
pip freeze >requirements.txt
把当前解释器环境下的所有第三方依赖都导出来
而使用第三方模块：pipreqs模块，可以实现精确导出依赖（只显示安装的模块，不显示模块的依赖模块）
使用步骤
步骤一
安装pipreqs模块
pip3 install pipreqs
步骤二
在项目目录下，执行命令导出项目依赖
pipreqs ./
这样就是在项目根路径下创建依赖文件requirements.txt
win由于编码问题会出错，需要执行下方命令（报错了在执行这个）：
pipreqs ./ --encoding=utf8
mac，linx没有问题
步骤三
执行上面的操作之后，我们就可以在当前路径下找到requirements.txt，并且里面只有我们下载的模块，模块的依赖并不会显示
1.2 函数和方法
函数：就是普通的函数，有几个参数就要传几个参数
方法：绑定给对象的方法，绑定给类的方法，绑定给谁的，由谁来调用，会自动把自身传入（self，cls等参数）
总结：
只要会自动传值，就是方法。函数则是有几个值就要传几个值，否则报错
ps：
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))
# 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对象
参考文档：https://zhuanlan.zhihu.com/p/351234611
在别的语言中，他叫 local 对象
在Python中，threading.local对象是一种线程本地存储的机制。它允许我们为每个线程创建一个独立的变量，这些变量在不同的线程中互不干扰。
使用情景分析
并发编程时，多个线程操作同一个变量，会出现并发安全的问题，咱们需要加锁
如果使用local对象，多线程并发操作时，不需要加锁，不会出现数据错乱threading.local
其他语言中也有这个东西ThreadLocal，java中面试会被经常问到，python没人问
本质原理：
多个线程修改同一个数据，复制多份变量给每个线程用，为每个线程开辟一块空间进行数据存储，每个线程操作自己的那部分数据
使用threading.local对象的步骤如下：
- 创建
threading.local对象 - 在每个线程中，通过该对象的属性来访问线程本地存储的变量
代码演示
1、数据错乱
这种情况下会出现数据混乱，因为所有的线程修改的都是全局的变量，就会出现打印的值全是9的情况
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()
2、使用互斥锁解决解决并发安全的问题
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()
3、使用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，兼容线程和协程
local对象的本质：
{'线程id号':{arg:1},'线程id号':{arg:2},'线程id号':{arg:3}}
flask自己写的、兼容线程和写成的local：
{'协程id号':{arg:1},'协程id号':{arg:2},'协程id号':{arg:3}}
补充知识
# 进程：进程是资源分配的最小单位，一个应用程序运行，至少会开启一个进程
# 线程：线程是cpu调度的最小单位，cpu执行的最小单位
# 协程：单线程下实现并发，代码层面遇到io，自己切换（单线程下实现并发效果）
自定义封装local，实现兼容线程和协程
ps：当没有用协程但是导入了协程模块的时候，我们可以获取到协程id号，这个时候他的作用就跟进程id号一样了，因为现在一个进程内只有一个协程
# 尝试导入greenlet试一下，如果导入不进来，说明根本没有用greenlet，就没有用协程，用了协程就不报错
try:
from greenlet import getcurrent as get_ident
except Exception as e:
from threading import get_ident
from threading import Thread
import time
class Local(object):
def __init__(self):
object.__setattr__(self, 'storage', {}) # 这个不会触发setattr
# self.storage={} # 它会触发 __setattr__,就会递归
'''
-__getattr__ 对象.属性，属性不存在，触发
-__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 偏函数
Python的偏函数是一个高级函数的概念，它可以让我们在调用函数时，先指定一部分参数，从而产生一个新函数。这个新函数就是原来函数的一个特定版本，它的某些参数已经被预设了值，我们只需要再传入剩下的参数就可以调用它。（即先传一部分参数，再传一部分参数）
例如，我们有一个函数add，它用于将两个数相加：
def add(x, y): return x + y
我们可以使用偏函数来创建一个新函数add1，它的第一个参数已经被预设为1：
from functools import partial
add1 = partial(add, 1)
# 现在，我们可以直接调用add1函数来计算1和另一个数的和：
result = add1(2)
print(result) # 输出3
在这个例子中，我们使用偏函数来创建了一个新函数add1，它的第一个参数已经被预设为1。当我们调用add1(2)时，实际上是调用了add(1, 2)。因此，result的值为3。
1.5 flask 整个生命执行流程（1.1.4版本为例）
这是一个简易的flask项目
from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
return 'xxx'
if __name__ == '__main__':
app.run()
我们可以得知，当项目运行的时候，app.run()是项目的启动位置
当我们点进他的源码进行查看的时候，我们可以看到他的最下方，有一个方法是我们很熟悉的，如下：
from werkzeug.serving import run_simple
try:
run_simple(t.cast(str, host), port, self, **options)
finally:
self._got_first_request = False
在初学flask 的时候，我们介绍到：Flask是一个基于Python开发并且依赖jinja2模板和Werkzeug WSGI服务的一个微型框架
这里我们就可以理解，app.run()的本质就是调用了Werkzeug 的run_simple
根据run_simple方法的参数，我们可以得知第一个参数是ip，第二个是端口，第三个是要运行的方法，这里就相当于执行：self()，而这个self就是Flask产生的对象app。
而app对象加括号运行，会触发Flask的双下call
def __call__(self, environ: dict, start_response: t.Callable) -> t.Any:
return self.wsgi_app(environ, start_response)
通过双下call我们可以得知，他的本质就是用app对象去执行了wsgi_app这个方法
因此整个请求的入口就是self.wsgi_app
flask生命周期流程概述：
来一个请求，就会执行它，它包装了请求对象request，执行了请求扩展，根据路由匹配视图函数，执行视图函数，视图函数返回，整个过程结束
我们接着分析wsgi_app方法
# 请求来了---》app()----->Flask.__call__--->self.wsgi_app(environ, start_response)
def wsgi_app(self, environ, start_response):
# environ:http 请求，被符合wsgi协议的web服务器做成了 environ 字典 ，environ就是当次http请求的字典对象
# ctx对象：RequestContext类的对象，对象里有：当次的requets对象，app对象，session对象
ctx = self.request_context(environ)
'看到这里我们就去找request_context，看看他的源码干了什么（看下方的源码）'
'研究了request_context之后，我们得出结论ctx就是RequestContext对象，对象中有：当前app对象，当次请求request，当次请求的session'
error = None
try:
try:
#ctx RequestContext类 push方法
ctx.push()
'这里RequestContext对象执行了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)
request_context源码：
def request_context(self, environ: dict) -> RequestContext: return RequestContext(self, environ)
在request_context方法中返回了RequestContext的对象
因此我们去看RequestContext类的双下init方法
def __init__(
self,
app: "Flask",
environ: dict,
request: t.Optional["Request"] = None,
session: t.Optional["SessionMixin"] = None,
) -> None:
self.app = app
if request is None:
request = app.request_class(environ)
request.json_module = app.json
self.request: Request = request
self.url_adapter = None
try:
self.url_adapter = app.create_url_adapter(self.request)
except HTTPException as e:
self.request.routing_exception = e
self.flashes: t.Optional[t.List[t.Tuple[str, str]]] = None
self.session: t.Optional["SessionMixin"] = session
self._after_request_functions: t.List[ft.AfterRequestCallable] = []
self._cv_tokens: t.List[t.Tuple[contextvars.Token, t.Optional[AppContext]]] = []
在他的参数中，我们结合下面的代码就可以发现，app就是我们Flask生成的app对象，request是请求对象，还有当次请求的session，到此为止，我们回到上面的wsgi_app源码
RequestContext类的push方法：
def push(self):
top = _request_ctx_stack.top
if top is not None and top.preserved:
top.pop(top._preserved_exc)
app_ctx = _app_ctx_stack.top
'这个叫应用上下文'
if app_ctx is None or app_ctx.app != self.app:
app_ctx = self.app.app_context()
app_ctx.push()
self._implicit_app_ctx_stack.append(app_ctx)
else:
self._implicit_app_ctx_stack.append(None)
if hasattr(sys, "exc_clear"):
sys.exc_clear()
_request_ctx_stack.push(self)
#session相关的
if self.session is None:
session_interface = self.app.session_interface
self.session = session_interface.open_session(self.app, self.request)
'这里出现了open_session，之前分析session源码的时候，我们只是简单解释了：请求来了，会执行open_session，创建出带session数据的session对象'
if self.session is None:
self.session = session_interface.make_null_session(self.app)
# 路由匹配相关的
if self.url_adapter is not None:
self.match_request()
别的代码，我们看不懂，这里老师说了
_request_ctx_stack.push(self)
就是关键，我们ctrl点击他，可以看到他的代码如下：
_request_ctx_stack = LocalStack()
因此本质就是LocalStack对象执行了push方法
push方法源码如下：
def push(self, obj):
"""Pushes a new item to the stack"""
rv = getattr(self._local, "stack", None)
if rv is None:
self._local.stack = rv = []
rv.append(obj)
return rv
从push 的源码中我们可以发现关键就是rv这个变量，我们又得知rv这个变量是用了反射，而反射查找的对象是self._local
所以我们接下去的研究点就是他，然后再LocalStack的双下init中就可以找到他
def __init__(self): self._local = Local()
接着我们去看Local类，我们可以发现，他就是我们前面自己封装的threading.local对象，可以兼容协程和线程
部分Local的源码
try:
from greenlet import getcurrent as get_ident
except ImportError:
try:
from thread import get_ident
except ImportError:
from _thread import get_ident
class Local(object):
__slots__ = ("__storage__", "__ident_func__")
def __init__(self):
object.__setattr__(self, "__storage__", {})
object.__setattr__(self, "__ident_func__", get_ident)
def __getattr__(self, name):
try:
return self.__storage__[self.__ident_func__()][name]
except KeyError:
raise AttributeError(name)
def __setattr__(self, name, value):
ident = self.__ident_func__()
storage = self.__storage__
try:
storage[ident][name] = value
except KeyError:
storage[ident] = {name: value}
这里的双下ident_func跟我们自己写的不一样，但是就是在创建对象的时候，双下init里面，给他重新设置了一下
我们回到LocalStack类的push方法
LocalStack类的push方法源码如下：
def push(self, obj):
"""obj 是ctx对象"""
rv = getattr(self._local, "stack", None)
if rv is None:
self._local.stack = rv = []
rv.append(obj)
# self._local.stack.append(obj)
# {'线程id号'：{stack：[ctx]},'线程id号2'：{stack：[ctx]}}
return rv
这个时候我们就可以分析出self._local就是Local的对象（Local对象可以根据线程协程区分数据）
然后再Local的源码中我们我们并没有发现stack这个方法，因此下面的那个if判断肯定是会进去走的（即rv一开始是空的）
然后给rv和self._local.stack设置了值（空列表）
接着给rv加入了obj对象，也就是ctx对象(内部有：当前app对象，当次请求request，当次请求的session)，然后把他返回了出去
结果如下：
{'线程id号'：{stack：[ctx]},'线程id号2'：{stack：[ctx]}}
这样就可以根据线程id或协程id，对request对象进行区分，不会出现混乱
再往后执行，就会进入到路由匹配，执行视图函数
接着我们去回顾一下视图函数中request的使用场景，在使用的过程中，我们都是直接导入request对象来使用的，因此我们在导入语句中去查看request的源码，如下：
request = LocalProxy(partial(_lookup_req_object, "request"))
LocalProxy 代理类---》method---》代理类去当前线程的stack取出ctx，取出当时放进去的request
视图函数中使用：
print(request.method)
分析：
print(request) 会执行LocalProxy类的__str__方法
request.method 会执行LocalProxy类的__getattr__
因此我们去看会执行LocalProxy类的双下str和双下getattr方法的源码
然后我们找到了双下getattr
def __getattr__(self, name):
if name == "__members__":
return dir(self._get_current_object())
return getattr(self._get_current_object(), name)
在他的内部，我们分析得到结论，无论走不走if语句，都会执行self._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
下面是相关的源码
class LocalProxy(object):
__slots__ = ("__local", "__dict__", "__name__", "__wrapped__")
def __init__(self, local, name=None):
object.__setattr__(self, "_LocalProxy__local", local)
object.__setattr__(self, "__name__", name)
if callable(local) and not hasattr(local, "__release_local__"):
object.__setattr__(self, "__wrapped__", local)
然后我们回顾request的源码：
request = LocalProxy(partial(_lookup_req_object, "request"))
得出结论：LocalProxy的双下init的local参数是 partial(_lookup_req_object, "request")
因此partial(_lookup_req_object, "request")就是通过协程id或线程id获取存储在local中的对应的request
更深层次的分析
请求上下文执行流程（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就是代理对象，用的就是代理模式
二、wtforms（了解）
django 有forms组件可以
- 生成前端模板
- 校验数据
- 渲染错误信息
而flask中我们需要使用第三方模块：wtforms模块
使用它我们可以实现像django的forms一样的功能
使用步骤
步骤一
下载wtforms模块
pip install wtforms
步骤二
导入，定义一个类，继承form
步骤三
模板中， for循环生成模板
步骤四
视图函数中，使用form校验数据
示例代码：
from flask import Flask, render_template, request, redirect
from wtforms import Form
from wtforms.fields import simple
from wtforms import validators
from wtforms import widgets
app = Flask(__name__, template_folder='templates')
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()
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>