4 つを放棄するための Flask 入門 (複数のアプリ アプリケーション、Flask スクリプト、プロジェクトの依存関係のエクスポート、関数とメソッド、部分関数、Threading.Local、カスタム ローカル サポート スレッドとコルーチン、Flask リクエスト コンテキスト ソース コード分析)

プログラミング 2023-08-25 19:04:31 訪問数: null

記事タイトル

1. マルチアプリアプリケーション

from flask import Flask
from werkzeug.serving import run_simple
from werkzeug.middleware.dispatcher import DispatcherMiddleware

app = Flask(app01)
app = Flask(app02)

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

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

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

'''
	1.请求来了会执行会执行dm(environ,start_response)
	2.dm的__call__ 根据请求的地址，拿到不同的app，执行app(environ,start_response)--->Flask的__call__
'''

ここに画像の説明を挿入

二、Flask-Script

Flask スクリプトをインストールする

pip install flask-script
# Flask==2.2.2	Flask-script==2.0.3

カスタムコマンド

from flask import Flask
from flask_script import Manager

app = Flask('app01')
manager = Manager(app)

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

@manager.option('-n', '--name', desc='name')
@manager.option('-u', '--url', desc='url')
def cmd(name, url):
	print(name, url)
	
	"""
		执行： python manage.py  cmd -n Like -u http://www.baidu.com
    	执行： python manage.py  cmd --name Like --url http://baidu.com
	"""

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

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

ここに画像の説明を挿入

Django のカスタム コマンド

# 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=Like

3. プロジェクトの依存関係をエクスポートする

虚拟环境：只装了该项目的模块
	pip freeze > requirements.txt
	
真实环境导出依赖会把所有都导出，可能会有问题导出太多
- 项目依赖 pip3 install pipreqs
- 生成依赖文件：pipreqs ./ --encoding=utf8
- 安装依赖文件：pip3 install -r requirements.txt

4. 機能とメソッド

classmethods	绑定给类的方法，由类来调用，自动将类本身当作第一个参数传入 
staticmethod	非绑定方法，不与类和对象绑定，类和对象都可以调用，普通函数，没有自动传值 
property		一种特殊属性、访问它时会执行一段功能，用来绑定给对象的方法，将函数对象伪装成数据属性，然后返回值

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))

五、部分機能

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 0x7fb0380ce1f0>, 4, 5)
print(res(6))

ここに画像の説明を挿入

六、Threading.local

threading.local对象多个线程操作同一个变量，如果不加锁会出现数据错乱问题
线程变量，意思是threading.local中填充的变量属于当前线程，该变量对其他线程而言是隔离的，也就是说该变量是当前线程独有的变量。
threading.local为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量
多个线程同时操作 threading.local 对象 就不会出现数据错乱

Local オブジェクトを使用しないでください

from threading import Thread
import time
from threading import Lock

Like = -1
lock = Lock()			# # 不用local,会出现数据错乱问题，除非加锁解决

def task():
    lock.acquire()
    global Like
    tem = Like
    time.sleep(0.0001)
    Like = tem + 1
    print('---', Like)

    lock.release()

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

print(Like)

ローカル オブジェクト 2 は使用しないでください

from threading import Thread
import time
from threading import Lock

lock = Lock()
Like = -1

def task(arg):
    lock.acquire()
    global Like
    Like = arg
    time.sleep(0.01)
    print(Like)
    lock.release()

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

ローカルオブジェクトを使用する

from threading import Thread, get_ident
from threading import local
import time

Like = local()       # 特殊的对象

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

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

ここに画像の説明を挿入

7. カスタム ローカルはスレッドとコルーチンをサポートします

1) カスタム ローカルはスレッドとコルーチンをサポートします

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

Local的本质是如何实现的?	(变量对其他线程而言是隔离的)
	local： {'线程id号':{}}
	设置值：
		-线程1：local.val='Like'   ---> {'线程1id号':{val:Like},}
    	-线程2：local.val='hg'   ---> {'线程1id号':{val:Like},'线程2id号':{val:hg},}
	取值：
		-线程1：print(local.val)  ---->l={'线程1id号':{val:Like}},'线程2id号':{val:hg},}--》先当前线程的id号：get_ident()   l[get_ident(线程1)]['val']
    	-线程2：print(local.val)  ---->l={'线程1id号':{val:Like}},'线程2id号':{val:hg},}--》先当前线程的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()

# 6 兼容线程和协程
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()

2) Flask カスタム ローカルはスレッドとコルーチンをサポートします

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}

8、Flaskリクエストコンテキスト分析

请求上下文执行流程（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就是代理对象，用的就是代理模式

技術初心者が学習プロセスを記録します。間違いやパズルがある場合はご指摘ください。この記事が役に立った場合は、点点赞收藏+关注サポートに感謝します。

おすすめ

転載: blog.csdn.net/MeiJin_/article/details/128320282
おすすめ
ランキング
k8s 通过set-context 控制namespace 进行隔离
Offensive and Defense World Web の初心者ゾーンのいくつかの質問に対する解決策
Macはpipのインストールが遅いという問題を恒久的に解決します
Spring-SSM整合详细版本-纯注解
5G率は、実際には5GのBBの致死率の最も弱い兵器システムであります
第3章 バス
MySQLデータベース-SQLステートメント（1）（高レベルのアプリケーション）（詳細なグラフィックとテキスト）
インターフェース設計法（2）—1。インターフェースとコンポーネントの概念
Netty フレームワークを理解する
partedコマンドの詳細説明 - パーティション
アーカイブ
もっと
2024-05-01(4)
2024-04-30(35)
2024-04-29(5)
2024-04-28(12)
2024-04-27(29)
2024-04-26(22)
2024-04-25(31)
2024-04-24(30)
2024-04-23(31)
2024-04-22(5)

コードワールド

© 2018 codetd.com