turtle.RawTurtle

2025-06-06

turtle.RawTurtleは、このタートルグラフィックスにおいて、特定の描画画面（キャンバス）に紐付けられたタートルオブジェクトを作成するためのクラスです。

`turtle.RawTurtle`の主な特徴と使い方

オブジェクト指向インターフェース: turtleモジュールには、大きく分けて「手続き型インターフェース」と「オブジェクト指向インターフェース」の2つの使い方があります。RawTurtleはオブジェクト指向インターフェースの一部です。
- 手続き型インターフェース: turtle.forward(100)のように、モジュールレベルの関数を直接呼び出す方法です。この場合、内部で自動的にシングルトンのスクリーン（描画画面）とタートルが作成されます。
- オブジェクト指向インターフェース: turtle.RawTurtleやturtle.TurtleScreen（描画画面を表すクラス）のインスタンスを作成して、それらのメソッドを呼び出す方法です。これにより、複数のタートルを管理したり、より柔軟な描画環境を構築したりできます。

描画画面（スクリーン）の指定: RawTurtleのコンストラクタには、どこに描画するかを示すtkinter.Canvas、ScrolledCanvas、またはturtle.TurtleScreenのインスタンスを引数として渡す必要があります。これにより、プログラム内で複数の独立した描画領域を持つことが可能になります。

import turtle
import tkinter as tk

# Tkinterのルートウィンドウとキャンバスを作成
root = tk.Tk()
canvas = tk.Canvas(master=root, width=400, height=300)
canvas.pack()

# RawTurtleを作成し、上記のキャンバスに紐付ける
# RawTurtleは直接Canvasに紐付けられる
my_turtle = turtle.RawTurtle(canvas)

# タートルを動かして描画
my_turtle.forward(100)
my_turtle.left(90)
my_turtle.forward(100)

root.mainloop()

turtle.Turtleとの違い:
- turtle.Turtle: turtle.RawTurtleのサブクラスです。最も一般的なタートルグラフィックスの利用方法で、通常はこちらを使います。turtle.Turtle()のように引数なしでインスタンスを作成すると、自動的に「唯一の」Screenインスタンス（描画画面）に紐付けられます。つまり、通常は単一の描画画面でタートルを使う場合に便利です。
- turtle.RawTurtle: turtle.Turtleの親クラスです。描画先の画面（CanvasやTurtleScreen）を明示的に指定する必要があるため、TkinterなどのGUIアプリケーションにタートルグラフィックスを組み込んだり、複数の描画画面で異なるタートルを動作させたい場合に利用されます。

複数のタートル/画面の管理: 一つのプログラム内で複数の独立した描画領域（キャンバス）を作成し、それぞれに異なるタートルを配置して、別々の描画を行わせたい場合に役立ちます。
GUIアプリケーションへの組み込み: TkinterなどのPythonのGUIライブラリと組み合わせて、独自のウィンドウやフレーム内にタートルグラフィックスの描画エリアを埋め込みたい場合にRawTurtleが適しています。

TypeError: init missing 1 required positional argument: 'canvas'

トラブルシューティング: RawTurtleをインスタンス化する際には、必ず描画先のキャンバスオブジェクトを渡してください。

import turtle
import tkinter as tk

root = tk.Tk()
canvas = tk.Canvas(master=root, width=400, height=300)
canvas.pack()

# 誤り: canvasを渡していない
# my_turtle = turtle.RawTurtle()

# 正しい: canvasを渡す
my_turtle = turtle.RawTurtle(canvas)

my_turtle.forward(50)
root.mainloop()

あるいは、RawTurtleを使用する際は、通常turtle.TurtleScreenと組み合わせて使われます。

import turtle
import tkinter as tk

root = tk.Tk()
canvas = tk.Canvas(master=root, width=400, height=300)
canvas.pack()

# TurtleScreenをCanvasに紐付ける
screen = turtle.TurtleScreen(canvas)

# RawTurtleをTurtleScreenに紐付ける
my_turtle = turtle.RawTurtle(screen)

my_turtle.forward(50)
root.mainloop()

原因: RawTurtle()のように引数なしでインスタンスを作成しようとした場合。
エラーの意味: RawTurtleのコンストラクタには、描画先のキャンバス（tkinter.Canvasインスタンス、またはそれに基づいて作成されたturtle.TurtleScreenインスタンス）を引数として渡す必要がありますが、それが欠落しているというエラーです。

AttributeError: 'NoneType' object has no attribute 'getcanvas' または関連するエラー

トラブルシューティング:

RawTurtleに渡す前に、tkinter.Canvasが正しく作成され、利用可能な状態であることを確認してください。
通常、RawTurtleはtkinter.Canvasかturtle.TurtleScreenのインスタンスを引数にとります。他の種類のオブジェクトを渡していないか確認してください。

import turtle
import tkinter as tk

root = tk.Tk()
# canvas = tk.Canvas(master=root, width=400, height=300) # この行がない、またはcanvasがNoneの場合

# 正しい: canvasを正しく作成する
canvas = tk.Canvas(master=root, width=400, height=300)
canvas.pack()
my_turtle = turtle.RawTurtle(canvas) # ここでエラーになる可能性

my_turtle.forward(50)
root.mainloop()

原因:
- tkinter.Canvasオブジェクトがまだ完全に作成されていない状態でRawTurtleに渡された。
- RawTurtleにturtle.TurtleScreenではなく、不適切なオブジェクトが渡された。
- tkinter.Tk()の後にroot.mainloop()が呼ばれていない（ただし、これは描画自体に影響することが多い）。
エラーの意味: タートルが描画しようとした際に、紐付けられているはずのキャンバスオブジェクトがNoneであるか、期待されるメソッド（getcanvasなど）を持っていない場合に発生します。これは、キャンバスが適切に初期化されていないか、間違ったオブジェクトをRawTurtleに渡している可能性があります。

タートルが表示されない、または描画されない

トラブルシューティング:
- root.mainloop()の確認: プログラムの最後にroot.mainloop()があることを確認してください。
- タートルの初期位置確認: my_turtle.goto(0, 0)やmy_turtle.home()で中央に戻す、またはmy_turtle.setx(x)、my_turtle.sety(y)で座標を指定して、見える位置に移動させてみてください。
- ペンの状態確認: my_turtle.pendown()が呼び出されていることを確認してください。
- キャンバスサイズの調整: canvas = tk.Canvas(master=root, width=800, height=600)のように、より大きなサイズを試してみてください。
- turtle.Turtle()との混在を避ける: RawTurtleを使用する場合は、基本的にturtle.Turtle()（デフォルトのScreenに紐付く）は使用せず、すべてのタートルを明示的に作成したRawTurtleで管理することをお勧めします。
原因:
- root.mainloop()の呼び出し忘れ: Tkinterアプリケーションはイベントループを必要とします。これを呼び出さないとウィンドウが表示されず、タートルも描画されません。
- タートルの初期位置が画面外: タートルが描画開始時点でキャンバスの表示領域外にいる可能性があります。
- ペンの状態: ペンが上がっている（penup()）状態になっている可能性があります。
- キャンバスサイズとタートルの移動距離: キャンバスサイズが小さすぎて、描画が収まらない。
- 複数のScreenインスタンス: turtle.Turtle()とturtle.RawTurtle()を混在させており、意図しない画面に描画されている可能性がある。
エラーの意味: コードにエラーは出ていないが、期待通りの描画が行われない。

描画が重い、またはフリーズする

トラブルシューティング:
- tracer()とupdate()の使用: turtle.TurtleScreen（またはcanvasから取得できるスクリーン）のtracer(n, delay)メソッドを使って、描画更新頻度を制御し、update()で手動で描画を更新します。これにより、描画がスムーズになります。
```
import turtle
import tkinter as tk

root = tk.Tk()
canvas = tk.Canvas(master=root, width=400, height=300)
canvas.pack()
screen = turtle.TurtleScreen(canvas)

screen.tracer(0, 0) # アニメーションをオフにする（高速化）
my_turtle = turtle.RawTurtle(screen)

for _ in range(360):
    my_turtle.forward(1)
    my_turtle.left(1)

screen.update() # すべての描画を一度に更新

root.mainloop()
```
- 描画の最適化: 不要な描画操作を減らす、またはより効率的なアルゴリズムを検討します。
原因:
- tracer()の設定: アニメーションを高速化するためのtracer()が適切に設定されていないか、update()が呼び出されていない。
- 非常に複雑な描画: 多数の細かい描画操作を短時間に行っている。
エラーの意味: タートルの動きが非常に遅い、またはプログラムが応答しなくなる。

tkinter.TclError: cannot use geometry manager inside .

トラブルシューティング:
- 一つのウィジェットに対しては、一つのジオメトリマネージャのみを使用してください。通常はpack()で十分です。
- tkinter.Tk()のインスタンスに対してpack()などは不要です。
原因:
- canvas.pack()の後に、例えばcanvas.grid()を呼び出すなど。
- tkinter.Tk()のインスタンスに対してpack()などを呼び出していないのに、その子ウィジェットに対して呼び出そうとした場合。
エラーの意味: Tkinterのジオメトリマネージャ（pack, grid, place）の誤用。特に、既にジオメトリマネージャが適用されているウィジェット（ここではCanvas）に対して、別のジオメトリマネージャを適用しようとした場合に発生します。

printデバッグ: 変数の値やプログラムの流れを確認するために、print()関数をコードの様々な場所に追加してみてください。
最小限の再現コード: エラーが発生している部分を切り離して、最小限のコードでそのエラーが再現するかどうかを試してみてください。これにより、問題の特定が容易になります。
エラーメッセージをよく読む: Pythonのエラーメッセージは非常に役立ちます。どのファイル、どの行で、どのようなエラーが発生したかを確認し、その意味を理解しようと努めてください。

例1: 基本的な `RawTurtle` の使い方（Tkinterキャンバスに描画）

この例では、Tkinterを使ってウィンドウとキャンバスを作成し、そのキャンバス上にRawTurtleで図形を描画します。

import turtle
import tkinter as tk

def basic_rawturtle_example():
    # 1. Tkinterのルートウィンドウを作成
    root = tk.Tk()
    root.title("RawTurtle Basic Example")

    # 2. 描画領域となるCanvasウィジェットを作成
    # RawTurtleはこのCanvasに直接描画します
    canvas = tk.Canvas(master=root, width=400, height=300, bg="lightblue")
    canvas.pack(padx=20, pady=20) # ウィンドウ内にキャンバスを配置

    # 3. RawTurtleインスタンスを作成し、canvasに紐付ける
    # RawTurtleはどのキャンバスに描画するかを知る必要があります
    my_turtle = turtle.RawTurtle(canvas)

    # 4. タートルの設定（色、形、速さなど）
    my_turtle.shape("turtle")
    my_turtle.color("red")
    my_turtle.speed(5) # 1 (遅い) から 10 (速い), 0 (最速)

    # 5. タートルを動かして図形を描画
    my_turtle.forward(100)
    my_turtle.left(90)
    my_turtle.forward(100)
    my_turtle.left(90)
    my_turtle.forward(100)
    my_turtle.left(90)
    my_turtle.forward(100) # 四角形を描画

    # 6. Tkinterイベントループを開始
    # これがないとウィンドウが表示されません
    root.mainloop()

if __name__ == "__main__":
    basic_rawturtle_example()

説明:

最後にroot.mainloop()を呼び出すことで、Tkinterウィンドウが表示され、タートルの動きが確認できます。
あとは通常のタートルグラフィックスと同じように、my_turtle.forward(), my_turtle.left()などのメソッドを使って描画を行います。
turtle.RawTurtle(canvas)として、このcanvasに描画を行うRawTurtleインスタンスを作成します。
tkinter.Canvas()で描画を行う領域（キャンバス）を作成し、rootウィンドウにpack()で配置します。
tkinter.Tk()でアプリケーションのメインウィンドウを作成します。

例2: `RawTurtle` と `TurtleScreen` を組み合わせる

RawTurtleはtkinter.Canvasに直接紐付けられますが、turtleモジュールにはturtle.TurtleScreenというクラスもあります。これはCanvasの上にタートルグラフィックスのより高度な機能（背景画像、イベントハンドリングなど）を提供するレイヤーです。RawTurtleはTurtleScreenにも紐付けられます。

import turtle
import tkinter as tk

def rawturtle_with_turtlescreen_example():
    root = tk.Tk()
    root.title("RawTurtle with TurtleScreen Example")

    canvas = tk.Canvas(master=root, width=500, height=400, bg="lightgray")
    canvas.pack(padx=20, pady=20)

    # 1. CanvasからTurtleScreenインスタンスを作成
    # TurtleScreenはCanvasの上にタートルグラフィックスの機能を提供します
    screen = turtle.TurtleScreen(canvas)
    screen.bgcolor("skyblue") # スクリーンに背景色を設定
    screen.tracer(2, 0) # アニメーションを少し高速化（2フレームごとに更新、遅延なし）

    # 2. RawTurtleをこのscreenに紐付ける
    # RawTurtleはscreenからその描画コンテキストを取得します
    my_turtle = turtle.RawTurtle(screen)

    # 3. タートルの設定
    my_turtle.shape("circle")
    my_turtle.color("darkgreen")
    my_turtle.pensize(3)

    # 4. 複雑な図形を描画
    for i in range(180):
        my_turtle.forward(2 * i)
        my_turtle.right(61)

    screen.update() # tracer(0)を使用した場合、ここで更新を明示的に呼び出す

    root.mainloop()

if __name__ == "__main__":
    rawturtle_with_turtlescreen_example()

説明:

turtle.RawTurtle(screen)としてRawTurtleを作成し、screenに紐付けます。これにより、このタートルはscreenの持つ描画環境とイベント（クリックなど）を利用できます。
screen.tracer(2, 0)は描画の最適化です。nフレームごとに描画を更新し、delayミリ秒の遅延を設けます。tracer(0)とupdate()の組み合わせは、非常に高速な描画を必要とする場合に特に有効です。
screen.bgcolor("skyblue")のように、TurtleScreenのメソッドを使って背景色を設定できます。
turtle.TurtleScreen(canvas)を使って、先に作成したcanvasを基にTurtleScreenインスタンスを作成します。

例3: 複数の `RawTurtle` を異なる画面で制御する

RawTurtleの最大の利点の一つは、複数の独立した描画領域を作成し、それぞれに異なるタートルを配置できることです。

import turtle
import tkinter as tk

def multiple_rawturtles_example():
    root = tk.Tk()
    root.title("Multiple RawTurtles Example")

    # フレームを作成して、その中にキャンバスを配置する（レイアウトを整理するため）
    frame1 = tk.Frame(root, bd=2, relief="groove")
    frame1.pack(side=tk.LEFT, padx=10, pady=10)

    frame2 = tk.Frame(root, bd=2, relief="groove")
    frame2.pack(side=tk.RIGHT, padx=10, pady=10)

    # 1つ目の描画領域（キャンバスとスクリーン）
    canvas1 = tk.Canvas(master=frame1, width=250, height=250, bg="pink")
    canvas1.pack()
    screen1 = turtle.TurtleScreen(canvas1)
    screen1.tracer(0) # 高速化

    # 2つ目の描画領域（キャンバスとスクリーン）
    canvas2 = tk.Canvas(master=frame2, width=250, height=250, bg="lightgreen")
    canvas2.pack()
    screen2 = turtle.TurtleScreen(canvas2)
    screen2.tracer(0) # 高速化

    # 1つ目のスクリーンに紐付くタートル
    turtle1 = turtle.RawTurtle(screen1)
    turtle1.shape("triangle")
    turtle1.color("blue")
    turtle1.pensize(2)

    # 2つ目のスクリーンに紐付くタートル
    turtle2 = turtle.RawTurtle(screen2)
    turtle2.shape("square")
    turtle2.color("purple")
    turtle2.pensize(2)

    # それぞれのタートルで異なる描画を行う
    # タートル1で星形を描画
    turtle1.penup()
    turtle1.goto(-50, 0)
    turtle1.pendown()
    for _ in range(5):
        turtle1.forward(100)
        turtle1.right(144)
    screen1.update()

    # タートル2で渦巻きを描画
    turtle2.penup()
    turtle2.goto(0, 0)
    turtle2.pendown()
    for i in range(100):
        turtle2.forward(i * 0.5)
        turtle2.right(10)
    screen2.update()

    root.mainloop()

if __name__ == "__main__":
    multiple_rawturtles_example()

説明:

screen.tracer(0)とscreen.update()の組み合わせは、複雑な描画でも滑らかに表示するために重要です。
これにより、turtle1はcanvas1上で、turtle2はcanvas2上で、それぞれ独立した描画を行うことができます。
turtle.RawTurtleのインスタンスを2つ作成し、それぞれを異なるscreen1とscreen2に紐付けます。
それぞれのフレーム内に、tk.Canvasとそれに対応するturtle.TurtleScreenを作成します。
この例では、tk.Frameを使ってウィンドウ内に2つの独立したセクションを作成しています。

RawTurtleは、それが紐付けられているTurtleScreenを介してイベント（マウスクリックなど）に反応することができます。

import turtle
import tkinter as tk

def rawturtle_event_handling_example():
    root = tk.Tk()
    root.title("RawTurtle Event Handling Example")

    canvas = tk.Canvas(master=root, width=400, height=300, bg="lightyellow")
    canvas.pack(padx=20, pady=20)

    screen = turtle.TurtleScreen(canvas)
    screen.bgcolor("lightgray")
    screen.tracer(0) # アニメーションをオフ

    my_turtle = turtle.RawTurtle(screen)
    my_turtle.shape("arrow")
    my_turtle.color("blue")
    my_turtle.penup() # 線を引かずに移動できるようにペンを上げる

    # クリックイベントのハンドラ関数
    def go_to_clicked_pos(x, y):
        my_turtle.goto(x, y) # クリックされた座標にタートルを移動
        screen.update() # 画面を更新

    # screenにクリックイベントをバインド
    # onclick()の第一引数に関数、第二引数にボタン番号（Noneは左クリック）
    screen.onclick(go_to_clicked_pos)

    # 画面に指示を表示
    info_turtle = turtle.RawTurtle(screen) # 指示用の別のタートル
    info_turtle.hideturtle()
    info_turtle.penup()
    info_turtle.goto(0, screen.window_height() / 2 - 30)
    info_turtle.color("black")
    info_turtle.write("Click anywhere to move the turtle!", align="center", font=("Arial", 14, "normal"))

    screen.update() # 初期表示を更新

    root.mainloop()

if __name__ == "__main__":
    rawturtle_event_handling_example()

説明:

もう一つのRawTurtle（info_turtle）を使って、画面上にテキストで指示を表示しています。これは、RawTurtleが複数作成できることの応用例でもあります。
screen.onclick(go_to_clicked_pos)を使って、screen（TurtleScreenインスタンス）のクリックイベントにgo_to_clicked_pos関数をバインドします。これにより、スクリーンがクリックされるたびにこの関数が実行されます。
go_to_clicked_pos(x, y)関数は、スクリーンがクリックされたときに呼び出されます。引数のxとyはクリックされた座標です。
my_turtle.penup()を呼び出すことで、タートルが移動しても線が引かれないようにします。

turtle.Turtle（デフォルトの単一スクリーンを使用）
tkinter.Canvasの直接的な描画（create_line, create_polygonなど）

それぞれについて詳しく見ていきましょう。

turtle.Turtle（デフォルトの単一スクリーンを使用）

これはturtleモジュールを最も手軽に使う方法であり、多くのタートルグラフィックスのチュートリアルや例で使われています。turtle.Turtleはturtle.RawTurtleのサブクラスですが、内部で自動的に単一のグローバルなturtle.Screen（描画画面）とtkinter.Canvasを作成し、それに紐付けられます。

利点:

手続き型インターフェース: turtle.forward(100)のような関数呼び出しで簡単に操作できます。
イベントループの自動管理: 通常、turtle.done()を呼び出すことで、描画が完了するまでウィンドウを開いたままにするイベントループが自動的に処理されます。
簡単: import turtleしてすぐにturtle.forward()やturtle.Turtle()のように使い始められます。自分でTkinterのキャンバスを用意する必要がありません。

欠点:

Tkinterのルートウィンドウへのアクセスが間接的: デフォルトのturtle.Screenが作成するTkinterのルートウィンドウやキャンバスに直接アクセスして、より詳細なGUI要素を追加するのが少し手間がかかります。
Tkinterアプリケーションへの組み込みが困難: 既存の複雑なTkinterアプリケーションの特定のフレームやタブに描画領域を組み込みたい場合、turtle.Turtleはデフォルトのグローバルな画面を使うため、制御が難しいです。turtle.RawTurtleはそのために存在します。
単一の描画画面: 複数の独立した描画領域を一つのアプリケーション内に持ちたい場合には適していません。

コード例:

import turtle

def alternative_turtle_example():
    # 1. タートルオブジェクトを作成（自動的にScreenが作成される）
    my_turtle = turtle.Turtle()

    # 2. タートルの設定（RawTurtleと同じ）
    my_turtle.shape("arrow")
    my_turtle.color("blue")
    my_turtle.pensize(2)
    my_turtle.speed(5)

    # 3. 図形を描画
    for _ in range(4):
        my_turtle.forward(100)
        my_turtle.left(90)

    # 4. 画面を閉じるまで待機
    turtle.done() # これがTkinterのmainloop()に相当
    # または、画面オブジェクトを取得してscreen.exitonclick()なども利用可能
    # screen = turtle.Screen()
    # screen.exitonclick()

if __name__ == "__main__":
    alternative_turtle_example()

tkinter.Canvasの直接的な描画（create_line, create_polygonなど）

turtleモジュールはTkinterの上に構築されています。もしタートルの「亀」というメタファーが不要で、より低レベルで直接的な描画制御が必要な場合は、tkinter.Canvasウィジェットのメソッドを直接使用することができます。

利点:

既存のTkinterアプリケーションとの統合が容易: 既存のGUIに描画機能を追加する際に、turtleモジュールに依存せず、Tkinterの標準的な方法で実現できます。
多様な描画プリミティブ: 線、四角形、円、多角形、テキスト、画像など、様々な図形を直接描画できます。タートルグラフィックスで描けるのは基本的に「線」ですが、Canvasはより多様な形状を扱えます。
軽量: turtleモジュールのオーバーヘッドがないため、非常に単純な描画にはより効率的かもしれません。
完全に制御可能: 描画のあらゆる側面（座標、色、線の太さ、図形の種類など）を直接制御できます。

欠点:

アニメーションの実装: アニメーションを行う場合は、canvas.after()メソッドを使って定期的に描画を更新したり、オブジェクトを移動させたりするロジックを自分で書く必要があります。
描画ロジックが複雑になる可能性: 動きのある描画やアニメーションを実現するためには、座標計算や再描画ロジックを自分で実装する必要があります。タートルグラフィックスのように「進む」「曲がる」といった直感的な操作ができません。

コード例:

import tkinter as tk

def alternative_tkinter_canvas_example():
    root = tk.Tk()
    root.title("Tkinter Canvas Direct Drawing Example")

    # 1. Canvasウィジェットを作成
    canvas = tk.Canvas(master=root, width=400, height=300, bg="lightcyan")
    canvas.pack(padx=20, pady=20)

    # 2. Canvasメソッドを使って直接図形を描画

    # 線を描画 (x1, y1, x2, y2)
    canvas.create_line(50, 50, 150, 50, fill="red", width=3)
    canvas.create_line(150, 50, 150, 150, fill="red", width=3)
    canvas.create_line(150, 150, 50, 150, fill="red", width=3)
    canvas.create_line(50, 150, 50, 50, fill="red", width=3) # 四角形

    # 楕円（円）を描画 (x1, y1, x2, y2 の矩形に内接する楕円)
    canvas.create_oval(200, 100, 300, 200, outline="blue", fill="yellow", width=2)

    # 多角形を描画 (頂点の座標リスト)
    canvas.create_polygon(300, 50, 350, 100, 250, 100, fill="green", outline="darkgreen", width=2)

    # テキストを描画
    canvas.create_text(200, 250, text="Hello, Canvas!", font=("Arial", 16, "bold"), fill="purple")

    root.mainloop()

if __name__ == "__main__":
    alternative_tkinter_canvas_example()

tkinter.Canvasの直接描画:
- タートルグラフィックスの抽象化が不要で、ピクセルレベルに近い厳密な描画制御が必要な場合。
- Tkinterアプリケーションに、線や図形、画像などを直接描画する機能を追加したい場合。
- 複雑なアニメーションやゲームをTkinterだけで構築したい場合（この場合はCanvasが基盤となります）。
turtle.Turtle:
- 単一のウィンドウで手軽にタートルグラフィックスを試したい場合。
- 学習目的や、非常にシンプルなグラフィックを作成する場合。
turtle.RawTurtle:
- 複数の描画領域を持つGUIアプリケーションにタートルグラフィックスを組み込みたい場合。
- タートルの直感的な「進む」「曲がる」というモデルを使いたい場合。
- turtle.TurtleScreenが提供するイベントハンドリング（クリック、キー入力など）や背景設定などの機能を利用したい場合。

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.RawTurtle