乙Py先生のプログラミング教室
初学者のためのプログラミング学習サイト

プログラミング

今回はドルコスト平均法による
積立投資のシミュレーションです

解説動画はこちら



ドルコスト平均法とは

価格が変動する金融商品に対して
一定金額を定期的に購入していく投資方法のことです

今回は毎月10万円積み立てるとして
それがどうなるかをシミュレーションしていきます。



eMaxisSlim米国株式S&P500

リンク先

S&P500指数(配当込み、円換算ベース)に
連動する運用成果を目指す投資信託
2018年7月3日に設定された商品です。

今回はこのデータを用いて
シミュレーションをしていきます。



eMAXIS Slim 米国株式 S&P500の価格推移

価格のデータを定義して
価格推移をだしてみます。

import numpy as np
import pandas as pd
import plotly.express as px
import seaborn as sns
import matplotlib.pyplot as plt

# データ定義
data = {
    2018 : [0,0,0,0,0,0,10038,10458,10709,11051,10188,10468],
    2019 : [8809,9854,10408,10565,10900,10031,10725,10978,10491,10890,11106,11680],
    2020 : [11873,11892,10825,9474,10655,11205,11465,11886,12707,12182,11767,12989],
    2021 : [13339,13407,14010,15217,15754,15924,16540,16712,17301,16677,18267,18005],
    2022 : [19291,18130,17601,19347,18798,18658,18052,19265,19394,18280,20283,19728],
    2023 : [17690,18714,19167,19388,20234,20666,22867,23260,23411,22911,22677,24155],
    2024 : [24154,25486,27473,28563,28573,29833,31693,29763,29789,29974,31336,32768],
    2025 : [33928,34065,32500,30512,28931,30867]
}

records = []
for year, prices in data.items():
    for month_idx, price in enumerate(prices):
        month = month_idx + 1
        if price == 0:
            continue
        date_str = f"{year}-{month:02d}-01"
        date = pd.to_datetime(date_str)
        records.append({"Date": date, "Price": price})

df = pd.DataFrame(records)
df = df.sort_values("Date")

# Plotlyでプロット
fig = px.line(df, x="Date", y="Price", title="Emaxis Slim value")
fig.show()
スクリーンショット 2025-06-21 16.43.01


良い感じに右肩上がりのようですが
この商品を毎月10万円ずつ積み立てたらどうなっていたでしょうか



2018年から2025年まで毎月積み立てた際のシミュレーション

毎月10万円
購入できる購入数量を算出して
2025年の最後の価格で
どれだけのリターンになっているかを算出します。
monthly_investment = 100000  # 毎月XX万円

# シミュレーション開始
total_units = 0  # 累計購入数量
total_invested = 0  # 累計投資金額
for year in sorted(data.keys()):
    for month_idx, price in enumerate(data[year], 1):
        if price == 0:
            continue
        units_bought = monthly_investment / price
        total_units += units_bought
        total_invested += monthly_investment

latest_year = max(data.keys())
latest_price = data[latest_year][-1]
current_value = total_units * latest_price
profit = current_value - total_invested
roi = (current_value / total_invested - 1) * 100

# 結果表示
print(f"総投資額: {total_invested:,.0f}円")
print(f"最終評価額: {current_value:,.0f}円")
print(f"損益: {profit:,.0f}円")
print(f"累計購入数量: {total_units:.4f}口")
print(f"リターン: {roi:.2f}%")
total_return = (100 + roi) / 100
years = 8
cagr = (total_return ** (1 / years)) - 1
print(f"年平均リターン: {cagr * 100:.2f}%")

総投資額: 8,400,000円
最終評価額: 16,458,895円
損益: 8,058,895円
累計購入数量: 533.2198口
リターン: 95.94%
年平均リターン: 8.77%


この価格推移のデータ上では
年平均8%超

7年で二倍近くの運用成績になっています。



ターンヒートマップ


今度は開始年から終了年までの
リターンヒートマップを出してみましょう。


開始と終了年を設定して
開始終了までのリターンを算出します。

years = list(data.keys())
monthly_invest = 100000
results = pd.DataFrame(index=years[:-1], columns=years[1:])
for start in years[:-1]:
    for end in years[years.index(start)+1:]:
        total_invest = 0
        total_units = 0
        for y in range(start, end+1):
            for price in data[y]:
                if price == 0:
                    continue
                units = monthly_invest / price
                total_units += units
                total_invest += monthly_invest
        # 最後の年の最後の価格で評価額計算
        final_price = [p for p in data[end] if p != 0][-1]
        final_value = total_units * final_price
        return_pct = (final_value - total_invest) / total_invest * 100
        results.loc[start, end] = return_pct

# ヒートマップ描画
results = results.astype(float)
plt.figure(figsize=(10, 7))
sns.heatmap(results, annot=True, fmt=".2f", cmap="coolwarm", center=0)
plt.title("dollar cost averaging method return heatmap (%)")
plt.xlabel("end year")
plt.ylabel("start year")
plt.show()
download

年単位だとどの年で買って売っても
プラスにはなっているようです。



まとめ

eMAXIS Slim 米国株式 S&P500のドルコスト平均法による積み立ては
年単位での運用であればマイナスは無いようです。

ただし、月単位だと乱高下があり
損する場合も有ったので、やはり長期積立で
見守るのが良いのではないかと思われます。

投資は自己判断で行うことが大切です。
その金融商品の良し悪しを判断し
投資するかどうかは人に言われるでなく
自分自身の判断で行うのが重要です。

投資判断を行うための材料作りとして
プログラムを用いたシミュレーションは
かなり役に立ちます。

データさえあればシミュレーションでき
結果の良し悪しから
投資判断の材料に使えるようになると思うので
プログラミングが出来るようになっていると
すぐに試すことができるのでお勧めです。

投資 x プログラミング
というテーマを今後も取り扱っていくので
両方できるようになりたい方は
要チェックしてみてください。

それでは


今回は金融庁の
NISA積立シミュレーターがやばいので
その解説です。


解説動画はこちら


 

金融庁の積立シミュレーター

これがそのシミュレーターです。

サイト

ここで
毎月の積立1万円
年利12%
40年間

で試算してみます。
スクリーンショット 2025-06-14 17.12.47


こんな感じになりました。

年利が高すぎますが
計算がわかりやすいようにして
計算してみた結果です。

40年後の資産は
11765万円になりました



Pythonでのシミュレーションコード


先程のシミュレーターと同じ計算を
Pythonでも計算してみましょう。

シミュレーションコード

monthly_rate = 0.12 / 12       # 月利(年利12%)
months = 40 * 12               # 総月数(480ヶ月)
monthly_payment = 10000       # 毎月の積立額(マイナス表記にする)

total = 0
for _ in range(months):
    total = total * (1 + monthly_rate) + monthly_payment

print(f"将来の資産総額: {total:,.0f} 円")
将来の資産総額: 117,647,725 円


金融庁のシミュレーターの結果は
11765万円 なので
ほぼ同じ結果になりました。


落とし穴

実はここに落とし穴があります!!!!

年利計算での正しいシミュレーション結果は
こうなります。
(年末に積立するパターン)

year_rate = 0.12            # 年利12%
years = 40                  # 総年数(40年)
year_payment = 120000    # 年の積立額

total = 0
for _ in range(years):
    total = total * (1 + year_rate) + year_payment

print(f"将来の資産総額: {total:,.0f} 円")
将来の資産総額: 92,050,970 円

先程の計算結果 : 117,647,725 円
とは大きく乖離してきます。


からくり

金融庁のサイトのシミュレーションは年利ではなく
年利を12ヶ月で割った月利の複利(年利 / 12)で計算しているようです。

そのため年利と月利では、計算結果が大きく異なってきます。

もし月利複利計算を正しくするとしたら
12乗して年利になるような値を月利にしないといけません。

月利 = (1 + 0.12) ** (1/12) - 1
= 0.009488792934583046 = 0.948%

年利から月利に直して計算するコードはこちら
monthly_rate = (1 + 0.12) ** (1/12) - 1  # 月利(年利12%)
months = 40 * 12                          # 総月数(480ヶ月)
monthly_payment = 10000                 # 毎月の積立額(マイナス表記にする)

total = 0
for _ in range(months):
    total = total * (1 + monthly_rate) + monthly_payment

print(f"将来の資産総額: {total:,.0f} 円")
将来の資産総額: 97,010,200 円

月利計算だとこのくらいの金額になります。




資産推移のシミュレーター

年利を月利換算しても正しく計算するようにしたものは
こんな感じになります。
import pandas as pd
import plotly.express as px

def plot_investment(rate_percent, years, payment_man):
    annual_rate = rate_percent / 100
    monthly_rate = (1 + annual_rate) ** (1/12) - 1
    months = years * 12
    monthly_payment = payment_man * 10000

    results, ci_total, am_total = [], 0, 0
    for month in range(1, months + 1):
        ci_total = ci_total * (1 + monthly_rate) + monthly_payment
        am_total += monthly_payment
        results.append({'月': month, '資産総額': ci_total, '積立金額': am_total})

    df = pd.DataFrame(results)
    fig = px.line(df, x='月', y=['資産総額', '積立金額'],
                  labels={'value': '金額(円)', 'variable': '項目'},
                  title=f'毎月{payment_man}万円積立(年利{rate_percent:.1f}%・{years}年)の資産推移')
    
    fig.update_layout(
        yaxis_tickformat=',',
        height=400
    )
    fig.show()

積立シミュレーション設定

#@title 積立シミュレーション設定
rate_percent = 5.1 # @param {type:"slider", min:1.0, max:20.0, step:0.1}
years = 30 # @param {type:"slider", min:10, max:50, step:1}
payment_man = 20 # @param {type:"slider", min:1, max:30, step:1}

plot_investment(rate_percent, years, payment_man)

colabで実行するとこのような画面が出てきます
スクリーンショット 2025-06-14 17.34.43

これを設定して実行すると
スクリーンショット 2025-06-14 17.34.53
積立のシミュレーション結果が反映されます。

colabで試せるので
コピペして試してみてください。



まとめ

金融庁のサイトのシミュレーターは
年利と月利を齟齬しているので
数十年後の金額が大きく乖離してくるようです。

単利と複利、月利と年利
この辺りの関係を正しく計算できるように
日々プログラムでシミュレーションすると安全です。

資産形成に取り組みたい方は
この機会にプログラミングも併せて
学んでみてはいかがでしょうか?


それでは。


今回は昔懐かしい
カイジの沼のシミュレーションです。

解説動画はこちら




カイジの沼のシミュレーション

沼とは

漫画『賭博破戒録カイジ』に登場する架空のパチンコ台

帝愛グループの運営するカジノに設置されている
パチンコの中でも特別な台で玉が1発あたり4000円
挑戦は最低300万円からという設定

その一方で、今までの挑戦者が消費した玉が
全てプールされる仕組みになっており
運良く大当たりを引ければ総取りで莫大な額の金を手にできるとか


仕掛け・役物

ここからは確率を計算するための
沼のギミックについてです。

1.釘の森

釘が密集した配置になっている「釘の森」
通常時の設定Cは1/100程度

2.スル

開閉する羽根のある電動役物「スルー」
釘の森を突破した玉を更にふるい落とす
確率は不明なので
ここでは通過率を1/5としておきます

3.3段クルーン

沼の本丸である「三段クルーン」
円形の皿に穴が3つ/4つ/5つ空いていて
当たりの穴に入ると次の段に進める

数学的にはクルーンに入ってさえしまえば
約1/60の確立で当たる


というような設定にはなっていますが
漫画の設定上ではこの台にはイカサマがあり
この確率では入らないようにはなっています。

しかし、今回は考慮しないで
イカサマなしだとどうなるかを見ていきたいと思います。



沼のシミュレーションコード


簡易な確率計算で大当たりしたかどうかだけ返す関数を用いて
シミュレーションしていきます。
最大回数は10万回(4億円相当)とします。

import numpy as np
import random
import pandas as pd
import matplotlib.pyplot as plt

# 確率でヒットするかどうかを判定する
def is_hit(n: int) -> bool:
    return random.randint(1, n) == 1

def numa_charenge():
  # 釘の森の通過
  mori = is_hit(100)
  if not mori:
    return False

  # スルーの通過
  throw = is_hit(5)
  if not throw:
    return False

  # クルーン1段目通過
  first = is_hit(3)
  if not first:
    return False

  # クルーン2段目通過
  second = is_hit(4)
  if not second:
    return False

  # クルーン3段目通過
  third = is_hit(5)
  if not third:
    return False
  else:
    return True


# 1000回施行して測ってみる
ball_price = 4000 # パチンコ玉の価格

def numa_result(num):
  all_result = []
  for a in range(1000):
    cumulative = 0
    for i in range(num):
      cumulative += ball_price
      is_atari = numa_charenge()
      if is_atari:
        all_result.append([i+1, cumulative,1])
        break
      if i == num-1:
        all_result.append([i+1, cumulative,0])
  return all_result

num = 100000 # 1回あたりの最大施行回数
all_result = numa_result(num)

df = pd.DataFrame(all_result,columns=["balls","cumulative","hit"])
df.head()
balls cumulative hit
0 30959 123836000 1
1 29604 118416000 1
...

plt.figure(figsize=(12, 6))
df["cumulative"].hist(bins=20)
plt.show()
download

おおよそこのような結果になります。


どれくらい注ぎ込めば当たるのか?


シミュレーション結果は使った額の累計を入れているので
それを用いれば、その金額以下の回数と
全体の回数から大体の確率を求められます。
times_300 = len(df[df["cumulative"]<3000000])
print(f"300万円で大当たりになる可能性 : {times_300/1000*100} % ")

なおこのシミュレーションの結果は
幾何分布に近似するため以下のようなコードで
回数あたりの大当たり確率の理論値が出せます。
# 幾何分布上の理論値
for i in range(10):
  p = 1 / 30000
  n = (i+1) * 10000
  prob = 1 - (1 - p)**n
  print(f"{i+1:02}万回で当たる確率 : {prob:.6f}")
01万回で当たる確率 : 0.283473
02万回で当たる確率 : 0.486589
03万回で当たる確率 : 0.632127
04万回で当たる確率 : 0.736409
05万回で当たる確率 : 0.811130
06万回で当たる確率 : 0.864669
07万回で当たる確率 : 0.903032
08万回で当たる確率 : 0.930520
09万回で当たる確率 : 0.950215
10万回で当たる確率 : 0.964328


シミュレーション結果もこの理論値に
近似してますね。


まとめ


沼の設定が玉が1発あたり4000円
3万発に1回の確率(100x5x3x4x5)
で当たるのだとしたら3億注ぎ込めば
9割くらいは大当たりするのではないか?

あくまでイカサマが無い事が前提ですが.....
イカサマさえなければ無尽蔵にお金を注ぎ込めるなら
勝てる気がしなくもない今日この頃でした。

それでは

今回はRedisを使ったNoSQL入門です。

解説動画はこちら


 

Redisで超簡単NoSQL入門

今回は Redis のお話です。

Redisは
オープンソースのインメモリデータベース(NoSQL)
になります。


Redisの特徴

キーと値の組み合わせ(キー・バリュー型)でデータを保存
すべてのデータをメモリ上に保持し、高速アクセスを実現
永続化(データの保存)も可能
シングルスレッドながら非常に高速な動作
Python, JavaScript, Go など多くの言語に対応
キャッシュやリアルタイム分析に最適です



Redisの仕組み

データは基本的にRAMに格納(超高速アクセス)
サーバーに配置すれば何処からでもアクセス可能
コマンド操作でデータの入出力などを行う

必要に応じてディスクにバックアップ(永続化)
RDB方式(スナップショット型)
一定間隔でメモリの状態を .rdb ファイルに保存



Redisが扱えるデータ構造

次のようなデータ型でデータを保存できます。

String 文字列、数値
List 順序付きリスト(スタック・キュー)
Set 重複のない集合
Sorted Set(ZSet) スコア付き集合(順序あり)
Hash フィールドと値の連想配列
Stream 時系列データのログ
Geo 地理情報(緯度・経度)



Redisの主なユースケース

Webアプリのキャッシュ
セッション管理
メッセージキュー
トークンや一時的なデータの保存



Colab で Redisを動かす

ここからはGoogle Colabで
Redisを動かしていきましょう。

Google Colabにはredis 関連のものが
インストールされていないので
インストール必要があります。


Redisのインストールと起動
!apt-get update > /dev/null
!apt-get install -y redis-server > /dev/null

Redisの起動
!redis-server --daemonize yes

接続確認
!redis-cli ping

Pythonクライアント(redis-py)のインストール
!pip install redis

Pythonでの接続確認
import redis

# Redisに接続
r = redis.Redis(host='localhost', port=6379, db=0)

# 接続テスト → True が返ればOK
r.ping()


ここからはデータの投入方法と
取得方法です。


String型(基本のキー・バリュー)
値のセット
r.set('キー名', '値')

値の取得
r.get('キー名')
※ データはバイト型で返る

# 値の保存(set)と取得(get)
r.set('message', 'こんにちは!')

print(r.get('message').decode())
こんにちは!




数値操作(インクリメント・デクリメント)

インクリメント
r.incr('キー名')

デクリメント
r.decr('キー名') 

# 値のセット(10)
r.set('count', 10)
print(r.get('count').decode())

# インクリメント(11)
r.incr('count')
print(r.get('count').decode())

# デクリメント(10)
r.decr('count')
print(r.get('count').decode())
10
11
10




List型(スタック/キュー構造)

値をキューに追加
r.rpush('キー名', '値1', '値2', '値3')

値をキューから取得(値を削除しつつ取得)
r.lpop('キー名')

値を全件取得
r.lrange('キー名', 0, -1)

# キューに追加(右) 3つ
r.rpush('task_queue', 'task1', 'task2', 'task3')

# キューから取り出す(左) → task1
print(r.lpop('task_queue').decode())

# 全件取得
print(r.lrange('task_queue', 0, -1))
task1
[b'task2', b'task3']




Hash型(辞書データ)

値のセット
r.hset('キー名', mapping=値)

値の取得(一部)
r.hget('キー名', 'キー名')

値の取得(全部)
r.hgetall('キー名')

# ユーザーデータを登録
r.hset('user:1001', mapping={'name': 'Alice', 'age': '30', 'email': 'alice@example.com'})

# 一部の取得
print(r.hget('user:1001', 'email').decode())

# すべての取得
print(r.hgetall('user:1001'))  # バイナリ形式
alice@example.com
{b'name': b'Alice', b'age': b'30', b'email': b'alice@example.com'}




Set型(重複なし集合)

値のセット
r.sadd('キー名', '値1', '値2', '値3')

値の取得(全部)
r.smembers('キー名')

# 値のセット(python は重複しない)
r.sadd('tags', 'python', 'redis', 'ai', 'python')
print(r.smembers('tags'))
{b'ai', b'redis', b'python'}



Sorted Set(ZSet)でランキング

値のセット
r.zadd('キー名', 値)

値の取得(昇順)
r.zrange('キー名', 開始インデックス, 終了インデックス, withscores=True or False)

値の取得(降順)
r.zrevrange('キー名', 開始インデックス, 終了インデックス, withscores=True or False)

# スコア付きで追加(ランキング)
r.zadd('ranking', {'Alice': 100, 'Bob': 80, 'Charlie': 90, 'Jon':20})

# スコアの降順で表示(上位3名)
print(r.zrevrange('ranking', 0, 2, withscores=True))

# スコアの昇順で表示(下位2名)
print(r.zrange('ranking', 0, 1, withscores=False))
[(b'Alice', 100.0), (b'Charlie', 90.0), (b'Bob', 80.0)]
[b'Jon', b'Bob']



キーの一覧と値の削除

キーの一覧を取得
r.keys('*')

値の削除
r.delete("キー名")

# すべてのキー
print(r.keys('*'))  

# 一括削除
r.delete('message', 'count', 'task_queue', 'user:1001', 'tags', 'ranking')  
print(r.keys('*')) 
[b'tags', b'user:1001', b'ranking', b'message', b'count', b'task_queue']
[]



ユースケースでの使い方

デジタル広告業界
広告クリックの誤クリック判定(5秒の一時記録)
クリックから5秒以内のクリックを無効にする

import redis
import time

# Redisに接続(ローカル or クラウド)
r = redis.Redis(host='localhost', port=6379, db=0, decode_responses=True)

def track_ckick(user_id: str, ad_id: str, timeout_sec: int = 5):
    key = f"clicked:{user_id}:{ad_id}"
    if r.exists(key):
        return "No (Already Counted)"
    else:
        r.setex(key, timeout_sec, 1)
        return "OK (New Click)"

print(track_ckick("user123", "ad789"))  # => OK
time.sleep(3)
print(track_ckick("user123", "ad789"))  # => NO
time.sleep(3)
print(track_ckick("user123", "ad789"))  # => OK (5秒過ぎた)
OK (New Click)
No (Already Counted)
OK (New Click)



まとめ

Redisが使えるようになると
プログラミングやシステム開発の幅が広がります

様々な業界の多用途にマッチする使い方があり
大規模なキャッシュサーバー構築なども出来るので
システム開発ではNoSQLの使用は必須項目です

まずは入門編で使い方を学んでみましょう
それでは

今回はSQLiteを用いた
超簡単なデータベース入門です。


解説動画はこちら



超簡単 SQLite入門

今回は
Google Colabでデータベースを使ってみましょう
SQLiteを用いてデータベースの操作の基本を
体験してみましょう


SQLiteとは

軽量な組み込み型データベースです。

一般的なRDBと使い方はほとんど一緒で
単一ファイルで管理されPython標準ライブラリで操作可能です。

小規模アプリ・学習用途に最適です。


データベースの仕組み


データベースはテーブルと呼ばれる
「表」形式のデータを複数組み合わせたものです。

表は複数のカラム(列)が存在し
データ行はレコードと呼ばれています。
スクリーンショット 2025-05-17 16.28.06

カラムはデータの形式によって
異なるデータ型を定義して格納できるようになっています。

通常のRDBはSQL文を用いて
テーブルの操作を行えるようになっています。

今回は詳細なSQL文の内容説明は省きますが
コードを実行すれば、SQL文を実行したことと同じ結果になります。




データベースの接続

ここからはデータベースの接続を行っていきましょう。

Google Colabでは初めから
SQLiteを使えるようになっています。

# データベース作成と接続
import sqlite3

# データベースの作成

# メモリに保存したい場合
# conn = sqlite3.connect(':memory:')

# ファイルに保存したい場合
conn = sqlite3.connect('sample.db')

# 接続
cursor = conn.cursor()

実行するとファイル置き場に
sample.db が出来上がります。



テーブルの作成

データベースを作成したら
その中にテーブルを作る事ができます。

cursor.execute でSQL文(CREATE文)を実行すると
テーブルを作成できます。

# テーブル作成CREATE文
create_query = '''
CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    name TEXT,
    age INTEGER
)
'''
# テーブル作成を実行
cursor.execute(create_query)
conn.commit()

# テーブルの確認
query = "select name from sqlite_master where type = 'table';"
cursor.execute(query)
cursor.fetchall()


データの投入

INSERT文を実行してデータを投入することができます。

INSERT INTO テーブル名 VALUES (?, ?, ?)

テーブルのカラムの個数と
? の個数を合わせておく必要があります。

投入するデータも、カラムの個数に合わせた
リスト型で定義しましょう。

# データを3件挿入
users_data = [
    (1, 'Alice', 25),
    (2, 'Bob', 30),
    (3, 'Charlie', 22)
]
cursor.executemany('INSERT INTO users VALUES (?, ?, ?)', users_data)
conn.commit()

ここまで実行すると、3件分のデータが格納されると思います。


データの取得

データの取得は
SELECT文を実行してデータを取得する事ができます。

SELECT 抽出カラム FROM テーブル名

# 全件取得
cursor.execute('SELECT * FROM users')
rows = cursor.fetchall()

# 結果を表示
for row in rows:
    print(row)
(1, 'Alice', 25)
(2, 'Bob', 30)
(3, 'Charlie', 22)



条件付きでデータ取得(WHERE)

SELECT文のWHERE句を加えると
条件を指定することができます。

SELECT 抽出カラム FROM テーブル名 WHERE 条件

# 条件付きで取得(年齢 > 23) 
cursor.execute('SELECT name FROM users WHERE age > 23')
print(cursor.fetchall())

[('Alice',), ('Bob',)]



データの更新(UPDATE)

UPDATE文を実行するとデータを更新することができます。

UPDATE テーブル名 SET 更新カラム名 WHERE 条件

# データの更新(Bobの年齢を35に)
cursor.execute("UPDATE users SET age = 35 WHERE name = 'Bob'")
conn.commit()
cursor.execute('SELECT * FROM users')
print(cursor.fetchall())
[(1, 'Alice', 25), (2, 'Bob', 35), (3, 'Charlie', 22)]


データの削除(DELETE)

データの削除はDELETE文を実行して行えます。

DELETE FROM テーブル名 WHERE 条件

# データの削除(Charlieを削除)
cursor.execute("DELETE FROM users WHERE name = 'Charlie'")
conn.commit()
cursor.execute('SELECT * FROM users')
print(cursor.fetchall())
[(1, 'Alice', 25), (2, 'Bob', 35)]



Pandasライブラリでデータ取得

pandasデータフレームでもテーブルからデータ取得できます。

import pandas as pd

df = pd.read_sql_query("SELECT * FROM users", conn)
df


応用編

ビットコインの取引データを取得してテーブルに格納する

取引データを格納するデータベースとテーブルを新たに作ります。
import requests
import sqlite3

# SQLiteデータベースの接続
conn = sqlite3.connect('trades.db')
cursor = conn.cursor()

# 取引テーブルの作成
cursor.execute('''
CREATE TABLE IF NOT EXISTS trades (
    id INTEGER PRIMARY KEY,
    amount REAL,
    rate REAL,
    pair TEXT,
    order_type TEXT,
    created_at DATETIME
)
''')

次のコードを実行すると取引データをDBに格納できます。

# 取引データを取得
# コインチェックのAPIエンドポイント
url = 'https://coincheck.com/api/trades'
params = {'pair': 'btc_jpy', 'limit': 100}
response = requests.get(url, params=params)
data = response.json()

if data['success']:
    # 取引データをデータベースにUPSERT
    for trade in data['data']:
        cursor.execute('''
        INSERT INTO trades (id, amount, rate, pair, order_type, created_at)
        VALUES (?, ?, ?, ?, ?, ?)
        ON CONFLICT(id) DO UPDATE SET
        amount = excluded.amount,
        rate = excluded.rate,
        pair = excluded.pair,
        order_type = excluded.order_type,
        created_at = excluded.created_at
        ''', (trade['id'], float(trade['amount']), float(trade['rate']), trade['pair'], trade['order_type'], trade['created_at']))
    conn.commit()

conn.close()
print("取引データの取得とUPSERTが完了しました。")


ここから先は
Pandasデータフレームで取引データを見てみましょう。

import pandas as pd
import sqlite3

conn = sqlite3.connect('trades.db')
cursor = conn.cursor()

df = pd.read_sql_query("SELECT * FROM trades", conn)

# created_atをdatetime型に変換
df['created_at'] = pd.to_datetime(df['created_at'])
df.set_index('created_at', inplace=True)

取引データを1分単位で集計してみやすくします。
minute_candles = df.resample('min').agg(
    open=('rate', 'first'),
    high=('rate', 'max'),
    low=('rate', 'min'),
    close=('rate', 'last'),
    volume=('amount', 'sum'),
    count=('rate', 'count')
).dropna()

minute_candles["volatility"] = minute_candles["high"] - minute_candles["low"]
minute_candles["volatility_rate"] = minute_candles["volatility"] / minute_candles["close"]
minute_candles["volume_avg"] = minute_candles["volume"] / minute_candles["count"]
スクリーンショット 2025-05-17 16.27.55



最後は可視化です。
集計したデータをplotlyで可視化します。

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

# subplot作成(上下2段)
fig = make_subplots(
    rows=2, cols=1,
    shared_xaxes=True,
    row_heights=[0.7, 0.3],
    vertical_spacing=0.02,
    subplot_titles=('ローソク足チャート', '出来高(Volume)')
)

# ローソク足(上段)
fig.add_trace(
    go.Candlestick(
        x=minute_candles.index,
        open=minute_candles['open'],
        high=minute_candles['high'],
        low=minute_candles['low'],
        close=minute_candles['close'],
        name='Candlestick'
    ),
    row=1, col=1
)

# 出来高(棒グラフ・下段)
fig.add_trace(
    go.Bar(
        x=minute_candles.index,
        y=minute_candles['volume'],
        name='Volume',
        marker_color='gray',
        opacity=0.5
    ),
    row=2, col=1
)

# レイアウト調整
fig.update_layout(
    title='ローソク足 + Volume(出来高)チャート',
    xaxis_rangeslider_visible=False,
    showlegend=False,
    height=600
)
fig.show()
スクリーンショット 2025-05-17 16.27.45





まとめ


SQLiteを用いると
非常に簡単にデータベースをセットアップできます。

データ投入や検索もPythonであれば
数行で行う事ができるので
非常に便利です。

これからSQLやデータベースを勉強したい方は
ぜひSQLiteを使ってみてください。

それでは。

このページのトップヘ