KI-Preisvorhersage

Preisvorhersagen kombinieren in der Regel maschinelles Lernen und Deep-Learning-Algorithmen und nutzen historische Daten und markttechnische Indikatoren. Hier sind einige gängige Methoden:

1. Zeitreihenanalyse

• ARIMA (Autoregressives integriertes gleitendes Durchschnittsmodell): Diese Methode dient der Vorhersage zukünftiger Werte stationärer Zeitreihen und eignet sich für kurzfristige Prognosen.
• SARIMA (Saisonales ARIMA): Basierend auf ARIMA wird eine saisonale Komponente hinzugefügt, die für Daten mit offensichtlichen saisonalen Trends geeignet ist.

2. Algorithmus für maschinelles Lernen

• zufälliger Wald: Die auf Entscheidungsbäumen basierende Ensemble-Lernmethode kann das Risiko einer Überanpassung wirksam reduzieren und stabile Vorhersageergebnisse liefern.
• Support-Vektor-Maschine (SVM): Geeignet für die Verarbeitung hochdimensionaler Daten und in der Lage, komplexe Aktienkursbewegungsmuster zu entdecken.

3. Deep-Learning-Modell

• LSTM (Long Short-Term Memory Network): Ein wiederkehrendes neuronales Netzwerk (RNN), das langfristige Abhängigkeiten in Zeitreihendaten gut verarbeiten kann und sich sehr gut für die Vorhersage von Aktienkurstrends eignet.
• GRU (Gated Recurrent Unit): Ähnlich wie LSTM, aber mit einfacherer Struktur und höherer Recheneffizienz.

4. Gemischtes Modell

• XGBoost + LSTM: Durch die Kombination von XGBoost und LSTM können gleichzeitig lineare und nichtlineare Muster in Daten erfasst und die Vorhersagegenauigkeit verbessert werden.

5. Technische Indikatoren

• Häufig verwendete technische Indikatoren wie zRelativer Stärkeindex (RSI)UndGleitende durchschnittliche Konvergenzdivergenz (MACD), kann dabei helfen, den Zeitpunkt des Ein- und Ausstiegs von Transaktionen zu ermitteln.

6. Verstärkungslernen

Intelligente Handelssysteme, die Reinforcement Learning nutzen, können in einer simulierten Marktumgebung lernen und Kauf- und Verkaufsentscheidungen im Laufe der Zeit optimieren, wodurch Handelsstrategien schrittweise verbessert werden.

7. Big Data und Stimmungsanalyse

KI-Modelle können die Marktstimmung durch Stimmungsanalysen von Nachrichten und sozialen Medien beurteilen und Aktienkursänderungen basierend auf externen Faktoren vorhersagen.

8. Vorsichtsmaßnahmen

Die Kombination mehrerer Algorithmen mit externen Daten (z. B. Wirtschaftsindikatoren, Unternehmensfundamentalanalyse) führt häufig zu den effektivsten KI-Aktienkursvorhersagemodellen.

Indikatoren und operative Strategien

Beim Einsatz von KI zur Aktienkursvorhersage generiert das Modell eine Vielzahl von Indikatoren, die Anlegern bei der Entscheidungsfindung helfen. Mithilfe dieser Indikatoren können Markttrends beurteilt und entsprechende Handelsgeschäfte auf der Grundlage verschiedener Szenarien durchgeführt werden. Hier sind einige gängige Vorhersageindikatoren und Strategien für deren Betrieb:

1. Preis vorhersagen

Dies ist der vom Modell direkt vorhergesagte zukünftige Aktienkurswert.

• Betriebsstrategie:Liegt der prognostizierte Preis über dem aktuellen Preis, kann ein Kauf empfohlen werden; Liegt er unter dem aktuellen Preis, wird ein Verkauf empfohlen.

2. Wahrscheinlichkeit von Anstieg und Fall

Ein Modell könnte die Wahrscheinlichkeit vorhersagen, dass der Kurs einer Aktie steigen oder fallen wird.

• Betriebsstrategie:Wenn die Wahrscheinlichkeit eines Anstiegs einen bestimmten Schwellenwert (z. B. 70 %) überschreitet, wird ein Kauf empfohlen; Wenn die Wahrscheinlichkeit eines Rückgangs höher ist, empfiehlt es sich zu verkaufen oder abzuwarten.

3. Trendsignale

Ein Modell kann die Trendrichtung einer Aktie anhand technischer Indikatoren wie gleitender Durchschnitte vorhersagen.

• Betriebsstrategie:Wenn Trendsignale darauf hindeuten, dass sich eine Aktie in einem Aufwärtstrend befindet, empfiehlt sich der Kauf; Wenn es einen Abwärtstrend anzeigt, wird empfohlen, zu verkaufen oder Leerverkäufe zu tätigen.

4. Überkauft/überverkauft-Signale

Mithilfe technischer Indikatoren wie dem RSI (Relative Strength Index) kann festgestellt werden, ob eine Aktie überkauft oder überverkauft ist.

• Betriebsstrategie:Wenn der RSI-Indikator anzeigt, dass eine Aktie überverkauft ist, könnte es an der Zeit sein, zu kaufen; Wenn ein Überkauft angezeigt wird, ist es möglicherweise an der Zeit, zu verkaufen oder Gewinne mitzunehmen.

5. Volatilität

Das Modell kann die zukünftige Preisschwankungsspanne von Aktien vorhersagen.

• Betriebsstrategie:Wenn die prognostizierte Volatilität hoch ist, bedeutet dies, dass der Markt instabil ist, und es wird empfohlen, eine konservative Strategie zu verfolgen; Wenn die Volatilität gering ist, können Sie erwägen, eine Position zu halten.

6. Handelsintensität

Prognose basierend auf der Stärke der Käufer und Verkäufer auf dem Markt.

• Betriebsstrategie:Wenn die Kaufintensität höher ist als die Verkaufsintensität, wird der Kauf empfohlen; andernfalls wird empfohlen, zu verkaufen oder Leerverkäufe zu tätigen.

7. Stoppen Sie den Verlust und nehmen Sie Gewinnpunkte mit

Das Modell kann auf der Grundlage historischer Daten angemessene Stop-Loss- und Take-Profit-Punkte vorschlagen.

• Betriebsstrategie:Wenn der Preis den Stop-Loss-Punkt erreicht, sollten Sie verkaufen, um größere Verluste zu vermeiden; Wenn der Preis den Stop-Profit-Punkt erreicht, wird empfohlen, Gewinne mitzunehmen.

Zusammenfassen

Anhand verschiedener Prognoseindikatoren können Anleger entsprechende Handelsentscheidungen treffen, wie z. B. Kaufen, Verkaufen oder Abwarten. Die Kombination mehrerer Indikatoren kann dazu beitragen, in verschiedenen Marktszenarien vernünftigere Anlageentscheidungen zu treffen.

Rotationsanzeigeprogramm

Unter den vielen Rotationsbeurteilungsindikatoren verfügen nicht alle Indikatoren über die gleiche Vorhersagekraft. Basierend auf den Markterfahrungen der letzten Jahre (2020 bis 2025) wird im Folgenden nach Genauigkeit und Praktikabilität abgestuft und erläutert, wie man marktübergreifend vergleicht und durch Prozessautomatisierung erhält und berechnet.

Frühindikatoren mit hoher Genauigkeit in den letzten Jahren

Warum sind diese Indikatoren in den letzten Jahren genauer geworden?

Der Grund dafür, dass die Zinsstrukturkurve ein hohes Maß an Genauigkeit beibehält, liegt darin, dass sie die kollektive Preisgestaltung des Anleihenmarkts für die zukünftige Wirtschaft widerspiegelt. Die Teilnehmer am Rentenmarkt werden von institutionellen juristischen Personen dominiert, und die Informationseffizienz ist viel höher als auf dem von Privatanlegern dominierten Markt. Die Neuaufträge von ISM spiegeln direkt die tatsächlichen Nachfrageänderungen auf Unternehmensseite wider und werden nicht von der Marktstimmung beeinflusst. Die Spreads von Hochzinsanleihen sind das „Stressmaß“ des Kreditmarktes. Wenn die Ausfallrisiken von Unternehmen zunehmen, werden sich die Fonds als Erste aus risikoreichen Vermögenswerten zurückziehen. Dieses Signal geht in der Regel der Reaktion des Aktienmarktes voraus.

Relativ gesehen hat die Genauigkeit des VIX und der Finanzierungssalden in den letzten Jahren abgenommen. Der Hauptgrund dafür ist, dass Zero-Day-Expiration-Optionen (0DTE) die Struktur des Optionsmarktes erheblich verändert und den VIX verzerrt haben; und das kollektive Verhalten von Privatanlegern über soziale Medien hat auch die Signalqualität traditioneller Stimmungsindikatoren verringert.

Methodik für marktübergreifende Vergleiche

Bei Rotationsvergleichen zwischen verschiedenen Märkten muss ein vergleichbarer standardisierter Rahmen geschaffen werden:

Relative Stärke

Vergleichen Sie die Preise zweier Märkte oder Sektoren und beobachten Sie die Trendrichtung des Verhältnisses. Wenn beispielsweise der „MSCI Emerging Markets Index/MSCI Developed Markets Index“ auf einer Kurve dargestellt wird, bedeutet ein Anstieg des Verhältnisses, dass die Schwellenländer eine Outperformance erzielen. Diese Methode kann auf zwei beliebige vergleichbare Vermögenswerte angewendet werden:

• Wachstum vs. Wert: Russell 1000-Wachstum / Russell 1000-Wert
• US-Aktien vs. europäische Aktien: S&P 500 / STOXX 600
• Groß vs. Klein: S&P 500/Russell 2000
• Taiwan-Aktien vs. Festland-Aktien: TAIEX/CSI 300

Z-Score-Normalisierungsmethode

Die Indikatoren verschiedener Märkte werden einheitlich in Z-Score (Vielfache der Standardabweichungen vom Mittelwert) umgerechnet und horizontale Vergleiche können erst nach Eliminierung von Dimensionsunterschieden durchgeführt werden. Die Formel lautet: Z = (aktueller Wert – Mittelwert der vergangenen N Perioden) / Standardabweichung der vergangenen N Perioden. Beispielsweise liegt der PMI der USA bei 52 und der PMI der Eurozone bei 47. Oberflächlich betrachtet gibt es keinen großen Unterschied. Wenn der historische Durchschnitt des US-PMI jedoch 53 beträgt, beträgt die Standardabweichung 3 und der Z-Score beträgt -0,33;

Methode zum Vergleich des wirtschaftlichen Überraschungsindex

Der Citi Economic Surprise Index misst die Abweichung der tatsächlichen Wirtschaftsdaten von den Markterwartungen. Durch einen länderübergreifenden Vergleich dieses Index kann festgestellt werden, welche Region sich über die Erwartungen hinaus verbessert oder verschlechtert. Mittel fließen tendenziell in Märkte, in denen sich der Überraschungsindex verbessert.

Programmierte automatische Datenerfassung und Berechnung von Indikatoren

Im Folgenden finden Sie die vollständige Architektur und das Programmbeispiel für die Verwendung von Python zum Aufbau eines automatisierten Überwachungssystems.

Datenquellen und entsprechende APIs

Kernprogrammierarchitektur

# === Erforderliche Pakete installieren ===
# pip install yfinance fredapi pandas numpy schedule

import yfinance as yf
import pandas as pd
import numpy as np
from fredapi import Fred
from datetime import datetime, timedelta

# FRED-API-Schlüssel (gehen Sie zu https://fred.stlouisfed.org/docs/api/api_key.html, um sich kostenlos zu bewerben)
fred = Fred(api_key='YOUR_FRED_API_KEY')

# ==========================================
# 1. Zinsstrukturkurve: 2-Jahres-10-Jahres-Zinsspanne
# ==========================================
def get_yield_curve_spread():
    gs10 = fred.get_series('DGS10')  # Rendite 10-jähriger Staatsanleihen
    gs2 = fred.get_series('DGS2')    # 2-Jahres-Staatsanleiherendite
    spread = gs10 - gs2
    spread = spread.dropna()
    latest = spread.iloc[-1]
    status = „Upside Down (Rezessionswarnung)“ if latest < 0 else "Normal"
    return {
        'spread': round(latest, 3),
        'status': status,
        'series': spread.tail(252)  # Informationen für das vergangene Jahr
    }

# ==========================================
# 2. Spread bei Hochzinsanleihen
# ==========================================
def get_hy_spread():
    hy = fred.get_series('BAMLH0A0HYM2')
    hy = hy.dropna()
    latest = hy.iloc[-1]
    avg_1y = hy.tail(252).mean()
    z_score = (latest - hy.tail(756).mean()) / hy.tail(756).std()
    return {
        'spread_bp': round(latest * 100, 0),
        'z_score': round(z_score, 2),
        'risk_level': „hohes Risiko“ if z_score > 1.5 else "neutral" if z_score > -0.5 else „geringes Risiko“
    }

# ==========================================
# 3. Bronze-Gold-Verhältnis
# ==========================================
def get_copper_gold_ratio():
    copper = yf.download('HG=F', period='2y')['Close']
    gold = yf.download('GC=F', period='2y')['Close']
    ratio = copper / gold
    ratio = ratio.dropna()
    current = ratio.iloc[-1]
    ma_200 = ratio.rolling(200).mean().iloc[-1]
    trend = „Signal der wirtschaftlichen Expansion“ if current > ma_200 else „Signal für wirtschaftlichen Abschwung“
    return {'ratio': round(current, 5), 'ma200': round(ma_200, 5), 'trend': trend}

# ==========================================
# 4. Vergleich der relativen Stärke zwischen den Märkten
# ==========================================
def relative_strength(ticker_a, ticker_b, period='1y'):
    „““Berechnen Sie das relative Stärkeverhältnis und den Trend zweier Vermögenswerte““
    a = yf.download(ticker_a, period=period)['Close']
    b = yf.download(ticker_b, period=period)['Close']
    ratio = a / b
    ratio = ratio.dropna()
    ma_50 = ratio.rolling(50).mean()
    latest_ratio = ratio.iloc[-1]
    latest_ma = ma_50.iloc[-1]
    outperformer = ticker_a if latest_ratio > latest_ma else ticker_b
    return {
        'ratio': round(latest_ratio, 4),
        'ma50': round(latest_ma, 4),
        'outperformer': outperformer,
        'series': ratio
    }

#Anwendungsbeispiel:
# relative_strength('IWF', 'IWD') # Wachstum vs. Wert
# relative_strength('EEM', 'SPY') # Schwellenländer vs. US-Aktien
# relative_strength('^TWII', '000300.SS') # Taiwan-Aktien vs. CSI 300

# ==========================================
# 5. Z-Score-normalisierter marktübergreifender Vergleich
# ==========================================
def zscore_compare(series_dict, lookback=756):
    „““
    Erhalten Sie Zeitreihen aus mehreren Märkten, berechnen Sie den Z-Score und vergleichen Sie horizontal
    series_dict: {'United States': pd.Series, 'Europe': pd.Series, ...}
    „““
    results = {}
    for name, series in series_dict.items():
        s = series.dropna().tail(lookback)
        current = s.iloc[-1]
        z = (current - s.mean()) / s.std()
        results[name] = {
            'current': round(current, 3),
            'z_score': round(z, 2),
            'percentile': round((s < current).mean() * 100, 1)
        }
    return pd.DataFrame(results).T.sort_values('z_score', ascending=False)

# ==========================================
# 6. Branchen-Momentum-Ranking
# ==========================================
def sector_momentum_ranking():
    „Erzielte Mehrperioden-Momentum und Ranking von 11 großen US-Aktiensektor-ETFs“
    sectors = {
        „Wissenschaft und Technologie“: 'XLK', 'Finanzen': 'XLF', „Medizin“: 'XLV',
        „Nicht lebensnotwendiger Konsum“: 'XLY', „Grundlegender Konsum“: 'XLP', 'Industrie': 'XLI',
        'Energie': 'XLE', „Rohstoffe“: 'XLB', 'Dienstprogramme': 'XLU',
        'Immobilie': 'XLRE', 'Kommunikation': 'XLC'
    }
    results = []
    for name, ticker in sectors.items():
        data = yf.download(ticker, period='1y')['Close']
        ret_1m = (data.iloc[-1] / data.iloc[-21] - 1) * 100
        ret_3m = (data.iloc[-1] / data.iloc[-63] - 1) * 100
        ret_6m = (data.iloc[-1] / data.iloc[-126] - 1) * 100
        # Umfassender Momentum-Score: höhere Gewichtung in naher Zukunft
        score = ret_1m * 0.4 + ret_3m * 0.35 + ret_6m * 0.25
        results.append({
            'Platte': name, '1 Monat%': round(ret_1m, 2),
            '3 Monate%': round(ret_3m, 2), '6 Monate%': round(ret_6m, 2),
            „Umfassende kinetische Energie“: round(score, 2)
        })
    df = pd.DataFrame(results).sort_values(„Umfassende kinetische Energie“, ascending=False)
    return df.reset_index(drop=True)

Automatische Planung und Benachrichtigungen

import schedule
import time
import requests

def send_line_notify(token, msg):
    „“„Eine Nachricht über LINE Notify senden““
    headers = {'Authorization': f'Bearer {token}'}
    requests.post('https://notify-api.line.me/api/notify',
                  headers=headers, data={'message': msg})

def daily_rotation_report():
    „Täglicher Rotationsüberwachungsbericht“
    yc = get_yield_curve_spread()
    hy = get_hy_spread()
    cg = get_copper_gold_ratio()
    sectors = sector_momentum_ranking()

    report = f"""
=== Tägliche Rotationsüberwachung ===
Datum: {datetime.now().strftime('%Y-%m-%d')}

Renditekurve (2J-10J): {yc['spread']}% {yc['status']}
Spread Z-Score für Hochzinsanleihen: {hy['z_score']} ({hy['risk_level']})
Trend des Kupfer-Gold-Verhältnisses: {cg['trend']}

Die drei besten Branchen-Momentum-Rankings:
{sectors.head(3).to_string(index=False)}

Die Sektordynamik liegt auf den letzten drei Plätzen:
{sectors.tail(3).to_string(index=False)}
„““
    print(report)
    # send_line_notify('YOUR_LINE_TOKEN', report)
    return report

# Wird jeden Handelstag um 18:00 Uhr ausgeführt
schedule.every().monday.at("18:00").do(daily_rotation_report)
schedule.every().tuesday.at("18:00").do(daily_rotation_report)
schedule.every().wednesday.at("18:00").do(daily_rotation_report)
schedule.every().thursday.at("18:00").do(daily_rotation_report)
schedule.every().friday.at("18:00").do(daily_rotation_report)

while True:
    schedule.run_pending()
    time.sleep(60)

Umfassende Berechnungslogik für das Rad-Dashboard

def rotation_dashboard():
    „““
    Umfassende Mehrfachindikatoren zur Beurteilung der aktuellen Konjunkturzyklusphase
    Rendite: Wahrscheinlichkeitsschätzung für Erholung/Expansion/Überhitzung/Rezession
    „““
    scores = {'Erholung': 0, 'Erweiterung': 0, 'überhitzen': 0, 'Abfall': 0}

    #Zinskurvensignal
    yc = get_yield_curve_spread()
    if yc['spread'] < -0.5:
        scores['Abfall'] += 3
    elif yc['spread'] < 0:
        scores['überhitzen'] += 2; scores['Abfall'] += 1
    elif yc['spread'] < 1.0:
        scores['Erweiterung'] += 2
    else:
        scores['Erholung'] += 3

    # Spread-Signal für Hochzinsanleihen
    hy = get_hy_spread()
    if hy['z_score'] > 1.5:
        scores['Abfall'] += 3
    elif hy['z_score'] > 0.5:
        scores['überhitzen'] += 2
    elif hy['z_score'] > -0.5:
        scores['Erweiterung'] += 2
    else:
        scores['Erholung'] += 2

    # Kupfer-Gold-Verhältnissignal
    cg = get_copper_gold_ratio()
    if cg['ratio'] > cg['ma200']:
        scores['Erweiterung'] += 2
    else:
        scores['Abfall'] += 1; scores['Erholung'] += 1

    # In Wahrscheinlichkeitsverteilung umwandeln
    total = sum(scores.values())
    probs = {k: round(v/total*100, 1) for k, v in scores.items()}
    phase = max(probs, key=probs.get)

    return {
        „Gerichtszyklus“: phase,
        „Wahrscheinlichkeit jeder Stufe“: probs,
        „Empfohlene Konfiguration“: {
            'Erholung': „Übergewichtung von Technologie und Finanzen; Untergewicht defensiv,
            'Erweiterung': „Übergewichtung von Rohstoffen und Energie; Aufrechterhaltung eines hohen Wasserstandes der Bestände,
            'überhitzen': „Wachstumsaktien untergewichtet; Erhöhung der Rohstoffe und Anti-Inflations-Vermögenswerte,
            'Abfall': „Staatsverschuldung und Bargeld erhöhen; Übergewichtung defensiver Sektoren
        }[phase]
    }

Erweitert: Überwachung der Rotation des taiwanesischen Aktiensektors

def tw_sector_rotation():
    „“„Taiwan-Aktien-ETF-Momentum-Tracking““
    tw_sectors = {
        „Taiwan Semiconductor“: '00891.TW',
        „Taiwan ESG-Nachhaltigkeit“: '00850.TW',
        „Taiwan-Finanzen“: '0055.TW',
        „Taiwan hohe Dividenden“: '0056.TW',
        „Taiwan 50“: '0050.TW',
        „Taiwan Medium 100“: '0051.TW',
    }
    results = []
    for name, ticker in tw_sectors.items():
        try:
            data = yf.download(ticker, period='6mo')['Close'].dropna()
            if len(data) < 63:
                continue
            ret_1m = (data.iloc[-1] / data.iloc[-21] - 1) * 100
            ret_3m = (data.iloc[-1] / data.iloc[-63] - 1) * 100
            results.append({
                'Aktie': name,
                „1 Monatsvergütung %“: round(ret_1m, 2),
                '3 Monatsvergütung%': round(ret_3m, 2),
                „Kinetischer Energieanteil“: round(ret_1m * 0.5 + ret_3m * 0.5, 2)
            })
        except Exception as e:
            print(f"{name}Folgendes konnte nicht abgerufen werden:{e}")
    return pd.DataFrame(results).sort_values(„Kinetischer Energieanteil“, ascending=False)

Praktische Vorschläge

Der Kernwert der programmierten Überwachung besteht nicht darin, das menschliche Urteilsvermögen zu ersetzen, sondern emotionale Störungen zu beseitigen und Disziplin sicherzustellen. Folgende Punkte erfordern beim Aufbau des Systems besondere Aufmerksamkeit:

1. Die Erfolgsquote eines einzelnen Indikators liegt bei etwa 55 bis 65 %, und eine Kreuzvalidierung mehrerer Indikatoren ist erforderlich, um die Zuverlässigkeit auf über 70 % zu erhöhen.
2. Die FRED-API hat ein tägliches Aufruflimit von 120 (kostenlose Version). Es wird empfohlen, die erhaltenen Daten lokal in SQLite oder CSV zu speichern, um wiederholte Anfragen zu vermeiden.
3. yfinance ist keine offizielle API und kann aufgrund von Yahoo-Überarbeitungen gelegentlich ungültig werden. Es wird empfohlen, Try-Except- und alternative Quellen (z. B. FinMind für taiwanesische Aktien) hinzuzufügen.
4. Für alle Indikatoren gelten gültige Zeitrahmen. Die Zinsstrukturkurve eignet sich für die mittel- und langfristige Beurteilung (mehr als 6 Monate) und die Sektordynamik eignet sich für die kurz- und mittelfristige Beurteilung (1 bis 3 Monate). Beim Mischen müssen Sie auf die Konsistenz der Zeitskala achten.
5. Es wird empfohlen, einmal pro Woche einen vollständigen Bericht zu erstellen und ungewöhnliche Veränderungen täglich nur zu überwachen (z. B. die Spread-Ausweitung um mehr als 20 Basispunkte an einem einzigen Tag), um übermäßigen Handel zu vermeiden.

Python yfinance-Paket

yfinance ist eine von Ran Aroussi entwickelte Open-Source-Python-Suite zum Abrufen von Finanzmarktdaten von Yahoo Finance. Nachdem Yahoo Finance 2017 seine offizielle API geschlossen hatte, wurde yfinance zum beliebtesten Tool für den Zugriff auf seine öffentlichen Informationen. Die neueste Version ist 1.2.0 (veröffentlicht im Februar 2026), die von Apache lizenziert ist, völlig kostenlos und für Forschungs- und Bildungszwecke geeignet ist.

Installation und Grundeinrichtung

# Installieren
pip install yfinance

#Upgrade auf die neueste Version
pip install yfinance --upgrade

# Grundlegender Import
import yfinance as yf

Zu den Abhängigkeitspaketen von yfinance gehören Pandas, Numpy, Requests und LXML, die bei Verwendung der Anaconda-Umgebung alle vorinstalliert sind.

Übersicht über die Kernkategorien und Funktionen

Zugänglicher Datenbereich

Die Informationen, die yfinance erhalten kann, gehen weit über einfache Aktienkurse hinaus und decken die folgenden Kategorien ab:

Unterstützte Zielcodeformate

Historische Preise: Am häufigsten verwendete Funktionen

import yfinance as yf

# ========================================
# Methode 1: Verwenden Sie das Ticker-Objekt (geeignet für die detaillierte Analyse eines einzelnen Ziels).
# ========================================
tsmc = yf.Ticker("2330.TW")

# Erhalten Sie historische Preise
hist = tsmc.history(period="1y")        # fast ein Jahr
hist = tsmc.history(period="6mo")       # Letzte 6 Monate
hist = tsmc.history(period="5d")        # Letzte 5 Tage
hist = tsmc.history(period="max")       # alle Geschichte
hist = tsmc.history(start="2024-01-01",
                    end="2025-12-31")   #Datumsbereich angeben

# Optionen für Periodenparameter:
# 1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, 10y, ytd, max

# ========================================
#Methode 2: Verwenden Sie download() (geeignet für den Batch-Download mehrerer Standards)
# ========================================
data = yf.download(
    tickers="SPY QQQ EEM GC=F BTC-USD",
    period="1y",
    interval="1d",      #日线
    group_by="ticker",  #Nach Ziel gruppieren
    auto_adjust=True,   # Ex-Rechtszinsen automatisch anpassen
    threads=True        #Mehrere Threads beschleunigen das Herunterladen
)
# Auf bestimmte Objekte zugreifen: data['SPY']['Close']

# ========================================
# Zeitgranularität (Intervallparameter)
# ========================================
# Minutenniveau: 1 m, 2 m, 5 m, 15 m, 30 m, 60 m, 90 m
# Stundenstufe: 1h
# Tagesniveau und höher: 1 Tag, 5 Tage, 1 Woche, 1 Monat, 3 Monate
#
# Einschränkungen beachten:
# 1 Mio. Daten können nur aus den letzten 7 Tagen abgerufen werden
# Intraday-Daten (Intervall < 1 Tag) können nur die letzten 60 Tage umfassen
# Oberhalb der Tageslinie stehen jahrzehntelange Geschichte zur Verfügung

# Holen Sie sich die 5-Minuten-K-Linie (letzte 5 Tage)
intraday = yf.download("AAPL", period="5d", interval="5m")

Zurückgegebene DataFrame-Struktur

Sowohl „history()“ als auch „download()“ geben den Pandas DataFrame zurück, der die folgenden Felder enthält:

Unternehmensinformationen und Finanzberichte

msft = yf.Ticker("MSFT")

# === Grundlegende Unternehmensinformationen (Return-Dikt) ===
info = msft.info
print(info['marketCap'])         # Marktkapitalisierung
print(info['trailingPE'])        # Preis-Gewinn-Verhältnis
print(info['dividendYield'])     #Dividendenrendite
print(info['fiftyTwoWeekHigh'])  #52 Wochenhoch
print(info['sector'])             #Industrie
print(info['longBusinessSummary'])# Unternehmensprofil

# === Finanzberichte (Return DataFrame) ===
msft.income_stmt              # Jährliche Gewinn- und Verlustrechnung
msft.quarterly_income_stmt    # Vierteljährliche Gewinn- und Verlustrechnung
msft.balance_sheet            # Jahresbilanz
msft.quarterly_balance_sheet  # Vierteljährliche Bilanz
msft.cashflow                 #Jährliche Kapitalflussrechnung
msft.quarterly_cashflow       # Vierteljährliche Kapitalflussrechnung

# === Dividenden und Splits ===
msft.dividends                #Historische Dividenden
msft.splits                   # Historische Aktiensplits
msft.actions                  # Dividende + Split-Fusion

# === Analysteninformationen ===
msft.analyst_price_targets    # Zielpreis (hoch/niedrig/durchschnittlich/median)
msft.recommendations          #Analystenbewertungen
msft.calendar                 # Kalender (Finanzberichtstag usw.)

# === Beteiligung juristischer Personen ===
msft.institutional_holders    # Institutionelle Bestände
msft.major_holders            # Großaktionäre
msft.insider_transactions     #Insiderhandel

# === Auswahl ===
msft.options                  # Liste der verfügbaren Fälligkeitstermine
chain = msft.option_chain(msft.options[0])
chain.calls                   # Anrufinformationen
chain.puts                    # Informationen eingeben

Praktische Tipps und gängige Muster

# ========================================
# 1. Erhalten Sie den Schlusskurs eines einzelnen Ziels nach dem Batch-Download
# ========================================
data = yf.download(["SPY", "GC=F", "BTC-USD"], period="1y")
spy_close = data['Close']['SPY']     # Multi-Index ist MultiIndex

# Direkter Zugriff beim Herunterladen eines einzelnen Ziels
spy = yf.download("SPY", period="1y")
spy_close = spy['Close']

# ========================================
# 2. .squeeze()-Technik zur Handhabung von MultiIndex
# ========================================
# Beim Herunterladen eines einzelnen Ziels lautet das Feld „Schließen“ möglicherweise „DataFrame“ statt „Serie“.
# Verwenden Sie .squeeze(), um die Konvertierung in eine Serie sicherzustellen
close = yf.download("AAPL", period="1y")['Close'].squeeze()

# ========================================
# 3. Fehlerbehandlung (yfinance kann gelegentlich fehlschlagen)
# ========================================
def safe_download(ticker, **kwargs):
    „“„Sicherer Download, leeren DataFrame zurückgeben, wenn fehlgeschlagen““
    try:
        data = yf.download(ticker, progress=False, **kwargs)
        if data.empty:
            print(f"{ticker}: Keine Informationen")
        return data
    except Exception as e:
        print(f"{ticker}Download fehlgeschlagen:{e}")
        return pd.DataFrame()

# ========================================
# 4. Schnelle Überprüfung häufig verwendeter Codes für taiwanesische Aktien
# ========================================
tw_tickers = {
    'TSMC': '2330.TW',
    „Hon Hai“:   '2317.TW',
    „MediaTek“: '2454.TW',
    „Taiwan 50“: '0050.TW',
    „Hohe Dividende“: '0056.TW',
    'Finanzen':   '0055.TW',
    'Halbleiter': '00891.TW',
    'Gewichteter Index': '^TWII',
}

# ========================================
# 5. Vollständiges Beispiel zur Berechnung technischer Indikatoren
# ========================================
import pandas as pd

ticker = yf.Ticker("2330.TW")
df = ticker.history(period="1y")

# gleitender Durchschnitt
df['MA20'] = df['Close'].rolling(20).mean()
df['MA60'] = df['Close'].rolling(60).mean()
df['EMA12'] = df['Close'].ewm(span=12).mean()

# RSI
delta = df['Close'].diff()
gain = delta.where(delta > 0, 0).rolling(14).mean()
loss = (-delta.where(delta < 0, 0)).rolling(14).mean()
df['RSI'] = 100 - (100 / (1 + gain / loss))

# Bollinger-Bänder
df['BB_mid'] = df['Close'].rolling(20).mean()
df['BB_std'] = df['Close'].rolling(20).std()
df['BB_upper'] = df['BB_mid'] + 2 * df['BB_std']
df['BB_lower'] = df['BB_mid'] - 2 * df['BB_std']

print(df[['Close','MA20','RSI','BB_upper','BB_lower']].tail())

# ========================================
# 6. Als CSV exportieren
# ========================================
df.to_csv("tsmc_data.csv", encoding="utf-8-sig")  #utf-8-sig ermöglicht Excel die korrekte Anzeige von Chinesisch

Nutzungsbeschränkungen und Vorsichtsmaßnahmen

Vergleich von Alternativen

Für persönliches Recherchieren und Lernen, Strategie-Prototyping und mittel- bis langfristige Investitionsanalysen ist yfinance der beste Ausgangspunkt. Sein einfaches Design ermöglicht es Anfängern, globale Marktdaten mit zwei oder drei Codezeilen zu erhalten und diese mit Pandas zu analysieren. Wenn die Anforderungen auf Echtzeittransaktionen oder kommerzielle Anwendungen erweitert werden, können Sie auf kostenpflichtige APIs zurückgreifen.

Datenbankdesign für den Handelsmarkt

1. Datenbankstruktur

2. Beziehungsbeschreibung

• UserTabelle: Speichert Benutzerinformationen, einschließlich Käufer und Verkäufer.
• ProductTabelle: Speichert Produktinformationen und jedes Produkt ist einem Verkäufer zugeordnet.
• OrderTabelle: Speichert Bestellinformationen und jede Bestellung ist einem Käufer zugeordnet.
• OrderItemTabelle: Speichert die detaillierten Informationen zu den Produkten in der Bestellung und verknüpft sie mit den Produkten und Bestellungen.
• PaymentTabelle: Speichert Zahlungsinformationen. Jede Zahlung entspricht einer Bestellung.

Datenbankdesign für öffentliche Handelsmärkte

1. Datenbankstruktur

2. Beziehungsbeschreibung

• AssetTabelle: Speichert die grundlegenden Informationen zu Handelswerten, einschließlich Name, Vermögenswerttyp, Basiswert (BaseAsset) und notierter Vermögenswert (QuoteAsset), sowie den aktuellen Preis und die letzte Aktualisierungszeit.
• MarketDataTisch: mitAssetDie Tabellenzuordnung zeichnet tägliche Marktdaten wie Preisschwankungen und Handelsvolumen auf, um die Wertentwicklung von Vermögenswerten zu analysieren.
• OrderBookTisch: mitAssetDie Tabellenzuordnung zeichnet Momentaufnahmen des Auftragsbuchs zu einem bestimmten Zeitpunkt auf, um die Markttiefe sowie die Angebots- und Nachfragebedingungen zu analysieren.
• HistoricalTradeTisch: mitAssetDie Tabellenzuordnung zeichnet historische Transaktionsaufzeichnungen von Vermögenswerten auf und wird zur Analyse von Transaktionsmustern und zur quantitativen Forschung verwendet.

3. Schlüsselfunktionen

• Vermögenspreisanalyse: Basierend aufMarketDataTabellendaten berechnen Volatilität und Rendite und beobachten die Trends verschiedener Vermögensportfolios (BaseAsset/QuoteAsset).
• Markttiefe und Liquidität: BestandenOrderBookDie Tabelle analysiert das Verhalten der Marktteilnehmer und seine Auswirkungen auf die Vermögenspreise.
• Analyse des Handelsverhaltens: AusbeutungHistoricalTradeTabellendaten, entdecken Sie Perioden mit hoher Handelsfrequenz und Preis-Volumen-Korrelation.
• Basis- und Angebots-Asset-Struktur: VonAssetVerwalten Sie Handelspaare (z. B. BTC/USD) in der Tabelle, um eine Multi-Asset-Analyse zu erreichen.

MetaQuotes Language (MQL)

Sprachübersicht

MetaQuotes Language (kurz MQL) ist eine Programmiersprache, die speziell für den Finanzmarkthandel entwickelt wurde und zur Erstellung automatisierter Handelsstrategien (Expert Advisors), benutzerdefinierter Indikatoren, Skripte und Funktionsbibliotheken in MetaTrader-Plattformen (wie MT4 und MT5) verwendet wird.

MQL4 und MQL5

• MQL4：Die in MetaTrader 4 verwendete Syntax ähnelt der C-Sprache und eignet sich für die Entwicklung grundlegender automatischer Handelsprogramme.
• MQL5：Für MetaTrader 5 ist es leistungsfähiger und unterstützt objektorientierte Programmierung, ereignisgesteuerte Architektur und Multithread-Optimierung.

Anwendungstyp

• Expert Advisor (EA)：Automatische Handelsroboter können gemäß voreingestellten Strategien Aufträge erteilen, Positionen schließen, Stop-Losses setzen und andere Vorgänge ausführen.
• Custom Indicators：Benutzerdefinierte technische Indikatoren zur Analyse von Preisdaten und zur Unterstützung von Handelsentscheidungen.
• Scripts：Führen Sie einmalige Aufgaben durch, z. B. das gleichzeitige Schließen aller Aufträge, das Ändern aller Stop-Loss-Levels usw.
• Libraries：Funktionsbibliothek, gemeinsamer Code zur Wiederverwendung durch mehrere EAs oder Indikatoren.

Grammatische Merkmale

• Die grundlegende Syntax ähnelt C/C++
• Unterstützt Variablen, bedingte Beurteilungen, Schleifen, Funktionen und benutzerdefinierte Datenstrukturen
• Zugriff auf Marktdaten (Preis, Zeit, Volumen usw.)
• Unterstützt Diagrammzeichnung und UI-Komponenten (MQL5)

Einfaches Beispiel: EA für MQL4

// Jedes Mal ausführen, wenn ein neuer K-Stick gestartet wird
int start() {
    if (OrdersTotal() == 0 && Volume[0] == 1) {
        OrderSend(Symbol(), OP_BUY, 0.1, Ask, 3, 0, 0, "Buy Order", 0, 0, clrGreen);
    }
    0 zurückgeben;
}

Einfaches Beispiel: Indikatoren für MQL5

#property indicator_separate_window
#property indicator_buffers 1
double Buffer[];

int OnInit() {
    SetIndexBuffer(0, Buffer);
    return(INIT_SUCCEEDED);
}

int OnCalculate(const int rates_total, const int prev_calculated,
                const datetime &time[], const double &open[],
                const double &high[], const double &low[],
                const double &close[], const long &tick_volume[],
                const long &volume[], const int &spread[]) {
    for (int i = 0; i < rates_total; i++) {
        Buffer[i] = close[i] - open[i];
    }
    return(rates_total);
}

Entwicklungstools

MQL-Code kann über den integrierten MetaEditor von MetaTrader bearbeitet und kompiliert sowie im Strategietester rückgetestet und optimiert werden.

Lernen und Gemeinschaft

• Offizielle MQL5-Website (einschließlich Chinesisch)
• Offizielle Foren, Dokumentation, CodeBase und Freelance-Funktionen unterstützen Lernen und Kommunikation
• Zehntausende vorgefertigte EAs und Indikatoren stehen zum Download oder Kauf zur Verfügung

Abschluss

MetaQuotes Language ist eine professionelle Sprache, die für die Handelsautomatisierung entwickelt wurde. Sowohl Einsteiger als auch professionelle quantitative Händler können die leistungsstarken Funktionen nutzen, um anspruchsvolle Handelsstrategien umzusetzen.

TradingView-Gadget

Erweitertes Echtzeitdiagramm

Dies ist die umfassendste Version, einschließlich mehrerer Indikatoren, Zeichentools und einer vollständigen Handelsschnittstelle (sofern mit einem Broker verbunden).

<!-- Erweiterter Diagrammcontainer -->
<div class="tradingview-widget-container">
  <div id="tradingview_adv"></div>
  <script type="text/javascript" src="https://s3.tradingview.com/tv.js"></script>
  <script type="text/javascript">
  neues TradingView.widget({
    „Autosize“: wahr,
    „symbol“: „BINANCE:BTCUSDT“,
    „Intervall“: „H“,
    „timezone“: „Etc/UTC“,
    „Thema“: „dunkel“,
    „Stil“: „1“,
    „locale“: „zh_TW“,
    „container_id“: „tradingview_adv“
  });
  </script>
</div>

Technische Analyse-Gadget (Technische Analyse)

Dieses Tool wird als Dashboard dargestellt und berechnet und zeigt automatisch Kauf- oder Verkaufsempfehlungen auf Basis verschiedener technischer Indikatoren (z. B. gleitende Durchschnitte, Oszillatoren) an.

<!-- Technische Analyse-Gadget -->
<div class="tradingview-widget-container">
  <div class="tradingview-widget-container__widget"></div>
  <script type="text/javascript" src="https://s3.tradingview.com/external-embedding/embed-widget-technical-analysis.js" async>
  {
    „Intervall“: „1m“,
    „Breite“: 425,
    „isTransparent“: falsch,
    „Höhe“: 450,
    „symbol“: „NASDAQ:TSLA“,
    „showIntervalTabs“: true,
    „locale“: „zh_TW“,
    „colorTheme“: „Licht“
  }
  </script>
</div>

Widget „Marktübersicht“ (Marktübersicht)

Es eignet sich zur Darstellung von Echtzeit-Preisvergleichen mehrerer Produkte. Es ist häufig in der Seitenleiste der Homepage von Finanzwebsites zu finden.

<!-- Marktübersicht -->
<div class="tradingview-widget-container">
  <script type="text/javascript" src="https://s3.tradingview.com/external-embedding/embed-widget-market-overview.js" async>
  {
    „colorTheme“: „dunkel“,
    „dateRange“: „12M“,
    „showChart“: wahr,
    „locale“: „zh_TW“,
    „Breite“: „100 %“,
    „Höhe“: „400“,
    "Tabs": [
      {
        „Titel“: „Index“,
        „Symbole“: [
          {"s": "FOREXCOM:SPX500", "d": "S&P 500"},
          {"s": "FOREXCOM:NSXUSD", "d": "Nasdaq 100"}
        ]
      }
    ]
  }
  </script>
</div>

So erhalten Sie benutzerdefinierten Code

Obwohl es möglich ist, JavaScript manuell zu schreiben, stellt TradingView einen offiziellen Grafikgenerator zur Verfügung, der zur Vermeidung von Syntaxfehlern empfohlen wird:

• Gehe zuTradingView Widget Library。
• Wählen Sie den gewünschten Gadget-Typ aus.
• Passen Sie Farbe, Größe und Standardprodukte im Einstellungsfeld an.
• Klicken Sie auf „Anwenden“ und kopieren Sie den generierten HTML-Code.

Häufig gestellte Fragen

Entwicklung eines Kryptowährungsprogramms

Binance API – Spot- und Kundeneinführung

Binance ist eine führende globale Kryptowährungsbörse, die Entwicklern umfassende API-Unterstützung bietet, darunterSpot APIUndClient API, um Benutzern die Durchführung automatischer Transaktionen und die Datenerfassung zu erleichtern.

Binance Spot API

Binance Spot API ist eine von Binance für Spotmarkthändler entwickelte API. Es kann zum Abfragen von Marktinformationen, zum Erteilen von Bestellungen, zum Stornieren von Bestellungen und für andere Vorgänge verwendet werden. Diese API wird häufig verwendet, um Trading-Bots und automatisierte Handelsstrategien zu entwerfen und Marktschwankungen zu überwachen.

Hauptfunktionen

• Marktinformationsanfrage: Einschließlich aktuellem Preis, K-Linien-Diagramm, Tiefendaten usw.
• Bestellungen aufgeben und handeln: Unterstützt verschiedene Auftragsarten wie Limit-Orders und Market-Orders.
• Kontoinformationen: Vermögenssalden, Transaktionsaufzeichnungen usw. anzeigen.
• Auftragsverwaltung: Einschließlich Vorgänge wie das Abfragen des Bestellstatus und das Stornieren von Bestellungen.

Binance Client API

Die Binance Client API bietet eine bequeme Möglichkeit, auf die verschiedenen API-Methoden von Binance zuzugreifen. Entwickler können verwendenbinance.clientBibliotheks-API Authentifizierung und Verwaltung sowie komfortabler Aufruf von Funktionen verschiedener Spot- und Vertragsmärkte.

Hauptfunktionen der Client-API

• API-Zertifizierung: Benutzer authentifizieren sich über API-Schlüssel und Geheimschlüssel.
• Vermögensverwaltung: Benutzervermögen bequem verwalten und Kontostandabfragen und Transaktionen in mehreren digitalen Währungen unterstützen.
• Umfassende Marktdatenerfassung: Kann Spot-API und Vertrags-API aufrufen und Daten aus verschiedenen Märkten integrieren.
• Einstellungen zur Risikokontrolle: Ermöglicht das Festlegen von Transaktionslimits und die Beauftragung des Managements, um Transaktionsrisiken zu reduzieren.

So verwenden Sie Binance Spot mit der Client-API

1. Zuerst müssen Sie den API-Schlüssel und den Geheimschlüssel bei Binance beantragen und diese ordnungsgemäß aufbewahren.
2. Installieren Sie das Binance API Python SDK:pip install binance
3. verwendenbinance.clientStellen Sie eine API-Verbindung her und rufen Sie aufbinance.spotVerfahren.

von binance.client Import-Client

    #Client initialisieren
    client = Client(api_key='your_api_key', api_secret='your_secret_key')

    # Holen Sie sich den aktuellen Preis
    Preis = client.get_symbol_ticker(symbol="BTCUSDT")
    drucken (Preis)

Bybit API

veranschaulichen

Bybit stellt REST- und WebSocket-APIs bereit, mit denen Marktbedingungen abgefragt, Bestellungen aufgegeben, Finanzierungsraten überprüft, Konten verwaltet usw. werden können. Im Folgenden wird gezeigt, wie Python verwendet wirdrequestsDie Suite ruft die öffentliche API von Bybit auf.

Installationssatz

pip install requests

Fragen Sie die Liste der Handelspaare ab

Importanfragen

BASE_URL = „https://api.bybit.com“

def get_symbols():
    url = f"{BASE_URL}/v5/market/instruments-info?category=linear"
    res = request.get(url)
    res.raise_for_status()
    data = res.json()
    symbole = [s["symbol"] für s in data["result"]["list"]]
    print(f"Es wurden insgesamt {len(symbols)} Handelspaare erhalten:")
    print(symbols[:10]) # Zeigt die ersten 10 Elemente an

if __name__ == "__main__":
    get_symbols()

K-Line-Informationen abfragen

import requests

def get_klines(symbol="BTCUSDT", interval="60", limit=5):
    url = f"{BASE_URL}/v5/market/kline?category=linear&symbol={symbol}&interval={interval}&limit={limit}"
    res = requests.get(url)
    res.raise_for_status()
    data = res.json()
    for k in data["result"]["list"]:
        print(k)

if __name__ == "__main__":
    get_klines()

Private API, die eine Signatur erfordert

Die privaten Endpunkte von Bybit wie Auftragserteilung und Asset-Abfrage erfordern einen API-Schlüssel und eine Signatur.

Importanfragen, Zeit, Hmac, Hashlib

API_KEY = „your_api_key“
API_SECRET = „your_api_secret“

def sign_request(params, Secret):
    „Bybit-Signaturgenerierung“
    query = "&".join([f"{k}={v}" for k, v in sorted(params.items())])
    return hmac.new(secret.encode(), query.encode(), hashlib.sha256).hexdigest()

def get_wallet_balance():
    endpoint = „/v5/account/wallet-balance“
    URL = BASE_URL + Endpunkt
    Zeitstempel = str(int(time.time() * 1000))

    Parameter = {
        „accountType“: „UNIFIED“,
        „timestamp“: Zeitstempel,
        "api_key": API_KEY,
    }
    params["sign"] = sign_request(params, API_SECRET)

    res = request.get(url, params=params)
    print(res.json())

if __name__ == "__main__":
    get_wallet_balance()

Auffüllen

• Offizielle Dokumente von Bybit:https://bybit-exchange.github.io/docs/v5/
• Die API ist unterteilt in:
  • Public(Keine Unterschrift erforderlich) – Marktdaten, K-Linie, Zielinformationen
  • Private(Unterschrift erforderlich) - Aufträge erteilen, Kontostand prüfen, Positionen schließen und Positionen verwalten
• Unterstützt Markttypen wie Linear (USDT Perpetual), Inverse, Spot usw.

Bybit erhält eine bestimmte Art von Handelspaar

veranschaulichen

Pionex verwendet/api/v1/common/symbols?type=PERPUm das Handelspaar „Perpetual Contract“ zu erhalten; Auf Bybit können Sie verwenden/v5/market/instruments-infound angebencategory=linear(USDT unbefristet) oderinverse(umgekehrter Vertrag) erzielt den gleichen Effekt.

Python-Beispiel

Importanfragen

classBybitAPI:
    BASE_URL = „https://api.bybit.com“

    @classmethod
    def get_symbols(cls, Category="linear"):
        „““
        Holen Sie sich eine bestimmte Art von Handelspaar
        Kategorie kann sein:
          - linear → USDT Perpetual (PERP)
          - invers → Inverser unbefristeter Vertrag/Liefervertrag
          - Punkt → Punkt
        „““
        endpoint = "/v5/market/instruments-info"
        url = f"{cls.BASE_URL}{endpoint}"
        params = {"Kategorie": Kategorie}
        
        res = request.get(url, params=params)
        res.raise_for_status()
        data = res.json()

        wenn data.get("retCode") == 0:
            symbole = [s["symbol"] für s in data["result"]["list"]]
            print(f"Insgesamt wurden Handelspaare vom Typ {len(symbols)} {category} erhalten")
            für s in Symbolen[:10]:
                Druck(e)
        sonst:
            print("Erfassung fehlgeschlagen:", Daten)

if __name__ == "__main__":
    BybitAPI.get_symbols("linear")

Parametervergleichstabelle

Beispiel für ein Rückgabedatenformat

{
  "retCode": 0,
  "result": {
    "list": [
      {
        "symbol": "BTCUSDT",
        "contractType": "LinearPerpetual",
        "status": "Trading",
        "lotSizeFilter": {
          "minOrderQty": "0.001",
          "maxOrderQty": "100",
          "qtyStep": "0.001"
        },
        "priceFilter": {
          "tickSize": "0.5"
        }
      }
    ]
  }
}

Auffüllen

• category=linearDas heißt, es entspricht dem Handelspaar „PERP“ von Pionex.
• Zu den Vertragsinformationen von Bybit gehört auch:priceFilter、lotSizeFilterund andere Einschränkungen.
• Wenn Sie mehrere Typen gleichzeitig prüfen möchten, können Sie die API mehrmals aufrufen.

Bybit REST API fragt K-Line-Daten ab

veranschaulichen

Erhältlich in Pionex/api/v1/market/klinesÜberprüfen Sie die Marktsituation; Der entsprechende Endpunkt von Bybit ist/v5/market/kline. durchcategoryGeben Sie den Markttyp an (z. B.linearStellt einen unbefristeten USDT-Vertrag dar) und kann übergeben werdensymbol、interval、limit、endTimeund andere Parameter.

Python-Beispielfunktion

Importanfragen
Importzeit

classBybitAPI:
    BASE_URL = „https://api.bybit.com“

    @classmethod
    def get_klines(cls, Symbol: str, Intervall: str, end_time: int = None, limit: int = 100):
        „““
        Fragen Sie Bybit-K-Line-Informationen ab
        :param-Symbol: Handelspaar, z. B. „BTCUSDT“
        :param-Intervall: Zeitintervall (1, 3, 5, 15, 30, 60, 120, 240, 360, 720, D, W, M)
        :param end_time: Endzeit (Unix-Millisekunden), Standard ist jetzt
        :param limit: Anzahl der zurückgegebenen Transaktionen, maximal 1000
        „““
        endpoint = „/v5/market/kline“
        url = f"{cls.BASE_URL}{endpoint}"

        Parameter = {
            „Kategorie“: „linear“, # USDT Perpetual
            „Symbol“: Symbol,
            „Intervall“: Intervall,
            „Grenze“: Grenze
        }

        wenn end_time:
            params["end"] = end_time
        sonst:
            params["end"] = int(time.time() * 1000)

        res = request.get(url, params=params)
        res.raise_for_status()
        data = res.json()

        wenn data.get("retCode") == 0:
            klines = data["result"]["list"]
            print(f"{symbol} hat insgesamt {len(klines)} K Zeilen erhalten")
            # Zeigt die ersten 3 Stamminformationen an
            für k in klines[:3]:
                open_time, open_price, hoch, niedrig, schließen, Volumen, Umsatz = k
                print(f"Open:{open_price} Close:{close} High:{high} Low:{low} Volume:{volume}")
        sonst:
            print("Erfassung fehlgeschlagen:", Daten)

if __name__ == "__main__":
    BybitAPI.get_klines(symbol="BTCUSDT", Intervall="60", limit=5)

Beispiel für Rückgabedaten

{
  „retCode“: 0,
  "Ergebnis": {
    „symbol“: „BTCUSDT“,
    „Kategorie“: „linear“,
    "Liste": [
      [
        „1735119600000“, // Startzeit (Millisekunden)
        „98342,5“, // Eröffnungskurs
        „98350.0“, // höchster Preis
        „98285.0“, // niedrigster Preis
        „98290,5“, // Schlusskurs
        „12.304“, // Handelsvolumen
        „1210000.5“ // Transaktionsvolumen (USDT)
      ]
    ]
  }
}

Auffüllen

• categoryKann geändert werdenspotoderinverseEntsprechen Sie verschiedenen Märkten.
• endDas Argument ist ein Zeitstempel in Millisekunden (Unix-Epoche × 1000).
• Unterstütztes Intervallformat: 1, 3, 5, 15, 30, 60, 120, 240, 360, 720, D, W, M.

Beschleunigen Sie die Batch-Erfassung von K-Linien

veranschaulichen

Unten finden Sie ein direkt reproduzierbares Python-Beispiel mit einem ThreadPoolExecutor mit integrierten Wiederholungsversuchen, Ratenbegrenzung und Cache. Prozess: Laden Sie zunächst die erfasste K-Linie (falls vorhanden) aus dem Cache und stellen Sie nur Anfragen für fehlende oder unzureichende Handelspaare. Verwenden Sie den Thread-Pool, um mehrere Anforderungen gleichzeitig auszuführen, und verwenden Sie Semaphore, um die Anzahl der Parallelität zu steuern und eine Einschränkung zu vermeiden. Im Falle eines Fehlers wird ein exponentieller Backoff zum erneuten Versuch verwendet.

Programmcode (Bybit /v5/market/kline-Beispiel)

# Anforderungen: Pip-Installationsanfragen
Importanfragen
Importzeit
json importieren
Betriebssystem importieren
aus concurrent.futures importieren ThreadPoolExecutor, as_completed
aus dem Threading-Import von Semaphor

BASE_URL = "https://api.bybit.com/v5/market/kline"
CACHE_FILE = „klines_cache.json“

# Einstellbare Parameter
MAX_WORKERS = 20 # Thread-Pool-Größe (vorbehaltlich der Anpassung der API-Ratenbegrenzung)
MAX_CONCURRENT = 10 # Anzahl der realen gleichzeitigen Anfragen (gesteuert mit Semaphor)
RETRY = 3 # Anzahl der Wiederholungsversuche für jede Anfrage
INITIAL_BACKOFF = 0,5 # Anzahl der Sekunden, die auf den ersten Wiederholungsversuch gewartet werden soll
CATEGORY = „linear“ # linear -> USDT nachhaltig; Spot/Invers kann geändert werden
LIMIT_PER_CALL = 200 # Jedes Kline-API-Limit (abhängig von der API-Obergrenzeneinstellung)
DATASET_ALLDAYS = 24 * 6 # Beispiel: Bestimmen Sie mindestens, wie viele K Zeilen benötigt werden (kann geändert werden)

# Cache laden/zugreifen
def load_cache():
    wenn os.path.exists(CACHE_FILE):
        Versuchen Sie:
            return json.load(open(CACHE_FILE, "r", binding="utf-8"))
        außerAusnahme:
            zurück {}
    zurück {}

def save_cache(cache):
    json.dump(cache, open(CACHE_FILE, "w",kodierung="utf-8"),sure_ascii=False, indent=2)

# API-Erfassung eines einzelnen Symbols, einschließlich Wiederholungsversuchen und Ratenkontrolle (die Anzahl gleichzeitiger Ausführungen wird durch Semaphor gesteuert)
def fetch_klines_for_symbol(symbol, Interval="60", end_time=None, limit=LIMIT_PER_CALL, sem: Semaphore = None):
    Parameter = {
        "Kategorie": KATEGORIE,
        „Symbol“: Symbol,
        „Intervall“: Intervall,
        „Grenze“: Grenze
    }
    wenn end_time:
        params["end"] = int(end_time)
    backoff = INITIAL_BACKOFF
    last_exc = Keine

    # Semaphor abrufen (falls bereitgestellt)
    wenn sem:
        sem.acquire()
    Versuchen Sie:
        für Versuch im Bereich(1, RETRY + 1):
            Versuchen Sie:
                resp = request.get(BASE_URL, params=params, timeout=10)
                resp.raise_for_status()
                data = resp.json()
                # Bybit v5 gibt retCode == 0 zurück, um den Erfolg anzuzeigen.
                wenn data.get("retCode", 0) == 0 und "result" in data:
                    klines = data["result"].get("list", [])
                    Klines zurückgeben
                sonst:
                    last_exc = Exception(f"API-Fehler: {data}")
            außer request.Exceptions.RequestException als e:
                last_exc = e
            #backoff
            time.sleep(backoff)
            Backoff *= 2
    endlich:
        wenn sem:
            sem.release()
    # Wenn fehlgeschlagen, den letzten Fehler auslösen oder None zurückgeben
    last_exc erhöhen

# Stapelverarbeitung: paarweise übergeben (Symbolliste), dict {symbol: klines} zurückgeben
def get_klines_batch(pairs, Interval="60", dataset_alldays=DATASET_ALLDAYS, limit=LIMIT_PER_CALL, max_workers=MAX_WORKERS, max_concurrent=MAX_CONCURRENT):
    Cache = Load_cache() # Cache-Format: { Symbol: [kline_list] }
    Ergebnisse = {}
    to_fetch = []

    # Bestimmen Sie, welche Symbole erfasst werden müssen (nicht im Cache vorhanden oder nicht lang genug)
    für s in Paaren:
        zwischengespeichert = Cache.get(s)
        wenn zwischengespeichert und len(cached) >= dataset_alldays:
            Ergebnisse[s] = zwischengespeichert
        sonst:
            to_fetch.append(s)

    # Wenn es nichts zum Abrufen gibt, geben Sie es einfach direkt zurück
    wenn nicht to_fetch:
        Ergebnisse zurückgeben

    sem = Semaphor(max_concurrent)
    mit ThreadPoolExecutor(max_workers=max_workers) als exe:
        Futures = {exe.submit(fetch_klines_for_symbol, sym, Intervall, None, limit, sem): sym für sym in to_fetch}
        für fut in as_completed(futures):
            sym = Futures[fut]
            Versuchen Sie:
                kl = fut.result()
                # Wenn die API-Rückgabe im Listenformat gespeichert wird (gemäß Bybit-Beispiel [time,open,high,low,close,vol,turnover])
                Cache[sym] = kl
                Ergebnisse[sym] = kl
            außer Ausnahme als e:
                # Fehler aufzeichnen, aber nicht das gesamte Programm blockieren
                print(f"[Fehler] {sym} konnte nicht abgerufen werden: {e}")
                results[sym] = Keine

    # Cache archivieren (optional: nur erfolgreiche speichern)
    save_cache(cache)
    Ergebnisse zurückgeben

# Beispielverwendung
if __name__ == "__main__":
    # Angenommen, es gibt 500 Paare (Richtwert)
    pairs = ["BTCUSDT", "ETHUSDT", "SOLUSDT"] # ... 500
    # Batch-Abruf ausführen
    all_klines = get_klines_batch(pairs, Interval="60", dataset_alldays=100, limit=200)
    # Filtern Sie Symbole heraus, die den Längenanforderungen entsprechen
    good = [s für s, kl in all_klines.items(), wenn kl und len(kl) >= 100]
    print(f"Die Anzahl der Handelspaare, die mehr als 100 übereinstimmen: {len(good)}")
    drucken(gut[:20])

Überlegungen und Best Practices

• Bitte überprüfen Sie zunächst das Ratenlimit der API-Datei und passen Sie es anMAX_WORKERSUndMAX_CONCURRENT. Wenn Sie über einen API-Schlüssel verfügen, können Sie in der Regel das Ratenkontingent erhöhen.
• Wenn Sie eine große Menge an historischen Daten benötigen (mehrere Tage am Stück erfassen), wird empfohlen, die öffentlichen Massendaten von Bybit (public.bybit.com) zu verwenden oder die bereitgestellten historischen Datendateien auszutauschen, um eine große Anzahl von REST-Anfragen zu speichern.
• Für die Echtzeitüberwachung können durch die Verwendung von WebSocket häufige REST-Anfragen vermieden werden, für historische Daten ist jedoch weiterhin eine einmalige REST- oder Massendatei erforderlich.
• Cache-Dateien können in Parquet/SQLite geändert werden, um das Lesen und Schreiben zu beschleunigen und Platz zu sparen.

Pionex API

Einführung

Pionex bietet eine offizielle API, die es Entwicklern ermöglicht, Transaktionen zu automatisieren, Marktdaten abzufragen und Kontobestände über Programme zu verwalten. Die API unterstützt sowohl REST- als auch WebSocket-Methoden.

Beantragen Sie einen API-Schlüssel

1. Melden Sie sich bei Ihrem Pionex-Konto an
2. EingebenAPI-VerwaltungSeite
3. Erstellen Sie einen neuen API-Schlüssel und legen Sie Berechtigungen fest (lesen, handeln, Münzen abheben usw.)
4. aufschreibenAPI KeyUndSecret, nur einmal angezeigt

REST-API-Beispiel (Node.js)

// Node.js Axios verwenden, um die Pionex-API anzufordern
const axios = require("axios");
const crypto = require("crypto");

const apiKey = „Ihr API_KEY“;
const Secret = „Ihr API_SECRET“;
const baseUrl = "https://api.pionex.com";

// Signaturgenerierung
Funktionszeichen(Abfrage) {
  return crypto.createHmac("sha256", Secret).update(query).digest("hex");
}

// Kontostand abfragen
asynchrone Funktion getBalances() {
  const timestamp = Date.now();
  const query = `timestamp=${timestamp}`;
  const signatur = sign(query);

  const res = waiting axios.get(`${baseUrl}/api/v1/account?${query}&signature=${signature}`, {
    Header: { "X-MBX-APIKEY": apiKey }
  });
  console.log(res.data);
}

getBalances();

REST-API-Beispiel (Python)

Importzeit
hmac importieren
Hashlib importieren
Importanfragen

API_KEY = „Ihr API_KEY“
SECRET = „yourAPI_SECRET“
BASE_URL = „https://api.pionex.com“

def sign(query: str) -> str:
    return hmac.new(SECRET.encode(), query.encode(), hashlib.sha256).hexdigest()

def get_balances():
    Zeitstempel = str(int(time.time() * 1000))
    query = f"timestamp={timestamp}"
    Signatur = signieren (Abfrage)

    url = f"{BASE_URL}/api/v1/account?{query}&signature={signature}"
    headers = {"X-MBX-APIKEY": API_KEY}
    res = request.get(url, headers=headers)
    print(res.json())

get_balances()

WebSocket-Beispiel (Node.js)

const WebSocket = require("ws");

const ws = new WebSocket("wss://ws.pionex.com/ws");

ws.on("open", () => {
  console.log("Verbunden mit Pionex WebSocket");
  // Abonnieren Sie BTC/USDT-Kurse
  ws.send(JSON.stringify({
    Ereignis: „Abonnieren“,
    Kanal: „Markt“,
    Markt: „BTC_USDT“
  }));
});

ws.on("message", (msg) => {
  console.log("Nachricht empfangen:", msg.toString());
});

WebSocket-Beispiel (Python)

WebSocket importieren
json importieren

def on_open(ws):
    print("Verbunden mit Pionex WebSocket")
    sub_msg = {
        „event“: „abonnieren“,
        „channel“: „market“,
        „market“: „BTC_USDT“
    }
    ws.send(json.dumps(sub_msg))

def on_message(ws, message):
    print("Nachricht empfangen:", Nachricht)

ws = websocket.WebSocketApp(
    „wss://ws.pionex.com/ws“,
    on_open=on_open,
    on_message=on_message
)

ws.run_forever()

Häufig verwendete Funktionen

• Marktbedingungen abfragen (Ticker, K-Line, ausführliche Informationen)
• Geben Sie Bestellungen auf, stornieren Sie Bestellungen und überprüfen Sie den Bestellstatus
• Abfrage des Kontoguthabens
• Roboterhandelskontrolle (einige funktionale Einschränkungen)

Dinge zu beachten

• Bitte geben Sie den API-Schlüssel nicht preis. Es wird empfohlen, eine IP-Whitelist einzurichten.
• Für verschiedene Funktionen gelten Geschwindigkeitsbegrenzungen, die vermieden werden müssen, um eine Blockierung auszulösen.
• Um den echten Handel nutzen zu können, testen Sie ihn bitte zunächst in einer Testumgebung oder mit kleinen Beträgen.

Pionex REST API Liste der Handelspaare abrufen

API-Beschreibung

verfügbarGET /api/v1/common/symbolsUm alle unterstützten Handelspaare und detaillierte Attribute von Pionex zu erhalten, wie z. B. Mindestauftragsgröße, Preisgenauigkeit, Transaktionstyp (Spot oder Kontrakt) usw.

HTTP-Anfrage

GET https://api.pionex.com/api/v1/common/symbols

Postback-Beispiel

{
  "code": 0,
  "data": [
    {
      "symbol": "BTC_USDT",
      "quoteCurrency": "USDT",
      "baseCurrency": "BTC",
      "minQty": "0.0001",
      "minNotional": "5",
      "pricePrecision": 2,
      "quantityPrecision": 6,
      "tradeEnable": true
    },
    {
      "symbol": "ETH_USDT",
      "quoteCurrency": "USDT",
      "baseCurrency": "ETH",
      "minQty": "0.001",
      "pricePrecision": 2,
      "quantityPrecision": 6,
      "tradeEnable": true
    }
  ]
}

Python-Beispiel

Importanfragen

BASE_URL = „https://api.pionex.com“

def get_symbols():
    url = f"{BASE_URL}/api/v1/common/symbols"
    res = request.get(url)
    data = res.json()
    
    wenn data.get("code") == 0:
        Symbole = data.get("data", [])
        print(f"Insgesamt {len(symbols)} erhaltene Handelspaare")
        für s in Symbolen[:10]: # Nur die ersten 10 anzeigen
            print(f"{s['symbol']} ({s['baseCurrency']}/{s['quoteCurrency']})")
    sonst:
        print("Erfassung fehlgeschlagen:", Daten)

if __name__ == "__main__":
    get_symbols()

Filtern Sie bestimmte Typen

Um nur Handelspaare zu entfernen, die unbefristete Verträge unterstützen, können Sie die folgende einfache Filterlogik verwenden:

perp_symbols = [s for s in data["data"] if ".PERP" in s["symbol"]]

verwenden

• Fragen Sie alle handelbaren Ziele auf Pionex ab.
• übereinstimmen/api/v1/market/tickersErhalten Sie sofortige Preise.
• Initialisierungsdaten vor der Erstellung eines automatisierten Handelsprogramms oder einer automatisierten Handelsstrategie.

Pionex-Rückgabeformat analysieren

veranschaulichen

Das folgende Programm wird aufgerufenhttps://api.pionex.com/api/v1/common/symbols, druckt automatisch die Struktur (Schlüssel und Datentyp) des zurückgegebenen JSON aus, um das Verständnis des tatsächlichen Formats zu erleichtern.

Python-Beispiel

Importanfragen
json importieren

def print_json_structure(data, indent=0):
    „JSON-Struktur rekursiv drucken“
    space = " " * Einzug
    if isinstance(data, dict):
        für k, v in data.items():
            if isinstance(v, (dict, list)):
                print(f"{space}{k}: {type(v).__name__}")
                print_json_structure(v, indent + 1)
            sonst:
                print(f"{space}{k}: {type(v).__name__}")
    elif isinstance(data, list) und data:
        print(f"{Leerzeichen}[Liste] Elementtyp: {Typ(Daten[0]).__name__}")
        print_json_structure(data[0], indent + 1)

def get_pionex_symbols_format():
    url = „https://api.pionex.com/api/v1/common/symbols“
    res = request.get(url)
    res.raise_for_status()
    data = res.json()
    print("Struktur auf Stammebene:")
    print_json_structure(data)

if __name__ == "__main__":
    get_pionex_symbols_format()

Beispielausgabe

Struktur auf Root-Ebene:
Code: int
Daten: Liste
  [Liste] Elementtyp: Diktat
    Symbol: str
    Basiswährung: str
    quoteCurrency: str
    Preisgenauigkeit: int
    MengePräzision: int
    minMenge:str
    minNotional: str
    tradeEnable: bool

Auffüllen

• Diese Methode erkennt automatisch jedes REST-API-JSON-Format und ist ideal für die Analyse der API-Struktur.
• Wenn die API Felder aktualisiert, führen Sie sie einfach erneut aus, um das neueste Format zu erhalten.
• Empfohlene Kombinationjson.dumps(data, indent=2)Vollständiger Inhalt verfügbar.

Pionex REST API Get Klines

API-Beschreibung

Erhalten Sie die K-Linien-Daten (Candlestick / OHLCV) des angegebenen Handelspaars, die aus öffentlichen Marktdaten von Pionex stammen.

GET /api/v1/market/klines

Parameter anfordern

Rückgabeformat

{
  "result": true,
  "data": {
    "klines": [
      {
        "time": 1691649240000,
        "open": "1851.27",
        "close": "1851.32",
        "high": "1851.32",
        "low": "1851.27",
        "volume": "0.542"
      }
    ]
  },
  "timestamp": 1691649271544
}

Python-Beispiel

Importanfragen

BASE_URL = „https://api.pionex.com“

def get_klines(symbol: str, Intervall: str, end_time: int = None, limit: int = 100):
    Parameter = {
        „Symbol“: Symbol,
        „Intervall“: Intervall,
        „Grenze“: Grenze
    }
    wenn end_time nicht None ist:
        params["endTime"] = end_time
    Antwort = Anfragen.get(f"{BASE_URL}/api/v1/market/klines", params=params)
    Ergebnis = Antwort.json()
    wenn result.get("result") und "data" im Ergebnis:
        Rückgabeergebnis["data"]["klines"]
    sonst:
        raise Exception(f"K-Zeile konnte nicht abgerufen werden: {result}")

if __name__ == "__main__":
    # Beispiel: Erhalten Sie die neuesten 50 15-Minuten-K-Linien des unbefristeten BTC_USDT-Vertrags
    symbol = „BTC_USDT.PERP“
    Intervall = „15M“
    klines = get_klines(symbol, Intervall, limit=50)
    für k in klines:
        print(k)

Die Pionex-REST-API-Abfrage unterstützt Vertrags-Grid-Handelspaare

veranschaulichen

Pionex hat keine einzige„Erhalten Sie Unterstützung für Grid-Handelspaare“dedizierte API, kann aber über aufgerufen werdenGET /api/v1/market/tickersHolen Sie sich alle Handelspaare und filtern Sie sie heraus.PERPGeben Sie (USDT Perpetual Contract) ein, um die Liste der von Futures Grid unterstützten Handelspaare zu erhalten.

Python-Beispielprogramme

Importanfragen

BASE_URL = „https://api.pionex.com“

def get_perp_pairs():
    url = f"{BASE_URL}/api/v1/market/tickers"
    res = request.get(url)
    data = res.json()
    
    perp_pairs = []
    wenn „Daten“ in Daten:
        für Element in data["data"]:
            market = item.get("symbol", "")
            # Handelspaare mit unbefristeten Verträgen enden normalerweise mit .PERP
            wenn „.PERP“ im Markt:
                perp_pairs.append(market)
    gebe perp_pairs zurück

if __name__ == "__main__":
    Paare = get_perp_pairs()
    print("Unterstützte Grid-Handelspaare für unbefristete Verträge:")
    für p paarweise:
        drucken(p)

Beispiel für ein Ausführungsergebnis

Unterstützte Grid-Handelspaare mit unbefristeten Verträgen:
BTC_USDT.PERP
ETH_USDT.PERP
SOL_USDT.PERP
LINK_USDT.PERP
...

Auffüllen

• Unbefristetes Vertragspaar (.PERP) kann direkt mit Futures Grid Bot verwendet werden.
• Um den tatsächlichen Supportstatus zu bestätigen, wird empfohlen, die Liste der Vertragshandelsmärkte auf der offiziellen Website von Pionex zu vergleichen.
• Einige Handelspaare werden möglicherweise vorübergehend aus den Regalen entfernt und die tatsächliche Unterstützungsliste unterliegt der Echtzeitreaktion der API.

Max Coin API

Was ist die Max Coin API?

Die Max Coin API ist eine Reihe von Anwendungsprogrammierschnittstellen, die von Max Exchange bereitgestellt werden und es Entwicklern ermöglichen, programmgesteuert auf die Funktionalität des Kryptowährungshandels zuzugreifen. Entwickler können Transaktionen automatisieren, Marktdaten abrufen und Vermögenswerte über APIs verwalten.

Wie verwende ich die Max Coin API?

1. Registrieren Sie sich für ein Max-Konto:ZugangOffizielle Max-Websiteund registrieren Sie ein Konto.
2. API-Schlüssel abrufen:Gehen Sie nach der Anmeldung zu Ihren Kontoeinstellungen, generieren Sie einen neuen API-Schlüssel und legen Sie die erforderlichen Berechtigungen fest.
3. Referenz-API-Dokumentation:Lesen Sie die offizielle API-Dokumentation, um die Funktionalität und Verwendung jedes Endpunkts zu verstehen.

Hauptfunktionen, die von der API unterstützt werden

• Marktdatenabruf:Erhalten Sie den Preis, die Auftragstiefe und das Volumen des aktuellen Handelspaares.
• Transaktionsvorgänge:Geben Sie Kauf- oder Verkaufsaufträge auf und sehen Sie sich ausstehende Aufträge an oder stornieren Sie sie.
• Vermögensverwaltung:Überprüfen Sie den Kontostand und die historischen Transaktionsaufzeichnungen.

API-Beispielanfrage

Das Folgende ist ein Beispiel für den Erhalt von Marktdaten über die API:

GET https://max-api.maicoin.com/api/v1/ticker?market=btctwd
    

Diese Anfrage gibt Echtzeit-Marktdaten für BTC/TWD zurück, einschließlich Preis, Volumen usw.

Beispielcode

Das Folgende ist ein einfaches Beispiel für den Aufruf der Max-API mithilfe der Python-Sprache:

Importanfragen

BASE_URL = „https://max-api.maicoin.com“

def get_ticker(Paar):
    endpoint = "/api/v1/ticker"
    params = {"Markt": Paar}
    Antwort = request.get(BASE_URL + Endpunkt, params=params)
    return Response.json()

# Holen Sie sich BTC/TWD-Marktdaten
ticker_data = get_ticker("btctwd")
print(ticker_data)

Hinweise zur Verwendung der Max Coin API

• Sicherheit:Schützen Sie Ihre API-Schlüssel vor unbefugtem Zugriff.
• API-Einschränkungen:Bitte beachten Sie die Dokumentation zu API-Frequenzbeschränkungen, um übermäßige Anfragen zu vermeiden.
• IP-Whitelist:Aktivieren Sie IP-Whitelisting, um die Sicherheit der API-Nutzung zu erhöhen.

Verwandte Ressourcen

• Offizielle Max-Website
• Max API-Dokumentation

Bitcoin PoW-Abrechnungsprozess

Der Kern der dezentralen Buchhaltung

Verwendung von BitcoinArbeitsnachweis (PoW)Als Konsensmechanismus zur Erreichung eines dezentralen Rechnungslegungssystems. Das Hauptziel von PoW besteht darin, den Knoten den Wettbewerb bei der Lösung mathematischer Probleme zu ermöglichen, um zu bestimmen, wer die Abrechnungsrechte hat, und sicherzustellen, dass Daten nicht nach Belieben manipuliert werden können.

Generierung und Verbreitung der Transaktionsnachfrage

• Benutzer stellen Transaktionsanfragen. Diese Anfragen umfassen Übertragungsinformationen und Bearbeitungsgebühren (Trinkgelder).
• Transaktion überKnotenübertragungJeder Knoten wird an das gesamte Bitcoin-Netzwerk weitergeleitet und kann diese Transaktionen empfangen.
• Der Miner-Knoten wählt aus den empfangenen Transaktionen Transaktionen aus, die in den Block aufgenommen werden sollen.

Priorität der Transaktionsauswahl

Miner werden Transaktionen anhand der folgenden Kriterien priorisieren, um die Chance zu erhöhen, Blöcke erfolgreich zu verpacken und Gebühren zu verdienen:

• Hohe Bearbeitungsgebühren (mehr Einnahmen pro Byte)
• Großer Transaktionsbetrag
• Die Transaktion hat lange gewartet
• Die Datengröße ist moderat, sodass der Block leicht aufgefüllt werden kann

Verpackungsblöcke und Wettbewerb um Buchhaltungsrechte

• Nachdem die Miner Transaktionen gesammelt haben, erstellen sie einen Kandidatenblock, der alle notwendigen Informationen enthält.
• PoW ausführen: Versuchen Sie, eine Reihe von Nonce-Werten zu finden, sodass der Hash des Blocks unter einem bestimmten Zielwert liegt (abhängig von der Schwierigkeit).
• Der Miner, der eine gültige Lösung findet, wird blockierenübertragenzu anderen Knoten im gesamten Netzwerk.

Überprüfung und Kettenauswahl

• Andere Knoten überprüfen nach Erhalt des Blocks (Transaktionslegalität, PoW-Korrektheit).
• Wenn die Überprüfung erfolgreich ist, wird der Block zur Blockchain des Knotens hinzugefügt.
• Wenn mehrere legale Blöcke gleichzeitig auftreten, akzeptiert der Knoten vorübergehend den zuerst empfangenen und wird dies schließlich auch tunlängste KetteHauptsächlich (d. h. die am meisten angesammelte Arbeitsbelastung).

Blockgrenzen und Generierungsfrequenz

• Die maximale Größe jedes Blocks beträgt etwa 1 MB (bis zu etwa 2 MB mit SegWit).
• Die Anzahl der enthaltenen Transaktionen ist ebenfalls begrenzt, um eine übermäßige Belastung des Knotens zu vermeiden.
• Das Bitcoin-Protokoll ist so konzipiert, dass im Durchschnitt jeder10 MinutenProduziere einen Block.
• Wenn die Problemlösungsgeschwindigkeit schneller wird, erhöht das System automatisch die Schwierigkeit, um die durchschnittliche Ausgabezeit stabil zu halten.

Buchhaltungsengpässe und Lösungen

Wenn das Transaktionsvolumen zu groß ist, kommt es zu Staus und steigenden Bearbeitungsgebühren. Um dieses Problem zu verbessern, werden verschiedene Erweiterungslösungen vorgeschlagen:

• SegWit (Segregated Witness):Trennen Sie die Signaturdaten von den Haupttransaktionsdaten, um das effektive Ladevolumen zu erhöhen.
• Lightning-Netzwerk:Richten Sie einen Zahlungskanal außerhalb der Kette ein, damit eine große Anzahl kleiner Transaktionen nicht sofort in die Kette hochgeladen werden muss, wodurch der Druck auf die Hauptkette verringert wird.

Datenstruktur des BTC-Blocks

Hauptstruktur des Blocks

Block-Header

Die Länge ist auf 80 Byte festgelegt und der Inhalt ist wie folgt:

Anzahl Transaktionen (Transaktionszähler)

Verwenden Sie das VarInt-Format (Ganzzahl variabler Länge), um anzugeben, wie viele Transaktionen sich im Block befinden:

• Wenn die Transaktionsmenge< 0xFD，則佔 1 個位元組
• 0xFD ~ 0xFFFF belegt 3 Bytes (Präfix 0xFD + 2 Byte Ganzzahl)
• Und so weiter, bis zu 9 Bytes

Transaktionen

Jede Transaktionsdaten enthält die folgenden Hauptteile (Längen variieren):

• version：Transaktionsversion
• input count：Diese Transaktion verwendet mehrere Eingaben
• inputs[]：Jede Eingabe enthält die Ausgabe der vorherigen Transaktion, des Entsperrskripts usw.
• output count：Diese Transaktion erzeugt mehrere Ausgaben
• outputs[]：Jede Ausgabe enthält den Betrag und das Sperrskript
• locktime：Das früheste Zeitlimit für das Hinzufügen dieser Transaktion zum Block

Die erste Transaktion ist in der RegelCoinbase-HandelDabei handelt es sich um eine spezielle Transaktion für Miner, um Blockbelohnungen zu erhalten, und beinhaltet keine Eingaben.

Implementierung des Prozesses zur Generierung und Verbreitung von Transaktionsnachfragen

Programmeinführung

Hauptprozess

• Benutzer generieren Transaktionen und übermitteln sie an einen beliebigen Knoten
• Der Knoten sendet die Transaktion an alle benachbarten Knoten
• Der Miner-Knoten empfängt die Transaktion, wählt die Transaktion entsprechend der Bearbeitungsgebühr aus und packt sie in den Block.

Python-Code

Importzeit

Klassentransaktion:
    def __init__(selbst, Absender, Empfänger, Betrag, Gebühr):
        self.sender = Absender
        self.receiver = Empfänger
        self.amount = Betrag
        self.fee = Gebühr
        self.timestamp = time.time()

    def __repr__(self):
        return f"[Tx: {self.sender} → {self.receiver}, ${self.amount}, fee: {self.fee}]"


Klassenknoten:
    def __init__(self, name):
        self.name = Name
        self.peers = []
        self.transaction_pool = []

    def connect(self, peer):
        wenn Peer nicht in self.peers:
            self.peers.append(peer)
            peer.connect(self) # Zwei-Wege-Verbindung

    def require_transaction(self, tx):
        wenn tx nicht in self.transaction_pool:
            self.transaction_pool.append(tx)
            print(f"{self.name} empfing Transaktion: {tx}")
            self.broadcast(tx)

    def Broadcast(self, tx):
        für Peer in self.peers:
            peer.receive_transaction(tx)


classMiner(Knoten):
    def mine_block(self):
        print(f"\n⛏️ {self.name} beginnt mit dem Packen des Blocks")
        # Sortieren Sie nach hoher Bearbeitungsgebühr und nehmen Sie bis zu 5 Transaktionen entgegen
        sorted_txs = sortiert(self.transaction_pool, key=lambda tx: tx.fee, reverse=True)
        selected = sorted_txs[:5]
        print(f"{self.name} verpackte Transaktion:")
        für tx in ausgewählt:
            print(f" - {tx}")
        #Verarbeitete Transaktionen löschen
        self.transaction_pool = [tx für tx in self.transaction_pool, wenn tx nicht ausgewählt ist]


# Erstellen Sie Knoten und Miner
A = Knoten("Knoten A")
B = Knoten("Knoten B")
C = Miner("Miner C")

# Knotennetzwerk verbinden
A.connect(B)
B.connect(C)

# Benutzer gibt Transaktion aus
tx_list = [
    Transaktion("Alice", "Bob", 2.0, 0.0005),
    Transaktion("Eve", "Tom", 1.2, 0.0009),
    Transaktion("Joe", "Mary", 3.5, 0.0002),
    Transaktion(„Rick“, „Sam“, 0,8, 0,0015),
    Transaktion("Ann", "Lily", 1.7, 0.0001)
]

für tx in tx_list:
    print(f"\nBenutzer sendet Transaktion: {tx}")
    A.receive_transaction(tx)
    time.sleep(0.2)

# Bergleute beginnen mit dem Verpacken
C.mine_block()

Ausführungsanweisungen

• Alle Transaktionen werden von Knoten A gesendet und über Knoten B an Miner C gesendet
• Miner C sortiert nach der Bearbeitungsgebühr und wählt die ersten 5 zu verpackenden Transaktionen aus.

Erweiterbare Richtung

• Fügen Sie eine Signaturüberprüfung und eine Transaktionslegalitätsprüfung hinzu
• Simulieren Sie die Blockchain-Struktur und Hash-Operationen
• Integrieren Sie Konsensmechanismen und Netzwerkgabeln

Ethereum VM-Schreibprogramm

pragma solidity ^0.8.0;

contract SimpleStorage {
uint public storedData;

function set(uint x) public {
    storedData = x;
}

function get() public view returns (uint) {
    return storedData;
}
}
    

EVM-Bereitstellungsprozess

Vorbereitung

• InstallierenNode.jsUndnpm
• InstallierenHardhat：
  npm install --save-dev hardhat
• Erstellen Sie ein Hardhat-Projekt:
  npx hardhat, wählen Sie „Ein einfaches Beispielprojekt erstellen“

Schreiben Sie einen Vertrag

existierencontractsZum Ordner hinzugefügtLendingProtocol.solund fügen Sie Ihren Solidity-Vertrag ein.

Bereitstellungsskript einrichten

BeiscriptsOrdnererstellungdeploy.js, der Inhalt ist wie folgt:

asynchrone Funktion main() {
  const [deployer] = Warten auf ethers.getSigners();
  console.log("Bereitstellungskonto:", Deployer.address);

  const TokenAddress = "0xYourTokenAddressHere";
  const LendingProtocol = waiting ethers.getContractFactory("LendingProtocol");
  const lending = waiting LendingProtocol.deploy(TokenAddress);

  Warten Sie auf die Kreditvergabe.deployed();
  console.log("LendingProtocol erfolgreich bereitgestellt:", lending.address);
}

main().catch((error) => {
  console.error(error);
  prozess.exitCode = 1;
});

Bereitstellung in der lokalen Testkette

Starten Sie die Hardhat-Testkette:

Öffnen Sie ein anderes Terminal zur Bereitstellung:

Bereitstellung im Testnetz (z. B. Goerli)

• Registrieren Sie Infura oder Alchemy und erhalten Sie die RPC-URL
• existierenhardhat.config.jsFügen Sie hinzu:

require("@nomiclabs/hardhat-ethers");

module.exports = {
  Netzwerke: {
    goerli: {
      URL: „https://goerli.infura.io/v3/Ihr API-Schlüssel“,
      Konten: ["0xIhr privater Schlüssel"]
    }
  },
  Festigkeit: „0,8,20“
};

Dann bereitstellen:

Bereitstellung abgeschlossen

Nach der Bereitstellung wird die Vertragsadresse ausgegeben, die für die Front-End-Integration und Interaktion verwendet werden kann.

Darlehensvertrag

Vertragseinführung

Bei diesem Kreditvertrag handelt es sich um einen Smart Contract, der auf der Ethereum Virtual Machine (EVM) läuft. Über diesen Vertrag können Benutzer Vermögenswerte einzahlen, um Zinsen zu verdienen, oder Vermögenswerte verleihen, um Zinsen zu zahlen. Dieses Protokoll unterstützt ERC-20-Token und verfügt über Kernfunktionen wie Verleihen, Sparen und Clearing.

Hauptfunktionen

• Einzahlungen: Benutzer können Vermögenswerte in das Protokoll einzahlen und Zinsen verdienen.
• Ausleihen: Nach der Verpfändung von Vermögenswerten können Benutzer unterstützte Vermögenswerte verleihen.
• Liquidation: Wenn der Hypothekenwert des Kreditnehmers zu niedrig ist, können andere Nutzer liquidieren.

Beispiel für einen Smart Contract (Solidity)

// SPDX-Lizenz-Identifikator: MIT
Pragma-Solidität ^0.8.0;

Schnittstelle IERC20 {
    Funktion transferFrom(Adresssender, Adressempfänger, uint-Betrag) externe Rückgaben (bool);
    Funktionsübertragung (Adressempfänger, uint-Betrag) externe Rückgabe (bool);
    Funktion balanceOf(Adresskonto) externe Ansicht gibt (uint) zurück;
    Funktion genehmigen(Adressspender, uint-Betrag) externe Rückgaben (bool);
}

Vertrag LendingProtocol {
    Öffentlicher IERC20-Token;
    Adresse öffentlicher Eigentümer;
    uint public InterestRate = 5; // jährlicher Zinssatz 5 %

    Mapping(address => uint) öffentliche Einlagen;
    Mapping(Adresse => uint) öffentliche Anleihen;

    Konstruktor(Adresse _token) {
        token = IERC20(_token);
        Eigentümer = msg.sender;
    }

    Funktion Einzahlung(uint-Betrag) extern {
        require(amount > 0, „Betrag muss größer als 0 sein“);
        token.transferFrom(msg.sender, address(this), amount);
        Einzahlungen[msg.sender] += Betrag;
    }

    Funktion leihen(uint Betrag) extern {
        require(amount > 0, „Betrag muss größer als 0 sein“);
        uint collateral = Deposits[msg.sender];
        require(collateral >= amount * 2, „Unsufficient collateral“);
        leiht[msg.sender] += Betrag;
        token.transfer(msg.sender, Betrag);
    }

    Funktion repay(uint amount) external {
        require(amount > 0, „Betrag muss größer als 0 sein“);
        require(borrows[msg.sender] >= Betrag, „Unzureichende Kreditaufnahme“);
        leiht[msg.sender] -= Betrag;
        token.transferFrom(msg.sender, address(this), amount);
    }

    Funktion abheben (uint-Betrag) extern {
        require(deposits[msg.sender] >= Betrag, „Unzureichendes Guthaben“);
        require(borrows[msg.sender] == 0, „Es gibt unbezahlte Kredite“);
        Einzahlungen[msg.sender] -= Betrag;
        token.transfer(msg.sender, Betrag);
    }
}

Sicherheitsüberlegungen

• Um die Sicherheit der Protokollwerte zu gewährleisten, muss ein Liquidationsmechanismus hinzugefügt werden.
• Es wird empfohlen, Preisorakel (wie Chainlink) zu integrieren, um genaue Hypothekenwerte zu erhalten.
• Die Zinsberechnung wurde noch nicht verarbeitet und der Zinssatz sollte dynamisch basierend auf der Blockzeit berechnet werden.

zukünftige Erweiterung

• Unterstützt mehrere ERC-20-Token.
• Implementieren Sie ein Floating-Rate-Modell.
• Integrieren Sie NFTs als Sicherheit.

BSC Contract

Einführung

BSC (Binance Smart Chain) ist eine öffentliche Kette, die mit EVM (Ethereum Virtual Machine) kompatibel ist, sodass auf Ethereum geschriebene Solidity-Smart-Verträge fast direkt auf BSC bereitgestellt werden können. Der Hauptunterschied besteht darin, dass die Netzanschluss- und Gasgebühren während des Einsatzes in BNB berechnet werden.

Vertragsbeispiel (Solidität)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleStorage {
    uint private value;

    function setValue(uint _value) public {
        value = _value;
    }

    function getValue() public view returns (uint) {
        return value;
    }
}

Einstellungen der Bereitstellungsumgebung

Bereitstellung mit Hardhat, inhardhat.config.jsKonfigurieren Sie das BSC-Netzwerk in:

require("@nomiclabs/hardhat-ethers");

module.exports = {
  Festigkeit: „0,8,20“,
  Netzwerke: {
    bscTestnet: {
      URL: „https://data-seed-prebsc-1-s1.binance.org:8545/“,
      Ketten-ID: 97,
      Gaspreis: 20000000000,
      Konten: ["0xIhr privater Schlüssel"]
    },
    bscMainnet: {
      URL: „https://bsc-dataseed.binance.org/“,
      Ketten-ID: 56,
      Gaspreis: 20000000000,
      Konten: ["0xIhr privater Schlüssel"]
    }
  }
};

Bereitstellungsskript

asynchrone Funktion main() {
  const [deployer] = Warten auf ethers.getSigners();
  console.log("Bereitstellungskonto:", Deployer.address);

  const SimpleStorage = waiting ethers.getContractFactory("SimpleStorage");
  const storage = waiting SimpleStorage.deploy();

  Warten Sie auf storage.deployed();
  console.log("Vertrag bereitgestellt:", storage.address);
}

main().catch((error) => {
  console.error(error);
  prozess.exitCode = 1;
});

Bereitstellungsmethode

1. Abhängige Pakete installieren:
   npm install --save-dev hardhat @nomiclabs/hardhat-ethers ethers
2. Bereitstellung starten:
   npx hardhat run scripts/deploy.js --network bscTestnet
3. Nachdem Sie die Vertragsadresse bestätigt haben, können Sie zu gehenBscScan-TestnetzwerkoderBscScan-MainnetÜberprüfen Sie den Vertrag.

Dinge zu beachten

• Die Benzingebühren müssen in BNB bezahlt werden. Bitte halten Sie genügend BNB in ​​Ihrem Geldbeutel bereit.
• Es wird empfohlen, vor der Bereitstellung im Hauptnetz einen erfolgreichen Test im BSC-Testnetz (Testnetz, ChainID=97) durchzuführen.
• Wenn der Vertrag eine öffentliche Überprüfung erfordert, kann die Überprüfung des Quellcodes auf BscScan eingereicht werden.

Entwicklung von Börsenprogrammen

Implementierung von Aktienanstiegs- und -abfallwahrscheinlichkeiten

Verwenden Sie Python und ein Random-Forest-Modell, um die Wahrscheinlichkeit eines Anstiegs oder Rückgangs einer Aktie vorherzusagen. In diesem Beispiel werden Bestandsdaten von Yahoo Finance verwendet, technische Indikatoren zum Trainieren des Modells verwendet und schließlich die Wahrscheinlichkeit eines steigenden und fallenden Bestands ausgegeben.

Schritt 1: Installieren und importieren Sie die erforderlichen Pakete

Zuerst müssen wir einige Python-Pakete installieren und importieren:

Dann importieren Sie diese notwendigen Bibliotheken:

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
import yfinance as yf
    

Schritt 2: Laden Sie Bestandsdaten herunter und generieren Sie technische Indikatoren

Als nächstes laden wir die historischen Daten der Aktie von Yahoo Finance herunter und berechnen den Simple Moving Average (SMA) als technischen Indikator.

# Laden Sie Apple-Aktiendaten von Yahoo Finance herunter
symbol = 'AAPL'
data = yf.download(symbol, start='2020-01-01', end='2023-01-01')

# Berechnen Sie einfache gleitende 10-Tage- und 50-Tage-Durchschnitte (SMA)
data['SMA_10'] = data['Close'].rolling(window=10).mean()
data['SMA_50'] = data['Close'].rolling(window=50).mean()

#Legen Sie ein Erhöhungs- oder Verringerungsziel fest. Wenn der Schlusskurs des nächsten Tages höher ist als der Schlusskurs des Tages, ist er 1 (was einen Anstieg anzeigt), andernfalls ist er 0 (was einen Rückgang anzeigt).
data['Target'] = np.where(data['Close'].shift(-1) > data['Close'], 1, 0)

# Fehlende Werte entfernen
data.dropna(inplace=True)

Schritt 3: Trainings- und Testdatensätze vorbereiten

Wir werden gleitende Durchschnitte (SMA) und Schlusskurse als Merkmale verwenden und die Daten in Trainings- und Testsätze aufteilen.

Schritt 4: Verwenden Sie ein Zufallswaldmodell für Training und Vorhersage

Wir verwenden ein Zufallswaldmodell, um die Daten zu trainieren und die Anstiegs- und Abfallwahrscheinlichkeiten der Bestände im Testsatz vorherzusagen.

Schritt 5: Berechnen Sie die Modellgenauigkeit und zeigen Sie die Anstiegs- und Abfallwahrscheinlichkeit an

Wir können die Genauigkeit des Modells berechnen und die Wahrscheinlichkeit eines Anstiegs und Abfalls für jeden Tag anzeigen.

Schritt 6: Treffen Sie Handelsentscheidungen auf der Grundlage der Wahrscheinlichkeit eines Anstiegs und Rückgangs

Basierend auf der Wahrscheinlichkeit eines Anstiegs können Sie einen Schwellenwert festlegen, um zu entscheiden, ob eine Kaufoperation durchgeführt werden soll. Wenn beispielsweise die Wahrscheinlichkeit einer Steigerung 70 % übersteigt, kaufen Sie.

Zusammenfassen

Dieses Beispiel zeigt, wie man mithilfe eines Random-Forest-Modells die Wahrscheinlichkeit eines Anstiegs oder Rückgangs einer Aktie vorhersagt und auf der Grundlage der Vorhersageergebnisse Handelsentscheidungen trifft. Dies ist eine einfache, aber effektive Möglichkeit, die Genauigkeit Ihrer Handelsentscheidungen zu verbessern.

Öffentliche Abonnementankündigung der Taiwan Stock Exchange – Aktienauslosung und -erfassung

Schritt 1: Rufen Sie die öffentliche Ankündigungsseite für Abonnements auf

Die öffentliche Zeichnungsankündigungsseite der Taiwan Stock Exchange kann unter der folgenden URL aufgerufen werden:

Ankündigung des öffentlichen Abonnements

Schritt 2: Automatische Erfassung durch das Programm

Verwenden von Python mitrequestsUndBeautifulSoup, können Sie die öffentlichen Abonnementinformationen auf der Seite abrufen.

Beispielcode

Importanfragen
aus bs4 Import BeautifulSoup
Pandas als PD importieren

# Erfassen Sie die öffentliche Ankündigungsseite für Abonnements
url = „https://www.twse.com.tw/zh/announcement/public.html“
headers = {"User-Agent": "Mozilla/5.0"}
Antwort = Anfragen.get(URL, Header=Header)

wenn Response.status_code == 200:
    Suppe = BeautifulSoup(response.text, 'html.parser')
    tables = pd.read_html(response.text)
    wenn Tabellen:
        df = tables[0] # Holen Sie sich die erste Tabelle
        drucken(df)
    sonst:
        print("Tabellendaten nicht gefunden")
sonst:
    print("Verbindung zur öffentlichen Abonnementankündigungsseite konnte nicht hergestellt werden")

Dinge zu beachten

• Wenn die Seite über einen Anti-Crawler-Mechanismus verfügt, können Sie diesen verwendenSeleniumSimulieren Sie Browservorgänge.
• Stellen Sie sicher, dass die Nutzung der Informationen den Vorschriften der Taiwan Stock Exchange zur Nutzung öffentlicher Informationen entspricht.

Entwicklung von Forex-Programmen

Erhalten Sie den Wechselkurs zwischen US-Dollar und Taiwan-Dollar

Methode 1: Verwenden Sie CurrencyAPI

CurrencyAPI bietet Echtzeit-Wechselkursinformationen. Hier ist Beispielcode:

Importanfragen

url = 'https://api.currencyapi.com/v3/latest'
Parameter = {
    'apikey': 'Ihr API-Schlüssel',
    'base_currency': 'USD',
    'Währungen': 'TWD'
}
Antwort = Anfragen.get(url, params=params)
Daten = Antwort.json()
usd_to_twd = data['data']['TWD']['value']
print(f"1 US-Dollar entspricht {usd_to_twd} neuen Taiwan-Dollar")

Beachten:Sie müssen sich bei CurrencyAPI registrieren und einen API-Schlüssel erhalten, bevor Sie es verwenden können.

Methode 2: Verwenden Sie ExchangeRatesAPI

ExchangeRatesAPI bietet auch Echtzeit-Wechselkursabfragedienste:

Importanfragen

url = 'https://api.exchangeratesapi.io/latest'
Parameter = {
    'access_key': 'Ihr API-Schlüssel',
    'base': 'USD',
    'Symbole': 'TWD'
}
Antwort = Anfragen.get(url, params=params)
Daten = Antwort.json()
usd_to_twd = data['rates']['TWD']
print(f"1 US-Dollar entspricht {usd_to_twd} neuen Taiwan-Dollar")

Bitte registrieren Sie sich zunächst bei ExchangeRatesAPI, um einen API-Schlüssel zu erhalten, und ersetzen Sie „Ihren API-Schlüssel“ im Code.

Methode 3: Verwenden Sie das Forex-Python-Paket

Wenn Sie die API nicht direkt aufrufen möchten, können Sie ein Python-Paket eines Drittanbieters verwendenforex-python：

aus forex_python.converter Währungsraten importieren

cr = Währungskurse()
usd_to_twd = cr.get_rate('USD', 'TWD')
print(f"1 US-Dollar entspricht {usd_to_twd} neuen Taiwan-Dollar")

Befehl zum Installieren des Pakets:

pip install forex-python

Dinge zu beachten

• Für einige APIs oder Pakete ist ein API-Schlüssel erforderlich. Registrieren Sie sich daher unbedingt und aktivieren Sie den Dienst zuerst.
• Die Verwendung der kostenlosen Version der API kann Einschränkungen unterliegen, beispielsweise hinsichtlich der Anforderungshäufigkeit oder der Anzahl der unterstützten Währungen.
• Wechselkursdaten aus verschiedenen Quellen können geringfügig variieren. Bitte wählen Sie den entsprechenden Dienst entsprechend Ihren Anforderungen aus.

Verwenden Sie einen Crawler, um den Wechselkurs zwischen US-Dollar und Taiwan-Dollar von Currency.Wiki abzurufen

Vorwort

Wenn Sie die API nicht verwenden, können Sie mithilfe der Webcrawler-Technologie den Echtzeit-Wechselkurs des US-Dollars gegenüber dem Taiwan-Dollar direkt von der Website „Currency.Wiki“ abrufen.

Erforderliche Kits

Die folgenden Python-Pakete müssen installiert werden:

pip install requests
pip install beautifulsoup4

Beispielcode

Importanfragen
aus bs4 Import BeautifulSoup

# Ziel-URL festlegen
url = "https://currency.wiki/usd_twd"

#Senden Sie eine GET-Anfrage, um Webseiteninhalte abzurufen
Antwort = Anfragen.get(URL)
Suppe = BeautifulSoup(response.text, 'html.parser')

# Suchen Sie nach bestimmten Tags und Kategorien
span_tag = Suppe.find('span', class_='unit_secondary_value')
rate = span_tag.text
print(f"1 US-Dollar entspricht {rate} Taiwan-Dollar")

Code-Erklärung

• requests：Senden Sie eine HTTP-Anfrage und rufen Sie den Inhalt der Webseite ab.
• BeautifulSoup：Analysieren Sie die HTML-Struktur der Webseite und extrahieren Sie den angegebenen Tag-Inhalt.
• CSS-Selektoren:Verwenden Sie den Kategorienamen „.converter-result > strong“, um den Block zu lokalisieren, in dem der Wechselkurs angezeigt wird.

Dinge zu beachten

• Änderungen an der Struktur der Webseite:Wenn die HTML-Struktur der Currency.Wiki-Webseite aktualisiert wird, muss das Programm gleichzeitig den CSS-Selektor aktualisieren.
• Häufigkeit der Nutzung:Zu häufige Anfragen können von der Website blockiert oder der Zugriff eingeschränkt werden.
• Rechtmäßigkeit:Das Crawlen von Website-Daten unterliegt den Nutzungsbedingungen und der Robots-Vereinbarung der Website (robots.txt).

abschließend

Mithilfe der Python-Crawler-Technologie können Sie Echtzeit-Wechselkursinformationen direkt abrufen, müssen jedoch auf Änderungen der Webseitenstruktur und Compliance-Probleme achten. Es eignet sich für kleinere Anwendungen oder Lernzwecke.

Verkauf von Investmentsoftware

Marktprognoseprogrammverkäufe

Abonnement-Signalisierungsdienst

Verpacken Sie die vom Programm generierten Handelssignale in regelmäßige Berichte oder Push-Übertragungen in Echtzeit und berechnen Sie den Benutzern eine monatliche oder jährliche Gebühr. Zu den gängigen Plattformen gehören Substack, Patreon oder selbst erstellte Mitgliedschaftssysteme. Es ist je nach Funktionsebene in eine kostenlose Version und eine kostenpflichtige Version unterteilt. Die kostenlose Version zieht Traffic an und die kostenpflichtige Version bietet Echtzeitsignale, historische Abfragen und detaillierte Analysen.

SaaS-Toolplattform

Entwickeln Sie die prädiktive Ranking-Logik in eine Webseite oder App, sodass Benutzer selbst Abfragen durchführen können. Das Abrechnungsmodell kann ein monatliches Abonnement, eine nutzungsbasierte Bezahlung oder ein funktionsgestufter Preis sein. Dieses Modell ist hoch skalierbar und für Entwickler mit bestimmten technischen Fähigkeiten geeignet. Es beinhaltet keine direkte Anlageberatung und weist relativ geringe regulatorische Risiken auf.

Bezahlte Communities und Discord-Kanäle

Bauen Sie eine geschlossene Investment-Community auf. Mitglieder können nach Zahlung der Mitgliedsbeiträge wöchentliche oder tägliche Marktrankings, Diskussionen und Frage-und-Antwort-Dienste erhalten. Discord-, Telegram- oder LINE-Communities sind allesamt gängige Träger mit niedrigen Schwellenwerten und schnellem Start, sodass sie für die Kaltstartphase geeignet sind.

Newsletter

Versenden Sie regelmäßig Marktanalysen und Prognose-Ranking-Berichte, wobei die E-Mail-Liste das wichtigste Asset ist. Zunächst ein kostenloses Abonnement, um ein Publikum aufzubauen. Nach Erreichen einer bestimmten Größe wird eine kostenpflichtige Version oder eine Werbekooperation gestartet. Substack und Beehiiv sind derzeit die Mainstream-Monetarisierungsplattformen für Newsletter.

API-Lizenzierung an Dritte

Kapseln Sie das Vorhersagemodell in eine API und autorisieren Sie es für Broker, Finanzinformationsplattformen oder andere Anwendungsentwickler zur Integration und Nutzung. Dieses Modell eignet sich für Modelle, die einzigartig und stabil sind und in der Regel auf monatlichen Lizenzgebühren oder einer Abrechnung basierend auf dem Anrufvolumen basieren, mit hoher Kundenbindung und stabilem Einkommen.

White-Label-Lizenzierung für Organisationen

Autorisieren Sie das gesamte System in Form eines White Labels an Anlageberatungsunternehmen, Vermögensverwalter oder Wertpapierfirmen, und die andere Partei erbringt Dienstleistungen unter ihrer eigenen Marke. Der Auftragswert ist in der Regel höher, zur Unterstützung der Verhandlungen sind jedoch nachweisbare Leistungsnachweise und eine professionelle Dokumentation erforderlich.

Eigenverwaltete Fonds oder Agenturmanagement

Unter Verwendung von Programmsignalen als Grundlage für den Betrieb werden die eingeworbenen Mittel von ihnen selbst verwaltet oder mit der Arbeit in ihrem Namen beauftragt, und die Vergütung wird auf der Grundlage von Verwaltungsgebühren und Leistungsgebühren erhoben. Dieser Weg hat das größte Potenzial, aber in den meisten Ländern erfordert er eine Finanzlizenz (wie Taiwans Anlageberatungslizenz), die regulatorischen Schwellenwerte sind am höchsten und er muss innerhalb eines Compliance-Rahmens durchgeführt werden.

Bildungskurse und Workshops

Verpacken Sie die Marktauswahllogik, das Indikatordesign und die Backtesting-Methoden hinter dem Programm in Online-Kursen oder physischen Workshops und monetarisieren Sie sie in Form von Wissensprodukten. Dieses Modell ist nicht direkt durch Finanzvorschriften eingeschränkt und kann gleichzeitig eine persönliche Marke etablieren und Traffic auf andere Monetarisierungswege lenken. Geeignete Plattformen für die Auflistung sind Teachable, Hahow oder Udemy.

Kooperation mit Leistungsgewinnbeteiligung

Arbeiten Sie mit Investoren oder Händlern zusammen, die über Mittel verfügen, und diejenigen, die Signale liefern, werden kein Kapital beisteuern und Gewinne werden im Verhältnis zu den tatsächlichen Gewinnen aufgeteilt. Dieses Modell kann indirekt an Transaktionsgewinnen partizipieren, ohne dass Fundraising-Qualifikationen erforderlich sind, allerdings muss auf die Klarheit der Vertragsgestaltung und Nutzenverteilung geachtet werden.

Kernelemente der Werbung

Unabhängig davon, welcher Monetarisierungsweg eingeschlagen wird, entscheiden folgende Punkte über Erfolg oder Misserfolg der Werbung:

• Überprüfbare öffentliche Aufzeichnung:Die Backtest-Daten dienen nur als Referenz. Nur echte Tracking-Aufzeichnungen können Vertrauen aufbauen. Es wird empfohlen, die Signale und Ergebnisse jeder Periode so früh wie möglich auf der öffentlichen Plattform zu speichern.
• Klare Positionierung:Erklären Sie klar und deutlich die anwendbaren Märkte, Signalfrequenzen und Nutzungsmethoden des Programms, vermeiden Sie übertriebene Belohnungen und nutzen Sie stattdessen Transparenz, um einen guten Ruf aufzubauen.
• Kaltstartstrategie:Die Gewinnung eines Publikums in der Community mit kostenlosen Inhalten in einem frühen Stadium und die anschließende schrittweise Einführung bezahlter Konvertierungen wird eine höhere Erfolgsquote haben als die direkte Einführung kostenpflichtiger Produkte.
• Einhaltung gesetzlicher Vorschriften:Die finanziellen Regelungen verschiedener Realisierungsmodelle unterscheiden sich erheblich. Insbesondere Agentenbetrieb und Fondswege müssen vorab die Genehmigungsvoraussetzungen der örtlich zuständigen Behörden bestätigen.

email: [email protected]

T:0000

資訊與搜尋 | 回dev首頁
email: Yan Sa [email protected] Line: 阿央
電話: 02-27566655 ,03-5924828

阿央
泱泱科技
捷昱科技泱泱企業