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"

模板处理：

{% 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

巴特西

Flask（一）

最新文章

热门文章