from flask import Flask, request, g, redirect
# g对象的特性：
# 1.当前请求内你设置就可以取，必须先设置，然后取，当前请求可以无限次
# 2.如果不是当前请求，其他请求，也取不到
app = Flask(__name__)
@app.before_request
def dou():
if request.path == '/index':
request.name = 'sb'
g.name = 'sb'
def set_g():
g.name = '老子最帅'
# @app.route('/')
# def index():
# set_g()
# return redirect('/index')
#
@app.route('/index')
def login():
print(g.name)
return '2b'
if __name__ == '__main__':
app.run(port=8000)
信号：
from flask import Flask, signals
app = Flask(__name__)
# 第一步，编写一个函数
def func(*args, **kwargs):
print('触发信号', args, kwargs)
# 第二部：注册信号
signals.request_started.connect(func) # 请求来之前执行这个
# 第三部：触发信号（内置信号，不需要手动触发，框架自动触发）
@app.route('/')
def index():
return 'index'
if __name__ == '__main__':
app.run()
"""
request_started = _signals.signal('request-started') # 请求到来前执行
request_finished = _signals.signal('request-finished') # 请求结束后执行
before_render_template = _signals.signal('before-render-template') # 模板渲染前执行
template_rendered = _signals.signal('template-rendered') # 模板渲染后执行
got_request_exception = _signals.signal('got-request-exception') # 请求执行出现异常时执行
request_tearing_down = _signals.signal('request-tearing-down') # 请求执行完毕后自动执行（无论成功与否）
appcontext_tearing_down = _signals.signal('appcontext-tearing-down')# 应用上下文执行完毕后自动执行（无论成功与否）
appcontext_pushed = _signals.signal('appcontext-pushed') # 应用上下文push时执行
appcontext_popped = _signals.signal('appcontext-popped') # 应用上下文pop时执行
message_flashed = _signals.signal('message-flashed') # 调用flask在其中添加数据时，自动触发
"""
自定义信号
from flask import Flask, current_app, flash, render_template
from flask.signals import _signals
app = Flask(import_name=__name__)
# 1.自定义信号
xxxxx = _signals.signal('xxxxx')
# 2.定义函数
def func(*args, **kwargs):
print('信号来了', args, kwargs)
# 3.绑定函数
xxxxx.connect(func)
@app.route("/x")
def index():
# 触发信号
xxxxx.send('123123', k1='v1') # 自定义就在这里，需要什么时候执行（此时就是试图执行后运行信号）
return 'Index'
if __name__ == '__main__':
app.run()
local
"""
多个线程同时修改同一个数据，会造成数据混乱，
方法一：加线程锁
方法二：复制多份变量给每个线程用，为每个线程开辟一块空间进行数据存储
"""
# from threading import Thread
# import time
#
# cxw = -1
#
#
# def task(arg):
# global cxw
# cxw = arg
# time.sleep(2)
# print(cxw)
#
#
# for i in range(10):
# t = Thread(target=task, args=(i,))
# t.start()
# 结果为9，9，9为什么全部是9，当第一进程启动进去，等待2秒，因为异步其他进程也同时启动最终，cxm全局结果赋值为最后的9
# from threading import Thread
# from threading import local
# import time
# from threading import get_ident
#
# # 特殊的对象
# cxw = local()
#
#
# def task(arg):
# # 对象.val = 1/2/3/4/5
# # cxw['线程id']['value']=arg
# cxw.value = arg
# time.sleep(2)
# # cxw['线程id']['value']
# print(cxw.value)
#
#
# for i in range(10):
# t = Thread(target=task, args=(i,))
# t.start()
# 把数据存储到一个对象中，每个线程分配一个变量进行独立操作
# 函数的方式
from threading import get_ident, Thread
import time
storage = {}
def set(k, v):
ident = get_ident()
if ident in storage:
storage[ident][k] = v
else:
# cxw['线程id']['value']=arg
# storage[1][val]=arg
# storage={1:{val:agr}}
storage[ident] = {k: v}
def get(k):
ident = get_ident()
# 1
# storage = {1: {val: agr}}
return storage[ident][k]
def task(arg):
set('val', arg)
time.sleep(1)
v = get('val')
print(v)
for i in range(10):
t = Thread(target=task, args=(i,))
t.start()
请求上下文
"""
多个线程同时修改同一个数据，会造成数据混乱，
方法一：加线程锁
方法二：复制多份变量给每个线程用，为每个线程开辟一块空间进行数据存储
"""
# from threading import Thread
# import time
#
# cxw = -1
#
#
# def task(arg):
# global cxw
# cxw = arg
# time.sleep(2)
# print(cxw)
#
#
# for i in range(10):
# t = Thread(target=task, args=(i,))
# t.start()
# 结果为9，9，9为什么全部是9，当第一进程启动进去，等待2秒，因为异步其他进程也同时启动最终，cxm全局结果赋值为最后的9
# from threading import Thread
# from threading import local
# import time
# from threading import get_ident
#
# # 特殊的对象
# cxw = local()
#
#
# def task(arg):
# # 对象.val = 1/2/3/4/5
# # cxw['线程id']['value']=arg
# cxw.value = arg
# time.sleep(2)
# # cxw['线程id']['value']
# print(cxw.value)
#
#
# for i in range(10):
# t = Thread(target=task, args=(i,))
# t.start()
# 把数据存储到一个对象中，每个线程分配一个变量进行独立操作
# 函数的方式
from threading import get_ident, Thread
import time
storage = {}
def set(k, v):
ident = get_ident()
if ident in storage:
storage[ident][k] = v
else:
# cxw['线程id']['value']=arg
# storage[1][val]=arg
# storage={1:{val:agr}}
storage[ident] = {k: v}
def get(k):
ident = get_ident()
# 1
# storage = {1: {val: agr}}
return storage[ident][k]
def task(arg):
set('val', arg)
time.sleep(1)
v = get('val')
print(v)
for i in range(10):
t = Thread(target=task, args=(i,))
t.start()
flask-session
from flask import Flask, session
from flask_session import RedisSessionInterface
import redis
app = Flask(__name__)
app.secret_key = "ajksda"
conn = redis.Redis(host='127.0.0.1', port=6379)
# use_signer是否对key签名
app.session_interface = RedisSessionInterface(conn, key_prefix='jason', use_signer=True, permanent=False)
@app.route('/')
def hello_world():
session['sb'] = 'jason'
return 'Hello World!'
@app.route("/index")
def index():
print(session['sb'])
return "ok"
if __name__ == '__main__':
app.run()
session第二种方法
from flask import Flask, session # 推荐
import redis
from flask_session import Session
app = Flask(__name__)
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = redis.Redis(host='127.0.0.1', port='6379')
app.config['SESSION_KEY_PREFIX'] = "jason"
Session(app)
@app.route('/')
def hello_world():
session['sb'] = 'jason'
return 'Hello World!'
@app.route("/index")
def index():
print(session['sb'])
return "ok"
if __name__ == '__main__':
app.run()
------------恢复内容结束------------