Python的Web可视化框架Dash(7)---回调共享

【Dash系列】Python的Web可视化框架Dash(1)---简介
【Dash系列】Python的Web可视化框架Dash(2)---安装
【Dash系列】Python的Web可视化框架Dash(3)---布局设置
【Dash系列】Python的Web可视化框架Dash(4)---基本回调
【Dash系列】Python的Web可视化框架Dash(5)---状态和预更新
【Dash系列】Python的Web可视化框架Dash(6)---交互和过滤
【Dash系列】Python的Web可视化框架Dash(7)---回调共享
【Dash系列】Python的Web可视化框架Dash(8)---核心组件

本节介绍Dash应用回调之间共享状态和数据，导入本节用到的所有包

import pandas as pd
import plotly.graph_objs as go
import dash
import dash_core_components as dcc                  # 交互式组件
import dash_html_components as html                 # 代码转html
from dash.dependencies import Input, Output         # 回调
from jupyter_plotly_dash import JupyterDash         # Jupyter中的Dash

一、概述

不同回调函数之间共享状态

回调入门指南 中提到过Dash的核心原则之一 ： Dash Callbacks 绝不能修改其范围之外的变量。修改任何 global 变量都是不安全的。本章解释这样操作为什么不安全，并提出在回调函数间共享状态的替代方式。

为什么要共享状态？

某些应用可能会有SQL查询、运行模拟或下载数据等扩展性数据处理任务，所以会使用多个回调函数。

与其让每个回调函数都运行同一个大规模运算任务，不如让其中一个回调函数执行任务，然后将结果共享给其它回调函数，而不是让每个回调函数运行相同的昂贵任务。

由于可以为一次回调设置多个输出，实现昂贵的任务一次完成，即可用于所有的输出。但在某些情况下，这仍然不太理想，例如，如果有简单的后续任务可以修改结果，例如单位转换。我们不需要重复大型数据库查询，只是为了将结果从华氏温度更改为摄氏温度。

为什么全局变量会破坏应用？

Dash应用旨在在多用户环境中工作，多个人可以同时查看应用程序，并具有独立会话。

如果用户可以修改应用的全局变量，即使用修改后的 global 变量，会影响下一位用户会话的值。

Dash的设计思路还包括运行多个Python workers，实现多个回调函数，并行执行。通常，使用gunicorn语法完成：

$ gunicorn --workers 4 app:server

• app：命名的文件app.py
• server：命名的文件的变量 server:server = app.server

当Dash应用跨多个工作程序(worker)运行时，不会共享内存。这意味着，如果某个回调函数修改了全局变量，则该修改将不会应用于其它的工作程序。

在回调函数之间共享数据

为了在多个python进程之间安全地共享数据，则需要将数据存储在每个进程可访问的位置。推荐在如下3个位置存储数据：

• 在用户的浏览器会话中
• 在磁盘上，例如：文件或新数据库
• 与Redis一样，存在共享内存空间

示例说明

下面的例子，展示了回调函数在其应用范围外修改数据。鉴于上述原因，它的运行结果可能不靠谱。

df = pd.DataFrame({'a': [1, 2, 3], 'b': [4, 1, 4], 'c': ['x', 'y', 'z']})

app = JupyterDash('wrong_id', height = 100)
app.layout = html.Div([
    dcc.Dropdown(
        id = 'dropdown_id',
        options = [{'label': i, 'value': i} for i in df['c'].unique()],
        value = 'x'),
    html.Div(id = 'output_id')
])

@app.callback(Output('output_id', 'children'), [Input('dropdown_id', 'value')])
def update_output(value):
    global df = df[df['c'] == value]    # 不要这样做，这不安全！
    return len(df)

app

要修复此示例，只需要将筛选器，重新分配给回调内的新变量，或者按照上述的“回调函数之间共享数据”介绍的任一方法，进行操作。

df = pd.DataFrame({'a': [1, 2, 3], 'b': [4, 1, 4], 'c': ['x', 'y', 'z']})

app = JupyterDash('wrong_id', height = 100)
app.layout = html.Div([
    dcc.Dropdown(
        id = 'dropdown_id',
        options = [{'label': i, 'value': i} for i in df['c'].unique()],
        value = 'x'),
    html.Div(id = 'output_id')
])

@app.callback(Output('output_id', 'children'), [Input('dropdown_id', 'value')])
def update_output(value):
    filtered_df = df[df['c'] == value]    # 安全地将筛选器，重新分配给新变量
    return len(filtered_df)

app

二、在浏览器中存储数据

(一) 代码

global_df = pd.read_csv('...')

app = JupyterDash('browser_id')
app.layout = html.Div([
    dcc.Graph(id = 'graph_id'),
    html.Table(id = 'table_id'),
    dcc.Dropdown(id = 'dropdown_id'),
    html.Div(id = 'intermediate-value', style = dict(display = None))    # 用于存储中间值的Hidden Div
])

@app.callback(Output('intermediate-value', 'children'), [Input('dropdown_id', 'value')])
def clean_data(value):
    cleaned_df = your_expensive_clean_or_compute_step(value)    # 清理大规模数据
    return cleaned_df.to_json(date_format = 'iso', orient = 'split')    # 转化成Json格式

@app.callback(Output('graph_id', 'children'), [Input('intermediate-value', 'children')])
def update_graph(jsonified_cleaned_data):
    dff = pd.read_json(jsonified_cleaned_data, orient='split')    # 将Json数据读取为dataframe
    fig = create_figure(dff)    # 生成表格图表
    return fig

@app.callback(Output('table_id', 'children'), [Input('intermediate-value', 'children')])
def update_table(jsonified_cleaned_data):
    dff = pd.read_json(jsonified_cleaned_data, orient='split')    # 将Json数据读取为dataframe
    table = create_table(dff)    # 生成表格图表
    return table

app

(二) 说明

1. 本例介绍了在回调函数中，执行大规模数据处理的步骤：以JSON格式进行序列化输出，并将其作为其他回调函数的输入。本例使用标准的Dash回调函数，将JSON数据存储在应用的Hidden Div里；

2. 通过Dash 社区中提供的方法，将数据保存为Dash前端的一部分；

3. 必须将数据转换为类似JSON的字符串，才能进行存储和传输；

4. 以这种方式缓存的数据，仅在用户的当前会话中可用(生效)：

• 数据仅在当前会话内的回调函数中缓存和传输。如果打开了一个新的浏览器，则应用程序的回调函数会重新计算；
• 与缓存不同，这种方法不会增加应用程序的内存占用量；
• 网络传输会产生成本。如果在回调函数之间，共享小于等于10M的数据，那么每次回调时，都会通过网络进行数据传输；
• 如果网络成本太高，可以先做聚合计算再传输数据。 应用程序一般不会显示多于10MB的数据，大部分情况下，只显示其子集或聚合结果。
  
  

三、预先聚合或筛选

(一) 代码

@app.callback(Output('intermediate-value', 'children'), [Input('dropdown_id', 'value')])
def clean_data(value):
    cleaned_df = your_expensive_clean_or_compute_step(value)    # 高消耗的查询
    
    # 筛选其它回调函数，所需的数据
    df_1 = cleaned_df[cleaned_df['fruit'] == 'apples']
    df_2 = cleaned_df[cleaned_df['fruit'] == 'oranges']
    df_3 = cleaned_df[cleaned_df['fruit'] == 'figs']
    datasets = {'df_1': df_1.to_json(orient='split', date_format='iso'),
                'df_2': df_2.to_json(orient='split', date_format='iso'),
                'df_3': df_3.to_json(orient='split', date_format='iso')}
    
    return json.dumps(datasets)

@app.callback(Output('graph_id', 'figure'), [Input('intermediate-value', 'children')])
def update_graph_1(jsonified_cleaned_data):
    datasets = json.loads(jsonified_cleaned_data)
    dff = pd.read_json(datasets['df_1'], orient='split')
    figure = create_figure_1(dff)
    return figure

@app.callback(Output('graph_id', 'figure'), [Input('intermediate-value', 'children')])
def update_graph_2(jsonified_cleaned_data):
    datasets = json.loads(jsonified_cleaned_data)
    dff = pd.read_json(datasets['df_2'], orient='split')
    figure = create_figure_2(dff)
    return figure

@app.callback(Output('graph_id', 'figure'), [Input('intermediate-value', 'children')])
def update_graph_3(jsonified_cleaned_data):
    datasets = json.loads(jsonified_cleaned_data)
    dff = pd.read_json(datasets['df_3'], orient='split')
    figure = create_figure_3(dff)
    return figure

(二) 说明

1. 这是一个简单的示例，说明如何将聚合或筛选的数据传输给多个回调函数；
2. 如果数据量过大，通过网络发送运算后的数据，代价会很高。在某些情况下，即便将数据序列化或使用JSON格式，其运算量也很大；
3. 通常数情况下，Dash应用可以在处理回调时，预先对数据进行计算、筛选、聚合，再将这些结果子集，传输给剩下的其它回调中。