turtle.undobufferentries()

2025-06-06

turtle.undobufferentries() は、Pythonの turtle モジュールで使用される関数で、アンドゥバッファ（undo buffer）に現在格納されているエントリーの数を返します。

タートルグラフィックスでは、通常、タートル（描画するカメのカーソル）が行った動きや変更（例えば、前進、回転、色の変更など）を記録する内部的なバッファを持っています。このバッファは、turtle.undo() 関数を使って操作を元に戻す（アンドゥする）ために使用されます。

turtle.undobufferentries() を呼び出すと、このアンドゥバッファに「元に戻せる操作」がいくつ記録されているかを知ることができます。

主な用途：

プログラムのフロー制御
アンドゥバッファが空になったら特定の処理を行う、といった条件分岐に利用できます。
アンドゥ機能の管理
独自のアンドゥ／リドゥ機能を実装する際に、バッファの残り容量や、アンドゥ可能な操作の数を判断する基準として利用できます。例えば、アンドゥ回数に制限を設ける場合などに役立ちます。
デバッグ
プログラムが予期せぬ動作をした際に、アンドゥバッファの状態を確認することで、どの程度の操作が記録されているか、あるいは記録されていないかを把握できます。

使用例

import turtle

# スクリーンとタートルをセットアップ
wn = turtle.Screen()
t = turtle.Turtle()

print(f"初期のアンドゥバッファエントリー数: {turtle.undobufferentries()}")

t.forward(50)
print(f"50進んだ後のアンドゥバッファエントリー数: {turtle.undobufferentries()}")

t.right(90)
print(f"90度回転した後のアンドゥバッファエントリー数: {turtle.undobufferentries()}")

t.forward(50)
print(f"さらに50進んだ後のアンドゥバッファエントリー数: {turtle.undobufferentries()}")

turtle.undo()
print(f"アンドゥ後のアンドゥバッファエントリー数: {turtle.undobufferentries()}")

turtle.undo()
print(f"もう一度アンドゥ後のアンドゥバッファエントリー数: {turtle.undobufferentries()}")

wn.mainloop()

初期のアンドゥバッファエントリー数: 0
50進んだ後のアンドゥバッファエントリー数: 1
90度回転した後のアンドゥバッファエントリー数: 2
さらに50進んだ後のアンドゥバッファエントリー数: 3
アンドゥ後のアンドゥバッファエントリー数: 2
もう一度アンドゥ後のアンドゥバッファエントリー数: 1

turtle.undobufferentries() 自体は単に数値（アンドゥバッファ内のエントリー数）を返すため、それ単体でエラーになることはほとんどありません。問題が発生する場合、それは通常、アンドゥ機能の予期せぬ動作や、他のタートル関数との連携によるものです。

TypeError: 'int' object is not callable または TypeError: 'builtin_function_or_method' object is not subscriptable

これは直接 undobufferentries() のエラーではありませんが、Pythonの一般的なエラーとして、関数呼び出し時に括弧を忘れたり、他の変数と同じ名前を使ってしまったりした場合に発生することがあります。

例

import turtle

t = turtle.Turtle()
# 誤り: 括弧を忘れた
# print(turtle.undobufferentries) # これだと関数オブジェクトそのものを参照する
# 誤り: 変数名と同じに
# undobufferentries = 10
# print(turtle.undobufferentries()) # undobufferentriesがint型になっているためエラー

print(turtle.undobufferentries()) # 正しい使い方

トラブルシューティング

変数名と関数名が重複していないか確認してください。
関数を呼び出す際は、必ず () を付けることを確認してください。

アンドゥバッファが期待通りの数にならない

これはエラーではなく、予期せぬ動作の例です。

考えられる原因

アニメーションの無効化（turtle.tracer()）
turtle.tracer(0) を使うと、タートルの描画アニメーションがオフになり、処理が高速化されます。これはアンドゥバッファの動作自体には直接影響しませんが、描画が即座に反映されないため、アンドゥ操作の効果がすぐに確認できない場合があります。turtle.update() を呼び出すことで画面を更新できます。
一部の操作はアンドゥバッファに記録されない
全てのタートル操作がアンドゥバッファに記録されるわけではありません。例えば、turtle.clear() や turtle.resetscreen() といった画面全体やタートル自体をリセットするような操作は、アンドゥバッファに直接影響を与えないか、あるいはバッファをクリアする可能性があります。

turtle.setundobuffer(size) によるバッファサイズ制限
turtle.setundobuffer(size) を呼び出すことで、アンドゥバッファに格納できる操作の最大数を設定できます。設定した size を超える操作を行うと、古い操作から順に削除されます。

import turtle
t = turtle.Turtle()
turtle.setundobuffer(3) # バッファサイズを3に設定

t.forward(10)
t.left(10)
t.forward(10)
print(f"3操作後: {turtle.undobufferentries()}") # 3

t.left(10) # 4番目の操作
print(f"4操作後: {turtle.undobufferentries()}") # 3 (古い操作が削除される)

turtle.setundobuffer(None) の使用
turtle.setundobuffer(None) を呼び出すと、アンドゥバッファが無効になり、以降の操作は記録されなくなります。この場合、undobufferentries() は常に 0 を返します。

import turtle
t = turtle.Turtle()
t.forward(100)
print(f"操作後: {turtle.undobufferentries()}") # 例: 1

turtle.setundobuffer(None) # アンドゥバッファを無効にする
t.left(90)
print(f"バッファ無効化後: {turtle.undobufferentries()}") # 0 になる

トラブルシューティング

どのような操作がアンドゥバッファに記録されるかを把握し、期待する操作が記録されているか確認してください。
turtle.setundobuffer() を使ってアンドゥバッファの有効・無効やサイズを設定していないか確認してください。意図しない設定になっている場合は、適切な値に再設定するか、デフォルトに戻す（turtle.setundobuffer(42) のように適当な大きな数を設定する）ことを検討してください。

turtle.undo() が期待通りに動作しない

これも undobufferentries() の間接的な問題であり、アンドゥバッファの状態が原因で発生します。

考えられる原因

アンドゥバッファが意図せず無効化されている、またはサイズが小さすぎる
前述の turtle.setundobuffer(None) や turtle.setundobuffer(size) の問題により、アンドゥできる操作が記録されていない、またはすぐに削除されてしまっている可能性があります。
アンドゥバッファが空
undobufferentries() が 0 を返している場合、アンドゥできる操作がないため、turtle.undo() を呼び出しても何も起こりません。
```
import turtle
t = turtle.Turtle()
print(f"初期のアンドゥバッファエントリー数: {turtle.undobufferentries()}") # 0
turtle.undo() # 何も起こらない
```

トラブルシューティング

turtle.setundobuffer() の設定を見直してください。
turtle.undobufferentries() の値を確認し、アンドゥ可能な操作が残っているかを確認してください。

ファイル名の競合（特にPyCharmなどのIDEで）

これは turtle モジュール全体でよくある一般的な問題です。

考えられる原因

作成したPythonファイルの名前が turtle.py になっている
もしあなたのファイル名が turtle.py だと、Pythonは標準ライブラリの turtle モジュールではなく、あなたの作成した turtle.py をインポートしようとします。その結果、turtle.undobufferentries() などの関数が見つからずに AttributeError などが発生することがあります。

Pythonファイルの名前を my_turtle_program.py のように、turtle.py 以外に変更してください。

turtle.undobufferentries() は主に以下の目的で使用されます。

アンドゥバッファの状態確認
現在どれくらいの操作を元に戻せるかを知るため。
アンドゥ機能の制御
例えば、アンドゥバッファが空になったらそれ以上アンドゥできないように制御するなど。
デバッグ
アンドゥ機能が期待通りに動作しているかを確認するため。

では、具体的なコード例を見ていきましょう。

例1: アンドゥバッファのエントリー数の変化を追跡する

この例では、タートルの動きに合わせて undobufferentries() の値がどのように変化するかを観察します。

import turtle
import time # 動作を分かりやすくするために遅延を入れる

# スクリーンとタートルをセットアップ
wn = turtle.Screen()
wn.setup(width=600, height=400)
wn.title("undobufferentries の変化を追跡")

t = turtle.Turtle()
t.shape("turtle")
t.speed(1) # タートルの速度を遅くする

def show_buffer_entries():
    """現在のアンドゥバッファエントリー数を表示するヘルパー関数"""
    print(f"現在のアンドゥバッファエントリー数: {turtle.undobufferentries()}")

# --- プログラム開始 ---

print("--- 初期状態 ---")
show_buffer_entries() # 0 が表示されるはず

print("\n--- タートルを動かす ---")
t.forward(100)
show_buffer_entries() # 1 が表示されるはず (forward操作が記録される)
time.sleep(1)

t.right(90)
show_buffer_entries() # 2 が表示されるはず (right操作が記録される)
time.sleep(1)

t.circle(50)
show_buffer_entries() # 3 が表示されるはず (circle操作が記録される)
time.sleep(1)

print("\n--- アンドゥ操作を行う ---")
turtle.undo() # 最後の操作 (circle) を元に戻す
print("1回アンドゥしました。")
show_buffer_entries() # 2 に減るはず
time.sleep(1)

turtle.undo() # その前の操作 (right) を元に戻す
print("2回アンドゥしました。")
show_buffer_entries() # 1 に減るはず
time.sleep(1)

turtle.undo() # その前の操作 (forward) を元に戻す
print("3回アンドゥしました。")
show_buffer_entries() # 0 に減るはず
time.sleep(1)

print("\n--- アンドゥバッファが空の状態でアンドゥを試みる ---")
turtle.undo() # 何も起こらない (バッファが空のため)
print("アンドゥバッファが空の状態でアンドゥを試みました。")
show_buffer_entries() # 0 のまま

wn.mainloop() # ウィンドウを閉じるまで待機

この例のポイント

アンドゥバッファが空（値が0）の状態で turtle.undo() を呼び出しても、何も起こらないことが確認できます。
turtle.undo() を呼び出すたびに、値が減っていきます。
タートルが動くたびに turtle.undobufferentries() の値が増えていくことがわかります。

例2: アンドゥバッファのサイズ制限と `undobufferentries()`

turtle.setundobuffer(size) を使うと、アンドゥバッファに格納できる操作の最大数を設定できます。この例では、サイズ制限がある場合の undobufferentries() の挙動を確認します。

import turtle
import time

wn = turtle.Screen()
wn.setup(width=600, height=400)
wn.title("アンドゥバッファのサイズ制限")

t = turtle.Turtle()
t.shape("arrow")
t.speed(1)

# アンドゥバッファのサイズを3に設定
# これにより、最新の3つの操作のみが記録されます
turtle.setundobuffer(3)
print(f"アンドゥバッファの最大サイズ: {turtle.getundobuffer()}")

def show_buffer_entries_with_message(action):
    """アクションと現在のエントリー数を表示するヘルパー関数"""
    print(f"'{action}' 後: エントリー数 = {turtle.undobufferentries()}")

print("\n--- 3つの操作を行う ---")
t.forward(50) # 1
show_buffer_entries_with_message("forward 50")
time.sleep(1)

t.right(90) # 2
show_buffer_entries_with_message("right 90")
time.sleep(1)

t.forward(50) # 3
show_buffer_entries_with_message("forward 50")
time.sleep(1)

print("\n--- 4つ目の操作を行う (最も古い操作が削除される) ---")
t.left(90) # 4
show_buffer_entries_with_message("left 90") # エントリー数は3のままのはず
time.sleep(1)

t.forward(50) # 5
show_buffer_entries_with_message("forward 50") # エントリー数は3のままのはず
time.sleep(1)

print("\n--- アンドゥを試みる ---")
turtle.undo() # 5番目の操作を元に戻す
print("1回アンドゥしました。")
show_buffer_entries_with_message("undo")
time.sleep(1)

turtle.undo() # 4番目の操作を元に戻す
print("2回アンドゥしました。")
show_buffer_entries_with_message("undo")
time.sleep(1)

turtle.undo() # 3番目の操作を元に戻す
print("3回アンドゥしました。")
show_buffer_entries_with_message("undo")
time.sleep(1)

turtle.undo() # これ以上元に戻せる操作はないはず (バッファは0になっている)
print("4回アンドゥしました (バッファが空のはず)。")
show_buffer_entries_with_message("undo")

wn.mainloop()

この例のポイント

アンドゥ操作を繰り返すと、最終的にバッファが空になり、それ以上アンドゥできなくなることがわかります。
4つ目の操作を行った後も undobufferentries() の値は 3 のままであることが確認できます。これは、最も古い操作（最初の forward(50)）がバッファから削除されたためです。
turtle.setundobuffer(3) でバッファサイズを3に制限しています。

例3: アンドゥバッファの有効/無効切り替えと `undobufferentries()`

turtle.setundobuffer(None) を使うと、アンドゥバッファを完全に無効にできます。この場合、undobufferentries() は常に 0 を返します。

import turtle
import time

wn = turtle.Screen()
wn.setup(width=600, height=400)
wn.title("アンドゥバッファの有効/無効")

t = turtle.Turtle()
t.shape("circle")
t.speed(1)

def show_buffer_entries_status():
    """現在のアンドゥバッファエントリー数を表示するヘルパー関数"""
    print(f"現在のアンドゥバッファエントリー数: {turtle.undobufferentries()}")

print("--- 初期状態 (アンドゥバッファは有効) ---")
t.forward(50)
show_buffer_entries_status()
time.sleep(1)

print("\n--- アンドゥバッファを無効にする ---")
turtle.setundobuffer(None) # アンドゥバッファを無効化
print("アンドゥバッファが無効になりました。")
show_buffer_entries_status() # 0 になるはず (これまでの履歴も消える)
time.sleep(1)

print("\n--- 無効な状態で操作を行う ---")
t.right(90)
show_buffer_entries_status() # 0 のまま (操作が記録されない)
time.sleep(1)

t.forward(50)
show_buffer_entries_status() # 0 のまま
time.sleep(1)

print("\n--- アンドゥを試みる (何も起こらない) ---")
turtle.undo()
print("アンドゥを試みましたが、何も起こりません。")
show_buffer_entries_status()

print("\n--- アンドゥバッファを再度有効にする ---")
# 適当な大きな数で有効化 (デフォルトの動作に戻す場合が多い)
turtle.setundobuffer(42)
print("アンドゥバッファが再度有効になりました。")
show_buffer_entries_status() # 0 (有効化した時点では履歴がないため)
time.sleep(1)

print("\n--- 再度有効な状態で操作を行う ---")
t.left(45)
show_buffer_entries_status() # 1 になるはず
time.sleep(1)

t.forward(30)
show_buffer_entries_status() # 2 になるはず
time.sleep(1)

print("\n--- アンドゥを試みる (今度は動作する) ---")
turtle.undo()
print("アンドゥしました。")
show_buffer_entries_status()

wn.mainloop()

再度 turtle.setundobuffer(任意の数値) を呼び出すことで、アンドゥバッファを有効に戻すことができます。ただし、無効になっていた間の操作は記録されていないため、有効に戻した時点から新たに履歴が作成されます。
無効な状態で turtle.undo() を呼び出しても効果はありません。
turtle.setundobuffer(None) を呼び出すと、アンドゥバッファがクリアされ、以降の操作は記録されなくなります。その結果、undobufferentries() は常に 0 を返します。

turtle.undobufferentries() はアンドゥバッファの現在のアクティブなエントリー数を返す関数ですが、これにはいくつか代替となるアプローチがあります。ただし、「代替方法」という文脈では、undobufferentries() が提供する情報（バッファ内の要素数）を異なる方法で管理・取得することや、より高度なアンドゥ/リドゥ機能を自作することを意味します。

turtle モジュール自体が提供する機能は限られているため、より柔軟な履歴管理が必要な場合は、Pythonのデータ構造を使って自作することになります。

独自のアンドゥ/リドゥスタックを実装する

turtle.undobufferentries() の最も直接的な代替であり、かつ最も強力な方法です。これは、タートルが実行した操作を独自のリストやスタックに記録し、そのリストを使って元に戻す（アンドゥ）およびやり直す（リドゥ）機能を実装するものです。

メリット

保存/読み込み機能と連携させて、操作履歴を永続化することも可能です。
アンドゥバッファのサイズを動的に変更したり、特定の種類の操作のみを記録したりできます。
リドゥ（やり直し）機能も簡単に実装できます。
どの操作を記録するか、どのように元に戻すかを完全に制御できます。
turtle モジュールの組み込みアンドゥ機能よりもはるかに柔軟です。

基本的なアプローチ

コマンドオブジェクトの定義
タートル操作（例: forward(100), right(90)) を表現するクラスや、タプル、辞書などでコマンドを定義します。これには、操作の内容と、元に戻すための逆操作（例: backward(100), left(90)) を含めるのが一般的です。
アンドゥスタック（リスト）の作成
実行されたコマンドを格納するためのリストを用意します。
リドゥスタック（リスト）の作成
アンドゥされたコマンドを一時的に格納し、やり直すために使用するリストを用意します。
コマンド実行のラッパー関数
タートル操作を実行する際に、このラッパー関数を介して実行し、同時にアンドゥスタックにコマンドを記録します。
アンドゥ関数の実装
アンドゥスタックから最後のコマンドを取り出し、その逆操作を実行し、取り出したコマンドをリドゥスタックに移動します。
リドゥ関数の実装
リドゥスタックから最後のコマンドを取り出し、その操作を再実行し、取り出したコマンドをアンドゥスタックに移動します。

例

import turtle

class TurtleCommand:
    """タートル操作とその逆操作をカプセル化するクラス"""
    def __init__(self, action, *args):
        self.action = action
        self.args = args
        self.reverse_action = None
        self.reverse_args = None

        if action == 'forward':
            self.reverse_action = 'backward'
            self.reverse_args = args
        elif action == 'backward':
            self.reverse_action = 'forward'
            self.reverse_args = args
        elif action == 'right':
            self.reverse_action = 'left'
            self.reverse_args = args
        elif action == 'left':
            self.reverse_action = 'right'
            self.reverse_args = args
        # 他の操作もここに追加

    def execute(self, t_obj):
        """コマンドを実行する"""
        getattr(t_obj, self.action)(*self.args)

    def undo_execute(self, t_obj):
        """コマンドの逆操作を実行する"""
        if self.reverse_action:
            getattr(t_obj, self.reverse_action)(*self.reverse_args)
        else:
            print(f"Warning: No reverse action defined for {self.action}")

# グローバルな履歴スタック
undo_stack = []
redo_stack = []

def execute_and_record(t_obj, command_name, *args):
    """コマンドを実行し、履歴に記録する"""
    cmd = TurtleCommand(command_name, *args)
    cmd.execute(t_obj)
    undo_stack.append(cmd)
    redo_stack.clear() # 新しい操作が行われたらリドゥ履歴はクリア

def custom_undo(t_obj):
    """カスタムアンドゥ機能"""
    if undo_stack:
        cmd = undo_stack.pop()
        cmd.undo_execute(t_obj)
        redo_stack.append(cmd)
        print(f"カスタムアンドゥ実行: 現在のアンドゥ履歴数: {len(undo_stack)}")
    else:
        print("アンドゥできる操作がありません。")

def custom_redo(t_obj):
    """カスタムリドゥ機能"""
    if redo_stack:
        cmd = redo_stack.pop()
        cmd.execute(t_obj)
        undo_stack.append(cmd)
        print(f"カスタムリドゥ実行: 現在のアンドゥ履歴数: {len(undo_stack)}")
    else:
        print("リドゥできる操作がありません。")

# --- メインプログラム ---
wn = turtle.Screen()
wn.setup(width=600, height=400)
wn.title("カスタムアンドゥ/リドゥ")

t = turtle.Turtle()
t.shape("turtle")
t.speed(1)

# `turtle.setundobuffer(0)` で組み込みのアンドゥを無効にするか、非常に小さい値に設定する
# そうしないと、組み込みのアンドゥとカスタムアンドゥが競合する可能性がある
turtle.setundobuffer(0) # 組み込みアンドゥを無効化

print(f"組み込みのアンドゥバッファエントリー数 (無効化後): {turtle.undobufferentries()}")

execute_and_record(t, 'forward', 100)
execute_and_record(t, 'right', 90)
execute_and_record(t, 'forward', 50)

print(f"現在のアンドゥスタックの長さ: {len(undo_stack)}") # これが undobufferentries() の代替
print(f"現在のリドゥスタックの長さ: {len(redo_stack)}")

# キーイベントに関数を割り当てる
wn.onkey(lambda: custom_undo(t), "u") # 'u' キーでアンドゥ
wn.onkey(lambda: custom_redo(t), "r") # 'r' キーでリドゥ
wn.listen() # キーイベントをリッスンする

wn.mainloop()

この例では、len(undo_stack) が turtle.undobufferentries() の代わりになります。

シンプルな操作履歴リストの管理

上記のカスタムスタックよりも単純に、実行した操作のリストだけを管理し、アンドゥ操作は単にリストの要素数を減らす、というアプローチも考えられます。この場合、実際のアンドゥ処理はタートルを初期状態に戻してから履歴の残りの操作を再実行する、といった形になります。

メリット

操作履歴の「数」を追跡するだけなら十分です。
実装が非常にシンプルです。

デメリット

リドゥ機能の実現は困難です。
実際のアンドゥ処理（タートルを元に戻す）は複雑になるか、限定的になります。

import turtle

# 実行された操作を記録するリスト
operation_history = []

def record_and_execute(t_obj, action, *args):
    """操作を記録し、実行する"""
    operation_history.append({'action': action, 'args': args})
    getattr(t_obj, action)(*args)
    print(f"操作 '{action}{args}' を実行。履歴数: {len(operation_history)}")

def simple_undo(t_obj):
    """シンプルなアンドゥ (履歴から最後の操作を削除するだけ)"""
    if operation_history:
        # 実際のアンドゥは複雑なため、ここでは簡略化
        # 厳密には、タートルをリセットし、残りの履歴を再実行する必要がある
        operation_history.pop()
        print(f"履歴から1つ削除しました。現在の履歴数: {len(operation_history)}")
        # この時点では、画面上のタートルは元に戻っていないので注意！
        # 画面を完全に元に戻すには、タートルを初期化し、operation_historyを再実行する
        t_obj.clear()
        t_obj.penup()
        t_obj.home()
        t_obj.pendown()
        for op in operation_history:
            getattr(t_obj, op['action'])(*op['args'])
    else:
        print("履歴がありません。")

# --- メインプログラム ---
wn = turtle.Screen()
wn.setup(width=600, height=400)
wn.title("シンプルな操作履歴管理")

t = turtle.Turtle()
t.shape("square")
t.speed(1)
turtle.setundobuffer(0) # 組み込みのアンドゥを無効化

record_and_execute(t, 'forward', 100)
record_and_execute(t, 'left', 90)
record_and_execute(t, 'forward', 50)

print(f"現在のアンドゥ可能操作数 (自作): {len(operation_history)}")

wn.onkey(lambda: simple_undo(t), "u")
wn.listen()

wn.mainloop()

このアプローチでは、len(operation_history) が turtle.undobufferentries() の代替となりますが、実際のアンドゥ処理（画面上のタートルを元に戻す）は別途実装が必要である点に注意が必要です。

Pythonグラフィックプログラミング：Turtle以外の選択肢（Tkinter, Pygame他）

「タートル」（亀）と呼ばれる小さなロボットが画面上を動き回り、その軌跡に沿って線を描いていく様子を想像してください。このタートルに命令を与えることで、様々な図形や模様を描くことができます。視覚的にプログラミングの結果がすぐに確認できるため、特に子供やプログラミングの基本概念を学ぶのに適しています。

Python Turtleグラフィック完全ガイド：メソッドと関数の使い方

Pythonのturtleモジュールは、グラフィック描画を簡単に行うための機能を提供します。このモジュールには、基本的な描画オブジェクトである「タートル」を制御するための様々なメソッドや関数が用意されています。大きく分けて、タートルを制御する方法には以下の2種類があります。

Methods of TurtleScreen/Screen and corresponding functions (turtle)

turtleモジュールは、グラフィカルな描画を簡単に行うためのPythonの標準ライブラリです。カメ（タートル）が画面上を移動しながら線を描く様子をシミュレートします。このモジュールには、描画を行う「カメ」と、そのカメが活動する「画面」という2つの主要な要素があります。

Python Turtleとは？初心者向けグラフィックプログラミング入門

Pythonのturtleモジュールは、グラフィック描画を簡単に行うためのモジュールです。Logoプログラミング言語にインスパイアされており、"タートル"と呼ばれる小さなカーソルを動かすことで線や図形を描くことができます。そして、turtledemoは、このturtleモジュールの使い方を示すデモスクリプト集です。これはPythonの標準ライブラリの一部として含まれており、turtleモジュールの様々な機能や、それを使ってどのような面白いグラフィックが描けるかを示すためのたくさんのサンプルプログラムが用意されています。

turtle.undobufferentries()

TypeError: 'int' object is not callable または TypeError: 'builtin_function_or_method' object is not subscriptable

アンドゥバッファが期待通りの数にならない

turtle.undo() が期待通りに動作しない

ファイル名の競合（特にPyCharmなどのIDEで）

例1: アンドゥバッファのエントリー数の変化を追跡する

例2: アンドゥバッファのサイズ制限と undobufferentries()

例3: アンドゥバッファの有効/無効切り替えと undobufferentries()

独自のアンドゥ/リドゥスタックを実装する

シンプルな操作履歴リストの管理

例2: アンドゥバッファのサイズ制限と `undobufferentries()`

例3: アンドゥバッファの有効/無効切り替えと `undobufferentries()`