AI価格予測

価格予測は通常、機械学習と深層学習アルゴリズムを組み合わせ、履歴データと市場テクニカル指標を使用します。一般的な方法をいくつか示します。

1. 時系列分析

• ARIMA (自己回帰統合移動平均モデル): この方法は、定常時系列の将来の値を予測するために使用され、短期予測に適しています。
• SARIMA（旬の有馬）: ARIMA に基づいて季節成分が追加されており、季節傾向が明らかなデータに適しています。

2. 機械学習アルゴリズム

• ランダムフォレスト: 決定木に基づくアンサンブル学習方法は、過剰適合のリスクを効果的に軽減し、安定した予測結果を提供します。
• サポート ベクター マシン (SVM)：高次元データの処理に適しており、複雑な株価変動パターンを発見することができます。

3. ディープラーニングモデル

• LSTM (長短期記憶ネットワーク): 時系列データの長期依存関係の処理に優れ、株価の傾向予測に非常に適したリカレント ニューラル ネットワーク (RNN)。
• GRU (ゲート・リカレント・ユニット): LSTM に似ていますが、構造がより単純で、計算効率が高くなります。

4. 混合モデル

• XGBoost + LSTM: XGBoost と LSTM を組み合わせることで、データ内の線形パターンと非線形パターンを同時にキャプチャし、予測精度を向上させることができます。

5. テクニカル指標

• よく使われるテクニカル指標としては、相対強度指数 (RSI)そして移動平均収束発散 (MACD)、トランザクションのエントリーとエグジットのタイミングを特定するのに役立ちます。

6. 強化学習

強化学習を使用したインテリジェント取引システムは、シミュレートされた市場環境で学習し、時間の経過とともに売買の意思決定を最適化し、取引戦略を徐々に改善することができます。

7. ビッグデータとセンチメント分析

AI モデルは、ニュースやソーシャルメディアのセンチメント分析を通じて市場センチメントを判断し、外部要因に基づいて株価の変化を予測できます。

8. 注意事項

複数のアルゴリズムと外部データ (経済指標、企業のファンダメンタルズ分析など) を組み合わせることで、最も効果的な AI 株価予測モデルが生成されることがよくあります。

指標と運用戦略

AI を株価予測に使用すると、モデルは投資家の意思決定を支援するさまざまな指標を生成します。これらの指標を使用して、市場の傾向を判断し、さまざまなシナリオに基づいて対応する取引操作を行うことができます。以下に、一般的な予測指標とその運用戦略をいくつか示します。

1. 価格を予測する

これは、モデルによって直接予測された将来の株価値です。

• 運用戦略:予測価格が現在の価格よりも高い場合は、購入が推奨される場合があります。現在の価格より安い場合は売却をお勧めします。

2. 上昇と下降の確率

モデルは、株価が上昇または下降する確率を予測する場合があります。

• 運用戦略:上昇確率が一定の閾値（70％など）を超えた場合は購入をお勧めします。下落する可能性が高い場合は、売るか様子見することをお勧めします。

3. トレンドシグナル

モデルは、移動平均などのテクニカル指標に基づいて株式のトレンドの方向を予測する場合があります。

• 運用戦略:株価が上昇傾向にあることをトレンドシグナルが示している場合は、購入することをお勧めします。下降トレンドを示している場合は、売るか空売りすることをお勧めします。

4.買われ過ぎ/売られ過ぎシグナル

RSI (相対力指数) などのテクニカル指標を使用して、株が買われすぎか売られすぎかを判断できます。

• 運用戦略:RSI インジケーターが株が売られすぎていることを示している場合は、買い時である可能性があります。買われ過ぎを示している場合は、売却または利益確定の時期である可能性があります。

5. ボラティリティ

このモデルは、株式の将来の価格変動幅を予測することができます。

• 運用戦略:予測のボラティリティが高い場合は、市場が不安定であることを意味するため、保守的な戦略を採用することをお勧めします。ボラティリティが低い場合は、ポジションを保持することを検討できます。

6. 取引の激しさ

市場の買い手と売り手の強さに基づいた予測。

• 運用戦略:購入強度が販売強度よりも高い場合は、購入することをお勧めします。それ以外の場合は、売るか空売りすることをお勧めします。

7. ストップロスとテイクプロフィットポイント

モデルは、履歴データに基づいて、合理的なストップロスポイントとテイクプロフィットポイントを提案する場合があります。

• 運用戦略:価格がストップロスポイントに達したら、さらなる損失を避けるために売却する必要があります。価格がストッププロフィットポイントに達したら、利益確定することをお勧めします。

要約する

さまざまな予測指標に従って、投資家は、購入、売却、静観など、それに応じた取引の決定を下すことができます。複数の指標を組み合わせることで、さまざまな市場シナリオの下でより合理的な投資決定を下すことができます。

回転インジケータープログラム

数あるローテーション判定インジケーターの中でも、すべてのインジケーターが同じ予測力を持っているわけではありません。近年（2020年から2025年）の市場経験に基づいて、以下は精度と実用性に基づいて等級付けされており、市場全体を比較し、プロセス自動化を通じて取得および計算する方法について説明します。

近年精度の高い先行指標

近年、これらの指標がより正確になったのはなぜですか?

イールドカーブが高い精度を維持している理由は、イールドカーブが債券市場の将来経済に対する総合的な価格設定を反映しているためです。債券市場の参加者は機関法人が多数を占めており、情報効率は個人投資家が多数を占める市場よりもはるかに優れています。 ISMの新規受注は企業側の実需変化を直接反映しており、市場センチメントの影響を受けない。高利回り債のスプレッドはクレジット市場の「ストレスゲージ」です。企業のデフォルトリスクが高まると、ファンドは真っ先に高リスク資産から撤退することになる。通常、このシグナルは株式市場の反応に先行して現れます。

相対的に言えば、VIX と融資残高の精度は近年低下しています。主な理由は、ゼロデイ有効期限オプション (0DTE) がオプション市場構造を大きく変え、VIX を歪めてしまったためです。また、ソーシャルメディアを通じた個人投資家の集団行動も、従来のセンチメント指標のシグナルの質を低下させています。

市場間比較の方法論

異なる市場間でローテーション比較を行う場合、比較可能な標準化されたフレームワークを確立する必要があります。

相対強度

2 つの市場またはセクターの価格を比較し、その比率の傾向の方向を観察します。たとえば、「MSCI新興国市場指数/MSCI先進国市場指数」が曲線上に描かれている場合、比率の上昇は新興国市場がアウトパフォームしていることを意味します。この方法は、次の 2 つの比較可能な資産に適用できます。

• 成長と価値: Russell 1000 の成長 / Russell 1000 の価値
• 米国株と欧州株: S&P 500 / STOXX 600
• 大規模対小規模: S&P 500/Russell 2000
• 台湾株対本土株：TAIEX/CSI 300

Z スコア正規化方法

異なる市場の指標は一律に Z スコア (平均値からの標準偏差の倍数) に変換され、次元の違いを排除した後でのみ水平比較が可能になります。式は次のとおりです。 Z = (現在の値 - 過去 N 期間の平均値) / 過去 N 期間の標準偏差。たとえば、米国のPMIは52、ユーロ圏のPMIは47です。表面的には大きな違いはありません。ただし、米国の PMI の過去の平均が 53 の場合、標準偏差は 3、Z スコアは -0.33 になります。

エコノミック・サプライズ指数の比較方法

シティ エコノミック サプライズ インデックスは、実際の経済データと市場の予想との乖離を測定します。この指数を国全体で比較すると、どの地域のファンダメンタルズが予想を超えて改善しているか悪化しているかを判断できます。サプライズ指数が改善する市場に資金が流れる傾向がある。

プログラムされたデータの自動取得と指標の計算

以下は、Python を使用して自動監視システムを構築する完全なアーキテクチャとプログラムの例です。

データソースと対応するAPI

コアプログラミングアーキテクチャ

# === 必要なパッケージをインストール ===
# 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 キー (無料で申請するには https://fred.stlouisfed.org/docs/api/api_key.html にアクセスしてください)
fred = Fred(api_key='YOUR_FRED_API_KEY')

# ==========================================
# 1. イールドカーブ: 2 年と 10 年の金利差
# ==========================================
def get_yield_curve_spread():
    gs10 = fred.get_series('DGS10')  # 10年国債利回り
    gs2 = fred.get_series('DGS2')    # 2年国債利回り
    spread = gs10 - gs2
    spread = spread.dropna()
    latest = spread.iloc[-1]
    status = 「アップサイド・ダウン（不況警告）」 if latest < 0 else "普通"
    return {
        'spread': round(latest, 3),
        'status': status,
        'series': spread.tail(252)  # 過去1年間の情報
    }

# ==========================================
#2. ハイイールド債のスプレッド
# ==========================================
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': 「ハイリスク」 if z_score > 1.5 else "中性" if z_score > -0.5 else 「リスクが低い」
    }

# ==========================================
#3. ブロンズとゴールドの比率
# ==========================================
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 = 「景気拡大の兆し」 if current > ma_200 else 「経済縮小のシグナル」
    return {'ratio': round(current, 5), 'ma200': round(ma_200, 5), 'trend': trend}

# ==========================================
#4. 市場全体の相対的な強さの比較
# ==========================================
def relative_strength(ticker_a, ticker_b, period='1y'):
    """2 つの資産の相対的な強さの比率と傾向を計算します"""
    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
    }

#使用例:
#relative_strength('IWF', 'IWD') #成長率と価値
#relative_strength('EEM', 'SPY') #新興市場 vs 米国株
#relative_strength('^TWII', '000300.SS') #台湾株 vs CSI 300

# ==========================================
#5. Z スコアの正規化された市場間比較
# ==========================================
def zscore_compare(series_dict, lookback=756):
    「」
    複数の市場から時系列を受信し、Z スコアを計算して水平方向に比較します
    series_dict: {'米国': pd.Series, 'ヨーロッパ': 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. セクター勢いランキング
# ==========================================
def sector_momentum_ranking():
    """米国株式セクターの主要11銘柄ETFの複数期間のモメンタムとランキングを取得"""
    sectors = {
        「科学技術」: 'XLK', 'ファイナンス': 'XLF', '医学': 'XLV',
        「不要不急の消費」: 'XLY', 「エッセンシャル消費」: 'XLP', '業界': 'XLI',
        'エネルギー': 'XLE', '原材料': 'XLB', 「ユーティリティ」: 'XLU',
        '不動産': 'XLRE', 'コミュニケーション': '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
        # 総合的な運動量スコア: 近い将来の比重が高くなる
        score = ret_1m * 0.4 + ret_3m * 0.35 + ret_6m * 0.25
        results.append({
            '皿': name, 「1か月%」: round(ret_1m, 2),
            「3か月%」: round(ret_3m, 2), 「6か月%」: round(ret_6m, 2),
            「総合運動エネルギー」: round(score, 2)
        })
    df = pd.DataFrame(results).sort_values(「総合運動エネルギー」, ascending=False)
    return df.reset_index(drop=True)

自動スケジュールと通知

import schedule
import time
import requests

def send_line_notify(token, msg):
    """LINE Notifyでメッセージを送信"""
    headers = {'Authorization': f'Bearer {token}'}
    requests.post('https://notify-api.line.me/api/notify',
                  headers=headers, data={'message': msg})

def daily_rotation_report():
    """毎日のローテーション監視レポート"""
    yc = get_yield_curve_spread()
    hy = get_hy_spread()
    cg = get_copper_gold_ratio()
    sectors = sector_momentum_ranking()

    report = ふ「」
=== 毎日のローテーション監視 ===
日付: {datetime.now().strftime('%Y-%m-%d')}

利回り曲線 (2Y-10Y): {yc['spread']}% {yc['status']}
ハイイールド債スプレッド Z スコア: {hy['z_score']} ({hy['risk_level']})
銅と金の比率のトレンド: {cg['trend']}

上位 3 セクターの勢いランキング:
{sectors.head(3).to_string(index=False)}

セクターの勢いは下位 3 位にランクされます。
{sectors.tail(3).to_string(index=False)}
「」
    print(report)
    # send_line_notify('YOUR_LINE_TOKEN', report)
    return report

# 毎取引日午後 6 時に約定
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)

包括的なホイールダッシュボード計算ロジック

def rotation_dashboard():
    「」
    現在の景気循環段階の判断を出力する総合的な複数の指標
    リターン：回復・拡大・過熱・景気後退の確率推計
    「」
    scores = {'回復': 0, '拡大': 0, 'オーバーヒート': 0, '衰退': 0}

    #イールドカーブシグナル
    yc = get_yield_curve_spread()
    if yc['spread'] < -0.5:
        scores['衰退'] += 3
    elif yc['spread'] < 0:
        scores['オーバーヒート'] += 2; scores['衰退'] += 1
    elif yc['spread'] < 1.0:
        scores['拡大'] += 2
    else:
        scores['回復'] += 3

    # ハイイールド債スプレッドシグナル
    hy = get_hy_spread()
    if hy['z_score'] > 1.5:
        scores['衰退'] += 3
    elif hy['z_score'] > 0.5:
        scores['オーバーヒート'] += 2
    elif hy['z_score'] > -0.5:
        scores['拡大'] += 2
    else:
        scores['回復'] += 2

    # 銅と金の比率信号
    cg = get_copper_gold_ratio()
    if cg['ratio'] > cg['ma200']:
        scores['拡大'] += 2
    else:
        scores['衰退'] += 1; scores['回復'] += 1

    # 確率分布に変換する
    total = sum(scores.values())
    probs = {k: round(v/total*100, 1) for k, v in scores.items()}
    phase = max(probs, key=probs.get)

    return {
        「ジャッジメントサイクル」: phase,
        「各ステージの確率」: probs,
        「推奨構成」: {
            '回復': 「テクノロジーと金融を重視しすぎている。守備力不足」,
            '拡大': 「原材料とエネルギーの過剰摂取。株の水位を高く維持する,
            'オーバーヒート': 「成長株をアンダーウエート。コモディティとインフレ防止資産を増やす,
            '衰退': 「公的債務と現金を増やす。守備セクターの偏重
        }[phase]
    }

上級: 台湾株式セクターローテーションの監視

def tw_sector_rotation():
    """台湾株ETFのモメンタムトラッキング"""
    tw_sectors = {
        「台湾半導体」: '00891.TW',
        「台湾のESG持続可能性」: '00850.TW',
        「台湾金融」: '0055.TW',
        「台湾の高配当」: '0056.TW',
        「台湾50」: '0050.TW',
        「台湾ミディアム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({
                'ストック': name,
                「1 月額報酬%」: round(ret_1m, 2),
                「月給3%」: round(ret_3m, 2),
                「運動エネルギー分率」: round(ret_1m * 0.5 + ret_3m * 0.5, 2)
            })
        except Exception as e:
            print(f"{name}取得に失敗しました:{e}")
    return pd.DataFrame(results).sort_values(「運動エネルギー分率」, ascending=False)

実践的な提案

プログラムされた監視の中心的な価値は、人間の判断に代わることではなく、感情的な干渉を排除し、規律を確保することです。システムを構築する際には、次の点に特別な注意が必要です。

1. 単一のインジケーターの勝率は約 55% ～ 65% ですが、信頼性を 70% 以上に高めるには複数のインジケーターの相互検証が必要です。
2. FRED API には 1 日あたりの呼び出し制限が 120 件あります (無料版)。リクエストの繰り返しを避けるために、取得したデータをローカルの SQLite または CSV に保存することをお勧めします。
3. yfinance は公式 API ではないため、Yahoo の改訂により無効になる場合があります。 Try-Except および代替ソース (台湾株の FinMind など) を追加することをお勧めします。
4. すべてのインジケーターには適用可能な時間枠があります。イールドカーブは中長期（6か月以上）の判断に適しており、セクターモメンタムは短期および中期（1～3か月）の判断に適しています。混合するときは、時間スケールの一貫性に注意を払う必要があります。
5. 過剰な取引を避けるために、完全なレポートを週に 1 回作成し、異常な変化 (1 日でスプレッドが 20 bp 以上拡大するなど) のみを毎日監視することをお勧めします。

Python yfinance パッケージ

yfinance は、Yahoo Finance から金融市場データを取得するために Ran Aroussi によって開発されたオープンソースの Python スイートです。 Yahoo Finance が 2017 年に公式 API を閉鎖した後、yfinance は公開情報にアクセスするための最も人気のあるツールとなりました。最新バージョンは 1.2.0 (2026 年 2 月リリース) で、Apache によってライセンス供与されており、完全に無料であり、研究および教育目的に適しています。

インストールと基本設定

＃ インストール
pip install yfinance

#最新バージョンにアップグレードする
pip install yfinance --upgrade

# 基本的なインポート
import yfinance as yf

yfinance の依存関係パッケージには、pandas、numpy、requests、lxml が含まれており、Anaconda 環境を使用する場合、これらはすべてプリインストールされています。

主要なカテゴリと機能の概要

アクセス可能なデータ範囲

yfinance が取得できる情報は単純な株価をはるかに超えており、次のカテゴリをカバーしています。

サポートされているターゲット コード形式

過去の価格: 最も使用されている機能

import yfinance as yf

# ========================================
# 方法 1: Ticker オブジェクトを使用する (単一ターゲットの詳細な分析に適しています)
# ========================================
tsmc = yf.Ticker("2330.TW")

# 過去の価格を取得する
hist = tsmc.history(period="1y")        #ほぼ1年
hist = tsmc.history(period="6mo")       # 過去 6 か月
hist = tsmc.history(period="5d")        # 過去 5 日間
hist = tsmc.history(period="max")       # すべての歴史
hist = tsmc.history(start="2024-01-01",
                    end="2025-12-31")   #日付範囲を指定

# 期間パラメーターのオプション:
# 1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, 10y, ytd, max

# ========================================
#方法 2: download() を使用する (複数の規格の一括ダウンロードに適しています)
# ========================================
data = yf.download(
    tickers="SPY QQQ EEM GC=F BTC-USD",
    period="1y",
    interval="1d",      #日線
    group_by="ticker",  #ターゲットごとにグループ化
    auto_adjust=True,   # 権利落ち金利を自動調整
    threads=True        #複数のスレッドによりダウンロードが高速化される
)
# 特定のオブジェクトにアクセスします: data['SPY']['Close']

# ========================================
# 時間粒度 (間隔パラメータ)
# ========================================
# 分レベル: 1m、2m、5m、15m、30m、60m、90m
# 時間レベル: 1 時間
# 日レベル以上: 1日、5日、1週間、1ヶ月、3ヶ月
#
# 制限事項に注意してください:
# 100 万のデータは過去 7 日間のみ取得可能
# 日内データ (間隔 < 1d) は過去 60 日間のみ取得可能
# 日々のラインを超えると、数十年の歴史が得られます

# 5 分間の K ラインを取得 (過去 5 日間)
intraday = yf.download("AAPL", period="5d", interval="5m")

返された DataFrame 構造体

History() と download() は両方とも、次のフィールドを含む pandas DataFrame を返します。

会社情報と財務諸表

msft = yf.Ticker("MSFT")

# === 会社の基本情報 (辞書を返す) ===
info = msft.info
print(info['marketCap'])         # 時価総額
print(info['trailingPE'])        # 価格収益率
print(info['dividendYield'])     #配当利回り
print(info['fiftyTwoWeekHigh'])  #52 週間最高値
print(info['sector'])             ＃業界
print(info['longBusinessSummary'])＃ 会社概要

# === 財務諸表 (データフレームを返す) ===
msft.income_stmt              # 年次損益計算書
msft.quarterly_income_stmt    # 四半期損益計算書
msft.balance_sheet            # 年次貸借対照表
msft.quarterly_balance_sheet  # 四半期貸借対照表
msft.cashflow                 #年次キャッシュフロー計算書
msft.quarterly_cashflow       # 四半期キャッシュフロー計算書

# === 配当と分割 ===
msft.dividends                #過去の配当金
msft.splits                   # 過去の株式分割
msft.actions                  # 配当＋分割合併

# === アナリスト情報 ===
msft.analyst_price_targets    # 目標価格 (高値/低値/平均/中央値)
msft.recommendations          #アナリストの評価
msft.calendar                 # カレンダー（決算報告日など）

# === 法人株主 ===
msft.institutional_holders    # 機関投資家向け保有銘柄
msft.major_holders            # 大株主
msft.insider_transactions     #インサイダー取引

# === 選択肢 ===
msft.options                  # 利用可能な期日のリスト
chain = msft.option_chain(msft.options[0])
chain.calls                   # 通話情報
chain.puts                    # 情報を載せる

実践的なヒントと一般的なパターン

# ========================================
# 1. バッチダウンロード後に単一ターゲットの終値を取得する
# ========================================
data = yf.download(["SPY", "GC=F", "BTC-USD"], period="1y")
spy_close = data['Close']['SPY']     # マルチインデックスはMultiIndexです

# 単一のターゲットをダウンロードする場合の直接アクセス
spy = yf.download("SPY", period="1y")
spy_close = spy['Close']

# ========================================
# 2. MultiIndex を処理するための .squeeze() テクニック
# ========================================
# 単一のターゲットをダウンロードする場合、Close フィールドは Series ではなく DataFrame になる場合があります。
# .squeeze() を使用してシリーズに確実に変換します
close = yf.download("AAPL", period="1y")['Close'].squeeze()

# ========================================
# 3. エラー処理 (yfinance は時々失敗する場合があります)
# ========================================
def safe_download(ticker, **kwargs):
    """安全なダウンロード、失敗した場合は空のデータフレームを返します"""
    try:
        data = yf.download(ticker, progress=False, **kwargs)
        if data.empty:
            print(f"{ticker}：情報なし」)
        return data
    except Exception as e:
        print(f"{ticker}ダウンロードに失敗しました:{e}")
        return pd.DataFrame()

# ========================================
#4. 台湾株でよく使われるコードを簡単にチェック
# ========================================
tw_tickers = {
    「TSMC」: '2330.TW',
    「ホンハイ」:   '2317.TW',
    「メディアテック」: '2454.TW',
    「台湾50」: '0050.TW',
    「高配当」: '0056.TW',
    'ファイナンス':   '0055.TW',
    '半導体': '00891.TW',
    「加重インデックス」: '^TWII',
}

# ========================================
#5. テクニカル指標の計算の完全な例
# ========================================
import pandas as pd

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

# 移動平均
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))

# ボリンジャーバンド
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. CSV へのエクスポート
# ========================================
df.to_csv("tsmc_data.csv", encoding="utf-8-sig")  #utf-8-sig により Excel で中国語を正しく表示できるようになります

使用制限と注意事項

代替品の比較

個人的な調査や学習、戦略のプロトタイピング、中長期的な投資分析を始めるには、yfinance が最適です。シンプルな設計なので、初心者でも 2 ～ 3 行のコードで世界市場データを取得し、パンダで分析できます。ニーズがリアルタイム トランザクションや商用アプリケーションにアップグレードされると、有料 API に頼ることができます。

取引市場向けのデータベース設計

1. データベース構造

2. 関係の説明

• Userテーブル: 購入者と販売者を含むユーザー情報を保存します。
• Productテーブル: 製品情報が格納され、各製品は販売者に関連付けられます。
• Orderテーブル: 注文情報が保存され、各注文は購入者に関連付けられます。
• OrderItemテーブル: 注文内の製品の詳細情報を保存し、それらを製品と注文に関連付けます。
• Paymentテーブル: 支払い情報を保存します。各支払いは注文に対応します。

公開取引市場向けのデータベース設計

1. データベース構造

2. 関係の説明

• Assetテーブル: 名前、資産タイプ、基本資産 (BaseAsset) および見積もられた資産 (QuoteAsset)、現在の価格、最終更新時刻などの取引資産の基本情報が保存されます。
• MarketDataテーブル:付きAssetテーブル関連付けは、資産パフォーマンスを分析するために、価格変動や取引量などの毎日の市場データを記録します。
• OrderBookテーブル:付きAssetテーブル関連付けは、市場の深さと需要と供給の状態を分析するために、特定の時点での注文帳のスナップショットを記録します。
• HistoricalTradeテーブル:付きAssetテーブル関連付けは、資産の過去の取引記録を記録し、取引パターン分析と定量的調査に使用されます。

3. 主な機能

• 資産価格分析: に基づくMarketDataテーブル データはボラティリティと利回りを計算し、さまざまな資産ポートフォリオ (BaseAsset/QuoteAsset) の傾向を観察します。
• 市場の厚みと流動性: 合格OrderBookこの表は、市場参加者の行動とそれが資産価格に与える影響を分析しています。
• 取引行動分析: エクスプロイトHistoricalTradeデータをテーブル化し、取引頻度の高い期間と価格と出来高の相関関係を発見します。
• ベースおよび見積資産構造: からAssetテーブル内の取引ペア (BTC/USD など) を管理して、マルチアセット分析を実現します。

MetaQuotes Language (MQL)

言語の概要

MetaQuotes Language (略して MQL) は金融市場取引専用に開発されたプログラミング言語で、MetaTrader プラットフォーム (MT4 や MT5 など) で自動取引戦略 (エキスパートアドバイザー)、カスタム指標、スクリプト、関数ライブラリを作成するために使用されます。

MQL4 と MQL5

• MQL4：MetaTrader 4 で使用される構文は C 言語に近く、基本的な自動取引プログラムの開発に適しています。
• MQL5：MetaTrader 5 では、より強力になり、オブジェクト指向プログラミング、イベント駆動型アーキテクチャ、およびマルチスレッドの最適化をサポートします。

アプリケーションの種類

• Expert Advisor (EA)：自動取引ロボットは、事前に設定された戦略に従って注文、ポジションのクローズ、ストップロスの設定、その他の操作を行うことができます。
• Custom Indicators：価格データを分析し、取引の決定を支援するために使用されるカスタムテクニカル指標。
• Scripts：すべての注文を一度にクローズする、すべてのストップロスレベルを変更するなど、1 回限りのタスクを実行します。
• Libraries：関数ライブラリ、複数の EA またはインジケーターで再利用するための共通コード。

文法的特徴

• 基本的な構文は C/C++ に似ています
• 変数、条件判断、ループ、関数、カスタム データ構造をサポート
• 市場データ（価格、時間、出来高など）へのアクセス
• チャート描画と UI コンポーネント (MQL5) をサポート

簡単な例: MQL4 の EA

// 新しいKスティックが起動するたびに動作
int start() {
    if (OrdersTotal() == 0 && Volume[0] == 1) {
        OrderSend(Symbol(), OP_BUY, 0.1, Ask, 3, 0, 0, "買い注文", 0, 0, clrGreen);
    }
    0を返します。
}

簡単な例: 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);
}

開発ツール

MQL コードは、MetaTrader の組み込み MetaEditor を通じて編集およびコンパイルでき、ストラテジー テスターでバックテストおよび最適化できます。

学習とコミュニティ

• MQL5公式サイト（中国語含む）
• 公式フォーラム、ドキュメント、CodeBase、フリーランス機能が学習とコミュニケーションをサポート
• 数万の既製の EA とインジケーターをダウンロードまたは購入可能

結論

MetaQuotes Language は、取引自動化のために作成されたプロフェッショナル言語です。初心者もプロの定量トレーダーも、その強力な機能を使用して洗練された取引戦略を実装できます。

TradingViewガジェット

高度なリアルタイム チャート

これは、複数のインジケーター、描画ツール、完全な取引インターフェイス (ブローカーに接続されている場合) を含む、最も完全なバージョンです。

<!-- 高度なグラフ コンテナ -->
<div class="tradingview-widget-container">
  <div id="tradingview_adv"></div>
  <script type="text/javascript" src="https://s3.tradingview.com/tv.js"></script>
  <スクリプトタイプ="text/javascript">
  新しい TradingView.widget({
    "自動サイズ": true、
    "シンボル": "BINANCE:BTCUSDT",
    "間隔": "H"、
    "タイムゾーン": "等/UTC",
    "テーマ": "ダーク"、
    "スタイル": "1",
    "ロケール": "zh_TW",
    "container_id": "tradingview_adv"
  });
  </スクリプト>
</div>

テクニカル分析ガジェット（テクニカル分析）

このツールはダッシュボードとして表示され、さまざまなテクニカル指標 (移動平均、オシレーターなど) に基づいて買いまたは売りの推奨事項を自動的に計算して表示します。

<!-- テクニカル分析ガジェット -->
<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>
  {
    "間隔": "1m",
    「幅」: 425、
    "isTransparent": false、
    「高さ」：450、
    "シンボル": "ナスダック:TSLA",
    "showIntervalTabs": true、
    "ロケール": "zh_TW",
    "colorTheme": "ライト"
  }
  </スクリプト>
</div>

市場概要ウィジェット (市場概要)

複数の商品のリアルタイムの価格比較を表示するのに適しています。金融ウェブサイトのトップページのサイドバーでよく見られます。

<!-- 市場概要 -->
<div class="tradingview-widget-container">
  <script type="text/javascript" src="https://s3.tradingview.com/external-embedding/embed-widget-market-overview.js" async>
  {
    "colorTheme": "ダーク",
    "dateRange": "12M",
    "showChart": true、
    "ロケール": "zh_TW",
    "幅": "100%",
    "高さ": "400",
    「タブ」: [
      {
        "タイトル": "インデックス",
        「シンボル」: [
          {"s": "FOREXCOM:SPX500", "d": "S&P 500"},
          {"s": "FOREXCOM:NSXUSD"、"d": "ナスダック 100"}
        】
      }
    】
  }
  </スクリプト>
</div>

カスタムコードの入手方法

JavaScript を手動で記述することも可能ですが、TradingView には公式のグラフィカル ジェネレーターが用意されており、構文エラーを避けるために推奨されます。

• に行くTradingView Widget Library。
• 必要なガジェットの種類を選択します。
• 設定パネルで色、サイズ、デフォルトの製品を調整します。
• 「適用」をクリックし、生成された HTML コードをコピーします。

よくある質問

暗号通貨プログラム開発

Binance API - スポットとクライアントの紹介

Binance は、開発者に次のような豊富な API サポートを提供する世界的な仮想通貨取引所です。Spot APIそしてClient API、ユーザーが自動取引とデータ取得を容易に実行できるようにするため。

Binance Spot API

Binance Spot API は、Binance がスポット市場トレーダー向けに設計した API です。市場情報の照会、注文、注文のキャンセル、その他の操作に使用できます。この API は、取引ボット、自動取引戦略を設計し、市場変動を監視するために一般的に使用されます。

主な機能

• 市場情報照会：現在価格、Kラインチャート、水深データなどが含まれます。
• 注文と取引を行う：指値注文や成行注文など、さまざまな注文タイプをサポートします。
• アカウント情報：資産残高や取引記録などを閲覧できます。
• 注文管理：注文状況の照会や注文のキャンセルなどの操作が含まれます。

Binance Client API

Binance クライアント API は、Binance のさまざまな API メソッドにアクセスする便利な方法を提供します。開発者が使用できるのは、binance.clientライブラリAPI 認証と管理、およびさまざまなスポットおよび契約市場の機能を便利に呼び出します。

クライアントAPIの主な機能

• API認証: ユーザーは API キーと秘密キーを使用して認証します。
• 資産運用管理: ユーザーの資産を便利に管理し、残高照会や複数のデジタル通貨での取引をサポートします。
• 包括的な市場データの取得: スポット API、コントラクト API を呼び出し、さまざまな市場からのデータを統合できます。
• リスク管理設定：取引限度額の設定や管理の委託が可能となり、取引リスクの軽減に貢献します。

クライアントAPIでBinance Spotを使用する方法

1. まず、Binance で API キーとシークレット キーを申請し、適切に保管する必要があります。
2. Binance API Python SDK をインストールします。pip install binance
3. 使用binance.clientAPI接続を確立して呼び出すbinance.spot方法。

binance.clientインポートクライアントから

    #クライアントを初期化する
    client = Client(api_key='your_api_key', api_secret='your_secret_key')

    # 現在の価格を取得する
    価格 = client.get_symbol_ticker(symbol="BTCUSDT")
    プリント（価格）

Bybit API

説明する

Bybit は、市況のクエリ、注文、資金調達レートの確認、アカウントの管理などに使用できる REST および WebSocket API を提供します。 以下に Python の使用方法を示します。requestsこのスイートは Bybit のパブリック API を呼び出します。

取り付けキット

pip install requests

取引ペアのリストをクエリする

インポートリクエスト

BASE_URL = "https://api.bybit.com"

def get_symbols():
    URL = f"{BASE_URL}/v5/market/instruments-info?category=linear"
    res = リクエスト.get(url)
    res.raise_for_status()
    データ = res.json()
    シンボル = [s["シンボル"] for s in data["結果"]["リスト"]]
    print(f"合計 {len(symbols)} 個の取引ペアが取得されました:")
    print(symbols[:10]) # 最初の 10 項目を表示します

__name__ == "__main__"の場合:
    get_symbols()

K ライン情報のクエリ

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

署名が必要なプライベート API

注文やアセットのクエリなどの Bybit のプライベート エンドポイントには API キーと署名が必要です。

インポートリクエスト、時間、hmac、ハッシュリブ

API_KEY = "あなたのapi_key"
API_SECRET = "あなたのapi_secret"

defsign_request(パラメータ、シークレット):
    """Bybit署名の生成"""
    query = "&".join([f"{k}={v}" for k, v insorted(params.items())])
    hmac.new(secret.encode()、query.encode()、hashlib.sha256).hexdigest() を返す

def get_wallet_balance():
    エンドポイント = "/v5/アカウント/ウォレット残高"
    URL = BASE_URL + エンドポイント
    タイムスタンプ = str(int(time.time() * 1000))

    パラメータ = {
        "アカウントタイプ": "統一",
        「タイムスタンプ」: タイムスタンプ、
        "api_key": API_KEY、
    }
    params["sign"] =sign_request(params, API_SECRET)

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

__name__ == "__main__"の場合:
    get_wallet_balance()

補充する

• Bybit公式文書:https://bybit-exchange.github.io/docs/v5/
• API は次のように分かれています。
  • Public（署名不要） - マーケットデータ、Kライン、ターゲット情報
  • Private(署名が必要です) - 注文の発注、残高の確認、ポジションのクローズ、およびポジションの管理
• リニア（USDT永久）、インバース、スポットなどのマーケットタイプをサポートします。

Bybit は特定のタイプの取引ペアを取得します

説明する

パイオネックスは使用しています/api/v1/common/symbols?type=PERP「永久契約」取引ペアを取得するには; Bybit では、次のことができます。/v5/market/instruments-infoそして指定しますcategory=linear(USDT 永久) またはinverse（逆契約）でも同じ効果が得られます。

Python の例

インポートリクエスト

クラスBybitAPI:
    BASE_URL = "https://api.bybit.com"

    @クラスメソッド
    def get_symbols(cls, category="linear"):
        「」
        特定のタイプの取引ペアを取得する
        カテゴリは次のとおりです。
          - リニア → USDT パーペチュアル (PERP)
          - インバース → インバース永久/納品契約
          - スポット→スポット
        「」
        エンドポイント = "/v5/market/instruments-info"
        URL = f"{cls.BASE_URL}{エンドポイント}"
        params = {"カテゴリ": カテゴリ}
        
        res = request.get(url, params=params)
        res.raise_for_status()
        データ = res.json()

        data.get("retCode") == 0の場合:
            シンボル = [s["シンボル"] for s in data["結果"]["リスト"]]
            print(f"合計 {len(symbols)} {category} 種類の取引ペアを取得しました")
            シンボル[:10]の の場合:
                印刷する
        それ以外の場合:
            print("取得に失敗しました:", data)

__name__ == "__main__"の場合:
    BybitAPI.get_symbols("リニア")

パラメータ比較表

戻りデータ形式の例

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

補充する

• category=linearつまり、パイオネックスの取引ペア「PERP」に相当します。
• Bybit の契約情報には以下も含まれますpriceFilter、lotSizeFilterおよびその他の制限。
• 複数のタイプを同時に確認したい場合は、API を複数回呼び出すことができます。

Bybit REST API クエリ K ライン データ

説明する

パイオネックスで入手可能/api/v1/market/klines市場の状況を確認してください。 Bybit の対応するエンドポイントは/v5/market/kline。を通してcategory市場の種類を指定します (例:linearUSDT の永久契約を表し、渡すことができますsymbol、interval、limit、endTimeおよびその他のパラメータ。

Python 関数の例

インポートリクエスト
インポート時間

クラスBybitAPI:
    BASE_URL = "https://api.bybit.com"

    @クラスメソッド
    def get_klines(cls、シンボル: str、間隔: str、end_time: int = なし、制限: int = 100):
        「」
        Bybit Kライン情報のクエリ
        :param シンボル: 取引ペア (「BTCUSDT」など)
        :param 間隔: 時間間隔 (1、3、5、15、30、60、120、240、360、720、D、W、M)
        :param end_time: 終了時刻 (Unix ミリ秒)、デフォルトは現在です
        :param limit: 返されるトランザクションの数、最大 1000
        「」
        エンドポイント = "/v5/マーケット/kline"
        URL = f"{cls.BASE_URL}{エンドポイント}"

        パラメータ = {
            "カテゴリ": "リニア"、# USDT 永久
            「シンボル」: シンボル、
            「間隔」: 間隔、
            「限界」：限界
        }

        終了時刻の場合:
            params["end"] = 終了時間
        それ以外の場合:
            params["end"] = int(time.time() * 1000)

        res = request.get(url, params=params)
        res.raise_for_status()
        データ = res.json()

        data.get("retCode") == 0の場合:
            klines = データ["結果"]["リスト"]
            print(f"{symbol} は合計 {len(klines)} K 行を取得しました")
            # 最初の 3 つのルート情報を表示します
            k の場合、kline[:3]:
                始値、始値、高値、安値、終値、出来高、出来高 = k
                print(f"始値:{open_price} 終値:{close} 高値:{high} 安値:{low} 出来高:{volume}")
        それ以外の場合:
            print("取得に失敗しました:", data)

__name__ == "__main__"の場合:
    BybitAPI.get_klines(symbol="BTCUSDT"、interval="60"、limit=5)

戻りデータの例

{
  "retCode": 0、
  「結果」: {
    "シンボル": "BTCUSDT",
    "カテゴリ": "線形",
    「リスト」: [
      [
        "1735119600000", // 開始時間 (ミリ秒)
        "98342.5", // 始値
        "98350.0", // 最高価格
        "98285.0", // 最低価格
        "98290.5", // 終値
        "12.304", // 取引高
        "1210000.5" // 取引量 (USDT)
      ]
    ]
  }
}

補充する

• categoryに変更できますspotまたはinverseさまざまな市場に対応します。
• end引数はミリ秒単位のタイムスタンプ (Unix エポック × 1000) です。
• サポートされる間隔形式: 1、3、5、15、30、60、120、240、360、720、D、W、M。

Kラインの一括取得を高速化

説明する

以下は、再試行、レート制限、キャッシュが組み込まれた ThreadPoolExecutor を使用した、直接再現可能な Python の例です。プロセス: まず、キャプチャされた K ライン (存在する場合) をキャッシュからロードし、欠落または不十分な取引ペアに対するリクエストのみを発行します。スレッド プールを使用して複数のリクエストを同時に実行し、セマフォを使用して同時実行数を制御し、制限を回避します。失敗した場合は、指数バックオフを使用して再試行されます。

プログラムコード (Bybit /v5/market/kline の例)

# 要件: pip インストールリクエスト
インポートリクエスト
インポート時間
jsonをインポートする
OSをインポートする
concurrent.futures からインポート ThreadPoolExecutor、as_completed
スレッドインポートセマフォから

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

# 調整可能なパラメータ
MAX_WORKERS = 20 # スレッド プール サイズ (API レート制限の調整の対象)
MAX_CONCURRENT = 10 # 実際の同時リクエストの数 (セマフォで制御)
RETRY = 3 # 各リクエストの再試行回数
INITIAL_BACKOFF = 0.5 # 最初の再試行を待機する秒数
CATEGORY = "linear" # 線形 -> USDT 持続可能;スポット/インバースを変更可能
LIMIT_PER_CALL = 200 # 各 kline API 制限 (API 上限設定による)
DATASET_ALLDAYS = 24 * 6 # 例: 少なくとも何 K 行必要かを決定します (変更可能)

# キャッシュのロード/アクセス
defload_cache():
    os.path.exists(CACHE_FILE)の場合:
        試してみてください:
            return json.load(open(CACHE_FILE, "r", encoding="utf-8"))
        例外例外:
            {}を返す
    {}を返す

def save_cache(キャッシュ):
    json.dump(cache, open(CACHE_FILE, "w", encoding="utf-8"), ensure_ascii=False, indent=2)

# 単一シンボルの API キャプチャ (再試行とレート制御を含む) (同時実行数はセマフォによって制御されます)
def fetch_klines_for_symbol(symbol、interval="60"、end_time=None、limit=LIMIT_PER_CALL、sem: セマフォ = None):
    パラメータ = {
        「カテゴリー」: カテゴリー、
        「シンボル」: シンボル、
        「間隔」: 間隔、
        「限界」：限界
    }
    終了時刻の場合:
        params["end"] = int(end_time)
    バックオフ = INITIAL_BACKOFF
    last_exc = なし

    # セマフォを取得します (指定されている場合)
    セムの場合:
        sem.acquire()
    試してみてください:
        範囲 (1, RETRY + 1) 内の試行の場合:
            試してみてください:
                resp = request.get(BASE_URL, params=params, timeout=10)
                resp.raise_for_status()
                データ = resp.json()
                # Bybit v5 は成功を示す retCode == 0 を返します。
                data.get("retCode", 0) == 0 で、データが "result" の場合:
                    klines = data["結果"].get("リスト", [])
                    クラインを返す
                それ以外の場合:
                    last_exc = Exception(f"API エラー: {data}")
            eとしてのrequests.Exceptions.RequestExceptionを除く：
                last_exc = e
            #バックオフ
            time.sleep(バックオフ)
            バックオフ *= 2
    最後に:
        セムの場合:
            sem.release()
    # 失敗した場合は、最後のエラーをスローするか、None を返します
    last_exc を発生させる

# バッチ処理: ペア (シンボルのリスト) で渡し、dict {symbol: klines} を返します。
def get_klines_batch(pairs、interval="60"、dataset_alldays=DATASET_ALLDAYS、limit=LIMIT_PER_CALL、max_workers=MAX_WORKERS、max_concurrent=MAX_CONCURRENT):
    キャッシュ = load_cache() # キャッシュ形式: { シンボル: [kline_list] }
    結果 = {}
    to_fetch = []

    # どのシンボルを取得する必要があるかを決定します (キャッシュに存在しないか、長さが不十分です)
    ペアの の場合:
        キャッシュ = キャッシュ.get(s)
        キャッシュされており、len(cached) >= dataset_alldays の場合:
            結果[s] = キャッシュ済み
        それ以外の場合:
            to_fetch.append(s)

    # 取得するものが何もない場合は、直接返します
    to_fetch しない場合:
        結果を返す

    sem = セマフォ(max_concurrent)
    ThreadPoolExecutor(max_workers=max_workers) を exe として使用:
        futures = {exe.submit(fetch_klines_for_symbol、sym、interval、None、limit、sem): to_fetch の sym の sym}
        as_completed(futures) の fut の場合:
            sym = 先物[fut]
            試してみてください:
                kl = fut.result()
                # API リターンがリスト形式で保存されている場合 (Bybit の例 [time,open,high,low,close,vol,turnover] による)
                キャッシュ[sym] = kl
                結果[sym] = kl
            e としての例外を除く:
                # 失敗を記録しますが、プログラム全体をブロックしません
                print(f"[エラー] {sym}の取得に失敗しました: {e}")
                結果[sym] = なし

    # キャッシュをアーカイブします (オプション: 成功したキャッシュのみを保存します)
    save_cache(キャッシュ)
    結果を返す

# 使用例
__name__ == "__main__"の場合:
    # 500 ペアあると仮定します (参考値)
    ペア = ["BTCUSDT", "ETHUSDT", "SOLUSDT"] # ... 500
    # 一括取得を実行する
    all_klines = get_klines_batch(ペア、間隔 = "60"、データセット_オールデイズ = 100、制限 = 200)
    # 長さの要件を満たすシンボルを除外します
    Good = [kl と len(kl) >= 100 の場合、all_klines.items() の s、kl]
    print(f"100 を超えて一致する取引ペアの数: {len(good)}")
    印刷(良好[:20])

考慮事項とベストプラクティス

• 最初に API ファイルのレート制限を確認し、調整してくださいMAX_WORKERSそしてMAX_CONCURRENT。 API キーをお持ちの場合は、通常、レート割り当てを増やすことができます。
• 大量の履歴データ (一度に何日もキャプチャ) が必要な場合は、Bybit のパブリック一括データ (public.bybit.com) を使用するか、提供された履歴データ ファイルを交換して、大量の REST リクエストを保存することをお勧めします。
• リアルタイム監視の場合、WebSocket を使用すると頻繁な REST リクエストを回避できますが、履歴データには依然として 1 回限りの REST またはバルク ファイルが必要です。
• キャッシュ ファイルを Parquet/SQLite に変更して、読み取りと書き込みを高速化し、スペース効率を高めることができます。

Pionex API

導入

Pionex は、開発者がプロ​​グラムを通じて取引を自動化し、市場データをクエリし、アカウント資産を管理できるようにする公式 API を提供しています。 API は、REST メソッドと WebSocket メソッドの両方をサポートします。

APIキーの申請

1. Pionex アカウントにログインします
2. 入力API管理ページ
3. 新しい API キーを作成し、権限 (読み取り、取引、コインの引き出しなど) を設定します。
4. 書き留めるAPI KeyそしてSecret、一度だけ表示されます

REST API の例 (Node.js)

// Node.js axios を使用して Pionex API をリクエストします
const axios = require("axios");
const crypto = require("crypto");

const apiKey = "あなたの API_KEY";
const Secret = "あなたのAPI_SECRET";
const BaseUrl = "https://api.pionex.com";

// 署名の生成
関数記号(クエリ) {
  return crypto.createHmac("sha256", Secret).update(query).digest("hex");
}

// アカウント残高を問い合わせる
非同期関数 getBalances() {
  const タイムスタンプ = Date.now();
  const クエリ = `タイムスタンプ=${タイムスタンプ}`;
  const 署名 = 署名 (クエリ);

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

getBalances();

REST API の例 (Python)

インポート時間
hmacをインポートする
ハッシュライブラリをインポートする
インポートリクエスト

API_KEY = "あなたの API_KEY"
SECRET = "あなたのAPI_SECRET"
BASE_URL = "https://api.pionex.com"

def 記号(クエリ: str) -> str:
    hmac.new(SECRET.encode()、query.encode()、hashlib.sha256).hexdigest() を返す

def get_balances():
    タイムスタンプ = str(int(time.time() * 1000))
    クエリ = f"タイムスタンプ={タイムスタンプ}"
    署名 = 署名(クエリ)

    URL = f"{BASE_URL}/api/v1/account?{クエリ}&signature={signature}"
    ヘッダー = {"X-MBX-APIKEY": API_KEY}
    res = request.get(url, headers=ヘッダー)
    print(res.json())

get_balances()

WebSocket の例 (Node.js)

const WebSocket = require("ws");

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

ws.on("開く", () => {
  console.log("Pionex WebSocket に接続しました");
  // BTC/USDT 相場を購読する
  ws.send(JSON.stringify({
    イベント: "購読"、
    チャネル: 「マーケット」、
    マーケット: "BTC_USDT"
  }));
});

ws.on("メッセージ", (msg) => {
  console.log("受信メッセージ:", msg.toString());
});

WebSocket の例 (Python)

Webソケットをインポートする
jsonをインポートする

def on_open(ws):
    print("Pionex WebSocket に接続されました")
    サブメッセージ = {
        "イベント": "購読",
        "チャネル": "市場"、
        "市場": "BTC_USDT"
    }
    ws.send(json.dumps(sub_msg))

def on_message(ws, メッセージ):
    print("受信メッセージ:", message)

ws = websocket.WebSocketApp(
    "wss://ws.pionex.com/ws",
    on_open=on_open、
    on_message=オンメッセージ
)

ws.run_forever()

よく使われる機能

• 市場状況のクエリ (ティッカー、K ライン、詳細情報)
• 注文、注文のキャンセル、注文状況の確認
• 口座資産照会
• ロボット売買制御（一部機能制限あり）

注意事項

• API Keyは漏洩しないようにしてください。 IP ホワイトリストを設定することをお勧めします。
• さまざまな機能にはレート制限があるため、ブロックをトリガーすることを回避する必要があります。
• 実際の取引を使用するには、最初にテスト環境または少額でテストしてください。

Pionex REST API 取引ペアリストの取得

APIの説明

利用可能GET /api/v1/common/symbolsサポートされているすべての取引ペアと、最小注文サイズ、価格精度、取引タイプ (スポットまたは契約) などの Pionex の詳細な属性を取得するため。

HTTPリクエスト

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

ポストバックの例

{
  "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 の例

インポートリクエスト

BASE_URL = "https://api.pionex.com"

def get_symbols():
    URL = f"{BASE_URL}/api/v1/common/symbols"
    res = リクエスト.get(url)
    データ = res.json()
    
    data.get("コード") == 0の場合:
        シンボル = data.get("データ", [])
        print(f"合計 {len(symbols)} 個の取引ペアを取得しました")
        for s inSymbols[:10]: # 最初の 10 個のみを表示します
            print(f"{s['symbol']} ({s['baseCurrency']}/{s['quoteCurrency']})")
    それ以外の場合:
        print("取得に失敗しました:", data)

__name__ == "__main__"の場合:
    get_symbols()

特定のタイプをフィルタリングする

無期限契約をサポートする取引ペアのみを削除するには、次の単純なフィルタリング ロジックを使用できます。

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

使用

• Pionex 上のすべての取引可能なターゲットをクエリします。
• マッチ/api/v1/market/tickers価格をすぐに入手できます。
• 自動取引プログラムまたは戦略を作成する前の初期化データ。

Pionex の戻り形式を解析する

説明する

次のプログラムは呼び出しますhttps://api.pionex.com/api/v1/common/symbols、返された JSON の構造 (キーとデータ型) が自動的に出力されるため、実際の形式を理解しやすくなります。

Python の例

インポートリクエスト
jsonをインポートする

def print_json_structor(データ、インデント=0):
    """JSON 構造を再帰的に出力します"""
    スペース = " " * インデント
    if isinstance(data, dict):
        data.items() の k、v の場合:
            if isinstance(v, (dict, list)):
                print(f"{space}{k}: {type(v).__name__}")
                print_json_struct(v, インデント + 1)
            それ以外の場合:
                print(f"{space}{k}: {type(v).__name__}")
    elif isinstance(data, list) とデータ:
        print(f"{space}[リスト]項目タイプ: {type(data[0]).__name__}")
        print_json_structor(data[0], インデント + 1)

def get_pionex_symbols_format():
    URL = "https://api.pionex.com/api/v1/common/symbols"
    res = リクエスト.get(url)
    res.raise_for_status()
    データ = res.json()
    print("ルートレベル構造:")
    print_json_struct(データ)

__name__ == "__main__"の場合:
    get_pionex_symbols_format()

出力例

ルートレベルの構造:
コード: int
データ: リスト
  [リスト]項目タイプ: dict
    記号: str
    基本通貨: str
    引用通貨: str
    価格精度: int
    数量精度: int
    最小数量:str
    最小概念: str
    tradeEnable: ブール値

補充する

• この方法は、REST API JSON 形式を自動的に検出し、API 構造の分析に最適です。
• API がフィールドを更新する場合は、再実行するだけで最新の形式が取得されます。
• おすすめの組み合わせjson.dumps(data, indent=2)完全なコンテンツが利用可能です。

Pionex REST API Get Klines

APIの説明

Pionex 公開市場データから取得した、指定された取引ペアの K ライン (ローソク足 / OHLCV) データを取得します。

GET /api/v1/market/klines

リクエストパラメータ

戻り値の形式

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

Python の例

インポートリクエスト

BASE_URL = "https://api.pionex.com"

def get_klines(シンボル: str、間隔: str、end_time: int = なし、制限: int = 100):
    パラメータ = {
        「シンボル」: シンボル、
        「間隔」: 間隔、
        「限界」：限界
    }
    end_time が None でない場合:
        params["endTime"] = 終了時間
    応答 = request.get(f"{BASE_URL}/api/v1/market/klines", params=params)
    結果 = 応答.json()
    result.get("result") と結果の "data" の場合:
        結果を返す["データ"]["クライン"]
    それ以外の場合:
        raise Exception(f"K 行の取得に失敗しました: {result}")

__name__ == "__main__"の場合:
    # 例: BTC_USDT 無期限契約の 15 分 K ラインの最新 50 本を取得する
    シンボル = "BTC_USDT.PERP"
    間隔 = "15M"
    klines = get_klines(シンボル、間隔、制限=50)
    クラインの k の場合:
        印刷(k)

Pionex REST API クエリはコントラクト グリッド取引ペアをサポートします

説明する

パイオネックスには1つもありません「グリッド取引ペアのサポートを受ける」専用の API ですが、経由でアクセスできますGET /api/v1/market/tickersすべての取引ペアを取得してフィルターで除外します.PERP「(USDT Perpetual Contract)」と入力して、Futures Grid でサポートされている取引ペアのリストを取得します。

Pythonのサンプルプログラム

インポートリクエスト

BASE_URL = "https://api.pionex.com"

def get_perp_pairs():
    URL = f"{BASE_URL}/api/v1/market/tickers"
    res = リクエスト.get(url)
    データ = res.json()
    
    perp_pairs = []
    データ内の「データ」の場合:
        data["data"] の項目の場合:
            マーケット = item.get("シンボル", "")
            # 無期限契約の取引ペアは通常 .PERP で終わります
            「.PERP」が市場にある場合:
                perp_pairs.append(マーケット)
    perp_pairs を返す

__name__ == "__main__"の場合:
    ペア = get_perp_pairs()
    print("サポートされている永久契約グリッド取引ペア:")
    p のペアの場合:
        印刷(p)

実行結果例

サポートされている永久契約グリッド取引ペア:
BTC_USDT.PERP
ETH_USDT.PERP
SOL_USDT.PERP
LINK_USDT.PERP
...

補充する

• 永久契約ペア (.PERP) は、Futures Grid Bot で直接使用できます。
• 実際の対応状況を確認するには、パイオネックス公式サイトの約定取引市場一覧を比較することをお勧めします。
• 一部の取引ペアは棚から一時的に削除される場合があり、実際のサポート リストは API のリアルタイム応答の影響を受けます。

Max Coin API

Max Coin APIとは何ですか?

Max Coin API は、Max Exchange が提供するアプリケーション プログラミング インターフェイスのセットで、開発者がその暗号通貨取引機能にプログラムでアクセスできるようにします。開発者は、API を通じて取引を自動化し、市場データを取得し、資産を管理できます。

Max Coin APIの使い方は？

1. Max アカウントに登録します。アクセスマックス公式サイトそしてアカウントを登録します。
2. API キーを取得します。ログインしたら、アカウント設定に移動し、新しい API キーを生成し、必要な権限を設定します。
3. リファレンス API ドキュメント:公式 API ドキュメントを読んで、各エンドポイントの機能と使用法を理解してください。

APIでサポートしている主な機能

• 市場データの取得:現在の取引ペアの価格、注文深度、およびボリュームを取得します。
• トランザクション操作:買い注文または売り注文を出し、未処理の注文を表示またはキャンセルします。
• 資産運用管理：口座残高と過去の取引記録を確認します。

APIサンプルリクエスト

以下は、API を介して市場データを取得する例です。

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

このリクエストは、価格、出来高などを含む、BTC/TWD のリアルタイム市場データを返します。

サンプルコード

以下は、Python 言語を使用して Max API を呼び出す簡単な例です。

インポートリクエスト

BASE_URL = "https://max-api.maicoin.com"

def get_ticker(ペア):
    エンドポイント = "/api/v1/ticker"
    params = {"マーケット": ペア}
    応答 = request.get(BASE_URL + エンドポイント、params=params)
    応答.json() を返す

# BTC/TWD マーケットデータを取得する
ティッカーデータ = get_ticker("btctwd")
print(ティッカーデータ)

Max Coin API利用時の注意点

• 安全：API キーを不正アクセスから保護します。
• API の制限事項:過剰なリクエストを避けるために、API 頻度制限に関するドキュメントを参照してください。
• IP ホワイトリスト:IP ホワイトリストを有効にして、API 使用のセキュリティを強化します。

関連リソース

• マックス公式サイト
• Max API ドキュメント

ビットコインPoWの会計プロセス

分散会計の核心

ビットコインの使用状況プルーフ・オブ・ワーク (PoW)分散型会計システムを実現するためのコンセンサスメカニズムとして。 PoW の中心的な目標は、ノードが数学的問題を競って解決して、誰が会計権限を持っているかを決定し、データが意のままに改ざんされないようにすることです。

取引需要の生成と普及

• ユーザーは取引リクエストを行いますが、このリクエストには送金情報と手数料 (チップ) が含まれます。
• 経由の取引ノードブロードキャストビットコイン ネットワーク全体に渡され、各ノードはこれらのトランザクションを受け取ることができます。
• マイナーノードは、受信したトランザクションからブロックに含めるトランザクションを選択します。

トランザクション選択の優先順位

マイナーは、ブロックを正常にパッケージ化して手数料を獲得できる可能性を高めるために、次の基準に基づいてトランザクションに優先順位を付けます。

• 手数料が高い（バイト当たりの収入が多い）
• 取引金額が大きい
• トランザクションが長い間待機されています
• データサイズが適度なのでブロックが埋まりやすい

パッケージングブロックと会計上の権利をめぐる競争

• マイナーはトランザクションを収集した後、必要な情報をすべて含む候補ブロックを作成します。
• PoW を実行する: ブロックのハッシュが特定の目標値 (難易度によって制御される) を下回るような一連のナンス値を見つけてみます。
• 有効な解決策を見つけたマイナーはブロックします放送ネットワーク全体の他のノードに送信します。

検証とチェーンの選択

• 他のノードはブロックを受信した後、(トランザクションの合法性、PoW の正確性) を検証します。
• 検証に合格すると、ブロックがノードのブロックチェーンに追加されます。
• 複数の正当なブロックが同時に出現した場合、ノードは最初に受信したブロックを一時的に受け入れ、最終的には受け入れます。最長のチェーン主に (最も蓄積されたワークロードを意味します)。

ブロック制限と生成頻度

• 各ブロックの最大サイズは約1MB（SegWit使用時は最大約2MB）です。
• 含まれるトランザクションの数も、ノードへの過度の負荷を避けるために制限されています。
• ビットコイン プロトコルは、平均して10分ブロックを生成します。
• 問題解決速度が速くなると、システムは平均出力時間を安定させるために自動的に難易度を上げます。

会計の混雑と解決策

取引量が多すぎると混雑や手数料の高騰が発生します。この問題を改善するために、さまざまな拡張ソリューションが提案されています。

• SegWit (隔離された証人):署名データをメインのトランザクション データから分離して、有効な読み込み量を増やします。
• ライトニングネットワーク:オフチェーンの支払いチャネルを確立すると、多数の少額トランザクションを直ちにチェーンにアップロードする必要がなく、メイン チェーンへの負担が軽減されます。

BTCブロックのデータ構造

ブロックの主な構造

ブロックヘッダー

長さは 80 バイト固定で、内容は次のとおりです。

トランザクション数（トランザクションカウンタ）

VarInt (可変長整数) 形式を使用して、ブロック内のトランザクションの数を示します。

• 取引数量の場合< 0xFD，則佔 1 個位元組
• 0xFD ～ 0xFFFF は 3 バイトを占有します (プレフィックス 0xFD + 2 バイトの整数)
• など、9バイトまで拡張

取引

各トランザクション データには、次の主要部分が含まれます (長さはさまざまです)。

• version：トランザクションバージョン
• input count：このトランザクションは複数の入力を使用します
• inputs[]：各入力には、前のトランザクションの出力、ロック解除スクリプトなどが含まれます。
• output count：このトランザクションはいくつかの出力を生成します
• outputs[]：各出力には量とロック スクリプトが含まれます
• locktime：このトランザクションがブロックに追加される最も早い制限時間

通常、最初のトランザクションはコインベース取引、これはマイナーがブロック報酬を受け取るための特別なトランザクションであり、入力は含まれません。

トランザクション需要の生成と普及プロセスの実装

プログラム紹介

主な工程

• ユーザーはトランザクションを生成し、任意のノードに送信します。
• ノードはトランザクションをすべての隣接ノードにブロードキャストします。
• マイナーノードはトランザクションを受け取り、手数料に従ってトランザクションを選択し、ブロックにパッケージ化します。

Pythonコード

インポート時間

クラストランザクション:
    def __init__(自分、送信者、受信者、金額、手数料):
        self.sender = 送信者
        self.receiver = 受信者
        self.amount = 金額
        self.fee = 料金
        self.timestamp = time.time()

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


クラスノード:
    def __init__(自分自身, 名前):
        self.name = 名前
        self.peers = []
        self.transaction_pool = []

    def connect(自分、ピア):
        ピアが self.peers にない場合:
            self.peers.append(ピア)
            peer.connect(self) # 双方向接続

    def accept_transaction(self, tx):
        tx が self.transaction_pool にない場合:
            self.transaction_pool.append(tx)
            print(f"{self.name} がトランザクションを受け取りました: {tx}")
            セルフブロードキャスト(tx)

    def ブロードキャスト(self, tx):
        self.peers のピアの場合:
            ピア.受信_トランザクション(tx)


クラスマイナー(ノード):
    def Mine_block(self):
        print(f"\n⛏️ {self.name} がブロックのパッキングを開始します")
        # 手数料の高い順に並べ替え、最大 5 件のトランザクションを受け付けます
        sorted_txs =sorted(self.transaction_pool, key=lambda tx: tx.fee, reverse=True)
        選択 =sorted_txs[:5]
        print(f"{self.name} パッケージ化されたトランザクション:")
        選択された tx の場合:
            print(f" - {tx}")
        #処理済みトランザクションをクリアする
        self.transaction_pool = [tx が選択されていない場合は self.transaction_pool の tx]


# ノードとマイナーを作成する
A = ノード("ノード A")
B = ノード("ノード B")
C = マイナー("マイナー C")

# ノードネットワークを接続する
A.connect(B)
B.接続(C)

# ユーザーがトランザクションを発行する
tx_list = [
    トランザクション("アリス", "ボブ", 2.0, 0.0005),
    トランザクション("イブ", "トム", 1.2, 0.0009),
    トランザクション("ジョー", "メアリー", 3.5, 0.0002),
    トランザクション("リック", "サム", 0.8, 0.0015),
    トランザクション("アン", "リリー", 1.7, 0.0001)
]

tx_list の tx の場合:
    print(f"\nユーザーがトランザクションを送信しました: {tx}")
    A.receive_transaction(tx)
    時間.睡眠(0.2)

# マイナーがパッケージングを開始
C.mine_block()

実行命令

• すべてのトランザクションはノード A によって送信され、ノード B 経由でマイナー C にブロードキャストされます。
• マイナー C は手数料に従って並べ替え、パッケージ化する最初の 5 つのトランザクションを選択します。

拡張可能な方向

• 署名検証とトランザクション合法性チェックを追加
• ブロックチェーンの構造とハッシュ操作をシミュレートする
• コンセンサスメカニズムとネットワークフォークを統合する

イーサリアムVM書き込みプログラム

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導入プロセス

準備

• インストールNode.jsそしてnpm
• インストールHardhat：
  npm install --save-dev hardhat
• ヘルメット プロジェクトを作成します。
  npx hardhat, 「基本サンプルプロジェクトの作成」を選択します。

契約書を書く

存在するcontractsフォルダに追加されましたLendingProtocol.solSolidity コントラクトを貼り付けます。

デプロイメントスクリプトをセットアップする

でscriptsフォルダーの作成deploy.js、内容は次のとおりです。

非同期関数 main() {
  const [デプロイヤー] = ethers.getSigners(); を待ちます。
  console.log("デプロイメントアカウント:",deployer.address);

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

  融資を待つ.deployed();
  console.log("LendingProtocol が正常に展開されました:",ending.address);
}

main().catch((エラー) => {
  コンソール.エラー(エラー);
  プロセス終了コード = 1;
});

ローカルのテストチェーンにデプロイする

ヘルメット テスト チェーンを開始します。

別のターミナルを開いてデプロイします。

テストネットへのデプロイ (例: Goerli)

• Infura または Alchemy を登録し、RPC URL を取得します
• 存在するhardhat.config.js追加:

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

module.exports = {
  ネットワーク: {
    ゲルリ: {
      URL: "https://goerli.infura.io/v3/API キー",
      アカウント: ["0xyour private key"]
    }
  }、
  固さ：「0.8.20」
};

次に、以下をデプロイします。

導入が完了しました

デプロイ後、コントラクト アドレスが出力され、フロントエンドの統合と対話に使用できます。

ローン契約書

契約のご紹介

この融資契約は、イーサリアム仮想マシン (EVM) 上で実行されるスマート コントラクトです。ユーザーは、この契約を通じて、利息を得るために資産を預けたり、利息を支払うために資産を貸したりすることができます。このプロトコルは ERC-20 トークンをサポートしており、貸出、貯蓄、清算などのコア機能を備えています。

主な機能

• 入金: ユーザーはプロトコルに資産を入金し、利子を得ることができます。
• 借入: 資産を担保にした後、ユーザーはサポートされている資産を貸与できます。
• 清算: 借り手の住宅ローンの価値が低すぎる場合、他のユーザーが清算することができます。

スマートコントラクトの例 (堅牢性)

// SPDX ライセンス識別子: MIT
プラグマ ソリッドティ ^0.8.0;

インターフェイス IERC20 {
    関数 transferFrom(アドレス送信者、アドレス受信者、単位量) 外部戻り値 (bool);
    関数 transfer(アドレス受信者、単位量) 外部戻り値 (bool);
    関数 BalanceOf(アドレス アカウント) 外部ビューは (uint) を返します。
    関数approve(アドレス消費者, 単位量) 外部戻り値(ブール値);
}

契約融資プロトコル {
    IERC20パブリックトークン。
    公開所有者のアドレスを指定します。
    uint public InterestRate = 5; // 年利 5%

    マッピング(アドレス => uint) 公的預金;
    マッピング(アドレス => uint) パブリック借用;

    コンストラクター(アドレス_トークン) {
        トークン = IERC20(_token);
        所有者 = メッセージ送信者;
    }

    関数 デポジット(単位量) 外部 {
        require(金額 > 0, "金額は 0 より大きい必要があります");
        token.transferFrom(msg.sender, address(this), amount);
        デポジット[msg.sender] += 金額;
    }

    関数borrow(単位量) 外部{
        require(金額 > 0, "金額は 0 より大きい必要があります");
        uint 担保 = 預金[msg.sender];
        require(担保 >= 金額 * 2, "担保が不十分です");
        借入[msg.sender] += 金額;
        token.transfer(msg.sender, amount);
    }

    関数 repay(単位量) 外部 {
        require(金額 > 0, "金額は 0 より大きい必要があります");
        require(borrows[msg.sender] >= 金額, "借入が不十分です");
        借入[msg.sender] -= 金額;
        token.transferFrom(msg.sender, address(this), amount);
    }

    関数draw(単位量)外部{
        require(deposits[msg.sender] >= 金額, "残高が不足しています");
        require(borrows[msg.sender] == 0, "未払いのローンがあります");
        デポジット[msg.sender] -= 金額;
        token.transfer(msg.sender, amount);
    }
}

セキュリティに関する考慮事項

• プロトコル資産のセキュリティを確保するには、清算メカニズムを追加する必要があります。
• 正確な住宅ローン価値を取得するには、価格オラクル (Chainlink など) を統合することをお勧めします。
• 利息の計算はまだ処理されていないため、利率はブロック時間に基づいて動的に計算される必要があります。

今後の展開

• 複数の ERC-20 トークンをサポートします。
• 変動金利モデルを導入します。
• NFTを担保として統合します。

BSC Contract

導入

BSC（Binance Smart Chain）はEVM（Ethereum Virtual Machine）と互換性のあるパブリックチェーンであるため、Ethereum上に書かれたSolidityスマートコントラクトをほぼ直接BSCにデプロイできます。主な違いは、展開中のネットワーク接続とガス料金が BNB で価格設定されることです。

契約例（Solidity）

// 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;
    }
}

導入環境の設定

ハードハットを使用して展開します。hardhat.config.jsBSC ネットワークを次のように設定します。

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

module.exports = {
  固さ: "0.8.20",
  ネットワーク: {
    bscテストネット: {
      URL: "https://data-seed-prebsc-1-s1.binance.org:8545/",
      チェーンID: 97、
      ガス価格: 20000000000、
      アカウント: ["0xyour private key"]
    }、
    bscメインネット: {
      URL: "https://bsc-dataseed.binance.org/",
      チェーンID: 56、
      ガス価格: 20000000000、
      アカウント: ["0xyour private key"]
    }
  }
};

デプロイメントスクリプト

非同期関数 main() {
  const [デプロイヤー] = ethers.getSigners(); を待ちます。
  console.log("デプロイメントアカウント:",deployer.address);

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

  storage.deployed(); を待ちます。
  console.log("展開された契約:", storage.address);
}

main().catch((エラー) => {
  コンソール.エラー(エラー);
  プロセス終了コード = 1;
});

導入方法

1. 依存パッケージをインストールします。
   npm install --save-dev hardhat @nomiclabs/hardhat-ethers ethers
2. 導入を開始します。
   npx hardhat run scripts/deploy.js --network bscTestnet
3. 契約アドレスを確認したら、次のページに進みます。BscScan テスト ネットワークまたはBscScan メインネット契約書を確認してください。

注意事項

• ガス料金はBNBで支払う必要がありますので、財布に十分なBNBを用意してください。
• メインネットにデプロイする前に、BSC テストネット (テストネット、ChainID=97) で正常にテストすることをお勧めします。
• 契約に公的検証が必要な場合は、BscScan でソース コード検証を送信できます。

株式市場プログラムの開発

株価の騰落確率の実装

Python とランダム フォレスト モデルを使用して、株価の上昇または下落の確率を予測します。この例では、Yahoo Finance の株式データを使用し、テクニカル指標を使用してモデルをトレーニングし、最終的に株価の上昇と下落の確率を出力します。

ステップ 1: 必要なパッケージをインストールしてインポートする

まず、いくつかの Python パッケージをインストールしてインポートする必要があります。

次に、これらの必要なライブラリをインポートします。

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
    

ステップ 2: 株価データをダウンロードし、テクニカル指標を生成する

次に、Yahoo Finance から株式の履歴データをダウンロードし、テクニカル指標として単純移動平均 (SMA) を計算します。

# Yahoo Finance から Apple の株価データをダウンロード
シンボル = 'AAPL'
データ = yf.download(シンボル、開始='2020-01-01'、終了='2023-01-01')

# 10 日および 50 日の単純移動平均 (SMA) を計算します。
data['SMA_10'] = data['Close'].rolling(window=10).mean()
data['SMA_50'] = data['Close'].rolling(window=50).mean()

#増加または減少の目標を設定します。翌日の終値がその日の終値より高ければ 1 (上昇を示す)、それ以外の場合は 0 (下落を示す)
data['Target'] = np.where(data['Close'].shift(-1) > data['Close'], 1, 0)

# 欠損値を削除する
data.dropna(inplace=True)

ステップ 3: トレーニング データ セットとテスト データ セットを準備する

移動平均 (SMA) と終値を特徴として使用し、データをトレーニング セットとテスト セットに分割します。

ステップ 4: トレーニングと予測にランダム フォレスト モデルを使用する

ランダム フォレスト モデルを使用してデータをトレーニングし、テスト セット内の株価の上昇確率と下落確率を予測します。

ステップ 5: モデルの精度を計算し、上昇と下降の確率を表示します。

モデルの精度を計算し、毎日の上昇と下降の確率を表示できます。

ステップ 6: 上昇と下落の確率に基づいて取引の決定を下す

上昇の確率に基づいて、購入操作を行うかどうかを決定するためのしきい値を設定できます。たとえば、上昇確率が 70% を超えたら買います。

要約する

この例では、ランダム フォレスト モデルを使用して株の上昇または下降の確率を予測し、予測結果に基づいて取引の意思決定を行う方法を示します。これは、取引上の意思決定の精度を向上させるためのシンプルですが効果的な方法です。

台湾証券取引所の公募発表 - 株式の抽選と取得

ステップ 1: パブリック サブスクリプションのお知らせページに入る

台湾証券取引所の公募発表ページには、次の URL からアクセスできます。

パブリックサブスクリプションのお知らせ

ステップ 2: プログラムを通じて自動的にキャプチャする

Python を使用するrequestsそしてBeautifulSoup、ページ上で公開サブスクリプション情報を取得できます。

サンプルコード

インポートリクエスト
bs4 インポートから BeautifulSoup
パンダをPDとしてインポートする

# パブリックサブスクリプションのお知らせページをキャプチャします
URL = "https://www.twse.com.tw/zh/payment/public.html"
headers = {"ユーザーエージェント": "Mozilla/5.0"}
応答 = request.get(url, headers=headers)

response.status_code == 200の場合:
    スープ = BeautifulSoup(response.text, 'html.parser')
    テーブル = pd.read_html(response.text)
    テーブルの場合:
        df = tables[0] # 最初のテーブルを取得します
        印刷(df)
    それ以外の場合:
        print("テーブルデータが見つかりません")
それ以外の場合:
    print("パブリックサブスクリプションのお知らせページに接続できません")

注意事項

• ページにクローラー対策メカニズムがある場合は、それを使用できます。Seleniumブラウザの操作をシミュレートします。
• 情報の使用が台湾証券取引所の公開情報使用規則に準拠していることを確認してください。

外国為替プログラムの開発

米ドルから台湾ドルへの為替レートを取得する

方法 1: CurrencyAPI を使用する

CurrencyAPI はリアルタイムの為替レート情報を提供します。サンプルコードは次のとおりです。

インポートリクエスト

URL = 'https://api.currencyapi.com/v3/latest'
パラメータ = {
    'apikey': 'API キー',
    '基本通貨': 'USD',
    '通貨': 'TWD'
}
応答 = request.get(url, params=params)
データ = 応答.json()
usd_to_twd = データ['データ']['TWD']['値']
print(f"1 米ドルは {usd_to_twd} 新台湾ドルに等しい")

知らせ：使用するには、CurrencyAPI に登録し、API キーを取得する必要があります。

方法 2: ExchangeRatesAPI を使用する

ExchangeRatesAPI は、リアルタイムの為替レート クエリ サービスも提供します。

インポートリクエスト

URL = 'https://api.exchangeratesapi.io/latest'
パラメータ = {
    'access_key': 'API キー',
    'ベース': '米ドル',
    「シンボル」: 「TWD」
}
応答 = request.get(url, params=params)
データ = 応答.json()
usd_to_twd = データ['レート']['TWD']
print(f"1 米ドルは {usd_to_twd} 新台湾ドルに等しい")

まず ExchangeRatesAPI に登録して API キーを取得し、コード内の「API キー」を置き換えてください。

方法 3: forex-python パッケージを使用する

API を直接呼び出したくない場合は、サードパーティの Python パッケージを使用できます。forex-python：

forex_python.converter から通貨レートをインポート

cr = 通貨レート()
usd_to_twd = cr.get_rate('USD', 'TWD')
print(f"1 米ドルは {usd_to_twd} 新台湾ドルに等しい")

パッケージのインストールコマンド:

pip install forex-python

注意事項

• 一部の API またはパッケージには API キーが必要なため、必ず最初にサービスを登録して有効にしてください。
• API の無料版を使用すると、リクエストの頻度やサポートされる通貨の数などの制限がある場合があります。
• さまざまなソースからの為替レート データは若干異なる場合があります。ニーズに基づいて適切なサービスを選択してください。

クローラーを使用して、Currency.Wiki から米ドルから台湾ドルへの為替レートを取得します。

序文

API を使用しない場合は、Web クローラー テクノロジーを使用して、Currency.Wiki Web サイトから直接米ドルと台湾ドルのリアルタイム為替レートを取得できます。

必要なキット

次の Python パッケージをインストールする必要があります。

pip install requests
pip install beautifulsoup4

サンプルコード

インポートリクエスト
bs4 インポートから BeautifulSoup

# リンク先URLを設定する
URL = "https://currency.wiki/usd_twd"

#GET リクエストを送信して Web ページのコンテンツを取得します
応答 = リクエスト.get(url)
スープ = BeautifulSoup(response.text, 'html.parser')

# 特定のタグとカテゴリを検索する
span_tag =Soup.find('スパン', class_='unit_secondary_value')
レート = スパンタグ.テキスト
print(f"1 米ドルは {rate} 台湾ドルに等しい")

コードの説明

• requests：HTTP リクエストを送信し、Web ページのコンテンツを取得します。
• BeautifulSoup：Web ページの HTML 構造を解析し、指定されたタグの内容を抽出します。
• CSS セレクター:カテゴリ名「.converter-result > Strong」を使用して、為替レートが表示されるブロックを特定します。

注意事項

• Web ページ構造の変更:Currency.Wiki Web ページの HTML 構造が更新された場合、プログラムは CSS セレクターも同時に更新する必要があります。
• 使用頻度:リクエストが頻繁すぎると、Web サイトによってブロックまたはアクセスが制限される場合があります。
• 合法性:Web サイト データのクロールには、Web サイトの利用規約とロボット契約 (robots.txt) が適用されます。

結論は

Python クローラー テクノロジーを通じてリアルタイムの為替レート情報を直接取得できますが、Web ページの構造の変更やコンプライアンスの問題に注意する必要があります。小規模なアプリケーションや学習目的に適しています。

投資用ソフトウェアの販売

市場予測プログラムの販売

サブスクリプションシグナリングサービス

プログラムによって生成された取引シグナルを定期レポートまたはリアルタイムのプッシュ ブロードキャストにパッケージ化し、ユーザーに月額料金または年額料金を請求します。一般的なプラットフォームには、Substack、Patreon、または独自に構築されたメンバーシップ システムが含まれます。機能レベルに応じて無料版と有料版に分かれています。無料版はトラフィックを引き寄せ、有料版はリアルタイムのシグナル、履歴クエリ、詳細な分析を提供します。

SaaSツールプラットフォーム

予測ランキング ロジックを Web ページまたはアプリに開発し、ユーザーが独自にクエリを実行できるようにします。課金モデルは、月次サブスクリプション、従量課金制、または機能階層型の価格設定にすることができます。このモデルは拡張性が高く、特定の技術的能力を持つ開発者に適しています。直接的な投資アドバイスは含まれず、規制リスクは比較的低いです。

有料コミュニティとDiscordチャンネル

クローズドな投資コミュニティを確立します。会員は会費を支払うと、週次または日次のマーケットランキング、ディスカッション、Q&Aサービスを受けることができます。 Discord、Telegram、LINE コミュニティはすべて一般的な通信事業者であり、敷居が低く、起動が速いため、コールド スタート段階に適しています。

ニュースレター

電子メール リストを中核資産として、市場分析と予測ランキング レポートを定期的に送信します。初回は無料で視聴者を獲得し、一定規模に達したら有料版や広告協力を開始する。 Substack と Beehiiv は、現在主流のニュースレター収益化プラットフォームです。

サードパーティへの API ライセンス

予測モデルを API にカプセル化して、ブローカー、金融情報プラットフォーム、またはその他のアプリケーション開発者に統合および使用を許可します。このモデルは、通常、月額ライセンス料または通話量に基づいた請求に基づいており、顧客の粘着力が高く、安定した収入を伴う、ユニークで安定したモデルに適しています。

組織へのホワイトラベルライセンス

ホワイトラベルの形でシステム全体を投資顧問会社や資産運用会社、証券会社に認可し、相手は自社ブランドでサービスを提供する。通常、契約金額は高くなりますが、交渉をサポートするには検証可能な実績記録と専門的な文書が必要です。

自主運用ファンドまたは代理店管理

番組シグナルをベースに運営を行い、集まった資金は自ら、または運営を委託され、管理費や成功報酬などをベースに報酬が徴収されます。この方法は最も可能性が高いですが、ほとんどの国で金融ライセンス (台湾の投資顧問ライセンスなど) が必要であり、規制の基準が最も高く、コンプライアンスの枠組みの中で実行する必要があります。

教育コースとワークショップ

プログラムの背後にある市場選択ロジック、指標設計、バックテスト方法をオンラインコースまたは物理的なワークショップにパッケージ化し、ナレッジプロダクトの形で収益化します。このモデルは金融規制によって直接制限されず、同時に個人ブランドを確立し、他の収益化経路にトラフィックを引き付けることができます。 Teachable、Hahow、または Udemy はすべて、リストに適したプラットフォームです。

パフォーマンス利益分配協力

資金を持っている投資家やトレーダーと協力し、シグナルを出す側は資金を拠出せず、実際の利益に比例して利益を分配する。このモデルは資金調達資格を必要とせずに間接的に取引利益に参加することができますが、契約設計と利益分配の明確さには注意を払う必要があります。

プロモーションの核となる要素

どの収益化パスを採用する場合でも、次の点がプロモーションの成功または失敗を決定します。

• 検証可能な公的記録:バックテストデータは参考値です。本物の追跡記録だけが信頼を築くことができます。各期間のシグナルと結果をできるだけ早くパブリック プラットフォームに保存することをお勧めします。
• 明確なポジショニング:該当する市場、シグナルの頻度、プログラムの使用方法を明確に説明し、過度な報酬の約束を避け、代わりに透明性を利用して評判を築きます。
• コールドスタート戦略:初期段階で無料コンテンツでコミュニティに視聴者を集め、その後徐々に有料コンバージョンを導入する方が、有料製品を直接立ち上げるよりも成功率が高くなります。
• 規制遵守:異なる実現モデルに関係する金融規制は大きく異なります。特に、代理店運営および資金ルートについては、事前に現地管轄当局のライセンス要件を確認する必要があります。

email: [email protected]

T:0000

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

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