flask(五)

今日内容概要

  • django的信号
  • 并发编程
  • 多app应用
  • flask-script
  • 导出项目依赖
  • 函数和方法
  • 偏函数
  • threading.local
  • 自定义local支持线程和协程
  • flask请求上下文分析

今日内容详细

django的信号

django的信号:https://www.cnblogs.com/liuqingzheng/articles/9803403.html

Django提供一种信号机制。其实就是观察者模式,又叫发布-订阅(Publish/Subscribe) 。当发生一些动作的时候,发出信号,然后监听了这个信号的函数就会执行
    -就是一些动作发生的时候,信号允许特定的发送者去提醒一些接受者。用于在框架执行操作时解耦

-23种设计模式:https://www.cnblogs.com/liuqingzheng/p/10038958.html

并发编程

# 1 操作系统发展史
# 2 进程基础:操作系统上运行的程序,是资源分配的最小单位
# 3 进程调度:时间片轮转法
# 4 并发和并行
# 5 同步,异步,阻塞,非阻塞
# 6 python创建进程
    -两种方式:
        -类继承:Process,重写run方法
        -Process(target=任务)
    -Process 属性和方法
    -python启动一个进程:相当于,又开了一个python解释器,执行这个代码
    -进程间数据是隔离的:进程间通信
# 7 进程同步:锁
# 8 进程间通信:Queue 队列
# 9 进程间数据共享
# 10 线程是什么:cpu调度的最小单位,真正执行程序的   每个进程下至少有一个主线程
# 11 创建多线程
    -两种方式:Thread
# 12 GIL全局解释器锁:对Python由全局解释器锁(GIL)来控制,正是这个锁能保证同一时刻只有一个线程在运行
    -作用:一个进程下开启的多个线程,必须获得GIL锁,才能运行
    -为什么有呢?
        -当年没有多核,为了处理方便,就加了gil
        -python垃圾回收机制,垃圾回收线程

    -(cpython解释器)大的互斥锁,获得锁才能运行,释放锁,被别的线程抢到才能执行
# 13 守护线程
# 14 锁:互斥锁,递归锁,信号量,event事件
    -互斥锁:作用,多线程并发操作变量时,保证数据安全
    -递归锁,可重入锁:科学家吃面问题:死锁问题
    -https://zhuanlan.zhihu.com/p/489305763
# 15 线程队列  queue
    -线程间通信:共享变量
    -线程间通信,使用queue,不需要使用锁了
# 16 线程池和进程池
# 17 协程:单线程下实现并发
# 18 gevent 实现协程(第三方实现)
    -io操作,使用gevent的io
    -同步:time.sleep()
# 19 asyncio实现协程
# 20 异步框架

# 有了gil锁为什么还要互斥锁?
两个锁不是同一个层面的:
1、GIL是限制同一个进程中只有一个线程进入Python解释器;
2、线程锁是由于在线程进行数据操作时保证数据操作的安全性(同一个进程中线程之间可以共用信息,如果同时对数据进行操作,则会出现公共数据错误);

其实线程锁完全可以替代GIL,但是Python的后续功能模块都是加在GIL基础上的,所以无法更改或去掉GIL, 这就是Python语言最大的bug…只能用多进程或协程改善,或者直接用其他语言写这部分

多app应用

# 之前咱们写flask,都是实例化得到一个app对象,其实是可以使用多个app的
from flask import Flask
from werkzeug.serving import run_simple
from werkzeug.middleware.dispatcher import DispatcherMiddleware

app01 = Flask('app01')
app02 = Flask('app02')

@app01.route('/index')
def index():
    return "app01"

@app02.route('/index2')
def index2():
    return "app2"

dm = DispatcherMiddleware(app01, {'/sec': app02, })
if __name__ == '__main__':
    run_simple('localhost', 5000, dm)

# 内部如何执行:
'''
1 请求来了,会执行dm(environ,start_response)
2 dm的__call__ 根据请求的地址,拿到不同的app,执行app(environ,start_response)--->Flask的__call__
'''

flask-script

# flask 的一个第三方插件,完成像django 的  python manage.py runserver 命令操作

# 下载:
pip3 install flask-script

Flask==2.2.2
Flask_Script==2.0.3

# django 中自定义命令
    -第一步:在app中新建包:management
    -第二步:在management下新建包:commands
    -第三步:commands新建py文件,py文件名就是命令名 init.py
    -第四步:init.py写入
    from django.core.management.base import BaseCommand, CommandError
    class Command(BaseCommand):
        def add_arguments(self, parser):
            parser.add_argument('--name', type=str) # 指令接受的参数列表,参数名左边有两个减号,可以添加类型限制

        def handle(self, *args, **options):
            name = options['name'] 
            # 执行这个命令的逻辑是什么
# python manage.py init --name=lqz

使用

from flask import Flask
from flask_script import Manager

app = Flask('app01')
# 使用第三方模块
manager = Manager(app)

# 自定制命令
@manager.command
def custom(arg):
    """
    自定义命令
    python manage.py custom 123
    """
    print(arg)

@manager.option('-n', '--name', dest='name')
@manager.option('-u', '--url', dest='url')
def cmd(name, url):
    """
    自定义命令(-n也可以写成--name)
    执行: python manage.py  cmd -n lqz -u http://www.oldboyedu.com
    执行: python manage.py  cmd --name lqz --url http://www.oldboyedu.com
    """
    print(name, url)

# 后期可以自己定制一些命令
@app.route('/index')
def index():
    return "app01"

if __name__ == '__main__':
    manager.run()

导出项目依赖

# 之前学过:
    # 虚拟环境:只装了该项目的模块
    pip freeze > requirements.txt

# 使用真实环境导出依赖,会把所有都导出,可能会有问题,导出太多
    - 项目依赖 pip3 install pipreqs
    - 生成依赖文件:pipreqs ./ --encoding=utf8
    - 安装依赖文件:pip3 install -r requirements.txt 

函数和方法

# 函数就是普通函数,有几个值就要传几个值
# 方法[面向对象]是绑定给对象,类,绑定给谁谁来调用,会自动传值,谁来调用就会把谁传入
#总结:只要能自动传值,就是方法,有几个值传几个值就是函数
# 就是个函数
def add(a, b):
    return a + b

class Person:
    # 方法:绑定给对象的【不一定是方法】
    def speak(self):
        print('人说话')

    @classmethod
    def test(cls):
        print('类的绑定方法')

    @staticmethod
    def ttt():
        print('static')

p = Person()
# p.speak()  # 能自动传值

# 如何确定到底是函数还是方法
from types import MethodType, FunctionType

print(isinstance(add, MethodType))  # False add 是个函数,不是方法
print(isinstance(add, FunctionType))  # True

print(isinstance(p.speak, MethodType))  # 方法
print(isinstance(p.speak, FunctionType))  # 不是函数

print(isinstance(Person.speak, FunctionType))  # 类来调用,它就是普通函数,有几个值就要传几个值
print(isinstance(Person.speak, MethodType))  # 不是方法了
Person.speak(p)  # 普通函数

print(isinstance(Person.test, FunctionType))  # 不是函数
print(isinstance(Person.test, MethodType))  # 类来调用,类的绑定方法

print(isinstance(p.test, FunctionType))  # 不是函数
print(isinstance(p.test, MethodType))  # 对象来调用,类的绑定方法
Person.test()

print(isinstance(p.ttt, FunctionType))  # 静态方法,本质就是个函数,有几个值就要传几个值
print(isinstance(p.ttt, MethodType))

偏函数

# python内置给咱们一个偏函数,可以把函数包裹一下,提前传参
from functools import partial

def add(a, b, c):
    return a + b + c

# 正常使用
res=add(4,5,6)
print(res)

# 使用偏函数,提前传值
res = partial(add, 4, 5)
print(res)  # functools.partial(<function add at 0x000002C4025C71F0>, 4)
print(res(6))

threading.local

# threading.local 对象
# 多个线程操作同一个变量,如果不加锁,会出现数据错乱问题

# 作用:
线程变量,意思是threading.local中填充的变量属于当前线程,该变量对其他线程而言是隔离的,也就是说该变量是当前线程独有的变量。threading.local为变量在每个线程中都创建了一个副本,那么每个线程可以访问自己内部的副本变量

# 但是 多个线程同时操作 threading.local 对象 就不会出现数据错乱
    -java:ThreadLocal
    -python:threading.local

使用

###不使用local对象
# 不用local,会出现数据错乱问题,除非加锁解决
from threading import Thread
import time
from threading import Lock
lock = Lock()
lqz = -1
def task(arg):
    # lock.acquire()
    global lqz
    lqz = arg
    time.sleep(0.01)
    print(lqz)
    # lock.release()

for i in range(10):
    t = Thread(target=task,args=(i,))
    t.start()


# 使用local
from threading import Thread,get_ident
from threading import local
import time

# 特殊的对象
lqz = local()

def task(arg):
    # 对象.val = 1/2/3/4/5
    lqz.value = arg
    time.sleep(0.1)
    print('第:%s条线程的值为:%s'%(get_ident(),lqz.value))

for i in range(10):
    t = Thread(target=task, args=(i,))
    t.start()

自定义local支持线程和协程

# flask 的request,和session 都是全局的,但是我们在不同的视图函数中使用的 是正对于当前这次请求的对象,它的底层就是基于local写的
# flask部署支持多进程线程架构,也支持协程架构,flask内部重写了local,让它支持线程和协程

# local的本质是如何实现的
    -变量对其他线程而言是隔离的
    -local: {'线程id号':{}}
    -设置值:
        -线程1:local.val='lqz'   ---> {'线程1id号':{val:lqz},}
        -线程2:local.val='pyy'   ---> {'线程1id号':{val:lqz},'线程2id号':{val:pyy},}
    -取值:
        -线程1print(local.val)  ---->l={'线程1id号':{val:lqz},'线程2id号':{val:pyy},}--》先当前线程的id号:get_ident()   l[get_ident(线程1)]['val']
        -线程2print(local.val)  ---->l={'线程1id号':{val:lqz},'线程2id号':{val:pyy},}--》先当前线程的id号:get_ident()   l[get_ident(线程2)]['val']

使用

# 1 通过字典自定义threading.local
from threading import get_ident, Thread
import time

storage = {}

def set(k, v):
    ident = get_ident()  # 当前线程id号
    if ident in storage:  # 如果当前线程id号在字典中,表示修改值,直接改即可
        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')
    time.sleep(0.01)
    print(v)

for i in range(10):
    t = Thread(target=task, args=(i,))
    t.start()

# 2 面向对象版
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(0.01)
    print(v)

for i in range(10):
    t = Thread(target=task, args=(i,))
    t.start()

# 3 重写类的 __setattr__  __getattr
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()  # 多个local对象公用一个storage

def task(arg):
    obj.val = arg
    v = obj.val
    time.sleep(0.01)
    print(v)

for i in range(10):
    t = Thread(target=task, args=(i,))
    t.start()

# 4 每个对象有自己的存储空间(字典)
# 取值:对象.属性,如果没有属性会触发 __getattr__
# 设置值:对象.属性='值',如果属性不存在,会触发 __setattr__
# 如果属性有,直接就拿回来了
from threading import get_ident, Thread
import time

class Local(object):
    def __init__(self):
        # self.storage = {}   # 只要self.属性,就会调用 __setattr__,内部又掉了self.storage--->递归了
        # 类来调用对象的绑定方法__setattr__,这个方法就会变成函数,有几个值就要传几个值
        # 本质就是完成 self.storage = {} 要完成的事,但是不会触发递归调用
        object.__setattr__(self, 'storage', {})
        # 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()  # 每个local对象,用自己的字典

def task(arg):
    obj.val = arg
    v = obj.val
    time.sleep(0.01)
    print(v)

for i in range(10):
    t = Thread(target=task, args=(i,))
    t.start()

# 5 兼容线程和协程
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):
        # self.storage = {}   # 只要self.属性,就会调用 __setattr__,内部又掉了self.storage--->递归了
        # 类来调用对象的绑定方法__setattr__,这个方法就会变成函数,有几个值就要传几个值
        # 本质就是完成 self.storage = {} 要完成的事,但是不会触发递归调用
        object.__setattr__(self, 'storage', {})
        # 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()  # 在协程中,gevent中是获取协程id号,如果在线程中,获取的是线程id号
        return self.storage[ident][k]

obj = Local()  # 每个local对象,用自己的字典

def task(arg):
    obj.val = arg
    v = obj.val
    time.sleep(0.01)
    print(v)

for i in range(10):
    t = Thread(target=task, args=(i,))
    t.start()

# 6 自定义的local,支持线程和协程
class Local(object):

    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}

flask请求上下文分析

# 请求来了---》app()--->Flask.__call__--->self.wsgi_app(environ, start_response)
    def wsgi_app(self, environ, start_response):
        # environ:http请求拆成了字典
        # ctx对象:RequestContext类的对象,对象里有:当次的requets对象,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):
        # _request_ctx_stack = LocalStack() --->push(ctx对象)--->ctx:request,session,app
        _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)

            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:
            rv = []
            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

请求上下文执行流程

-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放到了那个位置
posted @   空白o  阅读(22)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 【.NET】调用本地 Deepseek 模型
· CSnakes vs Python.NET:高效嵌入与灵活互通的跨语言方案对比
· DeepSeek “源神”启动!「GitHub 热点速览」
· 我与微信审核的“相爱相杀”看个人小程序副业
· Plotly.NET 一个为 .NET 打造的强大开源交互式图表库
点击右上角即可分享
微信分享提示