Streamlit新手避坑指南：5分钟搞定你的第一个数据可视化Dashboard

如果你是一名数据分析师、机器学习工程师，或者只是对数据可视化感兴趣的Python爱好者，可能都曾有过这样的念头：能不能用最简单的方式，把我的数据分析结果变成一个可以交互的Web应用？以前这可能需要学习HTML、CSS、JavaScript，甚至还要懂一些Flask或Django框架，但现在，有了Streamlit，这一切变得前所未有的简单。

Streamlit是一个专门为数据科学和机器学习设计的Python框架，它最大的魅力在于，你不需要任何前端开发经验，就能用纯Python代码构建出功能完整、界面美观的Web应用。想象一下，你刚刚完成了一个数据分析项目，通常的做法可能是生成一堆静态图表，然后通过邮件或PPT分享给同事。但有了Streamlit，你可以直接把分析过程变成一个交互式应用，让其他人能够实时调整参数、探索数据，这种体验的转变是革命性的。

不过，对于第一次接触Streamlit的新手来说，虽然入门门槛很低，但在实际搭建应用的过程中，还是会遇到一些“坑”。比如环境配置的小细节、缓存机制的理解偏差、地图渲染的性能问题等等。这些看似不大的问题，却可能让你在关键时刻卡壳，影响开发体验。今天，我就结合一个实际的Uber乘车数据案例，带你避开这些常见陷阱，在5分钟内搭建出你的第一个数据可视化Dashboard。

1. 环境配置与项目初始化：避开第一个“坑”

很多教程会告诉你“一行命令安装Streamlit”，这没错，但实际操作中，环境配置往往是最容易出问题的地方。特别是当你已经有一个复杂的Python环境时，直接安装可能会导致依赖冲突。

1.1 创建独立的虚拟环境

我强烈建议为每个Streamlit项目创建独立的虚拟环境。这不仅避免了依赖冲突，也方便后续的部署和管理。

# 创建新的虚拟环境
python -m venv streamlit-env

# 激活虚拟环境
# Windows
streamlit-env\Scripts\activate
# macOS/Linux
source streamlit-env/bin/activate

创建好虚拟环境后，再安装Streamlit：

pip install streamlit pandas numpy

这里有个小技巧：如果你在安装过程中遇到网络问题，可以尝试使用国内的镜像源：

pip install streamlit pandas numpy -i https://pypi.tuna.tsinghua.edu.cn/simple

1.2 验证安装与快速测试

安装完成后，不要急着开始写代码。先运行Streamlit自带的示例应用，确保一切正常：

streamlit hello

这个命令会启动一个本地服务器，并在浏览器中打开一个包含多个示例应用的页面。如果能看到这个页面，说明安装成功。如果遇到端口冲突（默认是8501端口），可以指定其他端口：

streamlit hello --server.port=8502

注意：第一次运行streamlit hello时，可能会提示你设置电子邮件用于错误报告。这不是必须的，可以直接按回车跳过。

1.3 项目结构规划

在开始编码前，花一分钟规划一下项目结构。一个良好的结构会让后续开发更顺畅：

uber-dashboard/
├── app.py              # 主应用文件
├── requirements.txt    # 依赖列表
├── data/              # 数据目录（可选）
├── utils/             # 工具函数（可选）
└── README.md          # 项目说明

创建requirements.txt文件，记录项目依赖：

streamlit>=1.28.0
pandas>=2.0.0
numpy>=1.24.0

这样，其他人要运行你的应用时，只需要pip install -r requirements.txt即可。

2. 数据加载与缓存机制：性能优化的关键

数据加载是Streamlit应用中最常见的性能瓶颈。特别是处理大型数据集时，如果不做优化，每次用户交互都会重新加载数据，体验会非常糟糕。

2.1 理解Streamlit的执行模型

在深入缓存之前，你需要理解Streamlit的一个核心特性：脚本从上到下重新执行。每次用户与界面交互（比如点击按钮、调整滑块），整个脚本都会重新运行。这意味着，如果没有缓存，数据加载函数每次都会被调用。

让我们先看看一个典型的“有问题”的数据加载方式：

import streamlit as st
import pandas as pd
import numpy as np

# 每次交互都会重新执行这个函数
def load_data():
    # 模拟从网络加载大数据集
    data_url = 'https://s3-us-west-2.amazonaws.com/streamlit-demo-data/uber-raw-data-sep14.csv.gz'
    data = pd.read_csv(data_url, nrows=10000)
    data['date/time'] = pd.to_datetime(data['date/time'])
    return data

st.title('Uber乘车数据分析')
data = load_data()  # 每次页面刷新都会调用
st.write(f"数据加载完成，共{len(data)}条记录")

这种写法的问题很明显：每次用户操作都会重新下载和解析数据，即使数据根本没有变化。

2.2 正确使用缓存装饰器

Streamlit提供了@st.cache_data装饰器来解决这个问题。它会缓存函数的返回值，只有当输入参数或函数代码发生变化时，才会重新执行函数。

import streamlit as st
import pandas as pd
import numpy as np

# 使用缓存装饰器
@st.cache_data
def load_data(nrows=10000):
    """加载Uber乘车数据，使用缓存提高性能"""
    data_url = 'https://s3-us-west-2.amazonaws.com/streamlit-demo-data/uber-raw-data-sep14.csv.gz'
    
    # 显示加载状态
    with st.spinner('正在加载数据...'):
        data = pd.read_csv(data_url, nrows=nrows, compression='gzip')
        
        # 标准化列名
        data.columns = [col.lower().replace(' ', '_') for col in data.columns]
        
        # 转换日期时间
        if 'date/time' in data.columns:
            data['date/time'] = pd.to_datetime(data['date/time'])
    
    st.success(f'成功加载 {len(data)} 条记录')
    return data

# 主应用逻辑
st.title('🚖 Uber纽约市乘车数据可视化')

# 添加数据量选择器
sample_size = st.slider('选择数据样本量', 1000, 50000, 10000, step=1000)

# 加载数据 - 由于缓存，相同参数下不会重复加载
data = load_data(sample_size)

# 显示数据预览
if st.checkbox('显示原始数据'):
    st.subheader('数据预览')
    st.dataframe(data.head(100))

这里有几个关键点需要注意：

  1. 缓存是基于函数签名和参数的：如果load_data函数的参数nrows发生变化，缓存会失效并重新加载。
  2. 缓存只对返回的值有效：函数内部的st.spinner和st.success只在第一次执行时显示。
  3. 避免在缓存函数中使用Streamlit组件：缓存函数应该是纯函数，不包含UI操作。

2.3 缓存的高级用法

对于更复杂的场景，你可能需要更细粒度的缓存控制：

import streamlit as st
import pandas as pd
from datetime import datetime

# 带TTL（生存时间）的缓存
@st.cache_data(ttl=3600)  # 缓存1小时
def load_data_from_api(api_url, params=None):
    """从API加载数据，缓存1小时"""
    # 模拟API调用
    import time
    time.sleep(2)  # 模拟网络延迟
    return pd.DataFrame({'data': [1, 2, 3]})

# 显示缓存信息
st.write(f"当前时间: {datetime.now().strftime('%H:%M:%S')}")
api_data = load_data_from_api('https://api.example.com/data')
st.write(api_data)

ttl参数指定了缓存的生存时间（秒），适合那些会定期更新的数据源。

3. 交互式组件与数据过滤：构建动态Dashboard

Streamlit的真正威力在于其丰富的交互组件。通过这些组件，你可以让用户动态地探索数据，而不是被动地查看静态图表。

3.1 基础交互组件

让我们从最常用的几个组件开始：

import streamlit as st
import pandas as pd
import numpy as np

# 假设data是之前加载的Uber数据
data = load_data(10000)

st.header('📊 数据探索与过滤')

# 1. 滑块 - 选择时间范围
st.subheader('按小时过滤数据')
hour_range = st.slider(
    '选择小时范围',
    min_value=0,
    max_value=23,
    value=(8, 18),  # 默认选择8点到18点
    step=1
)

# 应用时间过滤
filtered_by_hour = data[
    (data['date/time'].dt.hour >= hour_range[0]) & 
    (data['date/time'].dt.hour <= hour_range[1])
]

st.write(f"筛选结果: {len(filtered_by_hour)} 条记录 (原始数据: {len(data)} 条)")

# 2. 多选框 - 选择要显示的列
st.subheader('选择显示的数据列')
available_columns = data.columns.tolist()
selected_columns = st.multiselect(
    '选择要显示的列',
    options=available_columns,
    default=['date/time', 'lat', 'lon']  # 默认选中的列
)

if selected_columns:
    st.dataframe(filtered_by_hour[selected_columns].head(20))

# 3. 单选框 - 选择图表类型
st.subheader('选择可视化方式')
chart_type = st.radio(
    "选择图表类型",
    ["柱状图", "折线图", "面积图"],
    horizontal=True  # 水平排列
)

# 4. 数字输入 - 调整图表参数
st.subheader('图表参数设置')
num_bins = st.number_input(
    '直方图分组数量',
    min_value=5,
    max_value=50,
    value=24,
    step=1
)

# 5. 按钮 - 触发特定操作
if st.button('🔄 重置所有筛选'):
    st.rerun()  # 重新运行应用

3.2 高级过滤：使用会话状态

当过滤条件变得复杂时，你可能需要保存用户的选择状态。这时可以使用Streamlit的会话状态（Session State）：

import streamlit as st

# 初始化会话状态
if 'filters' not in st.session_state:
    st.session_state.filters = {
        'hour_range': (0, 23),
        'selected_columns': ['date/time', 'lat', 'lon'],
        'chart_type': '柱状图'
    }

st.header('🎛️ 高级过滤面板')

# 使用会话状态保存的默认值
hour_range = st.slider(
    '选择小时范围',
    min_value=0,
    max_value=23,
    value=st.session_state.filters['hour_range'],
    step=1,
    key='hour_slider'  # 为组件指定key，自动更新会话状态
)

# 手动更新会话状态
if st.button('保存当前筛选条件'):
    st.session_state.filters['hour_range'] = hour_range
    st.success('筛选条件已保存！')

# 显示当前保存的筛选条件
with st.expander('查看已保存的筛选条件'):
    st.json(st.session_state.filters)

会话状态是Streamlit中非常重要的概念，它允许你在多次重新运行之间保持数据。这对于构建复杂的多步骤表单、向导式界面特别有用。

3.3 表单：批量提交交互

当有多个输入组件，并且希望用户一次性提交所有选择时，可以使用表单：

import streamlit as st

st.header('📝 批量数据过滤')

with st.form("filter_form"):
    # 表单内的组件
    date_filter = st.date_input(
        "选择日期范围",
        value=(pd.Timestamp('2014-09-01'), pd.Timestamp('2014-09-30'))
    )
    
    location_filter = st.selectbox(
        "选择区域",
        ["曼哈顿", "布鲁克林", "皇后区", "全部"]
    )
    
    min_trips = st.slider("最小行程数", 1, 100, 10)
    
    # 表单提交按钮
    submitted = st.form_submit_button("应用筛选")
    
    if submitted:
        st.write(f"日期范围: {date_filter}")
        st.write(f"区域: {location_filter}")
        st.write(f"最小行程数: {min_trips}")
        # 这里可以执行实际的过滤逻辑

使用表单的好处是，只有当用户点击提交按钮时，才会触发应用的重新运行。这对于有多个输入的场景，可以避免频繁的重新计算。

4. 数据可视化与地图渲染：性能优化技巧

数据可视化是Dashboard的核心，但不当的使用方式可能导致性能问题，特别是当地图包含大量数据点时。

4.1 基础图表组件

Streamlit内置了多种图表组件，使用起来非常简单：

import streamlit as st
import pandas as pd
import numpy as np
import altair as alt

# 生成示例数据
@st.cache_data
def generate_chart_data():
    np.random.seed(42)
    dates = pd.date_range('2024-01-01', periods=100, freq='D')
    return pd.DataFrame({
        'date': dates,
        'value': np.random.randn(100).cumsum() + 50,
        'category': np.random.choice(['A', 'B', 'C'], 100)
    })

chart_data = generate_chart_data()

st.header('📈 多种可视化方式对比')

# 1. Streamlit原生图表（简单快速）
st.subheader('Streamlit原生图表')
col1, col2 = st.columns(2)

with col1:
    st.line_chart(chart_data.set_index('date')['value'])

with col2:
    # 对分类数据做透视
    pivot_data = chart_data.pivot_table(
        index='date', 
        columns='category', 
        values='value',
        aggfunc='mean'
    ).fillna(0)
    st.area_chart(pivot_data)

# 2. Altair图表（更灵活）
st.subheader('Altair交互式图表')
if st.checkbox('显示Altair高级图表'):
    brush = alt.selection_interval(encodings=['x'])
    
    base = alt.Chart(chart_data).mark_line().encode(
        x='date:T',
        y='value:Q',
        color='category:N',
        tooltip=['date', 'value', 'category']
    ).properties(
        width=600,
        height=300
    )
    
    upper = base.encode(
        alt.X('date:T').scale(domain=brush)
    )
    
    lower = base.properties(
        height=60
    ).add_params(brush)
    
    chart = alt.vconcat(upper, lower)
    st.altair_chart(chart, use_container_width=True)

4.2 地图渲染的性能优化

地图渲染是Streamlit应用中最消耗资源的操作之一。当数据点过多时，页面可能会变得非常卡顿。

错误做法（直接渲染所有点）：

# 不推荐：数据量太大时会导致性能问题
st.map(data[['lat', 'lon']])

优化方案1：数据采样

import streamlit as st

st.header('🗺️ 优化后的地图显示')

# 添加采样率控制
sample_rate = st.slider('地图点采样率 (%)', 1, 100, 10, 
                       help="降低采样率可以提高地图渲染性能")

if sample_rate < 100:
    # 随机采样
    sampled_data = data.sample(frac=sample_rate/100, random_state=42)
    st.write(f"显示 {len(sampled_data)} 个点 (采样率: {sample_rate}%)")
else:
    sampled_data = data
    st.write(f"显示所有 {len(data)} 个点")

# 显示地图
st.map(sampled_data[['lat', 'lon']].dropna())

优化方案2：按区域聚合

import streamlit as st
import numpy as np

st.subheader('按区域聚合显示')

# 创建网格聚合
def aggregate_by_grid(data, grid_size=0.01):
    """将数据按网格聚合，减少显示点数"""
    data = data.copy()
    
    # 创建网格ID
    data['grid_lat'] = (data['lat'] // grid_size) * grid_size
    data['grid_lon'] = (data['lon'] // grid_size) * grid_size
    
    # 按网格聚合
    aggregated = data.groupby(['grid_lat', 'grid_lon']).agg({
        'lat': 'mean',
        'lon': 'mean',
        'date/time': 'count'  # 计数
    }).rename(columns={'date/time': 'count'}).reset_index()
    
    return aggregated

# 让用户选择网格大小
grid_size = st.select_slider(
    '网格聚合精度',
    options=[0.005, 0.01, 0.02, 0.05, 0.1],
    value=0.01,
    format_func=lambda x: f'{x:.3f}度'
)

aggregated_data = aggregate_by_grid(data, grid_size)

# 使用颜色表示密度
aggregated_data['size'] = np.log1p(aggregated_data['count']) * 2

st.write(f"聚合后显示 {len(aggregated_data)} 个点 (原始: {len(data)} 个)")
st.map(aggregated_data[['lat', 'lon']])

优化方案3：使用PyDeck进行高性能渲染 对于超大规模数据集，可以考虑使用PyDeck（基于deck.gl）：

import streamlit as st
import pydeck as pdk

st.subheader('使用PyDeck渲染大规模数据')

# 创建PyDeck图层
layer = pdk.Layer(
    'ScatterplotLayer',
    data=data[['lat', 'lon']].to_dict('records'),
    get_position=['lon', 'lat'],
    get_color=[255, 140, 0, 160],  # RGBA
    get_radius=50,
    pickable=True,
    auto_highlight=True
)

# 设置视图状态
view_state = pdk.ViewState(
    latitude=data['lat'].mean(),
    longitude=data['lon'].mean(),
    zoom=10,
    pitch=0
)

# 创建地图
r = pdk.Deck(
    layers=[layer],
    initial_view_state=view_state,
    tooltip={
        'html': '<b>经纬度:</b> {lat:.4f}, {lon:.4f}',
        'style': {
            'color': 'white',
            'backgroundColor': 'steelblue',
            'padding': '5px'
        }
    }
)

st.pydeck_chart(r)

4.3 图表缓存与性能监控

对于复杂的图表计算，也可以使用缓存：

import streamlit as st
import plotly.express as px
import time

@st.cache_data
def create_complex_chart(data, chart_type='histogram', **kwargs):
    """创建复杂图表，使用缓存避免重复计算"""
    # 模拟耗时计算
    time.sleep(1)
    
    if chart_type == 'histogram':
        fig = px.histogram(data, x='hour', **kwargs)
    elif chart_type == 'scatter':
        fig = px.scatter(data, x='lon', y='lat', **kwargs)
    else:
        fig = px.line(data, x='date', y='value', **kwargs)
    
    return fig

# 显示性能信息
import datetime
start_time = datetime.datetime.now()

# 创建图表（第一次会慢，后续从缓存读取）
fig = create_complex_chart(
    data.assign(hour=data['date/time'].dt.hour),
    chart_type='histogram',
    nbins=24,
    title='乘车时间分布'
)

end_time = datetime.datetime.now()
st.write(f"图表生成时间: {(end_time - start_time).total_seconds():.2f}秒")

st.plotly_chart(fig, use_container_width=True)

5. 布局优化与部署上线：打造专业级应用

一个优秀的Dashboard不仅功能要强大，界面也要美观易用。Streamlit提供了丰富的布局组件，可以帮助你创建专业的应用界面。

5.1 使用多列布局

import streamlit as st

st.set_page_config(
    page_title="Uber数据分析Dashboard",
    page_icon="🚖",
    layout="wide"  # 使用宽屏布局
)

# 侧边栏 - 用于控制面板
with st.sidebar:
    st.title("⚙️ 控制面板")
    
    # 数据设置
    with st.expander("数据设置", expanded=True):
        sample_size = st.slider("数据量", 1000, 50000, 10000)
        auto_refresh = st.checkbox("自动刷新", value=False)
        if auto_refresh:
            refresh_interval = st.slider("刷新间隔(秒)", 5, 60, 30)
    
    # 可视化设置
    with st.expander("可视化设置"):
        chart_theme = st.selectbox(
            "图表主题",
            ["plotly", "plotly_white", "plotly_dark", "ggplot2", "seaborn"]
        )
        color_scheme = st.color_picker("主色调", "#FF4B4B")
    
    # 其他工具
    with st.expander("工具"):
        if st.button("导出数据"):
            st.success("数据导出功能待实现")
        if st.button("重置所有设置"):
            st.session_state.clear()
            st.rerun()

# 主内容区 - 使用多列布局
st.title("🚖 Uber纽约市乘车数据分析平台")

# 第一行：关键指标
st.subheader("📊 关键指标")
metric_col1, metric_col2, metric_col3, metric_col4 = st.columns(4)

with metric_col1:
    st.metric("总行程数", f"{len(data):,}", "+12%")

with metric_col2:
    avg_hour = data['date/time'].dt.hour.mean()
    st.metric("平均乘车时间", f"{avg_hour:.1f}:00", "-3%")

with metric_col3:
    peak_hour = data['date/time'].dt.hour.mode()[0]
    st.metric("高峰时段", f"{peak_hour}:00", "持平")

with metric_col4:
    unique_days = data['date/time'].dt.date.nunique()
    st.metric("数据天数", unique_days)

# 第二行：图表区
st.subheader("📈 数据分析")
chart_col1, chart_col2 = st.columns(2)

with chart_col1:
    st.write("**时间分布**")
    # 这里放时间分布图表
    
with chart_col2:
    st.write("**地理分布**")
    # 这里放地图

# 第三行：详细数据
st.subheader("📋 详细数据")
with st.expander("查看数据详情", expanded=False):
    st.dataframe(
        data,
        use_container_width=True,
        hide_index=True,
        column_config={
            "date/time": st.column_config.DatetimeColumn(
                "乘车时间",
                format="YYYY-MM-DD HH:mm"
            ),
            "lat": st.column_config.NumberColumn(
                "纬度",
                format="%.4f"
            ),
            "lon": st.column_config.NumberColumn(
                "经度", 
                format="%.4f"
            )
        }
    )

5.2 使用容器和展开器组织内容

对于内容较多的应用，合理使用容器和展开器可以提升用户体验：

import streamlit as st

# 使用容器分组相关功能
with st.container():
    st.subheader("数据质量检查")
    
    col1, col2, col3 = st.columns(3)
    
    with col1:
        missing_values = data.isnull().sum().sum()
        st.metric("缺失值数量", missing_values, 
                 delta_color="inverse" if missing_values > 0 else "normal")
    
    with col2:
        duplicate_rows = data.duplicated().sum()
        st.metric("重复行数", duplicate_rows,
                 delta_color="inverse" if duplicate_rows > 0 else "normal")
    
    with col3:
        date_range = f"{data['date/time'].min().date()} 至 {data['date/time'].max().date()}"
        st.metric("数据时间范围", date_range)

# 使用展开器隐藏详细信息
with st.expander("🔍 查看数据统计详情", expanded=False):
    st.write("**数据概览**")
    st.write(data.describe())
    
    st.write("**数据类型**")
    dtype_info = pd.DataFrame({
        '列名': data.columns,
        '类型': data.dtypes.astype(str),
        '非空值数量': data.count(),
        '唯一值数量': data.nunique()
    })
    st.dataframe(dtype_info, use_container_width=True)

# 标签页布局
tab1, tab2, tab3 = st.tabs(["📊 图表", "🗺️ 地图", "⚙️ 设置"])

with tab1:
    st.write("这里是图表标签页的内容")
    
with tab2:
    st.write("这里是地图标签页的内容")
    
with tab3:
    st.write("这里是设置标签页的内容")

5.3 部署到云端

开发完成后，你可能希望将应用分享给其他人。Streamlit提供了多种部署方式：

方案1：使用Streamlit Community Cloud（最简单）

  1. 将代码推送到GitHub仓库
  2. 访问 share.streamlit.io
  3. 连接GitHub账户，选择仓库和主文件
  4. 点击部署，几分钟后应用就上线了

方案2：使用Docker容器化部署 创建Dockerfile：

FROM python:3.9-slim

WORKDIR /app

# 复制依赖文件
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY . .

# 暴露端口
EXPOSE 8501

# 健康检查
HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health

# 启动命令
ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

创建docker-compose.yml：

version: '3.8'

services:
  streamlit-app:
    build: .
    ports:
      - "8501:8501"
    environment:
      - STREAMLIT_SERVER_MAX_UPLOAD_SIZE=200
    volumes:
      - ./data:/app/data
    restart: unless-stopped

方案3：部署到云平台（以Google Cloud Run为例）

# 安装gcloud CLI并登录
gcloud auth login

# 设置项目
gcloud config set project YOUR_PROJECT_ID

# 启用所需API
gcloud services enable run.googleapis.com cloudbuild.googleapis.com

# 从源代码部署
gcloud run deploy uber-dashboard \
  --source . \
  --platform managed \
  --region us-central1 \
  --allow-unauthenticated \
  --memory 1Gi

部署时需要注意的几个点：

  1. 资源限制：免费版本的Streamlit Community Cloud有资源限制，复杂应用可能需要升级
  2. 环境变量：敏感信息（如API密钥）应该通过环境变量传递
  3. 文件存储：云部署是临时文件系统，需要持久化的数据要使用外部存储
  4. 自定义域名：大多数平台都支持绑定自定义域名

5.4 性能监控与优化

应用上线后，还需要关注性能表现：

import streamlit as st
import time
from datetime import datetime

# 添加性能监控
if st.checkbox("显示性能信息"):
    st.sidebar.subheader("⚡ 性能监控")
    
    # 记录关键操作时间
    if 'load_time' not in st.session_state:
        st.session_state.load_time = 0
    
    # 模拟记录
    st.sidebar.metric("数据加载时间", f"{st.session_state.load_time:.2f}秒")
    st.sidebar.metric("页面渲染时间", f"{time.perf_counter():.2f}秒")
    st.sidebar.metric("内存使用", "~150MB")
    
    # 添加刷新按钮
    if st.sidebar.button("强制刷新缓存"):
        st.cache_data.clear()
        st.success("缓存已清除")
        st.rerun()

在实际项目中，我遇到过地图渲染超过5万点导致页面卡顿的情况，通过实施数据采样和网格聚合，将渲染时间从10秒降低到1秒以内。另一个常见问题是缓存失效，当数据源更新但缓存没有及时刷新时，用户看到的是旧数据。这时可以通过设置合理的ttl参数，或者提供手动刷新按钮来解决。

Streamlit的魅力在于它让数据应用的开发变得如此简单直接。我记得第一次用Streamlit把一个复杂的分析脚本变成交互式应用时，那种"原来可以这么简单"的惊喜感。现在，当团队需要快速验证一个数据想法时，我首先想到的就是用Streamlit搭个原型，往往一两个小时就能做出可用的Demo。

不过也要注意，Streamlit虽然强大，但并不适合所有场景。对于需要复杂前端交互、实时性要求极高、或者访问量巨大的生产级应用，可能还是需要传统的Web开发框架。但对于数据分析、机器学习演示、内部工具开发这些场景，Streamlit绝对是效率神器。

# 数据可视化
Logo
乐奇 Rokid 开放社区

更多推荐

cover

一期一会 | 什么是抬头显示器（HUD）？

avatar 乐奇 Rokid 开放社区
cover

极刻觅镜 | AI眼镜周报｜Rokid四款硬件发布与Android XR工具转稳定版

avatar 乐奇 Rokid 开放社区
cover

极刻觅镜 | AI眼镜日报｜京东智能眼镜西安站活动与千问AI眼镜OTA升级

avatar 乐奇 Rokid 开放社区