Flask

　　首先，学习flask之前，先了解一下Django和Flask中是怎么渲染字符串的。在Django中使用mark_safe()；在Flask中使用Markup()；还可以在HTML中使用管道符{{ add | safe }}。简单介绍一下Flask，它是轻量型的，第三方组件非常丰富，可扩展性比较强，用法和Django差不多。

一、介绍Flask、Django、Tornado框架

Django：重武器，内部包含了非常多的组件(ORM、Form、ModelForm、缓存、Session、中间件、信号等)

Flask：短小精悍，内部没有太多的组件，第三方组件非常丰富。路由比较特殊，基于装饰器来实现，但是究其本质还是通过add_url_rule来实现。

Tornado：异步非阻塞框架(node.js)

bottle：第三方库比较少

web.py：比较老

二、Flask入门

安装

　　pip3  install  flask

WSGI

 from werkzeug.wrappers import Request, Response

@Request.application
def hello(request):
    return Response('Hello World!')

if __name__ == '__main__':
    from werkzeug.serving import run_simple
    run_simple('localhost', 4000, hello)  # 看到run_simple要知道socket就来了
        

 from wsgiref.simple_server import make_server

def runserver(environ, start_response):
    start_response('200 OK', [('Content-Type', 'text/html')])
    return [bytes('<h1>Hello, web!</h1>', encoding='utf-8'), ]
            
if __name__ == '__main__':
    # obj = WSGIHandler()
    # httpd = make_server('', 8000, obj)
    httpd = make_server('', 8000, runserver)
    print("Serving HTTP on port 8000...")
    httpd.serve_forever()

 import socket
  
def handle_request(client):
    buf = client.recv(1024)
    client.send("HTTP/1.1 200 OK\r\n\r\n")
    client.send("Hello, Seven")
              
def main():
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.bind(('localhost',8000))
    sock.listen(5)
              
    while True:
        connection, address = sock.accept()
        handle_request(connection)
        connection.close()
              
if __name__ == '__main__':
    main()        

flask

from flask import Flask

# 实例化Flask对象
app = Flask(__name__)
        
@app.route('/')  #  -->1.v = app.route('/')  2.v(hello_world)
def hello_world():
    return 'Hello World!'
        
if __name__ == '__main__':
    app.run()

三、配置文件

class Config(object):
    DEBUG = False
    TESTING = False
    DATABASE_URI = 'sqlite://:memory:'

class ProductionConfig(Config):
    DATABASE_URI = 'mysql://user@localhost/foo'

class DevelopmentConfig(Config):
    DEBUG = True

class TestingConfig(Config):
    TESTING = True
            
# 在create_app函数中写上下面这句话，就可以使用配置了
app.config.from_object("settings.py.DevelopmentConfig")

四、路由系统 

设置URL路由使用route()装饰器，route()装饰哪个函数，那么route()中的参数就映射到哪个函数

路由路径支持变量

　　形式：<converter:variable_name>

　　converter支持的类型：

　　　　　

　　

@app.route('/user/<username>')
@app.route('/post/<int:post_id>')
@app.route('/post/<float:post_id>')
@app.route('/post/<path:path>')
@app.route('/login', methods=['GET', 'POST'])

@app.route和@app.add_url_rule参数

rule                                      　　 URL规则 
view_func                             　　 视图函数名称
defaults=None                     　　  默认值，当URL中无参数，函数需要参数时，使用defaults={'k':'v'}为函数提供参数
endpoint=None,                    　　 名称，用于反向生成URL，即： url_for('名称')
methods=None,                       　  允许的请求方式，如：["GET","POST"]
strict_slashes=False/True              对URL最后的 / 符号是否严格要求
注意：如果设置为True，URL后面没有加"/"，访问的时候一定不能加"/"
redirect_to=None                          重定向到指定地址
subdomain=None                          子域名访问

五、模板语言

Flask使用的是jinja2模板，所以其语法和Django无差别

Flask中自定义模板方法的方式和Bottle相似，创建一个函数并通过参数的形式传入render_template

六、请求&响应相关

request.method
request.args
request.form
request.values
request.cookies
request.headers
request.path
request.full_path
request.script_root
request.url
request.base_url
request.url_root
request.host_url
request.host
request.files
obj = request.files['the_file_name']
obj.save('/var/www/uploads/' + secure_filename(f.filename))

return "字符串"
return render_template('html模板路径',**{})
return redirect('/index.html')

response = make_response(render_template('index.html'))
# response是flask.wrappers.Response类型
response.delete_cookie('key')
response.set_cookie('key', 'value')
response.headers['X-Something'] = 'A value'
return response

七、Session&Cookie

 　　除请求对象之外，还有一个 session 对象。它允许你在不同请求间存储特定用户的信息。它是在 Cookies 的基础上实现的，并且对 Cookies 进行密钥签名要使用会话，你需要设置一个密钥。

　　设置：session['username'] ＝ 'xxx'

　　删除：session.pop('username', None)

八、闪现(基于session实现的)

应用：对临时数据操作，如显示错误信息

from flask import Flask, flash, get_flashed_messages

app = Flask(__name__)
app.secret_key = 'asdfasdf'

@app.route('/get')
def get():
    # 从某个地方获取设置过得所有值，并清除
    data = get_flashed_messages()
    print(data)
    return 'Hello World!'

@app.route('/set')
def set():
    # 向某个地方设置一个值
    flash('阿斯蒂芬')
    return 'Hello World!'
if __name__ == '__main__':
    app.run()

九、蓝图(blueprint)

目标：构造程序目录

优点：可以批量URL

　　　指定模板路径/静态文件路径

　　　请求扩展(针对pp或者针对某个蓝图)

注意：蓝图对象名称和函数名称不能重复

十、请求扩展(Django中间件)

基于before_request做用户登录认证

@app.before_request
def process_request(*args, **kwargs):
    if request.path == '/login':
        return None
    user = session.get('user_info')
    if user:
        return None
    return redirect('/login')        

执行顺序

 from flask import Flask, render_template, request, redirect, session, url_for
app = Flask(__name__)
app.secret_key = 'asdfasdf'

@app.before_request
def process_request1(*args, **kwargs):
    print('process_request1进来了')

@app.before_request
def process_request2(*args, **kwargs):
    print('process_request2进来了')

@app.after_request
def process_response1(response):
    print('process_response1走了')
    return response

@app.after_request
def process_response2(response):
    print('process_response2走了')
    return response

@app.route('/index', methods=['GET'])
def index():
    print('index函数')
    return 'Index'

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

运行结果：
    process_request1进来了
    process_request2进来了
    index函数
    process_response2走了
    process_response1走了

请求拦截后，response所有都执行，函数不再执行

from flask import Flask, render_template, request, redirect, session, url_for

app = Flask(__name__)
app.secret_key = 'asdfasdf'

@app.before_request
def process_request1(*args, **kwargs):
    print('process_request1进来了')
    return '拦截'

@app.before_request
def process_request2(*args, **kwargs):
    print('process_request2进来了')

@app.after_request
def process_response1(response):
    print('process_response1走了')
    return response

@app.after_request
def process_response2(response):
    print('process_response2走了')
    return response

@app.route('/index', methods=['GET'])
def index():
    print('index函数')
    return 'Index'

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

定制错误信息

@app.errorhandler(404)
def error_404(arg):
    return '404错误了'

模板中定义方法

@app.template_global()
def sb(a1, a2):
    return a1 + a2

# 在HTNL中使用：{{sb(1,2)}}
        
@app.template_filter()
def db(a1, a2, a3):
    return a1 + a2 + a3

# 在HTNL中使用：{{ 1|db(2,3)}}

第一次进来要执行的操作

@app.before_first_request
def first(*args, **kwargs):
    pass

十一、中间件

from flask import Flask, request

app = Flask(__name__)

@app.route('/')
def index():
    return 'Hello World!'


class Md(object):
    def __init__(self, old_wsgi_app):
        self.old_wsgi_app = old_wsgi_app
    def __call__(self, environ, start_response):
        print('开始之前')
        ret = self.old_wsgi_app(environ, start_response)
        print('结束之后')
        return ret

if __name__ == '__main__':
    app.wsgi_app = Md(app.wsgi_app)
    app.run()

十二、上下文管理

请求上下文

threading.local对象，用于为每个线程开辟一块空间来保存它独有的值

import threading
import time

local_values = threading.local()

class Foo(object):
    def __init__(self):
        self.name = 0

local_values = Foo()

def func(num):
     local_values.name = num
     time.sleep(1)
     print(local_values.name, threading.current_thread().name)

for i in range(20):
    th = threading.Thread(target=func, args=(i,), name='线程%s' % i)
    th.start()

源码(request)

　　情况一：单进程单线程，基于全局变量做

　　情况二：单进程多进程，基于threading.local对象做

　　情况三：单进程单线程(多个协程)，threading.local对象做不到

决定

　　以后不支持协程：threading.local对象

　　支持：自定义threading.local对象(支持协程)

　　

 import threading

try:
    from greenlet import getcurrent as get_ident  # 协程
except ImportError:
    try:
        from thread import get_ident
    except ImportError:
         from _thread import get_ident  # 线程


class local(object):
    def __init__(self):
        self.storage = {}
        self.get_ident = get_ident
    
    def set(self, k, v):
         ident = self.get_ident()
         origin = self.storage.get(ident)
         if not origin:
            origin = {k:v}
         else:
            origin[k] = v
          self.storage[ident] = origin
     
    def get(self, k):
           ident = self.get_ident()
           origin = self.storage.get(ident)
           if not origin:
               return None
           return origin.get(k, None)

local_values = local()

def task(num):
    local_values.set('name', num)
    import time
    time.sleep(1)
  print(local_values.get('name'),threading.current_thread().name)

for i in range(20):
    th = threading.Thread(target=task, args=(i,), name='线程%s' % i)
    th.start()    

自定义类似threading.local对象

　　一、self.storage={}

　　　　object.__setattr__(self, 'storage', {})  使用此方法时，对象.xx不会调用__setattr__()方法

　　二、对象.xx

　　　　触发：

　　　　　　def __setattr__(self, key, value):

　　　　　　　　print(key, value)

flask上下文管理机制

　　1.threading.local对每个线程保留它自己的值，但是flask为了支持协程，它自己定义了一个Local对象，其中创建了一个字典{greenlet做唯一标识：存数据}，保证数据隔离，在Local对象中保存它的值

　　2.三个流程

　　　　a.请求到来时

　　　　　　ctx=封装RequestContext(request, session)

　　　　　　ctx放到local中

　　　　　　请求刚进来封装了一个RequestContext对象，ctx=封装RequestContext(request,session)，ctx通过push()加到local对象中

　　　　　　具体用到的是_local.stack把信息加到local对象中

　　　　b.执行视图时

　　　　　　导入request

　　　　　　print(request)        --> LocalProxy对象的__str__方法

　　　　　　request.method    --> LocalProxy对象的__getattr__方法

　　　　　　request + 1           --> LocalProxy对象的__add__方法

　　　　　　都会调用_lookup_req_object函数：去local中将requestContext获取到，再去requestContext中获取request或session

　　　　c.请求结束

　　　　　　ctx.auto_pop()

　　　　　　ctx从local中移除

　　　　　　拿到之后在执行_request_ctx_stack.pop()，去local里面把原来请求相关的requestContext对象删除掉，这次请求终止

　　3.与Django相比是两种不同的实现方式

　　　　Django/tornado是通过传参数形式

　　　　flask是通过上下文管理，两种方式都可以实现，只不过实现方式不一样

应用上下文

请求流程：

　　_request_ctx_stack.local = { }

        _app_ctx_stack.local = { }

　　1.请求到来，有人来访问

　　　　

# ctx = RequestContext对象
# 将请求相关的数据environ封装到了RequestContext对象中
# 再将对象封装到Local中(每个线程/协程独立空间存储)
# ctx.app(当前app的名称)
# ctx.request(封装请求相关的东西)
# ctx.session 空
_request_ctx_stack.local = {
    唯一标识:{
        'stack':[ctx,]
    },
    唯一标识:{
         'stack':[ctx,]
    },
}
# app_ctx = AppContext对象
# app_ctx.app
# app_ctx.g
_app_ctx_stack.local = {
    唯一标识:{
        'stack':[app_ctx,]
    },
    唯一标识:{
         'stack':[app_ctx,]
    },
}

　　2.使用

　　　　

from flask import request, session, g, current_app
print(request, session, g, current_app)
都会执行相应LocalProxy对象的__str__
request = LocalProxy(partial(_lookup_req_object, 'request'))
session = LocalProxy(partial(_lookup_req_object, 'session'))
current_app = LocalProxy(_find_app)
g = LocalProxy(partial(_lookup_app_object, 'g'))

　　3.终止，ctx、app_ctx全部pop

问题1：多线程是如何实现？

　　不管几个线程进来都是两个local对象，只不过是每个线程的唯一标识不同，而所有线程的唯一标识都放在对应的Local对象中，使用时取自己对应的不会出错

问题2：flask的local中保存数据时，使用列表创建出来的是栈

　　如果写web程序，web运行环境：栈中永远保存1条数据(可以不用栈)

　　写脚本获取app信息时，可能存在app上下文嵌套关系(要使用栈)

　　　　

from flask import Flask, current_app, globals, _app_ctx_stack
app1 = Flask('app01')
app1.debug = True  
app2 = Flask('app02')
app2.debug = False
with app1.app_context():
    print(current_app.name)
    print(_app_ctx_stack._local.__storage__)
with app2.app_context():
    print(current_app.name)
    print(_app_ctx_stack._local.__storage__)
print(current_app.name)

多app应用

from werkzeug.wsgi import DispatcherMiddleware
from werkzeug.serving import run_simple
from flask import Flask, current_app
app1 = Flask('app01')
app2 = Flask('app02')
@app1.route('/index')
def index():
    print(current_app)
    return "app01"
@app2.route('/index2')
def index2():
    print(current_app)
    return "app02"

# http://www.oldboyedu.com/index
# http://www.oldboyedu.com/sec/index2
# 通过URL分发
dm = DispatcherMiddleware(app1, {
            '/sec': app2,
})

if __name__ == '__main__':
    # app2.__call__
    run_simple('localhost', 5000, dm) 

问题3：web访问多app应用时，上下文管理是如何实现？

　　每个app都会调用自己的__call__方法，而且都有自己的唯一标识，并且添加到相应的local对象中，只是对应的app是不一样的，执行过程和多线程实现过程类似

补充：当用脚本写flask时，有可能会出现堆栈

from flask import Flask, current_app, globals, _app_ctx_stack
app1 = Flask('app01')
app1.debug = True   # 用户名/密码/邮箱
app2 = Flask('app02')
app2.debug = False  
# with AppContext(self):   # 执行__enter__方法
# app_ctx = AppContext(self)
# app_ctx.app
# app_ctx.g
with app1.app_context():# 执行__enter__方法 -> push -> app_ctx添加到_app_ctx_stack.local
# {<greenlet.greenlet object at 0x00000184FEEBCCC0>: {'stack': [<flask.ctx.AppContext object at 0x00000184FEFC5748>]}}
print(current_app.name)  # app01
# print(current_app.config['DEBUG'])
print(_app_ctx_stack._local.__storage__)
with app2.app_context():
# {<greenlet.greenlet object at 0x00000184FEEBCCC0>: {'stack': [<flask.ctx.AppContext object at 0x00000184FEFC5748>, <flask.ctx.AppContext object at 0x00000184FEFC5860>]}}
print(current_app.name)  # app02
# print(current_app.config['DEBUG'])
print(_app_ctx_stack._local.__storage__)
print(current_app.name)  # app01

十三、偏函数

import functools

def func(a1, a2):
    print(a1, a2)

new_func = functools.partial(func, 666)
new_func(999)

十四、面向对象

当把面向对象中的所有__函数__实现时，对象做任何操作时，都会执行其中对应的方法

class Foo(object):
    def __init__(self, num):
        self.num = num
    
    def __add__(self, other):
        data = self.num + other.num
        return Foo(data)

obj1 = Foo(1)
obj2 = Foo(2)
v = obj1 + obj2

面向对象私有

class Foo(object):
    def __init__(self):
        self.name = 'alex'
        self.__age = 18
    
    def get_age(self):
         return self.__age

obj = Foo()
print(obj.name)
# 强制获取私有字段
print(obj._Foo__age)
print(obj.get_age())

十五、拼接列表中的值

from itertools import chain

v1 = [11, 22, 33]
v2 = [44, 55, 66]
new = chain(v1, v2)
for item in new:
    print(item)

from itertools import chain

def f1(x):
    return x + 1

func1_list = [f1, lambda x:x-1]

def f2(x):
    return x + 10

new_fun_list = chain([f2], func1_list)

for func in new_fun_list:
    print(func)

十六、数据库连接池(基于threading.local实现)

友情链接：https://www.cnblogs.com/wupeiqi/articles/8184686.html

Django和Flask使用数据库分析

　　Django：ORM(pymysql/MySQLdb)

　　Flask：原生SQL

　　　　　 　　pymysql(2/3)

　　　　　　　 MySQLdb(2)

　　　　　 SQLAlchemy(ORM)

原生SQL

import pymysql
CONN = pymysql.connect(host='127.0.0.1',
                                       port=3306,
                                       user='root',
                                       password='123',
                                       database='pooldb',
                                       charset='utf8')
cursor = CONN.cursor()
cursor.execute('select * from tb1')
result = cursor.fetchall()
cursor.close()
print(result)

问题

　　1.来一个用户连接一次数据库(把连接数据库的操作放到全局变量中)

　　2.并发运行时，拿到的数据有可能是错的

　　3.加锁可以解决信息错误的问题，但是没有并发运行

解决思路

　　不能为每个用户创建一个连接

　　创建一定数量的连接池，如果有人来使用时有空的就拿去用，用完再还回来，没有时就等待

使用DBUtils模块

　　安装：如果安装到虚拟环境，需要先切换到虚拟环境

　　使用：

　　　　模式一：为每个线程创建一个连接

　　　　模式二：创建n个连接，多线程来时，去获取

　　

import time
import pymysql
from DBUtils.PooledDB import PooledDB

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
    host='127.0.0.1',
    port=3306,
    user='root',
    password='123',
    database='pooldb',
    charset='utf8'
)

class SQLHelper(object):
@staticmethod
def fetch_one(sql, args):
    conn = POOL.connection()
    cursor = conn.cursor()
    cursor.execute(sql, args)
    result = cursor.fetchone()
    conn.close()
    return result
    
@staticmethod
def fetch_all(sql, args):
    conn = POOL.connection()
    cursor = conn.cursor()
    cursor.execute(sql, args)
    result = cursor.fetchall()
    conn.close()
    return result

result = SQLHelper.fetch_one('select * from tb1 where id > %s', [1,])
print(result)

十七、信号(只能执行不能终止)

Django：要有请求、有信号、信号中注册函数

Flask：

　　before_first_request

　　触发request_started信号

　　before_request

　　模板渲染

　　　　渲染前的信号：before_render_template.send(app, template=template, context=context)

　　　　　　rv = template.render(context)  # 模板渲染

　　　　渲染后的信号：template_rendered.send(app, template=template, context=context)

　　after_request

　　session.save_session()

　　触发request_finished信号

　　如果上述过程出错：

　　　　触发错误处理信号：got_request_exception.send(self, exception=e)

　　触发信号：request_tearing_down

十八、MetaClass

作用：用来指定当前类是由谁来创建(默认type创建)

类由type创建：class Foo(metaclass=type)

继承type：class Foo(type)

十九、Flask-session

Flask中的session处理机制(内置：将session保存在加密的cookie中实现)

　　请求刚进来：获取随机字符串，存在则去"数据库"中获取原来的个人数据，否则创建一个空容器。--> 内存：对象(随机字符串，{放置数据的容器})

　　　　# 到底是什么对象？

              # 1.obj = 创建SecureCookieSessionInterface()

              # 2.obj = open_session(self.app, self.request) = SecureCookieSession()

              # self.session = SecureCookieSession()对象

              # 为session创建一个特殊的字典

              self.session = session_interface.open_session(self.app, self.request)

　　视图：操作内存中对象(随机字符串，{放置数据的容器})

　　　　响应：内存对象(随机字符串，{放置数据的容器})

　　　　　　将数据保存到数据库

　　　　　　把随机字符串写在用户cookie中            

　　自定义

　　　　请求刚进来：

　　　　　　# 创建特殊的字典，并添加到Local中

                　  # 调用关系：

                     #     self.session_interface.open_session(self, request)

                     #     由于默认app中的session_interface = SecureCookieSessionInterface()

                     #         SecureCookieSessionInterface().open_session(self, request)

                     #   由于默认app中的session_interface = MySessionInterFace()

                     #         MySessionInterFace().open_session(self, request)

                     self.session = session_interface.open_session(self.app, self.request)

　　　　调用：

　　　　　　session --> LocalProxy --> 偏函数 --> LocalStack --> Local

　　　　请求终止：

　　　　　　#     由于默认app中的session_interface = SecureCookieSessionInterface()

                     #         SecureCookieSessionInterface().save_session(self, app, session, response)

                     #   由于默认app中的session_interface = MySessionInterFace()

                     #         MySessionInterFace().save_session(self, app, session, response)

　　flask-session组件

　　　　随机生成一个ID

　　　　　　>>> from uuid import uuid4

                     >>> uuid4()

                　 UUID('81a3ae5a-991f-4eb9-9e1d-76c11d248887')

　　　　使用：  

　　　　　　

 from flask import Flask, session
from flask_session import RedisSessionInterface
app = Flask(__name__)
app.secret_key = 'asdfasdf'

# 方式一
from redis import Redis
conn = Redis()
app.session_interface = RedisSessionInterface(conn, key_prefix='__', use_signer=False)

# 方式二
from redis import Redis
from flask_session import Session
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = Redis(host='localhost',port='6379')
Session(app)

@app.route('/')
def index():
    session['xxx'] = 123
    return "index"

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

　　　　问题：设置cookie时，如何设定关闭浏览器则cookie失效

　　　　　　request.set_cookie('k', 'v', exipre=None)   

二十、总结

1.哪里还用到过threading.local

　　DBUtils

2.上下文管理

　　请求：

　　　　request：封装请求相关信息

　　　　session：保存用户回话相关信息

　　应用：

　　　　app：当前应用相关信息

　　　　g：每个请求周期都会创建一个用于在请求周期中传递值的一个容器

3.多app应用&蓝图

　　都是分发URL，多app应用是在app前面分发，蓝图是在app后面分发

4.为什么用栈？

　　存在app上下文嵌套关系时，会将信息堆栈，但是不用担心取值的问题，因为当前app每次取值都是取的最后一个，用完之后就清除了，而不会影响其他app的使用，相当于一个先进后出的队列

5.面向对象

　　封装　

　　　　

 class Foo:
    def __init__(self):
       self.age = 23
       self.name = 'xiaoming'

class Bar:
    def __init__(self):
        self.xx = 123

# 把类再封装到一个对象里面
class Base:
    def __init__(self):
        self.f = Foo()
        self.x = Bar()

　　某个值 + 括号

　　　　函数/方法：看谁调用，判断函数或方法

　　　　类和对象

　　特殊的双下划线方法，flask中的LocalProxy里面都使用过

　　　　

 __new__
__init__
__call__
__str__
__setattr__
__getattr__
__setitem__
__enter__
__exit__
__add__

　　强制调用私有字段，只能在自己这个类中调用

　　　　子类和派生类中都不能调用基类私有字段