Flask（一）

pip install flask

依赖wsgi

flask框架是基于werkzegu的wsgi实现，flask没有自己的wsgi

用户一旦请求，就会调用app.__call__方法

flask 路由：

@app.route('/login',methods=['GET','POST'])
def login():
    if request.method == "GET":

路由参数：endpoint默认为函数名

增加路由的两种方式：

@app.route('/testflask')
def index():
    return  render_template('testflask.html')

def login():
    return render_template('login.html')
app.add_url_rule('/login','login',login)

路由源码流程：

  将url和函数打包成rule对象

  将url对象添加到map对象中

  app.url_map = map对象

支持动态路由：

@app.route('/del/<int:nid>')
def delete(nid):
    del DATA_DICT[nid]

 

2.获取提交的数据

request.args  GET形式传递参数
request.form  Post形式提交参数

返回数据

return render_template('edit.html',info=info)  
return jsonify({'code':200,'data':[1,2,3]})
return redirect(url_for('idx'))
return "string"

模板处理：

{{x}}

{% for key,value in data_dict.items() %}
<tr>
    <td>{{key}}</td>
    <td>{{value.name}}</td>
    <td>{{value.age}}</td>
    <td>
        <a href="/edit?nid={{key}}">编辑</a>
        <a href="/del/{{key}}">删除</a>

    </td>
</tr>
{% endfor %}

蓝图

装饰器：

def auth(func):
    @functools.wraps(func)
    def inner(*args,**kwargs):
        username = session.get('xxx')
        if not username:
            return redirect(url_for('login'))
        return func(*args,**kwargs)
    return inner()

静态文件处理：

app = Flask(__name__,template_folder='templates',static_folder='static',static_url_path='/static')

<!--<img src="/static/aa.jpg"/>-->
<img src="{{url_for('static',filename='aa.jpg')}}">

配置文件：

方法一：

#settings.py  服务器配置文件
XX=123
DB_HOST = '192.168.0.1'
PORT = 3306
SECRET_KEY='hjhhdibhdi'
try:
    from .localsettings import *
except ImportError:
    pass

#localsettings.py

DB_HOST = '127.0.0.1'
PORT = 3306

#基于全局变量
app.config.from_object('config.settings')

方法二：基于类

class BaseSettings(object):
    #放公共配置数据
    PORT = 3306
class DevSettings(BaseSettings):
    Host='127.0.0.1'

class ProdSettings(BaseSettings):
    Host = '127.0.3.1'

视图：

  FBV

  CBV（返回一个view函数，闭包的应用场景）

模板：

全局模板方法两种：

@app.template_global() #{{func("tttt")}}
def func(arg):
    return render_template('aa.index')

@app.template_filter()#{{"bbbb"|f1()}}
def f1(arg):
    return render_template('bb.index')

特殊的装饰器：

flask上下文管理

  wsgi是web服务网管接口，它是一个协议，实现它的协议有：wsgi/

栈：

  后进先出，通过列表可以实现一个栈  append()  pop()

class Local(object):
    def __init__(self):
        self.storage={}#这样写 容易递归 进入死循环
        object.__setattr__(self,'storage',{})

    def __setattr__(self, key, value):
        self.storage[key] = value

    def __getattr__(self, item):
        return self.storage.get(item)

loacl = Local()
loacl.x1 = 123
print(loacl.x1)

线程的唯一标识：

import threading
from threading import get_ident

def task():
    ident = get_ident()
    print(ident)
for i in range(20):
    t = threading.Thread(target=task)
    t.start()

自定义threading local

import threading
class Local(object):
    def __init__(self):
        object.__setattr__(self,'storage',{})
    def __setattr__(self, key, value):
        ident = threading.get_ident()
        if ident in self.storage:
            self.storage[ident][key] = value
        else:
            self.storage[ident] = {key:value}

    def __getattr__(self, item):
        ident = threading.get_ident()
        if ident not in self.storage:
            return
        return self.storage[ident].get(item)

local = Local()
def task(arge):
    local.x = arge
    print(local.x)

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

'''
加强版的 Threading Local   list栈  
'''
import threading

class Local(object):
    def __init__(self):
        object.__setattr__(self, 'storage', {})

    def __setattr__(self, key, value):
        ident = threading.get_ident()
        if ident in self.storage:
            self.storage[ident][key].append(value)
        else:
            self.storage[ident] = {key: [value,]}

    def __getattr__(self, item):
        ident = threading.get_ident()
        if ident not in self.storage:
            return
        return self.storage[ident][item][-1]

local = Local()

def task(arge):
    local.x = arge
    print(local.x)

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

在flask中有一个Local 类，它和 threading local的功能一样，每个线程开辟一个空间，存储数据

内部实现机制：内部会维护一个字典，这个字典以线程（协程）id为key，进程数据隔离，如：

__storage__ = {

1211:{'k1':123}

}

obj = Local()

obj.k1 = 123

在flask 还有一个Localstack的类，它内部依赖Local对象，local对象负责存储数据，localstack对象用于将local的值维护成一个栈。

__storage__ = {

1211:{'stack':['k1',]}

}

obj = LocalStack()

object.push('k1')

obj.top

obj.pop()

 

上下文管理：

  

app