PythonのOrderedDictを活用してデータ構造を最適化する7つの方法

●OrderedDictとは？Pythonの強力な味方
- ○辞書とOrderedDictの違いを理解しよう
- ○なぜOrderedDictが必要なのか？実例で解説
●OrderedDictの基本操作をマスターしよう
●OrderedDictの高度な使い方
●OrderedDictのパフォーマンス最適化
- ○サンプルコード7：大規模データでのOrderedDictの活用
●よくあるエラーと対処法
●OrderedDictの応用例
まとめ

●OrderedDictとは？Pythonの強力な味方

Pythonにおいて、データの管理と操作は非常に重要です。

特に、キーと値のペアを扱う辞書型は頻繁に使用されますが、通常の辞書には一つ大きな制限があります。

それは、要素の順序が保証されないという点です。OrderedDictは、この制限を解決するために導入された特別な辞書型です。

OrderedDictは、Pythonの標準ライブラリであるcollectionsモジュールに含まれています。

通常の辞書と同様にキーと値のペアを保持しながら、要素が追加された順序を記憶する機能を持っています。

要素を順番通りに取り出したい場合や、特定の順序でデータを保持したい場合に非常に便利です。

○辞書とOrderedDictの違いを理解しよう

通常の辞書とOrderedDictの最も大きな違いは、要素の順序の扱い方にあります。

通常の辞書では、要素を追加した順序は保持されません。

一方、OrderedDictは要素を追加した順序を記憶し、その順序を維持します。

具体的な違いを見てみましょう。

まず、通常の辞書の動作を確認します。

# 通常の辞書の例
normal_dict = {}
normal_dict['apple'] = 'りんご'
normal_dict['banana'] = 'バナナ'
normal_dict['cherry'] = 'さくらんぼ'

print("通常の辞書:")
for key, value in normal_dict.items():
    print(f"{key}: {value}")

実行結果

通常の辞書:
apple: りんご
banana: バナナ
cherry: さくらんぼ

一見、追加した順序通りに出力されているように見えますが、要素の順序は保証されていません。

Pythonのバージョンや実行環境によって、出力順序が変わる可能性があります。

次に、OrderedDictの動作を見てみましょう。

from collections import OrderedDict

# OrderedDictの例
ordered_dict = OrderedDict()
ordered_dict['apple'] = 'りんご'
ordered_dict['banana'] = 'バナナ'
ordered_dict['cherry'] = 'さくらんぼ'

print("OrderedDict:")
for key, value in ordered_dict.items():
    print(f"{key}: {value}")

実行結果

OrderedDict:
apple: りんご
banana: バナナ
cherry: さくらんぼ

OrderedDictでは、要素を追加した順序が常に保持されます。

環境やバージョンに関係なく、この順序で出力されることが保証されています。

○なぜOrderedDictが必要なのか？実例で解説

OrderedDictが必要となる状況は多々あります。

例えば、データの処理順序が重要な場合や、特定の順序でデータを表示したい場合などです。

具体的な例を見てみましょう。

ユーザーの購入履歴を管理するシステムを考えてみます。

各ユーザーの最近の購入アイテムを、購入順に表示したいとします。

from collections import OrderedDict

def display_purchase_history(user_id, purchases):
    history = OrderedDict()
    for item, date in purchases:
        history[item] = date

    print(f"ユーザーID {user_id} の購入履歴:")
    for item, date in history.items():
        print(f"{date}: {item}")

# ユーザーの購入データ（アイテム名, 購入日）のリスト
user_purchases = [
    ("ノートPC", "2023-06-15"),
    ("マウス", "2023-06-20"),
    ("キーボード", "2023-06-18"),
    ("モニター", "2023-06-22")
]

display_purchase_history("U001", user_purchases)

実行結果

ユーザーID U001 の購入履歴:
2023-06-15: ノートPC
2023-06-20: マウス
2023-06-18: キーボード
2023-06-22: モニター

OrderedDictを使用することで、購入アイテムを追加した順序（すなわち購入順）を保持し、その順序通りに表示することができます。

通常の辞書を使用した場合、順序が保証されないため、正確な購入履歴を表示できない可能性があります。

●OrderedDictの基本操作をマスターしよう

OrderedDictの概念を理解したところで、実際の使い方に入っていきましょう。

基本操作をマスターすることで、順序付き辞書を効果的に活用できるようになります。

経験豊富なプログラマーでも、基本をしっかり押さえることが大切です。では、具体的なサンプルコードを見ながら、OrderedDictの操作方法を学んでいきましょう。

○サンプルコード1：OrderedDictの初期化と要素追加

OrderedDictの使用を始めるには、まず初期化が必要です。

初期化の方法はいくつかありますが、最も一般的な方法を見ていきましょう。

from collections import OrderedDict

# 空のOrderedDictを作成
od = OrderedDict()

# 要素を追加
od['apple'] = 'りんご'
od['banana'] = 'バナナ'
od['cherry'] = 'さくらんぼ'

print(od)

実行結果

OrderedDict([('apple', 'りんご'), ('banana', 'バナナ'), ('cherry', 'さくらんぼ')])

この例では、まず空のOrderedDictを作成し、その後キーと値のペアを追加しています。

通常の辞書と同じように、角括弧記法を使ってキーと値を追加できます。

OrderedDictの特徴は、要素を追加した順序を覚えている点です。

別の初期化方法として、既存のイテラブル（リストやタプルなど）からOrderedDictを作成することもできます。

# リストからOrderedDictを作成
fruit_list = [('apple', 'りんご'), ('banana', 'バナナ'), ('cherry', 'さくらんぼ')]
od = OrderedDict(fruit_list)

print(od)

実行結果

OrderedDict([('apple', 'りんご'), ('banana', 'バナナ'), ('cherry', 'さくらんぼ')])

リストの要素の順序がそのままOrderedDictの順序になります。

この方法は、既存のデータ構造からOrderedDictを作成する際に便利です。

○サンプルコード2：順序を保ったまま要素を取り出す

OrderedDictの主な利点は、要素を追加した順序を保持したまま取り出せる点です。

順序を保ったまま要素を取り出す方法をいくつか見ていきましょう。

from collections import OrderedDict

od = OrderedDict([('apple', 'りんご'), ('banana', 'バナナ'), ('cherry', 'さくらんぼ')])

# for文を使って順序通りに取り出す
print("for文を使った取り出し:")
for key, value in od.items():
    print(f"{key}: {value}")

# キーのリストを取得
print("\nキーのリスト:")
print(list(od.keys()))

# 値のリストを取得
print("\n値のリスト:")
print(list(od.values()))

実行結果

for文を使った取り出し:
apple: りんご
banana: バナナ
cherry: さくらんぼ

キーのリスト:
['apple', 'banana', 'cherry']

値のリスト:
['りんご', 'バナナ', 'さくらんぼ']

for文を使うことで、OrderedDictの要素を追加した順序通りに取り出すことができます。

また、keys()メソッドとvalues()メソッドを使うと、キーと値をそれぞれリストとして取得できます。

このメソッドも順序を保持しています。

○サンプルコード3：OrderedDictの要素を更新する

OrderedDictの要素を更新する方法は、通常の辞書と似ています。

ただし、OrderedDictには要素の順序を操作するための特別なメソッドがあります。

from collections import OrderedDict

od = OrderedDict([('apple', 'りんご'), ('banana', 'バナナ'), ('cherry', 'さくらんぼ')])

# 値の更新
od['banana'] = 'バナナ（更新）'

# 新しい要素の追加
od['date'] = 'なつめやし'

# 要素の移動（最後に移動）
od.move_to_end('apple')

print("更新後のOrderedDict:")
for key, value in od.items():
    print(f"{key}: {value}")

# 要素の削除
del od['cherry']

print("\n削除後のOrderedDict:")
for key, value in od.items():
    print(f"{key}: {value}")

実行結果

更新後のOrderedDict:
banana: バナナ（更新）
cherry: さくらんぼ
date: なつめやし
apple: りんご

削除後のOrderedDict:
banana: バナナ（更新）
date: なつめやし
apple: りんご

この例では、値の更新、新しい要素の追加、要素の移動、要素の削除といった操作を行っています。

特に注目すべきはmove_to_end()メソッドで、指定したキーの要素を最後に移動させることができます。

この機能は通常の辞書にはない、OrderedDictならではの機能です。

●OrderedDictの高度な使い方

OrderedDictの基本操作をマスターしたら、次はより高度な使い方に挑戦しましょう。

高度な技術を身につけることで、複雑なデータ構造の扱いや効率的なコーディングが可能になります。

プロのエンジニアとして成長するためには、基本だけでなく応用力も重要です。

それでは、OrderedDictの高度な使い方を具体的なサンプルコードとともに見ていきましょう。

○サンプルコード4：OrderedDictとfor文の組み合わせ

OrderedDictとfor文を組み合わせることで、順序を保ったまま効率的にデータを処理できます。

特に、大量のデータを扱う際に威力を発揮します。

from collections import OrderedDict

# 学生の成績データを格納するOrderedDict
grades = OrderedDict()
grades['Alice'] = 85
grades['Bob'] = 92
grades['Charlie'] = 78
grades['David'] = 95

# 成績が90点以上の学生を抽出
high_achievers = OrderedDict()

for name, score in grades.items():
    if score >= 90:
        high_achievers[name] = score

print("90点以上の成績の学生:")
for name, score in high_achievers.items():
    print(f"{name}: {score}")

# 全員の平均点を計算
average_score = sum(grades.values()) / len(grades)

print(f"\n全体の平均点: {average_score:.2f}")

実行結果

90点以上の成績の学生:
Bob: 92
David: 95

全体の平均点: 87.50

このコードでは、学生の成績データをOrderedDictに格納し、for文を使って90点以上の成績の学生を抽出しています。

OrderedDictを使用することで、成績入力順序を維持したまま高得点者を抽出できます。

また、valuesメソッドを使って全体の平均点も簡単に計算できます。

○サンプルコード5：OrderedDictとDictの相互変換

プロジェクトによっては、OrderedDictと通常のdictを相互に変換する必要が出てくるかもしれません。

この変換は簡単に行えますが、注意点もあります。

from collections import OrderedDict

# 通常のdictからOrderedDictへの変換
normal_dict = {'apple': 'りんご', 'banana': 'バナナ', 'cherry': 'さくらんぼ'}
ordered_dict = OrderedDict(normal_dict)

print("dictからOrderedDictへの変換結果:")
for key, value in ordered_dict.items():
    print(f"{key}: {value}")

# OrderedDictから通常のdictへの変換
normal_dict_again = dict(ordered_dict)

print("\nOrderedDictからdictへの変換結果:")
for key, value in normal_dict_again.items():
    print(f"{key}: {value}")

# 順序を保証したい場合は、リストを使用
fruit_list = [('date', 'なつめやし'), ('elderberry', 'エルダーベリー'), ('fig', 'いちじく')]
ordered_dict_from_list = OrderedDict(fruit_list)

print("\nリストから作成したOrderedDict:")
for key, value in ordered_dict_from_list.items():
    print(f"{key}: {value}")

実行結果

dictからOrderedDictへの変換結果:
apple: りんご
banana: バナナ
cherry: さくらんぼ

OrderedDictからdictへの変換結果:
apple: りんご
banana: バナナ
cherry: さくらんぼ

リストから作成したOrderedDict:
date: なつめやし
elderberry: エルダーベリー
fig: いちじく

通常のdictからOrderedDictへの変換は簡単ですが、Python 3.7未満のバージョンでは元のdictの順序が保持されないことに注意が必要です。

確実に順序を指定したい場合は、キーと値のペアのリストを使用してOrderedDictを作成するのが安全です。

○サンプルコード6：OrderedDictのキーと値を別々に取得

OrderedDictのキーと値を別々に取得する方法を見ていきましょう。

この操作は、データの分析や加工時に非常に便利です。

from collections import OrderedDict

# 果物の在庫数を管理するOrderedDict
fruit_stock = OrderedDict([
    ('apple', 50),
    ('banana', 30),
    ('cherry', 20),
    ('date', 15),
    ('elderberry', 10)
])

# キーのリストを取得
fruit_names = list(fruit_stock.keys())
print("果物の名前リスト:")
print(fruit_names)

# 値のリストを取得
stock_numbers = list(fruit_stock.values())
print("\n在庫数リスト:")
print(stock_numbers)

# キーと値のペアをタプルのリストとして取得
fruit_items = list(fruit_stock.items())
print("\n果物と在庫数のペア:")
print(fruit_items)

# 在庫が20個以下の果物を抽出
low_stock = [fruit for fruit, stock in fruit_stock.items() if stock <= 20]
print("\n在庫が20個以下の果物:")
print(low_stock)

実行結果

果物の名前リスト:
['apple', 'banana', 'cherry', 'date', 'elderberry']

在庫数リスト:
[50, 30, 20, 15, 10]

果物と在庫数のペア:
[('apple', 50), ('banana', 30), ('cherry', 20), ('date', 15), ('elderberry', 10)]

在庫が20個以下の果物:
['cherry', 'date', 'elderberry']

keysメソッド、valuesメソッド、itemsメソッドを使用することで、OrderedDictの内容を様々な形式で取得できます。

特にitemsメソッドは、キーと値のペアを同時に取得できるため、条件に基づいたフィルタリングなどに非常に便利です。

●OrderedDictのパフォーマンス最適化

OrderedDictの基本的な使い方と高度な操作方法を解説してきましたが、実際のプロジェクトでは、パフォーマンスの最適化も重要な課題となります。

特に大規模なデータを扱う場合、OrderedDictの効率的な使用法を知ることで、プログラムの実行速度を大幅に向上させることができます。

プロのエンジニアとして、コードの正確性だけでなく、効率性も考慮する必要があります。

パフォーマンスの最適化は、ユーザー体験の向上やサーバーリソースの節約につながる重要なスキルです。

では、OrderedDictを使用する際のパフォーマンス最適化のテクニックを見ていきましょう。

○サンプルコード7：大規模データでのOrderedDictの活用

大規模なデータセットを扱う際、OrderedDictの特性を活かしつつ、効率的に処理を行うことが求められます。

ここでは、100万件のデータを含むOrderedDictを作成し、そのデータに対して様々な操作を行う例を見てみましょう。

from collections import OrderedDict
import time
import random

def create_large_ordered_dict(size):
    return OrderedDict((f"key_{i}", random.randint(1, 1000)) for i in range(size))

def measure_time(func):
    start_time = time.time()
    result = func()
    end_time = time.time()
    print(f"{func.__name__}の実行時間: {end_time - start_time:.5f}秒")
    return result

# 100万件のデータを持つOrderedDictを作成
large_od = measure_time(lambda: create_large_ordered_dict(1000000))

# キーの検索
def search_key():
    return "key_500000" in large_od

measure_time(search_key)

# 値の取得
def get_value():
    return large_od["key_500000"]

measure_time(get_value)

# 要素の追加
def add_element():
    large_od["new_key"] = 999

measure_time(add_element)

# 要素の削除
def remove_element():
    del large_od["key_100000"]

measure_time(remove_element)

# 全要素の反復処理
def iterate_all():
    sum_values = sum(large_od.values())
    return sum_values

measure_time(iterate_all)

# 最初の10要素を取得
def get_first_ten():
    return list(large_od.items())[:10]

measure_time(get_first_ten)

実行結果

create_large_ordered_dictの実行時間: 0.78234秒
search_keyの実行時間: 0.00001秒
get_valueの実行時間: 0.00000秒
add_elementの実行時間: 0.00000秒
remove_elementの実行時間: 0.00000秒
iterate_allの実行時間: 0.05973秒
get_first_tenの実行時間: 0.00000秒

この例では、100万件のデータを持つOrderedDictを作成し、様々な操作の実行時間を測定しています。

重要なポイントをいくつか挙げてみましょう。

OrderedDictの作成に約0.78秒かかっています。大規模なデータセットを扱う際は、初期化にかかる時間を考慮する必要があります。
キーの検索や値の取得は非常に高速で、ほぼ瞬時に実行されています。OrderedDictは内部的にハッシュテーブルを使用しているため、キーによるアクセスが高速です。
要素の追加や削除も非常に高速です。OrderedDictは、要素の追加や削除を効率的に行えるよう設計されています。
全要素の反復処理には約0.06秒かかっています。大量のデータを処理する際は、反復処理の時間を考慮する必要があります。
最初の10要素の取得は瞬時に行われています。OrderedDictは順序を保持しているため、先頭からの要素取得が高速です。

パフォーマンスを最適化する際のポイントとして、次のことを覚えておきましょう。

大規模なOrderedDictを頻繁に作成する必要がある場合、可能であればキャッシュを利用するなど、再利用を検討しましょう。
キーによるアクセスは非常に高速なので、値の検索や取得にはキーを積極的に活用しましょう。
全要素の反復処理は比較的時間がかかるので、必要な部分だけを処理するなど、処理量を最小限に抑える工夫が重要です。
OrderedDictの順序保持機能を活用し、データの並び順が重要な場合は、ソート処理を省略できる可能性があります。

OrderedDictのパフォーマンス最適化を意識することで、大規模なデータ処理や高負荷なアプリケーションでも効率的なコードを書くことができます。

●よくあるエラーと対処法

OrderedDictを使用する際、時として予期せぬエラーに遭遇することがあります。

プログラミングにおいて、エラーは避けられないものですが、適切に対処できれば、むしろコードの品質向上につながる貴重な機会となります。

ここでは、OrderedDictを使用する際によく発生するエラーとその対処法について、具体的な例を交えて解説していきます。

○KeyError：存在しないキーにアクセスした場合

KeyErrorは、存在しないキーにアクセスしようとした際に発生するエラーです。

このエラーは、OrderedDictに限らず、通常の辞書でも頻繁に遭遇するものです。

from collections import OrderedDict

fruits = OrderedDict([('apple', 'りんご'), ('banana', 'バナナ')])

try:
    print(fruits['cherry'])
except KeyError as e:
    print(f"KeyError: {e}")

# 安全にキーにアクセスする方法
print(fruits.get('cherry', 'キーが存在しません'))

実行結果

KeyError: 'cherry'
キーが存在しません

この例では、存在しない’cherry’キーにアクセスしようとしてKeyErrorが発生しています。

エラーを回避するには、getメソッドを使用するのが効果的です。

getメソッドは、キーが存在しない場合にデフォルト値を返すので、エラーを防ぎつつ、適切な処理を行うことができます。

○TypeError：ハッシュ不可能なオブジェクトをキーにしようとした場合

OrderedDictを含むPythonの辞書では、キーとしてハッシュ可能なオブジェクトのみを使用できます。

リストやディクショナリなど、ミュータブル（変更可能）なオブジェクトをキーとして使用しようとすると、TypeErrorが発生します。

from collections import OrderedDict

try:
    invalid_dict = OrderedDict({[1, 2, 3]: 'リスト', 'valid_key': '正常なキー'})
except TypeError as e:
    print(f"TypeError: {e}")

# 正しい使用法
valid_dict = OrderedDict({(1, 2, 3): 'タプル', 'valid_key': '正常なキー'})
print(valid_dict)

実行結果

TypeError: unhashable type: 'list'
OrderedDict([((1, 2, 3), 'タプル'), ('valid_key', '正常なキー')])

この例では、リストをキーとして使用しようとしてTypeErrorが発生しています。

リストの代わりにタプルを使用することで、エラーを回避できます。

タプルはイミュータブル（変更不可能）なオブジェクトであり、ハッシュ可能です。

○AttributeError：通常の辞書にOrderedDictのメソッドを使用した場合

OrderedDictと通常の辞書は似ていますが、全く同じではありません。

OrderedDict特有のメソッドを通常の辞書に対して使用しようとすると、AttributeErrorが発生します。

normal_dict = {'a': 1, 'b': 2, 'c': 3}
ordered_dict = OrderedDict([('a', 1), ('b', 2), ('c', 3)])

try:
    normal_dict.move_to_end('a')
except AttributeError as e:
    print(f"AttributeError: {e}")

# 正しい使用法
ordered_dict.move_to_end('a')
print(ordered_dict)

実行結果

AttributeError: 'dict' object has no attribute 'move_to_end'
OrderedDict([('b', 2), ('c', 3), ('a', 1)])

この例では、通常の辞書に対してOrderedDict特有のmove_to_endメソッドを使用しようとして、AttributeErrorが発生しています。

エラーを回避するには、操作対象がOrderedDictであることを確認してから特有のメソッドを使用する必要があります。

●OrderedDictの応用例

OrderedDictの基本的な使い方と高度なテクニックを解説してきました。

では、実際のプロジェクトでOrderedDictをどのように活用できるでしょうか。

ここでは、OrderedDictの特性を活かした実践的な応用例を紹介します。

この例を通じて、OrderedDictの真の力を理解し、自分のプロジェクトに活かすヒントを得ることができるでしょう。

○サンプルコード8：LRUキャッシュの実装

LRU（Least Recently Used）キャッシュは、最近使用されていないアイテムを優先的に削除するキャッシュアルゴリズムです。

OrderedDictを使用すると、このアルゴリズムを簡潔に実装できます。

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity):
        self.cache = OrderedDict()
        self.capacity = capacity

    def get(self, key):
        if key not in self.cache:
            return -1
        self.cache.move_to_end(key)
        return self.cache[key]

    def put(self, key, value):
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            self.cache.popitem(last=False)

# LRUキャッシュの使用例
cache = LRUCache(2)
cache.put(1, 1)
cache.put(2, 2)
print(cache.get(1))       # 1を返す
cache.put(3, 3)           # 2が削除される
print(cache.get(2))       # -1を返す（2は既に削除されている）
cache.put(4, 4)           # 1が削除される
print(cache.get(1))       # -1を返す（1は既に削除されている）
print(cache.get(3))       # 3を返す
print(cache.get(4))       # 4を返す

実行結果

このLRUキャッシュの実装では、OrderedDictの特性を巧みに利用しています。

move_to_endメソッドを使ってアクセスされたアイテムを末尾に移動し、容量を超えた場合はpopitemメソッドで先頭（最も古いアイテム）を削除します。

OrderedDictを使用することで、アイテムの追加順序を簡単に管理でき、効率的なLRUキャッシュを実現できます。

○サンプルコード9：JSONデータの順序保持

JSONデータを扱う際、キーの順序を保持したいケースがあります。

例えば、APIのレスポンスを一貫した形式で返したい場合などです。

OrderedDictを使用すると、JSONデータの順序を簡単に保持できます。

import json
from collections import OrderedDict

# 順序を保持したJSONデータの作成
data = OrderedDict([
    ("name", "John Doe"),
    ("age", 30),
    ("city", "New York"),
    ("occupation", "Engineer")
])

# JSONに変換（順序保持）
json_str = json.dumps(data, indent=2)
print("元のJSON:")
print(json_str)

# JSONから読み込み（順序保持）
loaded_data = json.loads(json_str, object_pairs_hook=OrderedDict)

# 順序が保持されていることを確認
print("\n読み込んだデータの順序:")
for key, value in loaded_data.items():
    print(f"{key}: {value}")

# 新しいキーを追加（末尾に追加される）
loaded_data["skills"] = ["Python", "JavaScript", "SQL"]

# 更新されたJSONを出力
updated_json = json.dumps(loaded_data, indent=2)
print("\n更新後のJSON:")
print(updated_json)

実行結果

元のJSON:
{
  "name": "John Doe",
  "age": 30,
  "city": "New York",
  "occupation": "Engineer"
}

読み込んだデータの順序:
name: John Doe
age: 30
city: New York
occupation: Engineer

更新後のJSON:
{
  "name": "John Doe",
  "age": 30,
  "city": "New York",
  "occupation": "Engineer",
  "skills": [
    "Python",
    "JavaScript",
    "SQL"
  ]
}

この例では、OrderedDictを使用してJSONデータの順序を保持しています。

json.dumpsでJSONに変換する際、OrderedDictの順序がそのまま保持されます。

また、json.loadsでJSONを読み込む際にobject_pairs_hook=OrderedDictを指定することで、読み込んだデータの順序も保持できます。

○サンプルコード10：履歴機能の実装

アプリケーションに履歴機能を実装する際、OrderedDictが非常に役立ちます。

ユーザーの操作履歴を順序付きで保存し、必要に応じて古い履歴を削除することができます。

from collections import OrderedDict

class History:
    def __init__(self, max_size=10):
        self.actions = OrderedDict()
        self.max_size = max_size

    def add_action(self, action_id, description):
        if len(self.actions) >= self.max_size:
            self.actions.popitem(last=False)
        self.actions[action_id] = description

    def get_recent_actions(self, n):
        return list(self.actions.items())[-n:]

    def undo_last_action(self):
        if self.actions:
            return self.actions.popitem()
        return None

# 履歴機能の使用例
history = History(max_size=5)

# アクションの追加
history.add_action(1, "ファイルを開く")
history.add_action(2, "テキストを編集")
history.add_action(3, "画像を挿入")
history.add_action(4, "フォーマットを変更")
history.add_action(5, "ドキュメントを保存")

print("最近の3つのアクション:")
for action_id, description in history.get_recent_actions(3):
    print(f"ID: {action_id}, アクション: {description}")

# 新しいアクションを追加（最古のアクションが削除される）
history.add_action(6, "ファイルを閉じる")

print("\n直近のアクションを取り消し:")
undone_action = history.undo_last_action()
if undone_action:
    print(f"取り消されたアクション - ID: {undone_action[0]}, アクション: {undone_action[1]}")

print("\n現在の履歴:")
for action_id, description in history.actions.items():
    print(f"ID: {action_id}, アクション: {description}")

実行結果

最近の3つのアクション:
ID: 3, アクション: 画像を挿入
ID: 4, アクション: フォーマットを変更
ID: 5, アクション: ドキュメントを保存

直近のアクションを取り消し:
取り消されたアクション - ID: 6, アクション: ファイルを閉じる

現在の履歴:
ID: 2, アクション: テキストを編集
ID: 3, アクション: 画像を挿入
ID: 4, アクション: フォーマットを変更
ID: 5, アクション: ドキュメントを保存

この履歴機能の実装では、OrderedDictを使用してアクションを追加順に保存しています。

max_sizeを超えた場合は最も古いアクションが自動的に削除されます。

また、get_recent_actionsメソッドで最近のアクションを取得したり、undo_last_actionメソッドで直近のアクションを取り消したりすることができます。