local推导步骤
#多个线程修改同一个数据，复制多份变量给每个线程用,为每个线程开辟一块空间进行数据存储
这里的local实现原理，通过get_ident获取线程ID，通过getcurrent获取协程ID，放到字典中，
#不用local from threading import Thread import time lqz = -1 def task(arg): global lqz lqz = arg time.sleep(2) #最后显示9个相同的数字 print(lqz) for i in range(10): t = Thread(target=task,args=(i,)) t.start() --------------------------------- # 使用local对象 from threading import Thread from threading import local import time # {'线程id1':{'args':1},'线程id2':{'args':2}} #local存的格式如上，根据线程id进行存值 lqz = local() def task(arg): lqz.arg = arg time.sleep(2) print(lqz.arg) for i in range(10): t = Thread(target=task,args=(i,)) t.start() -------------------------------------------- #自定义local,函数版 # {'线程id1': {'args': 1}, '线程id2': {'args': 2}, '线程id3': {'args': 3}} from threading import get_ident,Thread import time storage = {} def set(k,v): #get_ident的作用是获取线程的id号 ident = get_ident() if ident in storage: storage[ident][k] = v else: storage[ident] = {k:v} def get(k): ident = get_ident() return storage[ident][k] def task(arg): set('val',arg) #设置值 v = get('val') #取值 print(v) for i in range(10): t = Thread(target=task,args=(i,)) t.start() ---------------------------------------------- #面向对象版的local #{'线程id1': {'args': 1}, '线程id2': {'args': 2}, '线程id3': {'args': 3}} from threading import get_ident,Thread import time class Local(object): storage = {} def set(self, k, v): ident = get_ident() if ident in Local.storage: #类的属性可以点出来 Local.storage[ident][k] = v else: Local.storage[ident] = {k: v} def get(self, k): ident = get_ident() return Local.storage[ident][k] obj = Local() def task(arg): obj.set('val',arg) v = obj.get('val') time.sleep(1) print(v) for i in range(10): t = Thread(target=task,args=(i,)) t.start() ---------------------------------------------- #改进版本 from threading import get_ident,Thread import time class Local(object): storage = {} def __setattr__(self, k, v): ident = get_ident() if ident in Local.storage: Local.storage[ident][k] = v else: Local.storage[ident] = {k: v} def __getattr__(self, k): ident = get_ident() return Local.storage[ident][k] obj = Local() # obj2=Local() # obj3=Local() # obj4=Local() # obj5=Local() def task(arg): obj.val = arg time.sleep(1) print(obj.val) for i in range(10): t = Thread(target=task,args=(i,)) t.start() -------------------------------------------- #每次生成local对象用的都是自己的字典，上面那个用的全是类的字典，不管生成几个对象，用的都是同一个 from threading import get_ident,Thread import time class Local(object): def __init__(self): object.__setattr__(self,'storage',{}) # self.storage={}，， #这样写会出现递归，所以用是上边的写法 def __setattr__(self, k, v): ident = get_ident() if ident in self.storage: self.storage[ident][k] = v else: self.storage[ident] = {k: v} def __getattr__(self, k): ident = get_ident() return self.storage[ident][k] obj = Local() def task(arg): obj.val = arg # obj.xxx = arg time.sleep(1) print(obj.val) for i in range(10): t = Thread(target=task,args=(i,)) t.start() #到此为止，自己写了一个local对象，只支持线程 --------------------------------------------------- #要支持协程 try: #getcurrent 获取协程id 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',{}) def __setattr__(self, k, v): ident = get_ident() if ident in self.storage: self.storage[ident][k] = v else: self.storage[ident] = {k: v} def __getattr__(self, k): ident = get_ident() return self.storage[ident][k] obj = Local() def task(arg): obj.val = arg obj.xxx = arg print(obj.val) for i in range(10): t = Thread(target=task,args=(i,)) t.start()
#请求来了执行__call__ def __call__(self, environ, start_response): """The WSGI server calls the Flask application object as the WSGI application. This calls :meth:`wsgi_app` which can be wrapped to applying middleware.""" return self.wsgi_app(environ, start_response) #点进来 这个方式基于哪个类？ 往上层推，基于自己写的app = Flask(__name__) 这个类 def wsgi_app(self, environ, start_response): #flask所有请求上下文基于这几行 ctx = self.request_context(environ) #与ctx.push()一起将请求相关的数据environ封装到了RequestContext对象中，再将对象封装到local中（每个线程/协程独立空间存储） error = None try: try: ctx.push() response = self.full_dispatch_request() #下面这些就是执行当前函数 except Exception as e: error = e response = self.handle_exception(e) except: # noqa: B001 error = sys.exc_info()[1] raise return response(environ, start_response) finally: if self.should_ignore_error(error): error = None ctx.auto_pop(error) #把当前请求对象从取出来
ctx = self.request_context(environ) #environ请求相关所有东西 #看这一行，self是当前请求对象，也就是实例化flask的app 点request_context进来 def request_context(self, environ): return RequestContext(self, environ) #返回这个类 #ctx = RequestContext(self, environ) 相当于ctx等于这个类 class RequestContext(object): #self应该是ctx吧 def __init__(self, app, environ, request=None, session=None): self.app = app if request is None: #第一次来肯定是None，看类中传的参数 request = app.request_class(environ) #发现这又是一个类，这一步把 #request重新封装了吧 self.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 = None self.session = session ------------------------------------------------------- def request_context(self, environ): """Create a :class:`~flask.ctx.RequestContext` representing a WSGI environment. Use a ``with`` block to push the context, which will make :data:`request` point at this request. See :doc:`/reqcontext`. Typically you should not call this from your own code. A request context is automatically pushed by the :meth:`wsgi_app` when handling a request. Use :meth:`test_request_context` to create an environment and context instead of this method. :param environ: a WSGI environment """ 创建一个:类:‘~ flask.ctx。RequestContext的代表 WSGI环境。使用“with”块来推送上下文， 这将使:data: ' request '指向这个请求。 看到:医生:“/ reqcontext”。 通常，您不应该从自己的代码中调用它。一个请求 上下文被:meth: ' wsgi_app '自动推送 处理一个请求。使用:meth: ' test_request_context '来创建 环境和上下文，而不是这个方法。 :param environment on:一个WSGI环境 """ return RequestContext(self, environ)
#看第二行 ctx.push() #上一行知道ctx=RequestContext(self, environ),所以执行的是这个类的push方法 def push(self): #self是ctx #进来之后先看最后一句 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) #这个push方法是_request_ctx_stack对象的类LocalStack的，不是当前类的 #把self添加到_request_ctx_stack中 #来到_request_ctx_stack #下面这些东西都是全局变量，程序开始阶段已经存在 _request_ctx_stack = LocalStack() _app_ctx_stack = LocalStack() current_app = LocalProxy(_find_app) request = LocalProxy(partial(_lookup_req_object, "request")) session = LocalProxy(partial(_lookup_req_object, "session")) g = LocalProxy(partial(_lookup_app_object, "g")) #看看LocalStack这个类 class LocalStack(object): def __init__(self): #self是_request_ctx_stack #_request_ctx_stack = LocalStack() self._local = Local() #看看Local这个类 #程序刚启动这里的数据是空的，仅仅完成实例化， 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} ------------------------------------ #看完下一个方法在回头看这里 #相当于 name=stack value=[] { 唯一ID：{stack:[ctx]} } #然后看LocalStack的push方法 def push(self, obj): rv = getattr(self._local, "stack", None) #刚来到时候是None if rv is None: self._local.stack = rv = [] #self._local，执行__setattr__ #现在看上边 rv.append(obj) #这一步把当前请求对象添加到列表中，也就是ctx return rv
#此时在自己写的函数中的request，点进去 _request_ctx_stack = LocalStack() _app_ctx_stack = LocalStack() current_app = LocalProxy(_find_app) #request = LocalProxy(partial(_lookup_req_object, "request")) 还是来到全局变量 session = LocalProxy(partial(_lookup_req_object, "session")) g = LocalProxy(partial(_lookup_app_object, "g")) #来到LocalProxy class LocalProxy(object): 里边有很多方法，此时自己写的类中的request相应的操作，会执行当前类中相对应的方法，比如，print(request) 执行_str__方法 #另外执行这些方法时，都执行偏函数LocalProxy(partial(_lookup_req_object, "request")) #来到_lookup_req_object def _lookup_req_object(name): top = _request_ctx_stack.top #_request_ctx_stack也是全局变量 #去localLocalStack找top if top is None: raise RuntimeError(_request_ctx_err_msg) return getattr(top, name) #来到top, def top(self) try: return self._local.stack[-1]
请求上下文执行流程
#0 flask项目一启动，有6个全局变量 #globals.py中 _request_ctx_stack：LocalStack对象 _app_ctx_stack ：LocalStack对象 request ： LocalProxy对象 session ： LocalProxy对象 #1请求来的时候。先到app.__call__()start_response) #app.py class Flask(_PackageBoundObject): def __call__(self, environ, start_response): return self.wsgi_app(environ, start_response) #执行 #2、点wsgi_app（）进去 #2.1执行 ctx = self.request_context(environ) def wsgi_app(self, environ, start_response): #ctx是RequestContext的对象，里面包含了当次请求的request，session ctx = self.request_context(environ) #点request_context error = None try: try: ctx.push() #此时的push其实是RequestContext类的push方法 2.1.1来到 def request_context(self, environ): return RequestContext(self, environ) #把RequestContext返回给了ctx ，所以ctx是RequestContext的对象 #2.2点 RequestContext进去 #ctx.py ，先看push方法 class RequestContext(object): def push(self): _request_ctx_stack.push(self) # 前面知道_request_ctx_stack是全局变量 #知道ctx是RequestContext类的对象，所以此时self是ctx, #2.2.1点_request_ctx_stack进去 #globals.py _request_ctx_stack = LocalStack() #进去找push方法 #2.2.2 #local.py class LocalStack(object): def push(self, obj): #传进来的obj就是ctx rv = getattr(self._local, "stack", None) #self._local是init的时候，实例化进来的，也就是flask定义的local（）对象可以点进去看看self._local = Local()，local和上面推导的哟杨 #一开始没有stack if rv is None: self._local.stack = rv = [] rv.append(obj) return rv #此时{"线程id：{'static':[ctx]},"线程id2：{'static':[ctx]}} #也就是把ctx放到local对象里 #那么，往回看， _request_ctx_stack = LocalStack() #相当于这句话完成把ctx放到local里 #再往回看 ctx.push() #也就是这句话完成的
print(request)
#其实走的是LocalProxy类的__ste__ request = LocalProxy(partial(_lookup_req_object, "request")) #点进去找__repr__，先把他理解为__str__ def __repr__(self): try: obj = self._get_current_object() #点进去 if not hasattr(self.__local, "__release_local__"): return self.__local() #是从__init__传过来的，隐藏属性传的 #self.__local就是传入的偏函数，偏函数的执行结果是request对象 def __init__(self, local, name=None): object.__setattr__(self, "_LocalProxy__local", local) object.__setattr__(self, "__name__", name) # return self.__local() ，此时i相当于偏函数partial(_lookup_req_object, "request")加括号执行，那么点_lookup_req_object进去 def _lookup_req_object(name): #name ‘request’ top = _request_ctx_stack.top #top就是ctx的对象 if top is None: raise RuntimeError(_request_ctx_err_msg) return getattr(top, name) #返回的就是request对象 也就是打印的request -------------------------------- #那么 print(request.method) 用点属性的时候，又是怎么执行的呢 通过__grtattr__方法实现 def __getattr__(self, name): if name == "__members__": return dir(self._get_current_object()) return getattr(self._get_current_object(), name) #通过反射找出点的内容
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对象，g的全称的为global g对象在一次请求中的所有的代码的地方，都是可以使用的 #g对象和session的区别 session对象是可以跨request的，只要session还未失效，不同的request的请求会获取到同一个session，但是g对象不是，g对象不需要管过期时间，请求一次就g对象就改变了一次，或者重新赋值了一次
from flask import Flask,g,request app = Flask(__name__) @app.before_request #好像必须与它一起用 def xxxx(): g.lqz='lqz' # request.lqz='lqz' 效果与g一样，估计作者是怕误操作 request.method='lqz' @app.route('/',methods=['GET','POST']) def index(): print(g.lqz) return 'dddddd' if __name__ == '__main__': app.run(port=8888)
偏函数
#偏函数 #提前给函数传值，以后就可以少传值了 from functools import partial def add(a,b,c,d): return a+b+c+d # print(add(1,2,3,4)) add=partial(add,1,2) print(add(3,4)) >>10