Skip to content

Streamlit DataFrame: Mostrar, Estilizar y Optimizar Pandas DataFrames (Actualizado para 2025)

En el mundo de la ciencia de datos, la capacidad de visualizar e interactuar con tus datos es fundamental. Streamlit, una librería de Python, ha revolucionado la forma de crear aplicaciones web ricas en datos con apenas unas líneas de código. Una de las características más potentes de Streamlit es su integración fluida con Pandas DataFrames. En este artículo profundizaremos en el universo de los Streamlit DataFrames, explorando cómo mostrar, estilizar y optimizar tus Pandas DataFrames en una app moderna de Streamlit. Mantendremos un estilo de tutorial fácil de seguir —desde el uso básico hasta consejos avanzados— actualizado para reflejar las capacidades más recientes de Streamlit en 2025.

¿Qué es un Streamlit DataFrame?

Un Streamlit DataFrame se refiere a la visualización de un Pandas DataFrame (u otra estructura tabular) dentro de una app de Streamlit. Es como tomar una tabla estática de un notebook Jupyter y convertirla en un elemento interactivo dentro de una aplicación web. Bajo el capó, Streamlit aprovecha Pandas (y otras estructuras como PyArrow o Polars) para gestionar datos, pero los envuelve en una interfaz amigable para la web. Los Pandas DataFrames son estructuras de datos bidimensionales y etiquetadas que son ubicuas en la ciencia de datos. Streamlit amplía Pandas al proporcionar una plataforma donde los DataFrames pueden mostrarse e interactuarse en tiempo real. En lugar de ver sólo tablas crudas, puedes ordenar columnas, filtrar datos, resaltar valores importantes e incluso permitir que los usuarios editen datos —todo mediante los componentes intuitivos de Streamlit.

Tutorial de Streamlit DataFrame

¿Has oído hablar de esta increíble herramienta de Análisis y Visualización de Datos que puede convertir fácilmente tu Streamlit App en algo parecido a Tableau?

PyGWalker (opens in a new tab) es una librería de Python que te ayuda a incrustar una interfaz alternativa a Tableau en tu propia app de Streamlit sin esfuerzo. Mira este increíble video how to explore data with pygwalker (opens in a new tab) que demuestra los pasos detallados para potenciar tu app de Streamlit con esta poderosa Data Visualization Python Library!


Comenzando con Streamlit DataFrames

Primero, asegúrate de que Streamlit esté instalado. Puedes instalarlo vía pip:

pip install streamlit

Importa Streamlit en tu script de Python, junto con Pandas para el manejo de datos:

import streamlit as st
import pandas as pd

A continuación, crea un DataFrame simple para mostrar. Por ejemplo, usemos un pequeño conjunto de datos de frutas:

data = {
    "Fruit": ["Apple", "Banana", "Cherry", "Date", "Elderberry"],
    "Quantity": [10, 15, 20, 25, 30],
    "Price": [0.5, 0.25, 0.75, 1.0, 2.0]
}
df = pd.DataFrame(data)

Ahora, para mostrar este DataFrame en una app de Streamlit, utiliza la función st.dataframe():

st.dataframe(df)

Cuando ejecutes tu app de Streamlit (streamlit run your_script.py), verás tu DataFrame renderizado como una tabla interactiva. Puedes ordenar la tabla haciendo clic en los encabezados de las columnas y redimensionar la tabla arrastrando su esquina inferior derecha. En versiones modernas de Streamlit, la tabla incluye una barra de herramientas que permite buscar en los datos, copiar al portapapeles e incluso descargar los datos como CSV. Por defecto, st.dataframe ajustará su altura para mostrar hasta 10 filas y permitirá desplazarse dentro de la tabla si hay más. Este ejemplo básico muestra lo fácil que es empezar. A continuación exploraremos cómo personalizar la visualización y manejar conjuntos de datos más grandes.

Mostrar DataFrames en Streamlit

Cómo mostrar un DataFrame como tabla interactiva

Como se mostró arriba, mostrar un DataFrame en Streamlit es tan sencillo como llamar a st.dataframe(df). Sin embargo, hay más que simplemente mostrar la tabla —Streamlit te permite personalizar la apariencia e interactividad del DataFrame. Personalizando tamaño: puedes establecer el tamaño del componente DataFrame para que se ajuste al diseño de tu app. Por ejemplo, para limitar la altura (en píxeles) de la visualización de la tabla:

st.dataframe(df, height=300)

En el código anterior, el DataFrame ocupará un espacio vertical de 300 píxeles (mostrando aproximadamente ~10 filas a la vez). Si el DataFrame tiene más filas, aparecerá una barra de desplazamiento dentro de la tabla para que el usuario pueda navegar por los datos. De forma similar, puedes controlar el ancho. En versiones recientes, st.dataframe acepta un parámetro width (o puedes usar width="stretch" para hacerlo expandir al ancho completo del contenedor). Por ejemplo:

st.dataframe(df, width="stretch", height=300)

Esto estirará la tabla al ancho completo de la columna/contenedor de la app mientras fija la altura. (Nota: El parámetro anterior use_container_width=True está ahora obsoleto en favor de width="stretch" en la API más reciente de Streamlit.) Funciones interactivas: La visualización del DataFrame en Streamlit no es estática; está impulsada por una cuadrícula de datos interactiva. Los usuarios pueden realizar las siguientes acciones directamente en la interfaz de la tabla:

  • Ordenar columnas: clic en un encabezado para ordenar ascendente/descendente.
  • Redimensionar y reordenar columnas: arrastra los bordes de las columnas para cambiar su tamaño, o arrastra encabezados para reordenar o fijar columnas.
  • Ocultar columnas: usa el menú de columna (generalmente un menú de desbordamiento "⋮" en el encabezado) para ocultar/mostrar columnas específicas.
  • Buscar: utiliza el cuadro de búsqueda en la barra de herramientas de la tabla (o presiona Ctrl+F/Cmd+F) para encontrar entradas en todo el DataFrame.
  • Copiar y descargar: selecciona celdas y presiona Ctrl+C/Cmd+C para copiar, o usa el botón de descarga en la barra de herramientas para bajar los datos como CSV.

Todas estas características están disponibles por defecto al usar st.dataframe, lo que lo convierte en una herramienta poderosa para explorar datos.

Resaltar datos y formato condicional

A menudo querrás llamar la atención sobre ciertos valores en el DataFrame. Una forma conveniente de hacerlo es usar Pandas Styler para aplicar formato condicional antes de mostrar el DataFrame. Streamlit soporta renderizar objetos Pandas Styler, lo que significa que puedes usar métodos como highlight_max, highlight_min, background_gradient, etc., y luego pasar el DataFrame estilizado a Streamlit. Por ejemplo, para resaltar el valor máximo en cada columna:

st.dataframe(df.style.highlight_max(axis=0))

En este ejemplo, el valor más alto en cada columna se resaltará (con un estilo de resaltado por defecto). Puedes personalizar el estilo más a fondo o usar diferentes métodos de Styler. Otro ejemplo: aplicar un gradiente de color basado en los valores de cada columna:

st.dataframe(df.style.background_gradient(cmap="Blues"))

Esto coloreará el fondo de las celdas de claro a oscuro según su magnitud, lo que puede ayudar a visualizar la distribución de un vistazo. Streamlit mostrará estos DataFrames estilizados, aunque ten en cuenta que algunas características avanzadas de estilo de Pandas (como gráficos de barras o tooltips en celdas) pueden no ser totalmente compatibles en la tabla de Streamlit. Sin embargo, los estilos más comunes para colores, texto y formato básico funcionarán.

Manejo de DataFrames grandes en Streamlit

Trabajar con DataFrames grandes (miles o incluso millones de filas) puede ser un desafío para cualquier aplicación web. El componente de tabla de Streamlit está diseñado para el rendimiento y puede manejar conjuntos de datos muy grandes usando virtualización eficiente (dibujando solo lo visible) y un canvas HTML bajo el capó. Sin embargo, todavía hay consideraciones prácticas y límites al tratar con datos enormes:

  • Límites del navegador y la red: típicamente los datos completos deben enviarse desde el servidor de Streamlit al navegador. Conjuntos de datos extremadamente grandes pueden alcanzar límites de tamaño de mensajes WebSocket o agotar la memoria del navegador. Por ejemplo, si intentas enviar un DataFrame de un millón de filas, la app podría manejarlo, pero podría ser lenta de transmitir y renderizar en el cliente.
  • Optimizaciones automáticas: Streamlit deshabilitará automáticamente ciertas características para tablas grandes para mantener la respuesta. Por ejemplo, si tu conjunto de datos tiene más de ~150,000 filas, Streamlit desactiva el ordenamiento de columnas para acelerar el renderizado. Las tablas muy grandes pueden no soportar todas las funciones interactivas para evitar problemas de rendimiento.
  • Buenas prácticas para datos grandes:
    • Mostrar subconjuntos de datos: en lugar de volcar un DataFrame enorme en st.dataframe de una vez, considera mostrar un subconjunto filtrado o muestreado. Por ejemplo, puedes permitir que el usuario elija un subconjunto de columnas o un rango de fechas para ver, o simplemente mostrar las primeras N filas con una opción para paginar los datos.
    • Implementar paginación sencilla: puedes crear manualmente un mecanismo de paginación. Una forma es usar un slider o un número de entrada para el índice de página y cortar el DataFrame en consecuencia:
page_size = 100  # rows per page
total_rows = len(df)
total_pages = (total_rows - 1) // page_size + 1
 
page = st.number_input("Page", min_value=1, max_value=total_pages, value=1)
start_idx = (page - 1) * page_size
end_idx = start_idx + page_size
st.write(f"Showing rows {start_idx} to {min(end_idx, total_rows)}")
st.dataframe(df.iloc[start_idx:end_idx])

En este ejemplo, el usuario puede seleccionar un número de página para ver un fragmento de 100 filas a la vez. Esto evita que la app intente renderizar el DataFrame entero de una vez, mejorando la capacidad de respuesta.

  • Aprovechar dataframes con evaluación perezosa: Streamlit puede mostrar datos de fuentes como PySpark o Snowflake (Snowpark) DataFrames. Estas estructuras solo traen datos según se necesite, lo que significa que si aplicas filtros o límites, el procesamiento puede ocurrir en el backend (por ejemplo, en una base de datos o en Spark) y solo los resultados limitados se envían a Streamlit. Si tu conjunto de datos es extremadamente grande y reside en una base de datos o plataforma de big data, considera consultarlo en fragmentos o usar métodos de evaluación perezosa en lugar de cargar todo en un Pandas DataFrame en memoria.
  • Usar caching para la carga de datos: (Cubriremos el caching con más detalle en una sección posterior, pero en breve: cachea el paso de obtención de datos para no leer repetidamente un conjunto de datos grande en cada rerun de la app.)

Si aplicas estas estrategias, podrás manejar conjuntos de datos grandes de forma más fluida en Streamlit. La clave es evitar saturar el frontend con demasiados datos a la vez y aprovechar las funciones de rendimiento de Streamlit.

Estilizar DataFrames en Streamlit

Mostrar datos es una cosa —hacer que se vean bien y sean legibles es otra. Streamlit ofrece múltiples maneras de estilizar tu DataFrame, desde opciones de formato integradas hasta CSS personalizado (con algunas advertencias). Veamos cómo mejorar la apariencia de tus tablas.

¿Puedo estilizar un DataFrame usando CSS en Streamlit?

Quizás te preguntes si es posible aplicar estilos CSS personalizados (como harías en una página web) al DataFrame en Streamlit. La respuesta corta es sí, pero con precaución. Streamlit permite inyectar HTML/CSS en tu app usando st.markdown con el flag unsafe_allow_html=True. Esto significa que puedes intentar dirigirte a los elementos de la tabla con CSS. Por ejemplo, para cambiar el color de fondo de la tabla:

st.markdown(
    """
    <style>
    table { background-color: #f0f0f0; }
    </style>
    """,
    unsafe_allow_html=True
)
st.dataframe(df)

En este fragmento, insertamos un bloque <style> que establece el fondo de todas las etiquetas HTML <table> a un gris claro antes de llamar a st.dataframe(df). Esto podría afectar el estilo del DataFrame si el renderizado subyacente usa elementos de tabla HTML estándar. Sin embargo, ten en cuenta:

  • Este enfoque no está oficialmente soportado y puede romperse si la implementación interna de Streamlit cambia. De hecho, el st.dataframe moderno se basa en un canvas HTML y no usa una simple tabla HTML para las celdas de datos, por lo que algunos selectores CSS pueden no aplicarse como se espera.
  • Usar unsafe_allow_html=True generalmente se desaconseja salvo para soluciones rápidas, porque puede introducir problemas de seguridad o estabilidad (si aplicas estilos globales por accidente, por ejemplo).

En resumen, aunque puedes usar CSS para ajustes menores (como establecer color de fondo o la fuente), es mejor usar las características de estilo integradas de Streamlit cuando sea posible.

Estilizado de DataFrame con Pandas y column_config

Una forma más robusta de estilizar DataFrames en Streamlit es usar Pandas Styler (como se mostró en la sección anterior con highlight_max y background_gradient) o las opciones de configuración de columnas de Streamlit para el formato. Pandas Styler: puedes aplicar muchas funciones de estilo que proporciona Pandas. Por ejemplo:

  • df.style.format(format_dict) – para formatear números o fechas en cada columna (por ejemplo, mostrar un float como porcentaje o moneda).
  • df.style.applymap(func) – para aplicar una función de estilo elemento por elemento (por ejemplo, colorear valores negativos en rojo).
  • df.style.set_properties(**props) – para establecer propiedades CSS en ciertas celdas (aunque no todas se transferirán a Streamlit).
  • df.style.hide(axis="index") – para ocultar el índice si no es significativo para tu visualización.

Después de estilizar el DataFrame con Pandas, pasas el objeto Styler a st.dataframe() tal como hicimos con highlight_max. Configuración de columnas: Streamlit (a partir de v1.22+) introdujo el parámetro column_config para st.dataframe y st.data_editor que te permite personalizar cómo se muestran las columnas. Esta es una forma pythonica de especificar cosas como:

  • Etiquetas de columna (renombrar columnas para la visualización sin cambiar el DataFrame en sí).
  • Ocultar columnas específicas.
  • Establecer el tipo de visualización de datos (por ejemplo, marcar una columna como Image, Link, Checkbox, Datetime, etc., lo que puede cambiar cómo se renderizan los valores).
  • Formatear números o fechas (similar a Styler pero mediante la API de Streamlit).

Por ejemplo, supongamos que tu DataFrame tiene una columna de precios y quieres mostrarlos como moneda USD y renombrar el encabezado:

import streamlit as st
import pandas as pd
 
df = pd.DataFrame({
    "item": ["A", "B", "C"],
    "price": [1.5, 2.0, 3.25]
})
 
st.dataframe(
    df,
    column_config={
        "price": st.column_config.NumberColumn(
            "Price (USD)",
            format="$%.2f"
        )
    }
)

En este fragmento:

  • Renombramos la columna price a Price (USD) para la visualización.
  • Formateamos los números en esa columna para que tengan un signo de dólar y dos decimales.

Este enfoque produce una tabla bien formateada sin necesidad de CSS personalizado, y funciona con la cuadrícula interactiva de Streamlit. También podríamos ocultar columnas configurando la columna a None, o usar otros tipos de configuración para diferentes datos (como imágenes o booleanos). En resumen, usa Pandas Styler o las configuraciones de columna de Streamlit para estilizar cuando sea posible, ya que son más estables y expresivas para tareas comunes que inyectar CSS crudo.

Optimización de DataFrames en Streamlit

A medida que construyes apps más complejas o trabajas con conjuntos de datos más grandes, el rendimiento se vuelve importante. Esta sección cubre cómo optimizar el uso de DataFrames en Streamlit para velocidad y eficiencia, centrándonos en caching y otras buenas prácticas.

¿Cómo optimizar un Pandas DataFrame en Streamlit?

Optimizar en este contexto significa tanto mejorar el rendimiento de tu app (tiempos de carga, capacidad de respuesta) como optimizar el uso de recursos (por ejemplo, memoria). Aquí tienes algunas estrategias clave:

Usa el caching de Streamlit para la carga y cómputo de datos: una de las formas más sencillas de acelerar tu app es evitar repetir operaciones costosas. Si tienes un dataset grande en CSV o en una base de datos, cargarlo en cada ejecución de la app puede ser lento. Streamlit provee un mecanismo de caching para ayudar con esto. En versiones anteriores se usaba @st.cache; en la versión actual deberías usar @st.cache_data para cachear funciones que retornan datos (como DataFrames). Por ejemplo:

import pandas as pd
import streamlit as st
 
@st.cache_data
def load_data():
    # Imagine this is an expensive operation, e.g., reading a large CSV
    df = pd.read_csv("large_dataset.csv")
    # (You could do additional processing here if needed)
    return df
 
# Use the cached function to load data
df_large = load_data()
st.dataframe(df_large.head(100))  # Display just first 100 rows as an example

Al usar @st.cache_data, la primera ejecución cargará el CSV y almacenará el DataFrame resultante en caché. En ejecuciones posteriores (o cuando los usuarios re-ejecuten la app), siempre que las entradas de la función no hayan cambiado, Streamlit omitirá ejecutar load_data() y obtendrá el DataFrame desde la caché. Esto puede acelerar significativamente apps que necesitan repetidamente los mismos datos.

Optimiza el tamaño y tipos del DataFrame: los DataFrames grandes a veces se optimizan usando tipos de datos adecuados. Por ejemplo, si tienes datos de texto categóricos, convertirlos a tipo Pandas Categorical puede ahorrar memoria. Si tienes columnas que sólo necesitan 0/1 o True/False, usa boolean en lugar de enteros. Los floats que no requieren alta precisión pueden reducirse a float32. Estas optimizaciones de pandas reducen el uso de memoria, lo que indirectamente mejora el rendimiento en Streamlit (especialmente importante al desplegar en servidores con recursos limitados).

Usa formatos de datos eficientes: si controlas la fuente de los datos, usar formatos binarios como Parquet o Arrow puede hacer que la carga sea más rápida que CSV. Streamlit puede leer tablas Arrow directamente y las manejará eficientemente. Esto también se relaciona con el caching —por ejemplo, puedes cachear el resultado de leer un archivo Parquet que ya es más rápido de cargar.

Ahora veamos más de cerca el caching y consejos de rendimiento, ya que el caching es una parte crucial de la optimización.

Caching de Streamlit para DataFrames y consejos de rendimiento

El caching es una herramienta poderosa en Streamlit, pero es importante usarla correctamente. Aquí tienes consejos y buenas prácticas para caching y rendimiento:

Elige el decorador de caché adecuado: usa @st.cache_data para cachear cálculos o consultas de datos (funciones que retornan datos como DataFrames, listas, diccionarios, etc.). Usa @st.cache_resource para cachear recursos singleton (como una conexión a base de datos, un modelo ML u otro objeto que deba inicializarse una vez y reutilizarse). Reemplazar @st.cache por el decorador nuevo y apropiado evitará advertencias de deprecación y ofrecerá mejor rendimiento según el caso de uso.

Los inputs de la función importan: las funciones cacheadas se invalidan según sus argumentos de entrada. Cada vez que llames a una función cacheada con un valor de argumento nuevo, se volverá a ejecutar y almacenará ese resultado. Esto puede ser útil para actualizaciones de datos. Por ejemplo:

@st.cache_data
def load_data(filename):
    return pd.read_csv(filename)
 
file_choice = st.selectbox("Choose a data file", ["data1.csv", "data2.csv"])
df = load_data(file_choice)
st.dataframe(df.head())

En este escenario, si el usuario cambia de "data1.csv" a "data2.csv", load_data se ejecutará de nuevo para el nuevo nombre de archivo y cacheará ese resultado por separado. Volver a "data1.csv" recuperará desde cache. Este comportamiento asegura que tu app maneje múltiples datasets eficientemente sin recomputar innecesariamente.

Evita mutar datos cacheados: un error común es alterar un objeto cacheado in-place. Por ejemplo, si cacheas un DataFrame y luego lo modificas en su lugar, esos cambios persistirán en el objeto cacheado entre ejecuciones, lo que puede dar resultados inesperados. Con st.cache_data, Streamlit ayuda a evitar esto devolviendo una copia fresca de los datos cada vez que llamas a la función (desde caché) para prevenir problemas de mutación. Generalmente no necesitarás usar el antiguo allow_output_mutation=True (que era una opción en st.cache) porque el sistema nuevo lo maneja de manera diferente. Si tienes un caso en el que necesitas cachear un objeto que debe mutarse, considera usar st.cache_resource para ello, pero hazlo con precaución y documenta ese comportamiento.

Limpiar la caché cuando sea necesario: si tus datos se actualizan externamente y necesitas refrescar la caché, puedes añadir un botón para que los usuarios borren manualmente la caché (st.cache_data.clear() por ejemplo) o incorporar un ttl (time-to-live) en la caché o un hash de la versión externa de los datos. Por ejemplo, si sabes que los datos se actualizan diariamente, podrías incluir la fecha actual como parte de la clave de caché o usar @st.cache_data(ttl=86400) para que expire después de un día. Esto asegura que los usuarios no se queden con datos obsoletos.

Limitar el tamaño de renderizado del DataFrame: incluso con caching, renderizar un DataFrame enorme puede ser lento en el navegador. A menudo es prudente limitar cuánto del DataFrame se muestra a la vez. Hablamos de usar el parámetro height o paginación manual arriba. Otra táctica simple es mostrar solo resúmenes o muestras del dataset grande, y proporcionar enlaces de descarga o una vista completa opcional bajo demanda. La app de Streamlit debería enfocarse en lo relevante para el análisis del usuario en un momento dado, en lugar de abrumarlo (y al navegador) con una tabla masiva. Si necesitas mostrar muchos datos, los usuarios siempre pueden usar las funciones de búsqueda y desplazamiento, pero asegúrate de que la app siga siendo receptiva.

Siguiendo estos consejos de caching y rendimiento, asegurarás que tu app de Streamlit se mantenga ágil y eficiente, incluso a medida que crecen tus datos.

Streamlit DataFrame: Casos de uso avanzados

En esta sección, exploremos un par de escenarios avanzados (pero comunes) donde los Streamlit DataFrames juegan un papel crucial: filtrado interactivo de datos e integrar el uso de DataFrames en un flujo de trabajo de machine learning.

Filtrado de Streamlit DataFrame

Filtrar datos es una parte central de la exploración. Los widgets de Streamlit facilitan añadir filtros interactivos a la visualización de tu DataFrame. En lugar de predefinir subconjuntos estáticos, puedes permitir que el usuario elija cómo filtrar el DataFrame. Por ejemplo, supongamos que quieres permitir al usuario filtrar el DataFrame df seleccionando un rango de valores en una de las columnas numéricas. Puedes usar un slider para el rango y un selectbox para escoger la columna a filtrar:

# Assume df is already loaded
column = st.selectbox("Select column to filter", df.columns)
if pd.api.types.is_numeric_dtype(df[column]):
    min_val, max_val = int(df[column].min()), int(df[column].max())
    # Slider to pick a range within [min, max]
    range_values = st.slider(f"Filter {column} between:", min_val, max_val, (min_val, max_val))
    # Filter the dataframe based on slider
    filtered_df = df[(df[column] >= range_values[0]) & (df[column] <= range_values[1])]
else:
    # If non-numeric, maybe use multiselect for categories
    options = st.multiselect(f"Filter values for {column}:", df[column].unique(), default=list(df[column].unique()))
    filtered_df = df[df[column].isin(options)]
 
st.dataframe(filtered_df)

En este ejemplo:

  • Primero permitimos que el usuario elija la columna por la que filtrar.
  • Si la columna escogida es numérica, mostramos un slider de rango desde el mínimo al máximo de la columna, y la selección del usuario nos da una tupla (min_val, max_val). Luego filtramos df a ese rango.
  • Si la columna no es numérica (por ejemplo strings/categorías), usamos un multiselect para que el usuario elija qué valores de esa columna incluir, y filtramos en consecuencia.
  • Finalmente, mostramos el filtered_df.

Este patrón se puede adaptar a muchos escenarios: podrías tener múltiples filtros simultáneos (simplemente añade más widgets y condiciones), o distintos tipos de widgets para distintas columnas (date pickers para columnas de fecha, inputs de texto para búsquedas por contenido, etc.). El resultado es una app donde los usuarios pueden explorar y segmentar el DataFrame al instante y ver la tabla actualizarse con los datos que cumplen sus criterios.

Streamlit DataFrames en apps de Machine Learning

Streamlit no es solo para visualización estática —es excelente para crear demos interactivas de machine learning y dashboards. Los DataFrames suelen aparecer en apps de ML: por ejemplo, para mostrar una vista previa de los datos de entrenamiento, mostrar puntuaciones de importancia de features, o permitir que el usuario suba nuevos datos para obtener predicciones. Consideremos un ejemplo simple: tienes un dataset y quieres permitir que el usuario entrene un modelo (por ejemplo un clasificador) con click de un botón y luego mostrar los resultados. Puedes usar un DataFrame para mostrar los datos y widgets de Streamlit para gestionar la interacción:

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
 
# Display the DataFrame (e.g., training dataset preview)
st.dataframe(df)
 
# Let user trigger model training
if st.button("Train Model"):
    # Assume 'target' is the label column in df
    if 'target' not in df.columns:
        st.error("No target column found in data!")
    else:
        # Split the data
        X = df.drop('target', axis=1)
        y = df['target']
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
        
        # Train a simple RandomForest model
        model = RandomForestClassifier(n_estimators=100, random_state=42)
        model.fit(X_train, y_train)
        
        # Evaluate the model
        preds = model.predict(X_test)
        accuracy = accuracy_score(y_test, preds)
        
        # Display accuracy result
        st.write(f"**Model Accuracy:** {accuracy*100:.2f}%")

Esto es lo que ocurre en este snippet de ML:

  • Mostramos el DataFrame df para que el usuario pueda inspeccionar los datos crudos.
  • Incluimos un botón etiquetado "Train Model". Cuando el usuario lo pulsa, se ejecuta el código dentro del bloque if st.button.
  • Hacemos una comprobación rápida para asegurarnos de que existe una columna target para predecir (la etiqueta).
  • Separamos el DataFrame en features (X) y target (y), y luego en conjuntos de entrenamiento y prueba.
  • Inicializamos un RandomForestClassifier (de scikit-learn) y lo entrenamos con los datos de entrenamiento.
  • Realizamos predicciones sobre el conjunto de prueba y calculamos la accuracy.
  • Finalmente usamos st.write para mostrar la accuracy en la app.

Este ejemplo simple ilustra cómo puedes integrar la visualización de DataFrame con controles interactivos para crear una mini pipeline de machine learning en una app de Streamlit. El usuario podría ajustar hiperparámetros (por ejemplo, número de árboles o la proporción de test mediante sliders), o elegir distintos modelos y ver los resultados al instante. El DataFrame es central aquí como forma de presentar los datos usados para entrenar o los resultados (también podrías mostrar un DataFrame con predicciones o ejemplos mal clasificados, etc.). Con los DataFrames interactivos y los widgets de Streamlit, conviertes un script en una app real donde los usuarios pueden experimentar en tiempo real.

Conclusión

Streamlit ha hecho más fácil que nunca construir apps de datos interactivas, y su integración con Pandas DataFrames pone mucho poder al alcance de tus manos. En este artículo cubrimos cómo mostrar DataFrames en Streamlit, desde el uso básico hasta la personalización avanzada. Vimos cómo estilizar los datos para mejorar la legibilidad, cómo manejar conjuntos de datos grandes de forma eficiente y cómo los DataFrames encajan en casos de uso interactivos como filtrado y machine learning. Con las últimas actualizaciones de Streamlit (a fecha de 2025), st.dataframe es más capaz y eficiente que antes —ofreciendo ordenamiento integrado, búsqueda, descarga y un renderizado en grid ágil que puede manejar volúmenes de datos considerables. También introdujimos st.data_editor para aquellos escenarios donde necesitas que los usuarios editen o contribuyan datos a través de la app. Tanto si eres un científico de datos experimentado como si estás empezando, Streamlit proporciona una plataforma amigable y poderosa para compartir insights. Un DataFrame que en un notebook sería estático puede convertirse en una herramienta de exploración interactiva en una app de Streamlit. A medida que continúes tu viaje, recuerda aprovechar el caching para el rendimiento, pensar en la experiencia del usuario (muestra la porción de datos más relevante, no todo a la vez) y usar las opciones de estilo para que tus datos cuenten una historia clara. Así que adelante —prueba estas técnicas en tu propia app de Streamlit. Convierte tus DataFrames en tablas interactivas, construye un dashboard en torno a ellos o crea la próxima gran app de ciencia de datos. Las posibilidades son infinitas cuando combinas Pandas y Streamlit.

¿Has oído hablar de esta increíble herramienta de Análisis y Visualización de Datos que convierte tu Streamlit App en Tableau?

PyGWalker (opens in a new tab) es una librería de Python que te ayuda a incrustar una interfaz alternativa a Tableau en tu propia app de Streamlit sin esfuerzo.

PyGWalker for Data visualization in Streamlit (opens in a new tab)

Preguntas Frecuentes

¿Cómo puedo estilizar un DataFrame en Streamlit? – Puedes estilizar un DataFrame usando tanto el stylin g de Pandas como las opciones de visualización de Streamlit. Por ejemplo, usa métodos de Pandas Styler como highlight_max o background_gradient para añadir resaltados de color. También puedes aplicar CSS personalizado vía st.markdown (con unsafe_allow_html=True) para ajustar estilos simples (aunque esto es avanzado y con limitaciones). Además, aprovecha column_config en st.dataframe para formatear columnas (por ejemplo, formato numérico, ocultar índice) de manera directa.

¿Cómo puedo filtrar un DataFrame en Streamlit? – Streamlit proporciona widgets interactivos que facilitan el filtrado. Puedes usar dropdowns (st.selectbox o st.multiselect) para filtros categóricos, sliders (st.slider) para rangos numéricos, inputs de texto para búsquedas por texto, etc. En tu código, usa los valores de estos widgets para subestablecer tu DataFrame (por ejemplo, df[df[column] == value] o usando indexación booleana de pandas para rangos). La app se actualizará en tiempo real cuando el usuario ajuste los widgets, mostrando los datos filtrados.

¿Puedo mostrar imágenes dentro de un DataFrame en Streamlit? – Streamlit puede mostrar imágenes, pero no directamente dentro de las celdas de st.dataframe por ahora. Un enfoque común es tener una columna en tu DataFrame con URLs de imágenes o rutas de archivos. En lugar de intentar insertar las imágenes en la tabla, recorrerías el DataFrame y usarías st.image() para cada imagen (o usar st.columns para colocarlas en una cuadrícula). Alternativamente, si tienes URLs de miniaturas, podrías usar la configuración de columna para marcar esa columna como Image (cuando esa característica esté habilitada) y esto podría mostrar imágenes directamente. Pero en general, manejarás imágenes mediante llamadas separadas a Streamlit en lugar de incrustarlas en st.dataframe. Recuerda que cualquier dato de imagen debe ser accesible (ya sea como URL o archivo subido) para que st.image pueda mostrarlo.