← Volver al BlogTutorial

Python Básico para Streamlit: Lo Que Realmente Necesitas Saber

Abril 2026 · 8 min de lectura

Streamlit es la forma más rápida de crear herramientas financieras interactivas con Python. Pero mucha gente se frena en el paso previo: ¿cuánto Python necesito saber? La respuesta es menos de lo que crees. Estos 10 conceptos cubren el 90% de lo que necesitarás en aplicaciones Streamlit reales.

1. Variables y Tipos de Datos

Python no requiere declarar el tipo de una variable — simplemente asigna un valor y Python infiere el tipo. Los tipos que más usarás en Streamlit son: enteros (int), decimales (float), texto (str) y booleanos (bool).

# Integers and floats
revenue     = 480_000        # int — underscores for readability
growth_rate = 0.12           # float — 12%
margin      = 42.5           # float — percentage

# Strings
company     = "Acme Ltd"
region      = "UK"

# Booleans
is_profitable = True
has_debt      = False

# f-strings — format values into text
label = f"{company}: £{revenue:,} revenue, {margin}% margin"
print(label)
# → Acme Ltd: £480,000 revenue, 42.5% margin

En Streamlit, las variables se recalculan en cada rerun del script. No son permanentes — usa st.session_state para persistir valores entre interacciones.

2. Listas y Diccionarios

Las listas almacenan colecciones ordenadas de valores. Los diccionarios almacenan pares clave-valor. Ambas estructuras aparecen constantemente en Streamlit: para opciones de selectbox, para agrupar datos de configuración y para pasar parámetros a funciones de gráficos.

# Lists — ordered, indexed from 0
regions   = ["UK", "US", "EU", "APAC"]
years     = [2022, 2023, 2024, 2025]
revenues  = [420_000, 480_000, 530_000, 610_000]

# Access by index
first  = regions[0]     # "UK"
last   = regions[-1]    # "APAC"
subset = regions[1:3]   # ["US", "EU"]

# Dictionaries — key:value pairs
company = {
    "name":    "Acme Ltd",
    "revenue": 480_000,
    "margin":  42.5,
    "region":  "UK",
}
print(company["name"])           # "Acme Ltd"
print(company.get("ceo", "N/A")) # "N/A" — safe access with default

# In Streamlit: lists power dropdowns
import streamlit as st
region = st.selectbox("Region", regions)          # list as options
year   = st.selectbox("Year",   years, index=2)   # default = 2024

3. Condicionales (if / elif / else)

La lógica condicional controla qué se muestra y qué se calcula en función de los valores de los widgets. Es el mecanismo principal para crear apps Streamlit dinámicas que reaccionan a las entradas del usuario.

import streamlit as st

revenue = st.number_input("Annual Revenue £", value=500_000)
costs   = st.number_input("Total Costs £",    value=380_000)
profit  = revenue - costs
margin  = profit / revenue * 100 if revenue > 0 else 0

# Conditional display
if margin >= 30:
    st.success(f"Strong margin: {margin:.1f}%")
elif margin >= 15:
    st.warning(f"Acceptable margin: {margin:.1f}%")
elif margin > 0:
    st.warning(f"Thin margin: {margin:.1f}% — review cost structure")
else:
    st.error(f"Loss-making: {margin:.1f}%")

# Conditional sections
show_breakdown = st.checkbox("Show cost breakdown")
if show_breakdown:
    st.write(f"Revenue: £{revenue:,}")
    st.write(f"Costs:   £{costs:,}")
    st.write(f"Profit:  £{profit:,}")

4. Funciones

Las funciones encapsulan lógica reutilizable. En Streamlit, las usarás principalmente de dos formas: envolver cargas de datos en funciones decoradas con @st.cache_data, y encapsular cálculos financieros en funciones puras (sin efectos secundarios) que son fáciles de probar.

import streamlit as st
import pandas as pd

# Pure function — takes inputs, returns output, no side effects
def gross_margin(revenue: float, cogs: float) -> float:
    if revenue == 0:
        return 0.0
    return (revenue - cogs) / revenue * 100

def loan_payment(principal: float, annual_rate: float, years: int) -> float:
    r = annual_rate / 12
    n = years * 12
    if r == 0:
        return principal / n
    return principal * r * (1 + r) ** n / ((1 + r) ** n - 1)

# Cached function — runs once, then returns from cache
@st.cache_data(ttl=3600)
def load_data(path: str) -> pd.DataFrame:
    return pd.read_csv(path, parse_dates=["Date"])

# Usage in the app
revenue = st.number_input("Revenue £", value=500_000)
cogs    = st.number_input("COGS £",    value=300_000)
st.metric("Gross Margin", f"{gross_margin(revenue, cogs):.1f}%")

Las anotaciones de tipo (revenue: float) son opcionales pero altamente recomendables — hacen el código más legible y ayudan a los IDEs a detectar errores antes de ejecutar.

5. Bucles y List Comprehensions

Los bucles for recorren colecciones. Las list comprehensions son su versión compacta — muy comunes en Python real. En Streamlit los usarás para generar columnas, tarjetas de métricas y opciones de selectbox dinámicamente.

import streamlit as st

kpis = [
    ("Revenue",      "£480k", "+12%"),
    ("Gross Margin", "42%",   "+2pp"),
    ("EBITDA",       "£96k",  "+18%"),
    ("Cash",         "£210k", "+5%"),
]

# Loop to generate metric cards
cols = st.columns(len(kpis))
for col, (label, value, delta) in zip(cols, kpis):
    col.metric(label, value, delta)

# List comprehension — build a list in one line
years   = [2020, 2021, 2022, 2023, 2024]
revenue = [320_000, 380_000, 440_000, 490_000, 560_000]

# Calculate YoY growth for each year (skip first)
growth = [
    (revenue[i] - revenue[i-1]) / revenue[i-1] * 100
    for i in range(1, len(revenue))
]
# → [18.75, 15.79, 11.36, 14.29]

6. Pandas — La Librería Más Importante

Pandas es el corazón de casi cualquier app Streamlit de finanzas. Un DataFrame es una tabla con filas y columnas — piensa en él como un Excel con superpoderes programables. Las operaciones más importantes que necesitas dominar son: cargar, filtrar, agrupar y exportar.

import pandas as pd

# Create a DataFrame
df = pd.DataFrame({
    "Date":     ["2024-01", "2024-02", "2024-03", "2024-04"],
    "Region":   ["UK", "UK", "US", "US"],
    "Revenue":  [120_000, 135_000, 200_000, 190_000],
    "Costs":    [ 80_000,  88_000, 130_000, 125_000],
})
df["Date"]   = pd.to_datetime(df["Date"])
df["Profit"] = df["Revenue"] - df["Costs"]
df["Margin"] = df["Profit"] / df["Revenue"] * 100

# Filter rows
uk_only = df[df["Region"] == "UK"]

# Group and aggregate
by_region = (
    df.groupby("Region")
    .agg(Total_Revenue=("Revenue","sum"), Avg_Margin=("Margin","mean"))
    .reset_index()
)

# In Streamlit
import streamlit as st
st.dataframe(df, use_container_width=True, hide_index=True)
st.dataframe(by_region.style.format({"Total_Revenue": "£{:,.0f}", "Avg_Margin": "{:.1f}%"}))

7. Imports y Librerías

Python tiene un ecosistema enorme de librerías. En apps Streamlit de finanzas, usarás las mismas 6-8 librerías una y otra vez. No necesitas memorizar toda su API — solo las funciones que aparecen en el 80% de los proyectos.

# The core finance app stack
import streamlit as st          # UI and layout
import pandas as pd             # DataFrames and data manipulation
import numpy as np              # Numerical calculations
import plotly.express as px     # Interactive charts
import plotly.graph_objects as go  # Fine-grained chart control
from io import BytesIO          # In-memory file buffer for exports
import requests                 # API calls
import yfinance as yf           # Stock and financial data

# Import only what you need from a module
from datetime import date, timedelta
from pathlib import Path

# Alias long names for convenience
import matplotlib.pyplot as plt  # Matplotlib — static charts

Añade todas estas al fichero requirements.txt de tu proyecto para que Streamlit Cloud o Railway las instalen automáticamente al desplegar.

8. Manejo de Errores

Las apps de finanzas reciben entradas de usuario y datos externos — ambas fuentes pueden fallar. El bloque try/except evita que un error crache toda la app. En Streamlit, combínalo con st.error() para mostrar mensajes útiles en lugar de stack traces.

import streamlit as st
import pandas as pd
import requests

# Handle file upload errors
uploaded = st.file_uploader("Upload CSV", type=["csv"])
if uploaded:
    try:
        df = pd.read_csv(uploaded)
        required = {"Date", "Revenue", "Region"}
        missing  = required - set(df.columns)
        if missing:
            st.error(f"Missing columns: {', '.join(missing)}")
            st.stop()
        st.success(f"Loaded {len(df):,} rows")
    except Exception as e:
        st.error(f"Could not read file: {e}")
        st.stop()

# Handle API errors
@st.cache_data(ttl=300)
def get_rates(base: str) -> dict:
    try:
        r = requests.get(f"https://api.example.com/rates?base={base}", timeout=10)
        r.raise_for_status()
        return r.json()
    except requests.Timeout:
        st.warning("API timed out — showing cached data")
        return {}
    except requests.HTTPError as e:
        st.error(f"API error: {e}")
        return {}

9. Lo que NO Necesitas (Todavía)

Mucha gente pospone aprender Streamlit porque asume que necesita dominar toda la orientación a objetos (clases, herencia, métodos mágicos), decoradores avanzados, programación asíncrona o algoritmos de machine learning. No lo necesitas para construir apps de finanzas útiles y profesionales.

  • ✗Clases y orientación a objetos — útiles, pero no necesarias para Streamlit
  • ✗Programación asíncrona (async/await) — Streamlit maneja la concurrencia por ti
  • ✗Algoritmos ML — a menos que tu app los necesite específicamente
  • ✗Decoradores personalizados — @st.cache_data es el único que usarás habitualmente
  • ✓Variables, listas, diccionarios, funciones, if/else, loops — todo lo anterior es suficiente

10. Juntando Todo — Una App Completa

Esta app de ejemplo usa todos los conceptos anteriores: variables, listas, funciones, pandas, condicionales y manejo de errores. Es una calculadora de margen bruto con exportación CSV — 40 líneas, completamente funcional.

import streamlit as st
import pandas as pd
import plotly.express as px

st.title("Gross Margin Analyser")

# ── Input ──────────────────────────────────────────
months  = ["Jan","Feb","Mar","Apr","May","Jun",
           "Jul","Aug","Sep","Oct","Nov","Dec"]
revenue = [st.number_input(f"{m} Revenue £", value=40_000 + i*2_000, key=f"rev_{i}")
           for i, m in enumerate(months)]
cogs    = [r * 0.6 for r in revenue]          # assume 60% COGS

# ── Calculate ──────────────────────────────────────
df = pd.DataFrame({
    "Month":   months,
    "Revenue": revenue,
    "COGS":    cogs,
    "Profit":  [r - c for r, c in zip(revenue, cogs)],
    "Margin":  [(r - c) / r * 100 if r > 0 else 0 for r, c in zip(revenue, cogs)],
})

# ── KPIs ───────────────────────────────────────────
col1, col2, col3 = st.columns(3)
col1.metric("Total Revenue", f"£{df['Revenue'].sum():,.0f}")
col2.metric("Total Profit",  f"£{df['Profit'].sum():,.0f}")
col3.metric("Avg Margin",    f"{df['Margin'].mean():.1f}%")

# ── Chart ──────────────────────────────────────────
fig = px.bar(df, x="Month", y="Profit", color="Margin",
             color_continuous_scale="RdYlGn", title="Monthly Profit & Margin")
st.plotly_chart(fig, use_container_width=True)

# ── Export ─────────────────────────────────────────
st.download_button("⬇ Download CSV", df.to_csv(index=False), "margin.csv", "text/csv")

¿Por Dónde Seguir?

Con estos conceptos puedes construir herramientas de finanzas reales. El siguiente paso es aprender a estructurar apps multi-página, conectar a fuentes de datos externas (APIs, bases de datos) y desplegar en producción. Todo eso está cubierto en las lecciones interactivas de Streamlit en FinancePlots.

Próximos pasos →

Share this article

Share on XShare on LinkedIn