Cómo crear un panel de macro en Python con pandas y Plotly

Un panel de control macro pone los indicadores económicos y del banco central más importantes en un solo lugar, por lo que puede escanear las condiciones del mercado en segundos en lugar de saltar entre terminales de datos. las pandas, y lo hace con Es un complot.Cada panel se actualiza desde una sola clave de API y un puñado de llamadas de funciones.

Los requisitos previos

Antes de comenzar, necesitará lo siguiente:

• Python 3.9+
• La clave de la API de FXMacroData inscribirse en / suscribirse y copia tu llave del tablero de instrumentos
• Paquetes de Python¿ Qué ? requests¿ Qué ? pandas¿ Qué ? plotly

Instale las dependencias en un solo comando:

pip install requests pandas plotly

Almacene su clave de API como una variable de entorno nunca credenciales de código duro en scripts:

export FXMD_API_KEY="YOUR_API_KEY"

Paso 1 Comprender la forma del punto final del indicador

Cada indicador FXMacroData sigue el mismo patrón REST, lo que hace que sea trivial generalizar en una sola función de búsqueda.

GET https://fxmacrodata.com/api/v1/announcements/usd/policy_rate?api_key=YOUR_API_KEY&start=2020-01-01

La respuesta JSON es un objeto plano con un data - ¿ Qué es eso ?

{
  "data": [
    { "date": "2025-03-19", "val": 4.25, "announcement_datetime": "2025-03-19T18:00:00Z" },
    { "date": "2025-01-29", "val": 4.25, "announcement_datetime": "2025-01-29T19:00:00Z" },
    { "date": "2024-12-18", "val": 4.25, "announcement_datetime": "2024-12-18T19:00:00Z" }
  ]
}

Cada disco lleva un date (Año Año A-MM-DD), un número val, y cuando esté disponible un segundo nivel UTC announcement_datetimeLa forma consistente en todos los indicadores es lo que permite que una función sirva a todos los paneles en el salpicadero.

Paso 2 Escriba una función de recuperación reutilizable

Crear un módulo llamado macro_fetch.pyLa función siguiente solicita cualquier indicador para cualquier moneda, convierte la respuesta a una serie de pandas y la devuelve indexada por fecha lista para ser introducida directamente en un DataFrame.

import os
import requests
import pandas as pd

BASE_URL = "https://fxmacrodata.com/api/v1"
API_KEY = os.environ["FXMD_API_KEY"]


def fetch_indicator(currency: str, indicator: str, start: str = "2020-01-01") -> pd.Series:
    """
    Fetch a single indicator series from FXMacroData and return it as a
    pandas Series with a DatetimeIndex, named '{currency.upper()}_{indicator}'.
    """
    url = f"{BASE_URL}/announcements/{currency}/{indicator}"
    resp = requests.get(url, params={"api_key": API_KEY, "start": start}, timeout=15)
    resp.raise_for_status()

    records = resp.json().get("data", [])
    if not records:
        return pd.Series(name=f"{currency.upper()}_{indicator}", dtype=float)

    series = (
        pd.DataFrame(records)
        .assign(date=lambda df: pd.to_datetime(df["date"]))
        .set_index("date")["val"]
        .sort_index()
        .rename(f"{currency.upper()}_{indicator}")
    )
    return series

Paso 3 Busca todos los indicadores para el tablero

Con el ayudante de búsqueda en su lugar, tirar de cuatro indicadores para cuatro monedas es un bucle conciso.

import time

CURRENCIES = ["usd", "eur", "gbp", "aud"]
INDICATORS = {
    "policy_rate": "Policy Rate (%)",
    "inflation": "CPI Inflation (% YoY)",
    "unemployment": "Unemployment Rate (%)",
    "pmi": "Manufacturing PMI",
}


def fetch_all(start: str = "2020-01-01", retries: int = 3) -> dict[str, pd.DataFrame]:
    """
    Return a dict mapping each indicator slug to a wide DataFrame where
    each column is one currency (e.g. USD_policy_rate, EUR_policy_rate).
    """
    frames: dict[str, list[pd.Series]] = {ind: [] for ind in INDICATORS}

    for currency in CURRENCIES:
        for indicator in INDICATORS:
            for attempt in range(retries):
                try:
                    s = fetch_indicator(currency, indicator, start=start)
                    frames[indicator].append(s)
                    break
                except requests.HTTPError as exc:
                    if attempt == retries - 1:
                        print(f"Warning: could not fetch {currency}/{indicator}: {exc}")
                    else:
                        time.sleep(1.5 ** attempt)

    return {ind: pd.concat(series, axis=1) for ind, series in frames.items() if series}

Puede inspeccionar cualquier DataFrame de forma interactiva para verificar el aspecto de los datos justo antes de renderizar:

data = fetch_all(start="2021-01-01")
print(data["policy_rate"].tail())
# Output (example):
#             USD_policy_rate  EUR_policy_rate  GBP_policy_rate  AUD_policy_rate
# date
# 2025-01-29             4.25              NaN              NaN              NaN
# 2025-02-06              NaN              NaN             4.50              NaN
# 2025-02-18              NaN              NaN              NaN             4.10
# 2025-03-06              NaN             2.50              NaN              NaN
# 2025-03-19             4.25              NaN              NaN              NaN

Paso 4 Formar los datos para la elaboración de gráficos

Con la trama funciona mejor . de carga de las máquinas La serie de gráficos de líneas, por lo que el valor más recientemente conocido se lleva adelante hasta la próxima versión.

def prepare_for_chart(df: pd.DataFrame) -> pd.DataFrame:
    """
    Forward-fill each column so lines in the chart step at each release date
    rather than showing gaps between announcements.
    Resample to a monthly frequency for a cleaner visual.
    """
    return (
        df
        .ffill()
        .resample("ME")      # month-end
        .last()
        .dropna(how="all")
    )

Para el PMI, que es un indicador mensual, el relleno anticipado es menos relevante pero la función lo maneja con gracia simplemente pasando los datos ya mensuales sin cambios.

Paso 5 Construye el panel de control de la gráfica

Es de Plotly. make_subplots Utilidad permite organizar múltiples gráficos en un solo objeto de figura, que se puede mostrar en un navegador, exportar como HTML, o incrustar en un cuaderno Jupyter.

import plotly.graph_objects as go
from plotly.subplots import make_subplots

# Palette aligned with FXMacroData brand colours
COLORS = {
    "usd": "#3B82F6",   # finance blue
    "eur": "#D97706",   # gold
    "gbp": "#16A34A",   # green
    "aud": "#7C3AED",   # purple
}

SUBPLOT_TITLES = list(INDICATORS.values())


def build_dashboard(data: dict[str, pd.DataFrame]) -> go.Figure:
    fig = make_subplots(
        rows=2, cols=2,
        subplot_titles=SUBPLOT_TITLES,
        shared_xaxes=False,
        vertical_spacing=0.12,
        horizontal_spacing=0.08,
    )

    positions = [(1, 1), (1, 2), (2, 1), (2, 2)]

    for (indicator, label), (row, col) in zip(INDICATORS.items(), positions):
        df = prepare_for_chart(data[indicator])
        for col_name in df.columns:
            currency = col_name.split("_")[0].lower()
            fig.add_trace(
                go.Scatter(
                    x=df.index,
                    y=df[col_name],
                    mode="lines",
                    name=currency.upper(),
                    line=dict(color=COLORS[currency], width=2),
                    legendgroup=currency,
                    showlegend=(indicator == "policy_rate"),  # one legend entry per currency
                    hovertemplate=f"%{{x|%b %Y}}: %{{y:.2f}}{valuta.superior() }",
                ),
                row=row, col=col,
            )

    fig.update_layout(
        title=dict(
            text="G4 Central Bank Macro Dashboard",
            font=dict(size=22, color="#1e3a5f"),
            x=0.5,
        ),
        paper_bgcolor="#f8fafc",
        plot_bgcolor="#f1f5f9",
        font=dict(family="Inter, system-ui, sans-serif", size=12, color="#334155"),
        legend=dict(
            orientation="h",
            yanchor="bottom",
            y=1.04,
            xanchor="center",
            x=0.5,
        ),
        height=700,
        margin=dict(t=100, b=50, l=60, r=40),
    )

    fig.update_xaxes(showgrid=True, gridcolor="#e2e8f0", zeroline=False)
    fig.update_yaxes(showgrid=True, gridcolor="#e2e8f0", zeroline=False)

    return fig

Paso 6 Ejecute el panel de control

Conecta todo en un dashboard.py Escritura de entrada. fig.show() abre el panel de control en su navegador predeterminado. fig.write_html() guarda un archivo HTML autónomo que puede compartir o incrustar en cualquier lugar.

if __name__ == "__main__":
    print("Fetching macro data …")
    data = fetch_all(start="2021-01-01")

    print("Building dashboard …")
    fig = build_dashboard(data)

    # Option A: open in browser
    fig.show()

    # Option B: save as portable HTML file
    fig.write_html("macro_dashboard.html", include_plotlyjs="cdn")
    print("Saved macro_dashboard.html")

Lo ejecutamos desde el terminal:

python dashboard.py

Plotly abrirá una ventana del navegador que muestra un panel de dos filas, dos columnas con cuatro paneles en vivo uno para cada indicador codificado por color de moneda.

Paso 7 Añadir anotaciones de tiempo de lanzamiento (opcional)

Una de las mejoras más útiles del tablero es la superposición . marcadores de liberación líneas verticales o puntos que muestran exactamente cuándo se hizo cada anuncio. announcement_datetime sellos de tiempo, para que pueda añadirlos sin ninguna conjetura:

def fetch_release_datetimes(currency: str, indicator: str, start: str) -> pd.Series:
    """Return a Series of UTC announcement datetimes for a given indicator."""
    url = f"{BASE_URL}/announcements/{currency}/{indicator}"
    resp = requests.get(url, params={"api_key": API_KEY, "start": start}, timeout=15)
    resp.raise_for_status()
    records = resp.json().get("data", [])
    if not records:
        return pd.Series(dtype="datetime64[ns, UTC]")
    df = pd.DataFrame(records)
    if "announcement_datetime" not in df.columns:
        return pd.Series(dtype="datetime64[ns, UTC]")
    return pd.to_datetime(df["announcement_datetime"], utc=True)


def add_release_markers(fig: go.Figure, currency: str, indicator: str,
                         start: str, row: int, col: int) -> None:
    """Overlay vertical dashed lines on a subplot at each release datetime."""
    datetimes = fetch_release_datetimes(currency, indicator, start)
    for dt in datetimes:
        fig.add_vline(
            x=dt.timestamp() * 1000,  # Plotly uses ms since epoch for datetime axes
            line_width=1,
            line_dash="dot",
            line_color=COLORS[currency],
            opacity=0.35,
            row=row, col=col,
        )

Llama . add_release_markers Después de build_dashboard y antes . fig.show() Los marcadores de liberación son especialmente útiles en el panel de tipos de interés, donde las fechas de decisión son infrecuentes pero de alto impacto.

Paso 8 Exportar paneles como imágenes individuales

Si desea incluir gráficos individuales en un informe o diapositiva, Plotly puede exportar cada subgrafía como un PNG a través de El kaleido¿ Qué ?

pip install kaleido

fig.write_image("macro_dashboard.png", width=1400, height=700, scale=2)

Para las exportaciones por panel, elabore cada indicador como un indicador independiente. go.Figure usando el mismo go.Scatter Rastreos y llamadas . write_image Las funciones de captación y forma desarrolladas en pasos anteriores funcionan sin cambios para figuras de un solo panel.

Referencia completa del guión

A continuación está el script completo, autónomo que combina todos los pasos anteriores. dashboard.py, puesto FXMD_API_KEY, y ejecutarlo.

"""
macro_dashboard.py — G4 Central Bank Macro Dashboard
Requires: requests, pandas, plotly
Usage:    FXMD_API_KEY=your_key python macro_dashboard.py
"""
import os
import time
import requests
import pandas as pd
import plotly.graph_objects as go
from plotly.subplots import make_subplots

BASE_URL = "https://fxmacrodata.com/api/v1"
API_KEY = os.environ["FXMD_API_KEY"]

CURRENCIES = ["usd", "eur", "gbp", "aud"]
INDICATORS = {
    "policy_rate": "Policy Rate (%)",
    "inflation": "CPI Inflation (% YoY)",
    "unemployment": "Unemployment Rate (%)",
    "pmi": "Manufacturing PMI",
}
COLORS = {"usd": "#3B82F6", "eur": "#D97706", "gbp": "#16A34A", "aud": "#7C3AED"}


def fetch_indicator(currency: str, indicator: str, start: str = "2020-01-01") -> pd.Series:
    url = f"{BASE_URL}/announcements/{currency}/{indicator}"
    resp = requests.get(url, params={"api_key": API_KEY, "start": start}, timeout=15)
    resp.raise_for_status()
    records = resp.json().get("data", [])
    if not records:
        return pd.Series(name=f"{currency.upper()}_{indicator}", dtype=float)
    return (
        pd.DataFrame(records)
        .assign(date=lambda df: pd.to_datetime(df["date"]))
        .set_index("date")["val"]
        .sort_index()
        .rename(f"{currency.upper()}_{indicator}")
    )


def fetch_all(start: str = "2020-01-01", retries: int = 3) -> dict[str, pd.DataFrame]:
    frames: dict[str, list[pd.Series]] = {ind: [] for ind in INDICATORS}
    for currency in CURRENCIES:
        for indicator in INDICATORS:
            for attempt in range(retries):
                try:
                    frames[indicator].append(fetch_indicator(currency, indicator, start))
                    break
                except requests.HTTPError as exc:
                    if attempt == retries - 1:
                        print(f"Warning: {currency}/{indicator}: {exc}")
                    else:
                        time.sleep(1.5 ** attempt)
    return {ind: pd.concat(series, axis=1) for ind, series in frames.items() if series}


def prepare_for_chart(df: pd.DataFrame) -> pd.DataFrame:
    return df.ffill().resample("ME").last().dropna(how="all")


def build_dashboard(data: dict[str, pd.DataFrame]) -> go.Figure:
    fig = make_subplots(
        rows=2, cols=2,
        subplot_titles=list(INDICATORS.values()),
        vertical_spacing=0.12,
        horizontal_spacing=0.08,
    )
    for (indicator, _), (row, col) in zip(INDICATORS.items(), [(1,1),(1,2),(2,1),(2,2)]):
        df = prepare_for_chart(data[indicator])
        for col_name in df.columns:
            currency = col_name.split("_")[0].lower()
            fig.add_trace(
                go.Scatter(
                    x=df.index, y=df[col_name], mode="lines",
                    name=currency.upper(),
                    line=dict(color=COLORS[currency], width=2),
                    legendgroup=currency,
                    showlegend=(indicator == "policy_rate"),
                    hovertemplate=f"%{{x|%b %Y}}: %{{y:.2f}}{valuta.superior() }",
                ),
                row=row, col=col,
            )
    fig.update_layout(
        title=dict(text="G4 Central Bank Macro Dashboard", font=dict(size=22, color="#1e3a5f"), x=0.5),
        paper_bgcolor="#f8fafc", plot_bgcolor="#f1f5f9",
        font=dict(family="Inter, system-ui, sans-serif", size=12),
        legend=dict(orientation="h", yanchor="bottom", y=1.04, xanchor="center", x=0.5),
        height=700, margin=dict(t=100, b=50, l=60, r=40),
    )
    fig.update_xaxes(showgrid=True, gridcolor="#e2e8f0", zeroline=False)
    fig.update_yaxes(showgrid=True, gridcolor="#e2e8f0", zeroline=False)
    return fig


if __name__ == "__main__":
    print("Fetching macro data …")
    data = fetch_all(start="2021-01-01")
    print("Building dashboard …")
    fig = build_dashboard(data)
    fig.show()
    fig.write_html("macro_dashboard.html", include_plotlyjs="cdn")
    print("Saved macro_dashboard.html")

Resumen de las actividades

Ahora tiene un panel de macro que funciona:

• Se obtienen tasas de interés, inflación, desempleo y PMI para USD, EUR, GBP y AUD de la Punto final de los anuncios de FXMacroData
• Reforma los datos en pandas alineados y rellenos hacia adelante DataFrames
• Render un panel interactivo de cuatro cuadros Plotly con líneas de divisas codificadas por colores
• Exporta un archivo HTML independiente que puede compartir o incrustar

Desde aquí se puede ampliar el tablero de instrumentos en varias direcciones: añadir más monedas, superposición el desempleo El catálogo completo de indicadores incluyendo la balanza comercial, el crecimiento del crédito y el posicionamiento de la COT está disponible en Aplicados a las aplicaciones de la categoría "APA"- ¿ Qué ?