Working with Data, Charts, and Caching in Streamlit

Streamlit’s primary use case is turning data workflows into interactive apps, which means integrating tightly with Pandas, NumPy, and Matplotlib is central to almost everything you’ll build. This chapter shows you how to load data efficiently with caching, display and filter DataFrames, perform quick NumPy calculations, and render charts — all inside a Streamlit app. By the end you’ll have the core patterns needed to build fully interactive data exploration tools.

Loading CSV Data

The standard approach is to read your CSV with Pandas inside a cached function. The @st.cache_data decorator tells Streamlit to run the function only once, then store the result in memory. On subsequent reruns (triggered by widget interactions), Streamlit returns the cached DataFrame instantly instead of re-reading the file.

import streamlit as st
import pandas as pd

@st.cache_data
def load_data():
    return pd.read_csv("data/sales.csv")

sales = load_data()
st.dataframe(sales.head())

Without caching, every widget interaction would re-read and re-parse your CSV from disk — noticeably slow for large files.

Handling Uploaded Files

When you want users to bring their own data, combine st.file_uploader with pd.read_csv:

import streamlit as st
import pandas as pd

uploaded = st.file_uploader("Upload a CSV file", type="csv")

if uploaded is not None:
    df = pd.read_csv(uploaded)
    st.success(f"Loaded {len(df):,} rows and {len(df.columns)} columns.")
    st.dataframe(df)
else:
    st.info("Please upload a CSV file to get started.")

Displaying DataFrames

import streamlit as st
import pandas as pd

monthly = pd.DataFrame({
    "Month": ["January", "February", "March", "April"],
    "Sales": [120_000, 180_000, 150_000, 220_000],
    "Region": ["North", "South", "North", "East"]
})

st.subheader("Monthly Sales Overview")
st.dataframe(monthly)               # Interactive — sortable, scrollable
st.table(monthly[["Month", "Sales"]])  # Static display

Filtering DataFrames with Widgets

Combining Pandas filters with Streamlit widgets is the heart of interactive data apps. User selections from widgets become filter conditions on your DataFrame:

import streamlit as st
import pandas as pd

products = pd.DataFrame({
    "Product": ["Phone", "Laptop", "Headphones", "Tablet"],
    "Region":  ["North", "South", "North", "East"],
    "Sales":   [100_000, 200_000, 50_000, 80_000]
})

# Widget inputs
search = st.text_input("Search product name")
region = st.selectbox("Filter by region", ["All", "North", "South", "East"])

# Apply filters
filtered = products[
    products["Product"].str.contains(search, case=False, na=False)
]
if region != "All":
    filtered = filtered[filtered["Region"] == region]

st.dataframe(filtered)
st.caption(f"Showing {len(filtered)} of {len(products)} products")

NumPy Calculations

NumPy integrates naturally into Streamlit. You can display NumPy outputs with st.write() or use them to feed charts:

import streamlit as st
import numpy as np

values = np.array([10, 25, 38, 47, 55, 61, 72, 88])

col1, col2, col3 = st.columns(3)
col1.metric("Sum",  int(values.sum()))
col2.metric("Mean", round(float(values.mean()), 1))
col3.metric("Std",  round(float(values.std()),  1))

st.write("Sorted values:", np.sort(values))

Rendering Matplotlib Charts

Streamlit renders Matplotlib figures with st.pyplot(fig). Always create the figure explicitly using the object-oriented interface (fig, ax = plt.subplots()) to avoid state leakage between reruns.

import streamlit as st
import pandas as pd
import matplotlib.pyplot as plt

sales = pd.DataFrame({
    "Month": ["Jan", "Feb", "Mar", "Apr", "May"],
    "Sales": [120, 180, 150, 220, 195]
})

fig, ax = plt.subplots(figsize=(7, 4))
ax.plot(sales["Month"], sales["Sales"], marker="o", color="#3B82F6", linewidth=2)
ax.set_title("Monthly Sales Trend")
ax.set_xlabel("Month")
ax.set_ylabel("Sales (₹ thousands)")
ax.grid(True, alpha=0.3)

st.pyplot(fig)

Always pass the fig object explicitly to st.pyplot(fig). Calling st.pyplot() without an argument (using the global Matplotlib state) is deprecated and can produce unexpected charts as your app grows.

Interactive Data Exploration Pattern

This pattern combines filtering widgets, a filtered DataFrame display, and a chart into a reusable template:

import streamlit as st
import pandas as pd
import matplotlib.pyplot as plt

@st.cache_data
def load_data():
    return pd.DataFrame({
        "Product":   ["Phone", "Laptop", "Headphones", "Tablet", "Monitor"],
        "Sales":     [100, 200, 50, 80, 150],
        "Rating":    [4, 5, 3, 4, 5],
        "Department": ["Electronics"] * 5
    })

df = load_data()

st.title("Product Performance")

# Filters
min_rating = st.slider("Minimum rating", 1, 5, 3)
show_chart = st.checkbox("Show bar chart", value=True)

# Filter data
filtered = df[df["Rating"] >= min_rating]
st.dataframe(filtered)

# Chart
if show_chart:
    fig, ax = plt.subplots()
    ax.bar(filtered["Product"], filtered["Sales"], color="#10B981")
    ax.set_ylabel("Sales")
    ax.set_title("Sales by Product")
    plt.xticks(rotation=30)
    plt.tight_layout()
    st.pyplot(fig)

Structure your data apps so that expensive operations (file reading, API calls, database queries) happen inside @st.cache_data functions. Everything that depends on widget values belongs in the main script body where it can react to user input.

SQL & Databases

Data Analysis

FastAPI

Frontend

Working with Data, Charts, and Caching in Streamlit

Loading CSV Data

Handling Uploaded Files

Displaying DataFrames

Filtering DataFrames with Widgets

NumPy Calculations

Rendering Matplotlib Charts

Interactive Data Exploration Pattern

​Loading CSV Data

​Handling Uploaded Files

​Displaying DataFrames

​Filtering DataFrames with Widgets

​NumPy Calculations

​Rendering Matplotlib Charts

​Interactive Data Exploration Pattern

Loading CSV Data

Handling Uploaded Files

Displaying DataFrames

Filtering DataFrames with Widgets

NumPy Calculations

Rendering Matplotlib Charts

Interactive Data Exploration Pattern