1.はじめに｜

Pythonでプログラムを書いていると、
「処理が遅い…」「同じ関数が何度も呼ばれていそう…」と感じたことはありませんか？

特に再帰処理や計算量の多いロジックでは、同じ引数で同じ関数が何度も実行され、無駄な計算が積み重なりがちです。
その結果、コード自体はシンプルなのに、実行速度だけが極端に遅くなるケースも少なくありません。

そんなときに役立つのが、Pythonの**メモ化（memoization）**という高速化テクニックです。
メモ化とは、一度計算した関数の結果を保存し、次回以降は計算せずに使い回す仕組みのこと。
これだけで、再帰処理の実行時間が劇的に短縮される場合があります。

そしてPythonでは、このメモ化を
@cache や @lru_cache といったデコレーターを1行追加するだけで簡単に実装できます。
難しい最適化や複雑なコード修正は必要ありません。

この記事では、Python初心者の方でも理解できるように、

• メモ化とは何か
• @cache デコレーターの使い方
• どんな処理で効果が出るのか
• 実際にどれくらい高速化されるのか

を順番に解説していきます。

最後には、定番のフィボナッチ数列を例に、
「なぜ再帰が遅くなるのか」「@cacheでなぜ爆速になるのか」を体感できる構成になっています。

それでは、Pythonコードを最小の修正で高速化する方法を見ていきましょう。

2.メモ化の基本｜なぜ高速化できるのか？

では、「メモ化（memoization）」って一体なにがどう高速なの？と思いますよね。ここでは、どうして処理が速くなるのか、その仕組みをやさしく解説します。

計算結果を“覚える”だけで速くなる！

メモ化の基本的な考え方はとてもシンプルです。
**「同じ計算を何度も繰り返さないように、前の結果を覚えておこう」**というものです。

例えばこんな関数があったとします：

def calc(x):
    print("計算中…")
    return (x + 10) // 3

この関数を、同じ引数（たとえば 110）で2回呼び出すと、2回とも「計算中…」が表示されて、同じ計算が繰り返されます。

でも、1回目の結果が保存されていて、2回目に使い回せたらどうでしょう？
2回目は計算をスキップして、保存しておいた値をそのまま返すことができます。

つまり、「時間のかかる計算を1回に減らせる」＝高速化につながるというわけです。

例えるなら「一度調べたことをノートにメモする」感覚

学校での勉強に例えると、一度辞書で調べた単語の意味をノートに書いておくイメージです。
2回目以降はそのノートを見ればすぐに答えが分かるので、わざわざまた辞書を開かなくても済みますよね。

プログラムでもこれと同じで、関数の結果をキャッシュ（保存）しておけば、次は一瞬で結果を返せるのです。

「キャッシュ」に保存しておく＝一種のメモリ機能

この「結果を覚えておく場所」を**キャッシュ（cache）**と呼びます。Pythonでは、@cacheや@lru_cacheといったデコレーターを使えば、関数にこのキャッシュ機能を簡単に付け加えることができます。

こうして一度呼び出した関数の「入力」と「出力」のペアをキャッシュに記録しておき、次に同じ「入力」が来たら、それに対応する「出力」を即座に返してくれるんです。

次は、実際にこのキャッシュ機能をPythonでどうやって使うのかを見てみましょう！
→ **「Pythonでの実装方法｜@cache / @lru_cacheの使い分け」**へ進みます。

3.Pythonでの実装方法｜@cache / @lru_cacheの使い分け

ここからは、実際にPythonでメモ化を使う方法を紹介していきます。
じつはPythonには、メモ化をすごく簡単に実装できる標準の仕組みが用意されています。それが、functoolsモジュールにある**@cacheと@lru_cache**というデコレーターです。

どちらも、関数の前に書くだけで使えるので、とても手軽ですよ！

Python 3.9以降なら @cache が一番シンプル

Python 3.9以上を使っている方には、**@functools.cache**がいちばんおすすめです。

from functools import cache

@cache
def calc(x):
    print("計算中…")
    return (x + 10) // 3

print(calc(110))  # 1回目：計算される
print(calc(110))  # 2回目：キャッシュが使われる

このように、関数の上に @cache と書くだけで、同じ引数が来たときには計算せず、結果を再利用してくれます。

特徴としては以下の通り：

• キャッシュの上限がない（無制限）
• 高速でシンプル
• 関数に変更がない場合に最適

Python 3.8以前は @lru_cache を使おう！

Python 3.8やそれ以前のバージョンを使っている場合は、代わりに @lru_cache を使いましょう。

from functools import lru_cache

@lru_cache(maxsize=128)
def calc(x):
    print("計算中…")
    return (x + 10) // 3

@lru_cache(maxsize=128) では、最大128個までの結果をキャッシュします。
maxsizeの数を大きくすれば、より多くのパターンを覚えられます。

特徴はこちら：

• キャッシュの上限を指定できる（デフォルトは128）
• 古いものから自動で削除（LRU：Least Recently Used）
• Python 3.2以降で使用可能

cacheとlru_cacheの違いまとめ

どちらを使うかはPythonのバージョンと使い方次第ですが、**最新のPythonが使えるなら迷わず@cache**がベストです！

次は、実際にメモ化を使うときに注意しておきたいポイントを紹介します。

4.メモ化の注意点｜使えばいいってものじゃない！

メモ化はとても便利なテクニックですが、どんなときでも使っていいわけではありません。
むしろ、ちゃんと理解して使わないと、「なんで速くならないの？」「逆にメモリが足りない…」ということにもなりかねません。

ここでは、メモ化を使うときに覚えておきたい2つの重要な注意点を紹介します。

① プロセスが終わればキャッシュは消える

メモ化で保存されるデータ（キャッシュ）は、プログラムを実行しているあいだだけ有効です。

つまり、Pythonスクリプトを一度閉じてしまえば、せっかくキャッシュされた情報も全部リセットされます。電源を切ったらノートが白紙になるようなイメージですね。

✅ ポイント： メモ化は「長期保存」ではなく、「一時的な高速化」に向いています！

② 関数に“副作用”があるとメモ化は危険！

メモ化がうまく機能するには、その関数が**「参照透過」であること**が必要です。

ちょっと難しそうに聞こえますが、簡単に言うと：

「同じ引数なら、いつでも同じ結果が返ってくる関数」じゃないとダメ！

ということです。

たとえば、関数の中で毎回ランダムな値を返したり、リストの内容を変更するような処理が入っていると、過去の結果を再利用するのが正しくなくなってしまいます。

❌ こんな関数はメモ化に不向き：

import random

def get_random_value(x):
    return x + random.randint(1, 10)

この関数は毎回結果が変わるので、キャッシュしても意味がありません。

まとめ：こんな関数にメモ化は向いてます！

✅ いつも同じ引数には、同じ結果が返ってくる関数
✅ 時間のかかる計算をする関数
✅ 再帰的に何度も呼ばれる関数（フィボナッチなど）

5.実例：フィボナッチ数列を使ったメモ化の効果

ここまで読んで「ふーん、メモ化って便利そうだな」と思った方、実際にどれくらい速くなるのか気になりますよね？
そこで、メモ化がとくに威力を発揮する例として有名な**「フィボナッチ数列」**を使って、効果を体験してみましょう！

フィボナッチ数列とは？

フィボナッチ数列は、次のようなルールで作られる数字の並びです：

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...

ルールはとてもシンプルで、「2つ前と1つ前の数字を足す」ことで次の数字を求めます。

メモ化なしで書くとどうなる？

まずは、メモ化を使わずにフィボナッチ数を求める関数を見てみましょう。

def fib(n):
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)

この関数、ぱっと見ではわかりやすいですが、同じ計算を何度も繰り返してしまうという弱点があります。
たとえば fib(30) を計算しようとすると、内部で fib(29) と fib(28) を呼び出し、それぞれがさらにその前の値を…と、計算が爆発的に増えてしまうんです。

メモ化ありで書くと一気に高速化！

そこで、さっそく @cache を使ってメモ化してみましょう。

from functools import cache

@cache
def fib(n):
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)

たったこれだけで、一度計算した結果がすべてキャッシュに保存されるので、同じ計算を何度もしなくて済みます。

実際に速度を比較してみた

試しに、次のようなコードで処理時間を測ってみましょう。

import time

start = time.time()
print(fib(35))
end = time.time()
print("処理時間：", end - start)

• メモ化なし：およそ 0.1〜1秒以上
• メモ化あり：およそ 0.00005秒前後

なんと、数千倍以上のスピードアップが見込める結果になりました！

再帰＋メモ化＝動的計画法にも応用可能！

このように、再帰処理にメモ化を組み合わせると、動的計画法（DP）のような効率的なアルゴリズムが実現できます。
競技プログラミングやデータ解析の現場でも、計算コストの高い処理を減らすために活用されています。

まとめ｜メモ化は再帰や動的計画法の味方

ここまで、Pythonで使える便利なテクニック「メモ化」について解説してきました。
最後に、今回の内容をざっくり振り返ってみましょう。

✅ メモ化とは？

関数の引数と結果をセットで記憶しておき、同じ引数が来たときに再利用する仕組み。
計算をサボれるので、その分処理が高速化されます！

✅ Pythonでの使い方

• Python 3.9以上なら @cache
• それ以前は @lru_cache(maxsize=128)
  どちらも functools モジュールからインポートして、関数の上に1行書くだけ！

✅ 注意点

• プログラム終了後はキャッシュが消える
• 関数は**参照透過（副作用なし）**であることが前提

✅ どんなときに使うと効果的？

• 再帰処理（例：フィボナッチ数列）
• 同じ関数が同じ引数で何度も呼ばれるケース
• アルゴリズムの最適化や動的計画法の実装時

メモ化は、普段のプログラミングではそこまで頻繁に使うものではありません。
でも、使いどころを見極めて導入すると、コードの効率が劇的に上がることもある、とっておきのテクニックです。

ぜひこの記事をきっかけに、「あれ？この関数、同じ引数で何度も呼ばれてない？」と思ったときには、@cacheデコレーターを試してみてください！

あわせて読みたい

以下の記事もあわせて読むと、Pythonの理解がさらに深まります！

• Pythonのデコレーターとは？基礎から使い方まで解説！
  　→ @cache や @lru_cache のようなデコレーターの仕組みを基礎から理解したい方におすすめ！
• Pythonの再帰関数をやさしく解説｜初心者でもわかる再帰処理の考え方
  　→ フィボナッチ数列のような再帰的な関数の考え方と書き方を学べます。
• Pythonのアルゴリズム基礎入門｜考え方とサンプルコードで身につけよう
  　→ 動的計画法を含むアルゴリズムの初歩を知りたい方向け。

よくある質問（Q&A）