# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'qteh2xx_xz#z#keg0%*++%yo%)n2nn27!ogxk5#2z%4*k57^s)'

with open ('env.json', 'r', encoding='utf-8') as env:
    ENV_CONST = json.load(env)

SECRET_KEY = ENV_CONST['SECRET_KEY']

STATIC_ROOT = os.path.join(BASE_DIR + "/static")

INSTALLED_APPS = [
    ...
![](images/python-djangosqlpand/v2-fd21b983e4e862ec45479c1937087269_1440w.webp)
    'django.contrib.auth',
    'django.contrib.contenttypes',

MIDDLEWARE = [
    ...
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    ]

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

urlpatterns = [

    path('chpa/', include('chpa_data.urls')),
    path('admin/', admin.site.urls),
    path('accounts/', include('django.contrib.auth.urls')),
]

from django.contrib.auth.decorators import login_required


@login_required
def index(request):
    ...


@login_required
@cache_page(60 * 60 * 24 * 30)
def query(request):
    ...


@login_required
@cache_page(60 * 60 * 24 * 30)
def search(request, column, kw):
    ...


@login_required
@cache_page(60 * 60 * 24 * 30)
def export(request, type):
    ...

from django.views.decorators.cache import cache_page

@cache_page(60 * 60 * 24 * 30) #  缓存30天
def query(request):
    ...
    return HttpResponse(json.dumps(context, ensure_ascii=False), content_type="application/json charset=utf-8") # 返回结果必须是json格式

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.dummy.DummyCache',
    }
}

from django.core.management.base import BaseCommand
from django.core.cache import cache


class Command(BaseCommand):
    def handle(self, *args, **kwargs):
        cache.clear()
        self.stdout.write('缓存已清除\n')

def get_df(form_dict, is_pivoted=True):
    sql = sqlparse(form_dict)  # sql拼接
    df = pd.read_sql_query(sql, ENGINE)  # 将sql语句结果读取至Pandas Dataframe

    if is_pivoted is True:
        dimension_selected = form_dict['DIMENSION_select'][0]
        if dimension_selected[0] == '[':

            column = dimension_selected[1:][:-1]
        else:
            column = dimension_selected

        pivoted = pd.pivot_table(df,
                                 values='AMOUNT',  # 数据透视汇总值为AMOUNT字段，一般保持不变
                                 index='DATE',  # 数据透视行为DATE字段，一般保持不变
                                 columns=column,  # 数据透视列为前端选择的分析维度
                                 aggfunc=np.sum)  # 数据透视汇总方式为求和，一般保持不变
        if pivoted.empty is False:
            pivoted.sort_values(by=pivoted.index[-1], axis=1, ascending=False, inplace=True)  # 结果按照最后一个DATE表现排序

        return pivoted
    else:
        return df


def query(request):
    form_dict = dict(six.iterlists(request.GET))
    pivoted = get_df(form_dict)

    # KPI
    kpi = get_kpi(pivoted)

    table = ptable(pivoted)
    table = table.to_html(formatters=build_formatters_by_col(table),  # 逐列调整表格内数字格式
                          classes='ui selectable celled table',  # 指定表格css class为Semantic UI主题
                          table_id='ptable'  # 指定表格id
                          )

    # Pyecharts交互图表
    bar_total_trend = json.loads(prepare_chart(pivoted, 'bar_total_trend', form_dict))

    # Matplotlib静态图表
    bubble_performance = prepare_chart(pivoted, 'bubble_performance', form_dict)
    context = {
        "market_size": kpi["market_size"],
        "market_gr": kpi["market_gr"],
        "market_cagr": kpi["market_cagr"],
        'ptable': table,
        'bar_total_trend': bar_total_trend,
        'bubble_performance': bubble_performance
    }

    return HttpResponse(json.dumps(context, ensure_ascii=False), content_type="application/json charset=utf-8") # 返回结果必须是json格式

try:
    from io import BytesIO as IO # for modern python
except ImportError:
    from io import StringIO as IO # for legacy python
import datetime


def export(request, type):
    form_dict = dict(six.iterlists(request.GET))

    if type == 'pivoted':
        df = get_df(form_dict)  # 透视后的数据
    elif type == 'raw':
        df = get_df(form_dict, is_pivoted=False)  # 原始数

    excel_file = IO()

    xlwriter = pd.ExcelWriter(excel_file, engine='xlsxwriter')

    df.to_excel(xlwriter, 'data', index=True)

    xlwriter.save()
    xlwriter.close()

    excel_file.seek(0)

    # 设置浏览器mime类型
    response = HttpResponse(excel_file.read(),
                            content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')

    # 设置文件名
    now = datetime.datetime.now().strftime("%Y%m%d%H%M%S")  # 当前精确时间不会重复，适合用来命名默认导出文件
    response['Content-Disposition'] = 'attachment; filename=' + now + '.xlsx'
    return response

def sqlparse(context):
    print(context)
    sql = "Select * from %s Where PERIOD = '%s' And UNIT = '%s'" % \
          (DB_TABLE, context['PERIOD_select'][0], context['UNIT_select'][0])  # 先处理单选部分

    # 下面循环处理多选部分
    for k, v in context.items():
        if k not in ['csrfmiddlewaretoken', 'DIMENSION_select', 'PERIOD_select', 'UNIT_select']:
            if k[-2:] == '[]':
                field_name = k[:-9]  # 如果键以[]结尾，删除_select[]取原字段名
            else:
                field_name = k[:-7]  # 如果键不以[]结尾，删除_select取原字段名
            selected = v  # 选择项
            sql = sql_extent(sql, field_name, selected)  #未来可以通过进一步拼接字符串动态扩展sql语句
    return sql

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.font_manager as fm
import matplotlib as mpl
from matplotlib.ticker import FuncFormatter
from adjustText import adjust_text
from io import BytesIO
import base64
import scipy.stats as stats

myfont = fm.FontProperties(fname='C:/Windows/Fonts/msyh.ttc')

def mpl_bubble(x, y, z, labels, title, x_title, y_title,
               x_fmt='{:.0%}', y_fmt='{:+.0%}',
               y_avg_line=False, y_avg_value=None, y_avg_label='',
               x_avg_line=False, x_avg_value=None, x_avg_label='',
               x_max=None, x_min=None, y_max=None, y_min=None,
               show_label=True, label_limit=15,
               z_scale=1, color_scheme='随机颜色方案', color_list=None):

    z = [x * z_scale for x in z]  # 气泡大小系数

    fig, ax = plt.subplots()  # 准备画布和轴
    fig.set_size_inches(15, 10)  # 画布尺寸

    # 手动强制xy轴最小值/最大值
    if x_min is not None and x_min > min(x):
        ax.set_xlim(xmin=x_min)
    if x_max is not None and x_max < max(x):
        ax.set_xlim(xmax=x_max)
    if y_min is not None and y_min > min(y):
        ax.set_ylim(ymin=y_min)
    if y_max is not None and y_max < max(y):
        ax.set_ylim(ymax=y_max)

    # 确定颜色方案
    if color_scheme == '随机颜色方案' or color_scheme is None:
        cmap = mpl.colors.ListedColormap(np.random.rand(256, 3))
        colors = iter(cmap(np.linspace(0, 1, len(x))))
    else:
        if len(x) <= len(color_list):
            colors = color_list[:len(x)]
        else:
            colors = []
            for i in range(len(x)):
                colors.append(color_list[i % len(color_list)])
        colors = iter(colors)

    # 绘制气泡
    for i in range(len(x)):
        ax.scatter(x[i], y[i], z[i], color=next(colors), alpha=0.6, edgecolors="black")

    # 添加系列标签，用adjust_text包保证标签互不重叠
    if show_label is True:
        texts = [plt.text(x[i], y[i], labels[i],
                          ha='center', va='center', multialignment='center', fontproperties=myfont, fontsize=10) for
                 i
                 in range(len(labels[:label_limit]))]
        adjust_text(texts, force_text=0.5, arrowprops=dict(arrowstyle='->', color='black'))

    # 添加分隔线（均值，中位数，0等）
    if y_avg_line is True:
        ax.axhline(y_avg_value, linestyle='--', linewidth=1, color='grey')
        plt.text(ax.get_xlim()[1], y_avg_value, y_avg_label, ha='left', va='center', color='r',
                 multialignment='center',
                 fontproperties=myfont, fontsize=10)
    if x_avg_line is True:
        ax.axvline(x_avg_value, linestyle='--', linewidth=1, color='grey')
        plt.text(x_avg_value, ax.get_ylim()[1], x_avg_label, ha='left', va='top',
                 color='r', multialignment='center', fontproperties=myfont, fontsize=10)

    # 设置轴标签格式
    ax.xaxis.set_major_formatter(FuncFormatter(lambda y, _: x_fmt.format(y)))
    ax.yaxis.set_major_formatter(FuncFormatter(lambda y, _: y_fmt.format(y)))

    # 添加图表标题和轴标题
    plt.title(title, fontproperties=myfont)
    plt.xlabel(x_title, fontproperties=myfont, fontsize=12)
    plt.ylabel(y_title, fontproperties=myfont, fontsize=12)

    """以下部分绘制回归拟合曲线及CI和PI
    参考
    http://nbviewer.ipython.org/github/demotu/BMC/blob/master/notebooks/CurveFitting.ipynb
    https://stackoverflow.com/questions/27164114/show-confidence-limits-and-prediction-limits-in-scatter-plot
    """

    n = y.size  # 观察例数
    if n > 2:  # 数据点必须大于cov矩阵的scale
        p, cov = np.polyfit(x, y, 1, cov=True) # 简单线性回归返回parameter和covariance
        poly1d_fn = np.poly1d(p)  # 拟合方程
        y_model = poly1d_fn(x)  # 拟合的y值
        m = p.size  # 参数个数

        dof = n - m  # degrees of freedom
        t = stats.t.ppf(0.975, dof)  # 显著性检验t值

        # 拟合结果绘图
        ax.plot(x, y_model, "-", color="0.1", linewidth=1.5, alpha=0.5, label="Fit")

        # 误差估计
        resid = y - y_model  # 残差
        s_err = np.sqrt(np.sum(resid ** 2) / dof)  # 标准误差

        # 拟合CI和PI
        x2 = np.linspace(np.min(x), np.max(x), 100)
        y2 = poly1d_fn(x2)

        # CI计算和绘图
        ci = t * s_err * np.sqrt(1 / n + (x2 - np.mean(x)) ** 2 / np.sum((x - np.mean(x)) ** 2))
        ax.fill_between(x2, y2 + ci, y2 - ci, color="#b9cfe7", edgecolor="", alpha=0.5)

        # Pi计算和绘图
        pi = t * s_err * np.sqrt(1 + 1 / n + (x2 - np.mean(x)) ** 2 / np.sum((x - np.mean(x)) ** 2))
        ax.fill_between(x2, y2 + pi, y2 - pi, color="None", linestyle="--")
        ax.plot(x2, y2 - pi, "--", color="0.5", label="95% Prediction Limits")
        ax.plot(x2, y2 + pi, "--", color="0.5")

    # 保存到字符串
    sio = BytesIO()
    plt.savefig(sio, format='png', bbox_inches='tight', transparent=True, dpi=600)
    data = base64.encodebytes(sio.getvalue()).decode()  # 解码为base64编码的png图片数据
    src = 'data:image/png;base64,' + str(data)  # 增加Data URI scheme

    # 关闭绘图进程
    plt.clf()
    plt.cla()
    plt.close()

    return src

from io import BytesIO
import base64
...

def mpl_bubble(x, y, z, labels, title, x_title, y_title,
               ...):

    ...

    # 保存到字符串
    sio = BytesIO()
    plt.savefig(sio, format='png', bbox_inches='tight', transparent=True, dpi=600)
    data = base64.encodebytes(sio.getvalue()).decode()  # 解码为base64编码的png图片数据
    src = 'data:image/png;base64,' + str(data)  # 增加Data URI scheme

    ...

    return src

D_TRANS = {
            'MAT': '滚动年',
            'QTR': '季度',
            'Value': '金额',
            'Volume': '盒数',
            'Volume (Counting Unit)': '最小制剂单位数',
            '滚动年': 'MAT',
            '季度': 'QTR',
            '金额': 'Value',
            '盒数': 'Volume',
            '最小制剂单位数': 'Volume (Counting Unit)'
           }

def prepare_chart(df,  # 输入经过pivoted方法透视过的df，不是原始df
                  chart_type,  # 图表类型字符串，人为设置，根据图表类型不同做不同的Pandas数据处理，及生成不同的Pyechart对象
                  form_dict,  # 前端表单字典，用来获得一些变量作为图表的标签如单位
                  ):
    label = D_TRANS[form_dict['PERIOD_select'][0]] + D_TRANS[form_dict['UNIT_select'][0]]

    if chart_type == 'bar_total_trend':
        df_abs = df.sum(axis=1)  # Pandas列汇总，返回一个N行1列的series，每行是一个date的市场综合
        df_abs.index = df_abs.index.strftime("%Y-%m")  # 行索引日期数据变成2020-06的形式
        df_abs = df_abs.to_frame()  # series转换成df
        df_abs.columns = [label]  # 用一些设置变量为系列命名，准备作为图表标签
        df_gr = df_abs.pct_change(periods=4)  # 获取同比增长率
        df_gr.dropna(how='all', inplace=True)  # 删除没有同比增长率的行，也就是时间序列数据的最前面几行，他们没有同比
        df_gr.replace([np.inf, -np.inf, np.nan], '-', inplace=True)  # 所有分母为0或其他情况导致的inf和nan都转换为'-'
        chart = echarts_stackbar(df=df_abs,
                                 df_gr=df_gr
                                 )  # 调用stackbar方法生成Pyecharts图表对象
        return chart.dump_options()  # 用json格式返回Pyecharts图表对象的全局设置
    elif chart_type == 'bubble_performance':
        df_abs = df.iloc[-1,:]  # 获取最新时间粒度的绝对值
        df_share = df.transform(lambda x: x / x.sum(), axis=1).iloc[-1,:] # 获取份额
        df_diff = df.diff(periods=4).iloc[-1,:]  # 获取同比净增长

        chart = mpl_bubble(x=df_abs,  # x轴数据
                           y=df_diff,  # y轴数据
                           z=df_share * 50000,  # 气泡大小数据
                           labels=df.columns.str.split('|').str[0],  # 标签数据
                           title='',  # 图表标题
                           x_title=label,  # x轴标题
                           y_title=label + '净增长',  # y轴标题
                           x_fmt='{:,.0f}',  # x轴格式
                           y_fmt='{:,.0f}',  # y轴格式
                           y_avg_line=True,  # 添加y轴分隔线
                           y_avg_value=0,  # y轴分隔线为y=0
                           label_limit=30  # 只显示前30个项目的标签
                           )
        return chart

def query(request):
    ...

    # Matplotlib静态图表
    bubble_performance = prepare_chart(pivoted, 'bubble_performance', form_dict)
    context = {
        ...
        'bubble_performance': bubble_performance
    }

    return HttpResponse(json.dumps(context, ensure_ascii=False), content_type="application/json charset=utf-8") # 返回结果必须是json格式

from .charts import *

D_TRANS = {
            'MAT': '滚动年',
            'QTR': '季度',
            'Value': '金额',
            'Volume': '盒数',
            'Volume (Counting Unit)': '最小制剂单位数',
            '滚动年': 'MAT',
            '季度': 'QTR',
            '金额': 'Value',
            '盒数': 'Volume',
            '最小制剂单位数': 'Volume (Counting Unit)'
           }

def prepare_chart(df,  # 输入经过pivoted方法透视过的df，不是原始df
                  chart_type,  # 图表类型字符串，人为设置，根据图表类型不同做不同的Pandas数据处理，及生成不同的Pyechart对象
                  form_dict,  # 前端表单字典，用来获得一些变量作为图表的标签如单位
                  ):
    label = D_TRANS[form_dict['PERIOD_select'][0]] + D_TRANS[form_dict['UNIT_select'][0]]

    if chart_type == 'bar_total_trend':
        df_abs = df.sum(axis=1)  # Pandas列汇总，返回一个N行1列的series，每行是一个date的市场综合
        df_abs.index = df_abs.index.strftime("%Y-%m")  # 行索引日期数据变成2020-06的形式
        df_abs = df_abs.to_frame()  # series转换成df
        df_abs.columns = [label]  # 用一些设置变量为系列命名，准备作为图表标签
        df_gr = df_abs.pct_change(periods=4)  # 获取同比增长率
        df_gr.dropna(how='all', inplace=True)  # 删除没有同比增长率的行，也就是时间序列数据的最前面几行，他们没有同比
        df_gr.replace([np.inf, -np.inf, np.nan], '-', inplace=True)  # 所有分母为0或其他情况导致的inf和nan都转换为'-'
        chart = echarts_stackbar(df=df_abs,
                                 df_gr=df_gr
                                 )  # 调用stackbar方法生成Pyecharts图表对象
        return chart.dump_options()  # 用json格式返回Pyecharts图表对象的全局设置
    else:
        return None

from pyecharts.charts import Line, Bar
from pyecharts import options as opts


def echarts_stackbar(df,  # 传入数据df，应该是一个行索引为date的时间序列面板数据
             df_gr=None,  # 传入同比增长率df，可以没有
             datatype='ABS'  # 主Y轴形式是绝对值，增长率还是份额，用来确定一些标签格式，默认为绝对值
             ) -> Bar:

    axislabel_format = '{value}'  # 主Y轴默认格式
    max = df[df>0].sum(axis=1).max()  # 主Y轴默认最大值
    min = df[df<=0].sum(axis=1).min()  # 主Y轴默认最小值
    if datatype in ['SHARE', 'GR']:  # 如果主数据不是绝对值形式而是份额或增长率如何处理
        df = df.multiply(100).round(2)
        axislabel_format = '{value}%'
        max = 100
        min = 0
    if df_gr is not None:
        df_gr = df_gr.multiply(100).round(2) # 如果有同比增长率，原始数*100呈现

    if df.empty is False:
        stackbar = (
            Bar()
            .add_xaxis(df.index.tolist())
        )
        for i, item in enumerate(df.columns): # 预留的枚举，这个方法以后可以根据输入对象不同从单一柱状图变成堆积柱状图
            stackbar.add_yaxis(item,
                          df[item].values.tolist(),
                          stack='总量',
                          label_opts=opts.LabelOpts(is_show=False),
                          z_level=1,  # 指定渲染图层，低版本pyecharts可能因为没有该参数报错
                          )
        if df_gr is not None:  # 如果有同比增长率数据则加入次Y轴
            stackbar.extend_axis(
                yaxis=opts.AxisOpts(
                    name="同比增长率",
                    type_="value",
                    axislabel_opts=opts.LabelOpts(formatter="{value}%"),
                )
            )
        stackbar.set_global_opts(
            legend_opts=opts.LegendOpts(pos_top='5%', pos_left='10%', pos_right='60%'),
            toolbox_opts=opts.ToolboxOpts(is_show=True),
            tooltip_opts=opts.TooltipOpts(trigger='axis',
                                          axis_pointer_type='cross',
                                          ),
            xaxis_opts=opts.AxisOpts(type_='category',
                                     boundary_gap=True,
                                     axislabel_opts=opts.LabelOpts(rotate=90), # x轴标签方向rotate有时能解决拥挤显示不全的问题
                                     splitline_opts=opts.SplitLineOpts(is_show=False,
                                                                       linestyle_opts=opts.LineStyleOpts(
                                                                           type_='dotted',
                                                                           opacity=0.5,
                                                                       )
                                                                       )
                                     ),
            yaxis_opts=opts.AxisOpts(max_=max,
                                     min_=min,
                                     type_="value",
                                     axislabel_opts=opts.LabelOpts(formatter=axislabel_format),
                                     # axistick_opts=opts.AxisTickOpts(is_show=True),
                                     splitline_opts=opts.SplitLineOpts(is_show=True,
                                                                       linestyle_opts=opts.LineStyleOpts(
                                                                           type_='dotted',
                                                                           opacity=0.5,
                                                                       )
                                                                       )
                                     ),
        )
        if df_gr is not None:
            line = (
                Line()
                    .add_xaxis(xaxis_data=df_gr.index.tolist())
                    .add_yaxis(
                    series_name="同比增长率",
                    yaxis_index=1,
                    y_axis=df_gr.values.tolist(),
                    label_opts=opts.LabelOpts(is_show=False),
                    linestyle_opts=opts.LineStyleOpts(width=3),
                    symbol_size=8,
                    itemstyle_opts=opts.ItemStyleOpts(border_width=1, border_color='', border_color0='white'),
                    z_level=2  # 渲染图层大于柱状图，保证线图在上方，低版本pyecharts可能因为没有该参数报错
               )
            )
    else:
        stackbar = (Bar())

    if df_gr is not None:
        return stackbar.overlap(line) # 如果有次坐标轴最后要用overlap方法组合
    else:
        return stackbar

def query(request):
    ...

    # Pyecharts交互图表
    bar_total_trend = json.loads(prepare_chart(pivoted, 'bar_total_trend', form_dict))

    context = {
        ...
        'bar_total_trend': bar_total_trend
    }

    return HttpResponse(json.dumps(context, ensure_ascii=False), content_type="application/json charset=utf-8") # 返回结果必须是json格式

def query(request):
    ...
    table = table.to_html(formatters=build_formatters_by_col(table),  # 逐列调整表格内数字格式
                          classes='ui selectable celled table',  # 指定表格css class为Semantic UI主题
                          table_id='ptable'  # 指定表格id
                          )
    ...

from django import template

register = template.Library()

@register.filter(name='percentage')
def percentage(value, decimal):
    try:
        format_str = '{0:.'+ str(decimal) + '%}'
        return format_str.format(value)
    except:
        return value

def kpi(df):
    ...
        
    return [market_size, "{0:.1%}".format(market_gr), "{0:.1%}".format(market_cagr)]

def query(request):
    ...
    table = ptable(pivoted)
    table = table.to_html(formatters=build_formatters_by_col(table))

    context = {
        ...
        'ptable': table,
    }
    ...


def build_formatters_by_col(df):
     format_abs = lambda x: '{:,.0f}'.format(x)
     format_share = lambda x: '{:.1%}'.format(x)
     format_gr = lambda x: '{:.1%}'.format(x)
     format_currency = lambda x: '¥{:,.0f}'.format(x)
     d = {}
     for column in df.columns:
          if '份额' in column or '贡献' in column:
               d[column] = format_share
          elif '价格' in column or '单价' in column:
               d[column] = format_currency
          elif '同比增长' in column or '增长率' in column or 'CAGR' in column or '同比变化' in column:
               d[column] = format_gr
          else:
               d[column] = format_abs
     return d

urlpatterns = [
    ...
    path(r'search/<str:column>/<str:kw>', views.search, name='search')
]

urlpatterns = [
    ...
    path(r'query', views.query, name='query'),
]

try:
    import six  # for modern Django
except ImportError:
    from django.utils import six  # for legacy Django


def query(request):
    ...
    form_dict = dict(six.iterlists(request.GET))
    ...

def sqlparse(context):
    print(context)
    sql = "Select * from %s Where PERIOD = '%s' And UNIT = '%s'" % \
          (DB_TABLE, context['PERIOD_select'][0], context['UNIT_select'][0])  # 先处理单选部分

    # 下面循环处理多选部分
    for k, v in context.items():
        if k not in ['csrfmiddlewaretoken', 'DIMENSION_select', 'PERIOD_select', 'UNIT_select']:
            field_name = k[:-9]  # 字段名
            selected = v  # 选择项
            sql = sql_extent(sql, field_name, selected)  #未来可以通过进一步拼接字符串动态扩展sql语句
    return sql


def sql_extent(sql, field_name, selected, operator=" AND "):
    if selected is not None:
        statement = ''
        for data in selected:
            statement = statement + "'" + data + "', "
        statement = statement[:-2]
        if statement != '':
            sql = sql + operator + field_name + " in (" + statement + ")"
    return sql

def query(request):
    form_dict = dict(six.iterlists(request.GET))
    sql = sqlparse(form_dict)  # sql拼接
    print(sql)
    df = pd.read_sql_query(sql, ENGINE)  # 将sql语句结果读取至Pandas Dataframe

    dimension_selected = form_dict['DIMENSION_select'][0]
    #  如果字段名有空格为了SQL语句在预设字典中加了中括号的，这里要去除
    if dimension_selected[0] == '[':

        column = dimension_selected[1:][:-1]
    else:
        column = dimension_selected
    pivoted = pd.pivot_table(df,
                             values='AMOUNT',  # 数据透视汇总值为AMOUNT字段，一般保持不变
                             index='DATE',  # 数据透视行为DATE字段，一般保持不变
                             columns=column,  # 数据透视列为前端选择的分析维度
                             aggfunc=np.sum)  # 数据透视汇总方式为求和，一般保持不变
    if pivoted.empty is False:
        pivoted.sort_values(by=pivoted.index[-1], axis=1, ascending=False, inplace=True)  # 结果按照最后一个DATE表现排序

    # KPI
    kpi = get_kpi(pivoted)

    context = {
        "market_size": kpi["market_size"],
        "market_gr": kpi["market_gr"],
        "market_cagr": kpi["market_cagr"],
        'ptable': ptable(pivoted).to_html()
    }

    return HttpResponse(json.dumps(context, ensure_ascii=False), content_type="application/json charset=utf-8") # 返回结果必须是json格式

def index(request):
    mselect_dict = {}
    for key, value in D_MULTI_SELECT.items():
        mselect_dict[key] = {}
        mselect_dict[key]['select'] = value

    context = {
        'mselect_dict': mselect_dict
    }
    return render(request, 'chpa_data/display.html', context)

# 该字典key为前端准备显示的所有多选字段名, value为数据库对应的字段名
D_MULTI_SELECT = {
    'TC I': '[TC I]',
    'TC II': '[TC II]',
    'TC III': '[TC III]',
    'TC IV': '[TC IV]',
    '通用名|MOLECULE': 'MOLECULE',
    '商品名|PRODUCT': 'PRODUCT',
    '包装|PACKAGE': 'PACKAGE',
    '生产企业|CORPORATION': 'CORPORATION',
    '企业类型': 'MANUF_TYPE',
    '剂型': 'FORMULATION',
    '剂量': 'STRENGTH'
}


def index(request):
    
    ...

    mselect_dict = {}
    for key, value in D_MULTI_SELECT.items():
        mselect_dict[key] = {}
        mselect_dict[key]['select'] = value
        # mselect_dict[key]['options'] = option_list 以后可以后端通过列表为每个多选控件传递备选项
    
    context = {
       ...
       'mselect_dict': mselect_dict
    }
    return render(request, 'chpa_data/analysis.html', context) # 注意本句和前一章也有变化，渲染至analysis.html而不是display.html

def index(request):
    
    ...

    mselect_dict = {}
    for key, value in D_FIELD.items():
        mselect_dict[key] = {}
        mselect_dict[key]['select'] = value
        mselect_dict[key]['options'] = option_list # option_list可以通过sql Distinct语句或Pandas的Unique方法获得，在此不再赘述
    
    ...

# 下面是一个获得各个字段option_list的简单方法
def get_distinct_list(column, db_table):
    sql = "Select DISTINCT " + column + " From " + db_table
    df = pd.read_sql_query(sql, ENGINE)
    l = df.values.flatten().tolist()
    return l

import json

def search(request, column, kw):
    sql = "SELECT DISTINCT TOP 10 %s FROM %s WHERE %s like '%%%s%%'" % (column, DB_TABLE, column, kw) # 最简单的单一字符串like，返回不重复的前10个结果
    try:
        df = pd.read_sql_query(sql, ENGINE)
        l = df.values.flatten().tolist()
        results_list = []
        for element in l:
            option_dict = {'name': element,
                           'value': element,
                           }
            results_list.append(option_dict)
        res = {
            "success": True,
            "results": results_list,
            "code": 200,
        }
    except Exception as e:
        res = {
            "success": False,
            "errMsg": e,
            "code": 0,
        }
    return HttpResponse(json.dumps(res, ensure_ascii=False), content_type="application/json charset=utf-8") # 返回结果必须是json格式

urlpatterns = [
    ...
    path(r'search/<str:column>/<str:kw>', views.search, name='search')
]