WEB框架之Flask
面试的时候聊：
1. Flask中令你影响深刻的是什么？
- 路由系统
- 装饰器，带参数的装饰器
- 额外装饰器
- 特殊的装饰器
2. 有没有遇到印象深刻：
- 本地线程
- 最大共享数（文档中写的是最大共享数，但是看源码实现时发现pymysql.threadsafety=1有关），无用。
1. flask知识点： - flask依赖wsgi，实现wsgi协议的模块：wsgiref(django),werkzeug,uwsgi
- 创建Flask对象
app = Flask(__name__)
def __init__(self, import_name, static_url_path=None,
static_folder='static', template_folder='templates',
instance_path=None, instance_relative_config=False,
root_path=None):
- 当前模块名
- 静态文件文件前缀
- 静态文件文件夹位置
- 模板路径
- 配置文件寻找位置：
from flask import Flask
app = Flask(__name__,instance_path=None, instance_relative_config=True) #只有当 引用文件的方式是 配置文件时，instance这两个参数才有用
#instance_path是指定 从哪个位置开始找settings文件
#__name__ 是当前模块名，当模块被直接运行时模块名为 __main__ 。这句话的意思就是，当模块被直接运行时，以下代码块将被运行，当模块是被导入时，代码块不被运行。
app.config.from_pyfile('settings.py') # C:\Users\Administrator\PycharmProjects\s6day120\1.实例化补充
if __name__ == '__main__':
app.run()
- 配置文件
- 推荐使用对象方式
方式一：
app.config['SESSION_COOKIE_NAME'] = 'session_lvning' #
方式二：
app.config.from_pyfile('settings.py')
settings.py ：
XXX=123
方式三：
import os
os.environ['FLAKS-SETTINGS'] = 'settings.py'
app.config.from_envvar('FLAKS-SETTINGS')
方式四：
app.config.from_object('settings.DevConfig')
settings.py ：
class BaseConfig(object):
NNN = 123
class TestConfig(BaseConfig):
DB = '127.0.0.1'
class DevConfig(BaseConfig):
DB = '192.168.1.1'
class ProConfig(BaseConfig):
DB = '47.18.1.1'
- 路由系统
- 通过带参数的装饰器实现的路由关系
注意：其他的装饰器要写在路由装饰器下面
- 两种形式：
第一种：
@app.route('/xxxx')
def index():
return "Index"
第二种：
def index():
return "Index"
app.add_url_rule('/xxx', "n1", index) #n1 是别名
- 将函数和url封装到一个 Rule对象
- 将Role对象添加到 app.url_map（Map对象）
- 参数： (url路径，endpoint，视图函数名，method=[]，default，redirect_to，strict_slashes，subdomain)
endpoint 是路由的别名，不写时默认是被装饰的函数名； 反向生成用url_for 来实现 url_for("aaa",**dic)或者 url_for("aaa",x=1)
method 允许的请求方式
/index/<int:nid> 不写类型的时候默认是 字符串
def index(nid):
print(nid)
defaults=None, 默认值,当URL中无参数，函数需要参数时，使用defaults={'k':'v'}为函数提供参数
strict_slashes=None, 对URL最后的 / 符号是否严格要求，
redirect_to 直接重定向，跳转的url需要参数时，也得传参，注意：不用加类型 redirect_to("/index/<nid>")
subdomain=None 二级域名 ：详见day118-06
首先你要有一个主域名
动态的二级域名
- 在本地hosts文件中找IP C:\Windows\System32\drivers\etc ios/lenux系统是在/etc/hosts
from flask import Flask,render_template,request,redirect,session,url_for
app = Flask(__name__)
app.config['SERVER_NAME'] = 'bjg.com:5000'
@app.route("/index",subdomain='<xxxxx>')
def index(xxxxx):
return "%s.bjg.com" %(xxxxx,)
if __name__ == '__main__':
app.run()
- 扩展Flask的路由系统，让他支持正则
from flask import Flask,url_for
app = Flask(__name__)
# 定义转换的类
from werkzeug.routing import BaseConverter
class RegexConverter(BaseConverter):
"""
自定义URL匹配正则表达式
"""
def __init__(self, map, regex):
super(RegexConverter, self).__init__(map)
self.regex = regex
def to_python(self, value):
"""
路由匹配时，匹配成功后传递给视图函数中参数的值
:param value:
:return:
"""
return int(value)
def to_url(self, value):
"""
使用url_for反向生成URL时，传递的参数经过该方法处理，返回的值用于生成URL中的参数
:param value:
:return:
"""
val = super(RegexConverter, self).to_url(value)
return val
# 添加到converts中
app.url_map.converters['xxx'] = RegexConverter
# 进行使用
@app.route('/index/<xxx("\d+"):nid>',endpoint='xx')
def index(nid):
url_for('xx',nid=123)
return "Index"
if __name__ == '__main__':
app.run()
- 视图函数
请求：
request.files 文件信息
request.values 所有的信息
request.form post请求
request.args get请求
响应：
reutrn render_template()
reutrn redirect()
return ""
return jsonify(name='alex',age='18') 返回json格式数据
make_response 每一个return的时候flask都做处理 → make_response(返回值), 可以设置cookie 及session 或者更多的其他内容
eg：
response = make_response('xxxxx')
response.headers['xxx'] = '123123'
return response
- CBV、FBV
回顾django的cbv：
url(r'^login_cbv/',views.Login.as_view)
from django.views import View
class Login(View):
def get(self,request):
return render(request,"login.html")
def post(self,request):
return HttpResponse("post...")
如果是get请求就走 get方法，如果是post请求就走post方法。
flask的cbv
def auth(func):
def inner(*args, **kwargs):
result = func(*args, **kwargs)
return result
return inner
class IndexView(views.MethodView):
methods = ['POST'] #只写POST时，只有请求时post时才生效，也就是get函数不执行
decorators = [auth,] 为每一个函数都加上auth装饰器
def get(self):
v = url_for('index')
print(v)
return "GET"
def post(self):
return "GET"
app.add_url_rule('/index', view_func=IndexView.as_view(name='index'))
if __name__ == '__main__':
app.run()
零碎知识点：
root_path 根路径
to_dict() 把url变成字典
urllib.parse 引入 urlencode 把字典变成url形式
quote 和 unquote 把汉字变成乱码/把乱码变成汉字
self.__class__ 找到对象的类
- 模板
1.方法不会自动执行，要加括号，字典也可以用get方法
2.Makeup相当于django的 mark_safe , 或者在前端页面上 |safe
Markup("<input type='text' />")
引出 xss 攻击
3.自定义的 标签和 过滤器 @ ，在页面上写的区别，
3.1 需要把test传给前端
def test(a1,a2):
return a1+a2
return render_template('index.html',test=test)
使用：{{test(1,19)}}
3.2 所有的模板都可以用
@app.template_global() #加上这个装饰器以后就不需要传了，所有的页面直接就可以使用
def sb(a1, a2):
return a1 + a2 + 100
使用：{{sb(1,2)}}
3.3 所有的模板都可以用
@app.template_filter()
def db(a1, a2, a3):
return a1 + a2 + a3
使用：{{ 1|db(2,3)}}
4.模板的继承和django一样的，include也是一样的
5.hong：
{% macro xxxx(name, type='text', value='') %}
<input type="{{ type }}" name="{{ name }}" value="{{ value }}">
<input type="{{ type }}" name="{{ name }}" value="{{ value }}">
<input type="{{ type }}" name="{{ name }}" value="{{ value }}">
<input type="{{ type }}" name="{{ name }}" value="{{ value }}">
{% endmacro %}
{{ xxxx('n1') }}
- 蓝图
- 项目目录规则化 (把一个py文件分成多个py文件 )
蓝图：小中型项目：结构
大中型项目：结构
- 特殊装饰器
app.before_first_request
app.before_request
app.after_request 必须要有返回值，并且得有一个形参
- session
设置值 session['xx']=1
取值 session.get('xx')
超时时间的设置
session超时时间如何设置？ PERMANENT_SESSION_LIFETIME
app.config['SESSION_COOKIE_NAME'] = 'session_lvning'
"""
'SESSION_COOKIE_NAME': 'session',
'SESSION_COOKIE_DOMAIN': None,
'SESSION_COOKIE_PATH': None,
'SESSION_COOKIE_HTTPONLY': True,
'SESSION_COOKIE_SECURE': False,
'SESSION_REFRESH_EACH_REQUEST': True, #是否实时更新
'PERMANENT_SESSION_LIFETIME': timedelta(days=31)
"""
session本质是操作的一个字典，在修改session的时候是在内存中操作的，等在return之前 把内存的session字典再返回给你open_session / save_session
- flash
同session的原理，区别在于flash取一次就没了
设置值，flash('xxxx')
取值，get_flashed_messages()
2.上下文管理
什么是上写文？
上下文个人理解是：程序运行时相关的周围环境，flask里的上下文是指：在请求刚进来的时候把某个数据或者变量放到一个栈里，等你后面什么时候用就去栈里取就行了。在java 和php中上下文被叫做 HttpRequestContext
a. 创建Local类：
{
线程或协程唯一标识: { 'stack':[request],'xxx':[session,] },
线程或协程唯一标识: { 'stack':[] },
线程或协程唯一标识: { 'stack':[] },
线程或协程唯一标识: { 'stack':[] },
}
b. 本质
当请求进来之后，将请求相关数据添加到 [request,]
以后使用时：去读取
请求完成之后，将request从列表中移除。
c. 关系
local= 宋康 = {
线程或协程唯一标识: { 'stack':[] },
线程或协程唯一标识: { 'stack':[] },
线程或协程唯一标识: { 'stack':[] },
线程或协程唯一标识: { 'stack':[] },
}
stack=强哥={
push
top
pop
}
存取数据时，要基于stack来做。
d. Flask和Django区别？
- 请求相关数据传递方式
- Django： 参数
- Flask： 基于 Local，LocalStack对象
- 问题：多个请求到来会不会混淆
- 单线程
- 多线程
- 协程
解决： from greenlet import getcurrent as get_ident
3. 数据库连接池
3.1本地线程 -每一个线程来的时候，都分配一个标示，也就是说每个线程都有自己的数据信息，当取值的时候，只取自己线程的数据，这样实现了线程之间的数据隔离
import threading
import time
# 本地线程对象
local_values = threading.local()
def func(num):
"""
# 第一个线程进来，本地线程对象会为他创建一个唯一标识
# 第二个线程进来，本地线程对象会为他创建一个唯一标识
{
线程1的唯一标识：{name:1},
线程2的唯一标识：{name:2},
}
"""
local_values.name = num
# 线程停下来了
time.sleep(2)
# local_values.name，去local_values中根据自己的唯一标识作为key，获取value中name对应的值
print(local_values.name, threading.current_thread().name)
for i in range(5):
th = threading.Thread(target=func, args=(i,), name='线程%s' % i)
th.start()
3.2原来连接数据库的方式： 1 #缺点：每次请求反复创建数据库连接，连接数太多
conn = pymysql.connect()
cursor = conn.cursor()
cursor.execute('select * from tb where id > %s',[5,])
result = cursor.fetchall()
cursor.close()
conn.close()
print(result)
2 # 公用一个连接，多线程有问题，加锁→缺点，不能支持并发
with LOCK:
cursor = CONN.cursor()
cursor.execute('select * from tb where id > %s', [5, ])
result = cursor.fetchall()
cursor.close()
print(result)
3.3数据库连接池：
原理：设置连接池中最大连接数、默认启动时连接池中创建的连接数
3.3.1.为每个线程创建一个连接，该线程关闭时，不是真正关闭；本线程再次调用时，还是使用的最开始创建的连接。直到线程终止，数据库连接才关闭。（本质是用本地线程实现的）
；当很多线程进来时还是会创建很多的连接，所以这种方法也不好。
from DBUtils.PersistentDB import PersistentDB
import pymysql
import threading
POOL = PersistentDB(
creator=pymysql, # 使用链接数据库的模块
maxusage=None, # 一个链接最多被重复使用的次数，None表示无限制
setsession=[], # 开始会话前执行的命令列表。如：["set datestyle to ...", "set time zone ..."]
ping=0,
# ping MySQL服务端，检查是否服务可用。# 如：0 = None = never, 1 = default = whenever it is requested, 2 = when a cursor is created, 4 = when a query is executed, 7 = always
closeable=False,
# 如果为False时， conn.close() 实际上被忽略，供下次使用，再线程关闭时，才会自动关闭链接。如果为True时， conn.close()则关闭链接，那么再次调用pool.connection时就会报错，因为已经真的关闭了连接（pool.steady_connection()可以获取一个新的链接）
threadlocal=None, # 本线程独享值得对象，用于保存链接对象，如果链接对象被重置
host='127.0.0.1',
port=3306,
user='root',
password='123',
database='pooldb',
charset='utf8'
)
def func():
conn = POOL.connection()
cursor = conn.cursor()
cursor.execute('select * from tb1')
result = cursor.fetchall()
cursor.close()
conn.close() # 不是真的关闭，而是假的关闭。
for i in range(10):
t = threading.Thread(target=func)
t.start()
3.3.2.创建一个连接池(10个连接)，为所有线程提供连接，使用时来进行获取，使用完毕后，再次放回到连接池。
注意: 连接池中的所有连接都可以被重新使用，原因是因为pymsql.threadsafety的 个数是1
数据库连接池样板：
xxx.py---------------
from flask import Flask
from db import POOL
app = Flask(__name__)
@app.route('/index')
def index():
conn = POOL.connection()
cursor = conn.cursor()
cursor.execute('select * from tb1')
result = cursor.fetchall()
conn.close()
return '执行成功'
if __name__ == '__main__':
app.run()
db.py---------------
import pymysql
from DBUtils.PooledDB import PooledDB, SharedDBConnection
POOL = PooledDB(
creator=pymysql, # 使用链接数据库的模块
maxconnections=6, # 连接池允许的最大连接数，0和None表示不限制连接数
mincached=2, # 初始化时，链接池中至少创建的空闲的链接，0表示不创建
maxcached=5, # 链接池中最多闲置的链接，0和None不限制
maxshared=3, # 链接池中最多共享的链接数量，0和None表示全部共享。PS: 无用，因为pymysql和MySQLdb等模块的 threadsafety都为1，所有值无论设置为多少，_maxcached永远为0，所以永远是所有链接都共享。
blocking=True, # 连接池中如果没有可用连接后，是否阻塞等待。True，等待；False，不等待然后报错
maxusage=None, # 一个链接最多被重复使用的次数，None表示无限制
setsession=[], # 开始会话前执行的命令列表。如：["set datestyle to ...", "set time zone ..."]
ping=0,
# ping MySQL服务端，检查是否服务可用。# 如：0 = None = never, 1 = default = whenever it is requested, 2 = when a cursor is created, 4 = when a query is executed, 7 = always
#ping ： 0 或 4最常用
host='127.0.0.1',
port=3306,
user='root',
password='123',
database='pooldb',
charset='utf8'
)
如果有三个线程来连接池（最大连接数：9个，初始化创建了5个）拿连接，有三种情况：
1. 他们三个先后顺序来， 同一个连接就够三个线程用了
2. 他们来的顺序不定， 有可能需要两个连接
3. 他们同时来的， 需要三个链接
4. 单例模式 ： - 推荐：__new__
- 文件
- 基于类方法
# 单例模式：无法支持多线程情况
"""
class Singleton(object):
def __init__(self):
import time
time.sleep(1)
@classmethod
def instance(cls, *args, **kwargs):
if not hasattr(Singleton, "_instance"):
Singleton._instance = Singleton(*args, **kwargs)
return Singleton._instance
import threading
def task(arg):
obj = Singleton.instance()
print(obj)
for i in range(10):
t = threading.Thread(target=task,args=[i,])
t.start()
"""
# # 单例模式：支持多线程情况
"""
import time
import threading
class Singleton(object):
_instance_lock = threading.Lock()
def __init__(self):
time.sleep(1)
@classmethod
def instance(cls, *args, **kwargs):
if not hasattr(Singleton, "_instance"):
with Singleton._instance_lock:
if not hasattr(Singleton, "_instance"):
Singleton._instance = Singleton(*args, **kwargs)
return Singleton._instance
def task(arg):
obj = Singleton.instance()
print(obj)
for i in range(10):
t = threading.Thread(target=task,args=[i,])
t.start()
time.sleep(20)
obj = Singleton.instance()
print(obj)
"""
- 基于__new__方法
引出：new，call，init 方法及区别
"""
1.对象是类创建，创建对象时候类的__init__方法自动执行，对象()执行类的 __call__ 方法
2.类是type创建，创建类时候type的__init__方法自动执行，类() 执行type的 __call__方法(类的__new__方法,类的__init__方法)
# 第0步: 执行type的 __init__ 方法【类是type的对象】
class Foo:
def __init__(self):
pass
def __call__(self, *args, **kwargs):
pass
# 第1步: 执行type的 __call__ 方法
# 1.1 调用 Foo类（是type的对象）的 __new__方法，用于创建对象。
# 1.2 调用 Foo类（是type的对象）的 __init__方法，用于对对象初始化。
obj = Foo()
# 第2步：执行Foodef __call__ 方法
obj()
"""
"""
class SingletonType(type):
def __init__(self,*args,**kwargs):
super(SingletonType,self).__init__(*args,**kwargs)
def __call__(cls, *args, **kwargs):
obj = cls.__new__(cls,*args, **kwargs)
cls.__init__(obj,*args, **kwargs) # Foo.__init__(obj)
return obj
class Foo(metaclass=SingletonType):
def __init__(self,name):
self.name = name
def __new__(cls, *args, **kwargs):
return object.__new__(cls, *args, **kwargs)
obj = Foo('name')
"""
import threading
class Singleton(object):
_instance_lock = threading.Lock()
def __init__(self):
pass
def __new__(cls, *args, **kwargs):
if not hasattr(Singleton, "_instance"):
with Singleton._instance_lock:
if not hasattr(Singleton, "_instance"):
Singleton._instance = object.__new__(cls, *args, **kwargs)
return Singleton._instance
obj1 = Singleton()
obj2 = Singleton()
print(obj1,obj2) # <__main__.Singleton object at 0x0000029B7FE127F0> <__main__.Singleton object at 0x0000029B7FE127F0>
- 基于metaclass方法
import threading
class SingletonType(type):
_instance_lock = threading.Lock()
def __call__(cls, *args, **kwargs):
if not hasattr(cls, "_instance"):
with SingletonType._instance_lock:
if not hasattr(cls, "_instance"):
cls._instance = super(SingletonType,cls).__call__(*args, **kwargs)
return cls._instance
class Foo(metaclass=SingletonType):
def __init__(self,name):
self.name = name
obj1 = Foo('name')
obj2 = Foo('name')
print(obj1,obj2) # <__main__.Foo object at 0x0000017B6A612898> <__main__.Foo object at 0x0000017B6A612898>
在哪应用了单例模式：
a. stark组件
b. 数据库连接池
5.Session
5.1- 读Flask session源码
5.2- 流程：
当请求第一次进来，生成随机字符串：sidfnsdfisdfs
- 发给用户cookie
- 保存到session字典中
PS: 调用 stack（强哥）将随机字符串和对应的值放到 local(宋康)
视图函数使用
session = LocalProxy(partial(_lookup_req_object, 'session'))
请求处理完毕
将session做持久化：
- 存到数据
- 存到redis
- 存到加密cookie中
5.3- 自定义session：
from flask import Flask,request,session
app = Flask(__name__)
app.secret_key = 'sdfsdfsd'
from flask.sessions import SessionInterface,SessionMixin
import uuid
import json
from flask.sessions import SessionInterface
from flask.sessions import SessionMixin
from itsdangerous import Signer, BadSignature, want_bytes
class MySession(dict, SessionMixin):
def __init__(self, initial=None, sid=None):
self.sid = sid
self.initial = initial
super(MySession, self).__init__(initial or ())
def __setitem__(self, key, value):
super(MySession, self).__setitem__(key, value)
def __getitem__(self, item):
return super(MySession, self).__getitem__(item)
def __delitem__(self, key):
super(MySession, self).__delitem__(key)
class MySessionInterface(SessionInterface):
session_class = MySession
container = {
# 'asdfasdfasdfas':{'k1':'v1','k2':'v2'}
# 'asdfasdfasdfas':"{'k1':'v1','k2':'v2'}"
}
def __init__(self):
pass
# import redis
# self.redis = redis.Redis()
def _generate_sid(self):
return str(uuid.uuid4())
def _get_signer(self, app):
if not app.secret_key:
return None
return Signer(app.secret_key, salt='flask-session',
key_derivation='hmac')
def open_session(self, app, request):
"""
程序刚启动时执行，需要返回一个session对象
"""
sid = request.cookies.get(app.session_cookie_name)
if not sid:
# 生成随机字符串，并将随机字符串添加到 session对象中
sid = self._generate_sid()
return self.session_class(sid=sid)
signer = self._get_signer(app)
try:
sid_as_bytes = signer.unsign(sid)
sid = sid_as_bytes.decode()
except BadSignature:
sid = self._generate_sid()
return self.session_class(sid=sid)
# session保存在redis中
# val = self.redis.get(sid)
# session保存在内存中
val = self.container.get(sid)
if val is not None:
try:
data = json.loads(val)
return self.session_class(data, sid=sid)
except:
return self.session_class(sid=sid)
return self.session_class(sid=sid)
def save_session(self, app, session, response):
"""
程序结束前执行，可以保存session中所有的值
如：
保存到resit
写入到用户cookie
"""
domain = self.get_cookie_domain(app)
path = self.get_cookie_path(app)
httponly = self.get_cookie_httponly(app)
secure = self.get_cookie_secure(app)
expires = self.get_expiration_time(app, session)
val = json.dumps(dict(session))
# session保存在redis中
# self.redis.setex(name=session.sid, value=val, time=app.permanent_session_lifetime)
# session保存在内存中
self.container.setdefault(session.sid, val)
session_id = self._get_signer(app).sign(want_bytes(session.sid))
response.set_cookie(app.session_cookie_name, session_id,
expires=expires, httponly=httponly,
domain=domain, path=path, secure=secure)
app.session_interface = MySessionInterface()
# app.session_interface = Foo()
# app.session_interface
# app.make_null_session()
@app.route('/index')
def index():
print('网站的所有session',MySessionInterface.container)
print(session)
session['k1'] = 'v1'
session['k2'] = 'v2'
del session['k1']
# 在内存中操作字典....
# session['k1'] = 'v1'
# session['k2'] = 'v2'
# del session['k1']
return "xx"
if __name__ == '__main__':
app.__call__
app.run()
5.4 最常用
pip3 install flask-session
#!/usr/bin/env python
# -*- coding:utf-8 -
from flask import Flask,current_app,session
from flask_session import Session
app = Flask(__name__)
app.debug = True
app.secret_key = 'xxxx'
# 为Flask-session组件提供的配置
# import redis
# app.config['SESSION_TYPE'] = 'redis' # session类型为redis
# app.config['SESSION_REDIS'] = redis.Redis(host='127.0.0.1', port='6379', password='123123') # 用于连接redis的配置
# app.config['SESSION_KEY_PREFIX'] = 'session:' # 保存到session中的值的前缀
# app.config['SESSION_PERMANENT'] = False # 如果设置为True，则关闭浏览器session就失效。
# app.config['SESSION_USE_SIGNER'] = False # 是否对发送到浏览器上 session:cookie值进行加密
# Session(app)
#
# import memcache
# app.config['SESSION_TYPE'] = 'memcached' # session类型为memcached
# app.config['SESSION_PERMANENT'] = True # 如果设置为True，则关闭浏览器session就失效。
# app.config['SESSION_USE_SIGNER'] = False # 是否对发送到浏览器上session的cookie值进行加密
# app.config['SESSION_KEY_PREFIX'] = 'session:' # 保存到session中的值的前缀
# app.config['SESSION_MEMCACHED'] = memcache.Client(['10.211.55.4:12000'])
# Session(app)
app.config['SESSION_TYPE'] = 'filesystem' # session类型为filesystem
app.config['SESSION_FILE_DIR'] = r'C:\Users\Administrator\PycharmProjects\day121\2.flask-session组件' # session类型为redis
app.config['SESSION_FILE_THRESHOLD'] = 500 # 存储session的个数如果大于这个值时，就要开始进行删除了
app.config['SESSION_FILE_MODE'] = 384 # 文件权限类型
app.config['SESSION_PERMANENT'] = True # 如果设置为True，则关闭浏览器session就失效。
app.config['SESSION_USE_SIGNER'] = False # 是否对发送到浏览器上session的cookie值进行加密
app.config['SESSION_KEY_PREFIX'] = 'session:' # 保存到session中的值的前缀
Session(app)
@app.route('/index')
def index():
session['k1'] = 'v1'
return 'xx'
if __name__ == '__main__':
app.run()
6.blinker 信号
pip3 install blinker
6.1 内置信号
10个信号：
2. request_started = _signals.signal('request-started') # 请求到来前执行
5. request_finished = _signals.signal('request-finished') # 请求结束后执行
3. before_render_template = _signals.signal('before-render-template') # 模板渲染前执行
4. template_rendered = _signals.signal('template-rendered') # 模板渲染后执行
2/3/4/5或不执行 got_request_exception = _signals.signal('got-request-exception') # 请求执行出现异常时执行
6. request_tearing_down = _signals.signal('request-tearing-down') # 请求执行完毕后自动执行（无论成功与否）
7. appcontext_tearing_down = _signals.signal('appcontext-tearing-down')# 请求上下文执行完毕后自动执行（无论成功与否）
1. appcontext_pushed = _signals.signal('appcontext-pushed') # 请求app上下文push时执行
8. appcontext_popped = _signals.signal('appcontext-popped') # 请求上下文pop时执行
message_flashed = _signals.signal('message-flashed') # 调用flask在其中添加数据时，自动触发
问题：
特殊的装饰器和信号有什么区别？
- 装饰器返回值有意义
- 信号用于做什么呢？
- 降低代码之间的耦合
6.2 自定义信号 ：创建信号→注册→触发
from flask import Flask,flash
from flask.signals import _signals
app = Flask(__name__)
wh = _signals.signal('wh')
# 定义函数
def luominwen(*args,**kwargs):
print('罗姑娘',args,kwargs)
# 定义函数
def shaowei(*args,**kwargs):
print('少姑娘',args,kwargs)
# 将函数注册到request_started信号中： 添加到这个列表
wh.connect(luominwen)
wh.connect(shaowei)
@app.route('/index')
def index():
# 触发这个信号：执行注册到列表中的所有函数
# 发送短信，邮件，微信
wh.send(sender='xxx',a1=123,a2=456)
return "xx"
if __name__ == '__main__':
app.__call__
app.run()
6.3Django内置
Request/response signals
request_started # 请求到来前，自动触发
request_finished # 请求结束后，自动触发
got_request_exception # 请求异常后，自动触发
Model signals
pre_init # django的modal执行其构造方法前，自动触发
post_init # django的modal执行其构造方法后，自动触发
pre_save # django的modal对象保存前，自动触发
post_save # django的modal对象保存后，自动触发， 它可以判断是增加的还是修改的
pre_delete # django的modal对象删除前，自动触发
post_delete # django的modal对象删除后，自动触发
m2m_changed # django的modal中使用m2m字段操作第三张表（add,remove,clear）前后，自动触发
class_prepared # 程序启动时，检测已注册的app中modal类，对于每一个类，自动触发
Management signals
pre_migrate # 执行migrate命令前，自动触发
post_migrate # 执行migrate命令后，自动触发
Test signals
setting_changed # 使用test测试修改配置文件时，自动触发
template_rendered # 使用test测试渲染模板时，自动触发
Database Wrappers
connection_created # 创建数据库连接时，自动触发
需求：新浪面试题，数据库12张表，每张表创建一条数据时，记录一条日志。
答案： 可以重写 django里面orm操作的save 方法，或者 使用信号
7. wtforms
- wtforms的源码
- 使用
metaclass的另外一种方式：
class MyType(type):
def __init__(self,*args,**kwargs):
print('xxxx')
super(MyType,self).__init__(*args,**kwargs)
def __call__(cls, *args, **kwargs):
obj = cls.__new__(cls,*args, **kwargs)
cls.__init__(obj,*args, **kwargs) # Foo.__init__(obj)
return obj
def with_metaclass(base):
return MyType("MyType",(base,),{})
class Foo(with_metaclass(object)):
def __init__(self,name):
self.name = name
#打印结果： xxxx xxxx
8. flask的简单 使用：
- 蓝图
- 配置 from_objects
- flask-session
- 记录：请求到来写日志
- wtforms
- DBUtils
- 单例模式
PS: 连接数据库，对用户表进行：登录和注册
9. 导出程序内应用的所有模块
# 获取环境中所有安装的模块
pip3 freeze #在终端查看
pip3 freeze > requirements.txt #写入requirements.txt文件中
# pip3 install pipreqs
# 获取当前所在程序目录中涉及到的所有模块，并自动生成 requirements.txt 且写入内容。
pipreqs ./
以后别人给你程序：
requirements.txt
进入程序目录：
pip3 install -r requirements.txt
浙公网安备 33010602011771号