Mostrando datos de Pandas por UI en Streamlit

La edición y visualización de DataFrames en Streamlit se basa en la poderosa integración con la librería Pandas. A continuación, se presentan técnicas avanzadas para manipular datos y formas de mostrarlos de manera interactiva, permitiendo a los usuarios explorar y editar la información directamente desde la interfaz de Streamlit.

Para comenzar, cargamos los datos utilizando pandas.read_csv. Supongamos que tenemos los archivos ventas.csv y clientes.csv:

import streamlit as st
import pandas as pd

df_ventas = pd.read_csv("ventas.csv")
df_clientes = pd.read_csv("clientes.csv")

Para facilitar el análisis, es útil permitir al usuario filtrar los datos. A continuación, añadimos un seleccionador de categorías:

categorias = df_ventas['categoria'].unique()
categoria = st.selectbox('Seleccione una categoría', categorias)

df_filtrado = df_ventas[df_ventas['categoria'] == categoria]
st.dataframe(df_filtrado)

Incorporar un slider para filtrar por ventas también mejora la interactividad:

min_ventas = int(df_ventas['ventas'].min())
max_ventas = int(df_ventas['ventas'].max())
rango = st.slider('Rango de ventas', min_ventas, max_ventas, (min_ventas, max_ventas))

df_filtrado = df_filtrado[(df_filtrado['ventas'] >= rango[0]) & (df_filtrado['ventas'] <= rango[1])]
st.dataframe(df_filtrado)

La búsqueda por nombre de tienda proporciona una herramienta adicional para explorar los datos:

tienda = st.text_input('Buscar tienda')

if tienda:
    df_filtrado = df_filtrado[df_filtrado['tienda'].str.contains(tienda, case=False)]
    st.dataframe(df_filtrado)

Pandas proporciona métodos como fillna y dropna para manejar valores nulos. Por ejemplo, para reemplazar valores nulos en la columna ventas con la media:

df_ventas['ventas'].fillna(df_ventas['ventas'].mean(), inplace=True)

La transformación de datos mediante funciones personalizadas es posible con apply. Por ejemplo, podemos categorizar las ventas:

def categorizar_venta(venta):
    if venta < 1000:
        return 'Baja'
    elif venta < 2000:
        return 'Media'
    else:
        return 'Alta'

df_ventas['nivel_venta'] = df_ventas['ventas'].apply(categorizar_venta)
st.dataframe(df_ventas)

Podemos obtener un resumen de ventas por categoría utilizando groupby:

ventas_por_categoria = df_ventas.groupby("categoria")["ventas"].sum()
st.bar_chart(ventas_por_categoria)

Convertimos la columna fecha a tipo datetime y realizamos una reindexación para analizar las ventas mensuales:

copia_ventas_df = df_ventas.copy()
copia_ventas_df["fecha"] = pd.to_datetime(copia_ventas_df["fecha"])
copia_ventas_df.set_index("fecha", inplace=True)
ventas_mensuales = copia_ventas_df["ventas"].resample("M").sum()
st.line_chart(ventas_mensuales)

Para realizar una combinación y unificación de DataFrames podemos utilizar los siguientes métodos merge y concat permitiendo manejar conjuntos de datos complejos y realizar análisis más sofisticados. Si deseamos combinar las ventas con los datos de clientes:

df_combinado = pd.merge(df_ventas, df_clientes, on=['fecha', 'tienda'])
st.dataframe(df_combinado)

Podemos filtrar los datos con query, por ejemplo, para obtener ventas altas en una categoría específica:

ventas_filtradas = df_ventas.query("categoria == 'Electrónica' and nivel_venta == 'Alta'")
st.dataframe(ventas_filtradas)

Podemos establecer un índice compuesto por fecha y tienda para mejorar el manejo de datos jerárquicos:

df_ventas.set_index(['fecha', 'tienda'], inplace=True)
st.dataframe(df_ventas)

Utilizamos st.download_button para que los usuarios puedan descargar los datos filtrados:

csv = df_filtrado.to_csv(index=False)
st.download_button(
    label='Descargar datos filtrados',
    data=csv,
    file_name='datos_filtrados.csv',
    mime='text/csv'
)

La actualización en tiempo real es posible mediante la inclusión de botones que refresquen los datos:

if st.button('Actualizar datos'):
    df_ventas = pd.read_csv('ventas.csv')
    st.success('Datos actualizados')
    st.dataframe(df_ventas)

Podemos resaltar las ventas superiores a 2000 con style.apply:

def highlight_sales(s):
    return ['background-color: yellow' if v > 2000 else '' for v in s]

df_ventas.reset_index(inplace=True)
df_styled = df_ventas.style.apply(highlight_sales, subset=['ventas'])
st.dataframe(df_styled)

Podemos mejorar la presentación de los datos utilizando formato condicional:

df_styled = df_filtrado.style.format({'ventas': '€{0:,.2f}'})
st.dataframe(df_styled)

La combinación de Streamlit y Pandas permite crear interfaces interactivas y dinámicas para visualizar y explorar DataFrames, ofreciendo una experiencia enriquecida al usuario.

Mostrando datos de Numpy por UI en Streamlit

El uso de NumPy en aplicaciones de Streamlit permite realizar cálculos numéricos avanzados de manera eficiente y efectiva. NumPy es fundamental para operaciones matemáticas en Python, ofreciendo funciones y estructuras de datos como arreglos multidimensionales y matrices.

Para comenzar, importamos las librerías necesarias:

import streamlit as st
import numpy as np

Supongamos que necesitamos realizar cálculos estadísticos sobre las ventas de nuestra empresa. Cargamos los datos utilizando Pandas y extraemos la columna de ventas:

import pandas as pd

df_ventas = pd.read_csv('ventas.py')
ventas = df_ventas['ventas'].to_numpy()

Con NumPy, podemos calcular rápidamente el promedio, la mediana y la desviación estándar de las ventas:

promedio_ventas = np.mean(ventas)
mediana_ventas = np.median(ventas)
desviacion_ventas = np.std(ventas)

Mostramos estos resultados en nuestra aplicación Streamlit:

st.write(f"El **promedio** de ventas es: {promedio_ventas:.2f}")
st.write(f"La **mediana** de ventas es: {mediana_ventas:.2f}")
st.write(f"La **desviación estándar** de ventas es: {desviacion_ventas:.2f}")

Para operaciones más complejas, como el cálculo de un histograma de las ventas:

hist, bins = np.histogram(ventas, bins=10)
st.bar_chart(hist)

Podemos incorporar funciones matemáticas avanzadas. Por ejemplo, si deseamos aplicar una transformada de Fourier a los datos:

fft_ventas = np.fft.fft(ventas)
st.line_chart(np.abs(fft_ventas))

El manejo de grandes conjuntos de datos se optimiza gracias a las operaciones vectorizadas de NumPy. Si queremos normalizar las ventas:

ventas_normalizadas = (ventas - promedio_ventas) / desviacion_ventas
st.line_chart(ventas_normalizadas)

Podemos realizar operaciones matriciales para análisis más profundos. Supongamos que tenemos una matriz de correlación:

matriz_corr = np.corrcoef(df_ventas[['ventas', 'fecha_ordinal']].T)
st.write("**Matriz de correlación:**")
st.write(matriz_corr)

Donde hemos convertido las fechas a valores numéricos:

df_ventas['fecha'] = pd.to_datetime(df_ventas['fecha'])
df_ventas['fecha_ordinal'] = df_ventas['fecha'].map(pd.Timestamp.toordinal)

El uso de funciones universales de NumPy permite aplicar operaciones elementales sobre arrays de forma eficiente. Por ejemplo, calcular el logaritmo de las ventas:

log_ventas = np.log(ventas)
st.line_chart(log_ventas)

Si deseamos resolver sistemas de ecuaciones lineales, NumPy ofrece funciones como **np.linalg.solve**. Aunque puede no ser común en análisis de ventas, es útil conocer estas herramientas:

# Ejemplo de sistema de ecuaciones Ax = b
A = np.array([[3, 1], [1, 2]])
b = np.array([9, 8])
x = np.linalg.solve(A, b)
st.write(f"Solución del **sistema de ecuaciones**: x = {x}")

Para simulaciones o generación de datos aleatorios, utilizamos el módulo np.random. Por ejemplo, simulamos ventas futuras basadas en una distribución normal:

ventas_simuladas = np.random.normal(promedio_ventas, desviacion_ventas, 100)
st.line_chart(ventas_simuladas)

La integración con Streamlit permite actualizar los cálculos en tiempo real al interactuar con la interfaz. Añadimos un slider para seleccionar un umbral y filtrar las ventas:

umbral = st.slider('Umbral de ventas', int(ventas.min()), int(ventas.max()), int(promedio_ventas))

ventas_filtradas = ventas[ventas > umbral]
st.write(f"Número de ventas por encima del **umbral**: {ventas_filtradas.size}")

Podemos aplicar funciones personalizadas utilizando np.vectorize. Supongamos que queremos clasificar las ventas:

def clasificar_venta(venta):
    if venta < promedio_ventas:
        return 'Baja'
    else:
        return 'Alta'

clasificar_vectorizado = np.vectorize(clasificar_venta)
clasificacion = clasificar_vectorizado(ventas)

Y mostramos los resultados en un histograma:

unique, counts = np.unique(clasificacion, return_counts=True)
st.bar_chart(dict(zip(unique, counts)))

La capacidad de NumPy para manejar operaciones de broadcasting simplifica cálculos sin necesidad de bucles explícitos. Por ejemplo, ajustar las ventas con un incremento del 10%:

ventas_ajustadas = ventas * 1.10
st.line_chart(ventas_ajustadas)

La utilización de NumPy en aplicaciones de Streamlit potencia el análisis numérico avanzado, proporcionando herramientas eficientes para manipular y calcular sobre grandes conjuntos de datos.