Wie man ein Makrodashboard in Python mit Pandas & Plotly erstellt

Ein Makrodashboard versammelt die wichtigsten Indikatoren für die Zentralbank und die Wirtschaft an einem Ort, sodass Sie die Marktbedingungen in Sekunden durchsuchen können, anstatt zwischen den Datenterminals zu springen. Pande, und es mit - Ich habe es vorgenommen.Jedes Panel wird von einem einzigen API-Schlüssel und einer Handvoll Funktionsanrufen aktualisiert.

Voraussetzungen

Vor dem Start benötigen Sie Folgendes:

• Python 3.9+
• FXMacroData-API-Schlüssel melden Sie sich an /abonnieren und kopieren Sie Ihren Schlüssel vom Armaturenbrett
• Python-Pakete- Ich weiß . requests- Ich weiß . pandas- Ich weiß . plotly

Installieren Sie die Abhängigkeiten in einem Befehl:

pip install requests pandas plotly

Speichern Sie Ihren API-Schlüssel als Umgebungsvariable niemals Hard-Code-Anmeldeinformationen in Skripts:

export FXMD_API_KEY="YOUR_API_KEY"

Schritt 1 Die Endpunktform des Indikators verstehen

Jeder FXMacroData-Indikator folgt dem gleichen REST-Muster, was es trivial macht, in eine einzige Abruffunktion zu verallgemeinern.

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

Die JSON-Antwort ist ein flaches Objekt mit einem data - Das ist nicht wahr.

{
  "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" }
  ]
}

Jede Platte trägt eine date (JJJ-MM-DD), eine Zahlenzahl val, und soweit verfügbar eine UTC der zweiten Ebene announcement_datetimeDie konsistente Form aller Indikatoren ermöglicht es einer Funktion, jedes Panel im Armaturenbrett zu bedienen.

Schritt 2 Schreiben Sie eine wiederverwendbare Abruffunktion

Erstellen Sie ein Modul namens macro_fetch.pyDie folgende Funktion fordert einen Indikator für jede Währung an, wandelt die Antwort in eine Pandas-Serie um und gibt ihn nach Datum bereit, direkt in einen Datenschema zu fallen, wieder.

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

Schritt 3 Alle Indikatoren für das Dashboard abrufen

Mit dem Abrufs-Helfer ist das Ziehen von vier Indikatoren für vier Währungen eine prägnante Schleife.

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}

Sie können jeden DataFrame interaktiv überprüfen , um zu überprüfen, ob die Daten aussieht , bevor sie dargestellt werden:

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

Schritt 4 Formen der Daten für die Karte

Plotely funktioniert am besten mit Vorgefüllt Die Daten sind in einer Reihe für Liniendiagramme erfasst, so dass der zuletzt bekannte Wert bis zur nächsten Veröffentlichung weitergeleitet wird.

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")
    )

Für den PMI, der ein monatlicher Indikator ist, ist die Vorlauf-Füllung weniger relevant , aber die Funktion behandelt sie anmutig, indem sie die bereits monatlichen Daten unverändert durchläuft.

Schritt 5 Erstellen Sie das Plotly Dashboard

Das ist Plotly. make_subplots Mit dem Dienstprogramm können Sie mehrere Diagramme in einem einzigen Objekt anordnen, das Sie in einem Browser anzeigen, als HTML exportieren oder in ein Jupyter-Notebook einbetten können.

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}}{Währung.Ober-) }",
                ),
                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

Schritt 6 Das Dashboard ausführen

Wird alles in einem dashboard.py Eintrittspunkt-Skript. fig.show() öffnet das Dashboard in Ihrem Standardbrowser. fig.write_html() speichert eine eigenständige HTML-Datei, die Sie überall teilen oder einbetten können.

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")

Führen Sie es vom Terminal aus aus:

python dashboard.py

Plotly öffnet ein Browserfenster mit einem zweischiffrigen, zweiskolonnenen Dashboard mit vier Live-Panels für jeden Indikator farbcodiert nach Währung.

Schritt 7 Hinzufügen von Anmerkungen zum Release-Timing (optional)

Eine der nützlichsten Dashboard-Erweiterungen ist die Überlagerung . Freisetzungsmarker vertikale Linien oder Punkte, die genau zeigen, wann jede Ankündigung gemacht wurde. announcement_datetime Zeitstempel, damit Sie sie ohne Vermutungen hinzufügen können:

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,
        )

Ruf an . add_release_markers Nachher . build_dashboard Und vor dem fig.show() Die Release-Marker sind besonders nützlich für das Rate-Panel, wo Entscheidungen selten getroffen werden, aber eine hohe Wirkung haben.

Schritt 8 Exportieren von Panels als einzelne Bilder

Wenn Sie einzelne Diagramme in einen Bericht oder ein Diagrammdeck einbeziehen möchten, kann Plotly jedes Teilplot als PNG exportieren. Kaledon- Ich weiß .

pip install kaleido

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

Für die Exporte pro Panel ist jeder Indikator als eigenständiger Indikatorsatz zu erstellen. go.Figure Ich benutze das gleiche . go.Scatter Spuren und Anrufe . write_image Die in früheren Schritten entwickelten Abruffunktionen und Formfunktionen funktionieren bei Einzelbildern unverändert.

Vollständige Referenzen

Hier ist das vollständige, eigenständige Skript, das alle oben genannten Schritte kombiniert. dashboard.py- Setzt . FXMD_API_KEY- Und sie führen.

"""
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}}{Währung.Ober-) }",
                ),
                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")

Zusammenfassung

Sie haben jetzt ein funktionierendes Makrodashboard , das:

• Die Daten für die Zinssätze, die Inflation, die Arbeitslosigkeit und den PMI für USD, EUR, GBP und AUD werden aus dem Endpunkt der Ankündigungen von FXMacroData
• Umgestaltet die Daten in ausgerichtete, nach vorne gefüllte Pandas
• Rendering eines vier-Panel-interaktiven Plot-Dashboards mit farbcodierten Währungslinien
• Exportiert eine eigenständige HTML-Datei, die Sie teilen oder einbetten können

Von hier aus können Sie das Dashboard in verschiedene Richtungen erweitern: mehr Währungen hinzufügen, überlagern Arbeitslosigkeit Die vollständige Indikatorenkatalog einschließlich Handelsbilanz, Kreditwachstum und COT-Positionierung ist unter verfügbar. Daten-Dokumentation- Ich weiß .