文章标题
一、多App应用
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-Script
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
三、导出项目依赖
虚拟环境:只装了该项目的模块
pip freeze > requirements.txt
真实环境导出依赖会把所有都导出,可能会有问题导出太多
- 项目依赖 pip3 install pipreqs
- 生成依赖文件:pipreqs ./ --encoding=utf8
- 安装依赖文件:pip3 install -r requirements.txt
四、函数和方法
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)
不使用Local对象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()
使用Local对象
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()
七、自定义Local支持线程和协程
1)自定义Local支持线程和协程
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自定义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请求上下文分析
请求上下文执行流程(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就是代理对象,用的就是代理模式
技术小白记录学习过程,有错误或不解的地方请指出,如果这篇文章对你有所帮助请
点点赞收藏+关注
谢谢支持 !!!