turtle — 海龟绘图

源代码： Lib/turtle.py

简介

海龟绘图是 Logo 中引入的流行几何绘图工具 的实现，由 Wally Feurzeig、Seymour Papert 和 Cynthia Solomon 于 1967 年开发。

在 Python 中，海龟绘图提供了一个物理“海龟”（一个带笔的小机器人）的表示，它在地板上的纸上绘图。

对于学习者来说，这是一种有效且经过验证的方法，可以让他们接触编程概念并与软件交互，因为它提供了即时、可见的反馈。它还提供了一种方便的方式来访问图形输出。

海龟绘图最初是作为一种教育工具创建的，供教师在课堂上使用。对于需要生成一些图形输出的程序员来说，这是一种无需引入更复杂或外部库到他们的工作中的方法。

教程

新用户应该从这里开始。在本教程中，我们将探索海龟绘图的一些基础知识。

启动海龟环境

在 Python shell 中，导入 turtle 模块的所有对象

from turtle import *

如果你遇到 No module named '_tkinter' 错误，你需要在你的系统上安装 Tk 接口包。

基本绘图

让海龟向前移动 100 步

forward(100)

你应该会看到（很可能是在你的显示器上的一个新窗口中）海龟画的一条线，朝向东方。改变海龟的方向，使其向左（逆时针）旋转 120 度

left(120)

让我们继续画一个三角形

forward(100)
left(120)
forward(100)

注意，由箭头表示的海龟在你操纵它时如何指向不同的方向。

尝试使用这些命令，以及 backward() 和 right()。

画笔控制

尝试改变颜色 - 例如，color('blue') - 和线条的宽度 - 例如，width(3) - 然后再画图。

你也可以在不画图的情况下移动海龟，方法是在移动之前抬起画笔：up()。要再次开始画图，请使用 down()。

海龟的位置

将你的海龟送回它的起点（如果它已经消失在屏幕外，这很有用）

home()

原点位于海龟屏幕的中心。如果你需要知道它们，可以使用以下方法获取海龟的 x-y 坐标

pos()

原点位于 (0, 0)。

过一段时间后，清除窗口可能会有所帮助，这样我们就可以重新开始了

clearscreen()

制作算法模式

使用循环，可以构建几何图案

for steps in range(100):
    for c in ('blue', 'red', 'green'):
        color(c)
        forward(steps)
        right(30)

- 当然，这些图案只受限于想象力！

让我们画出本页顶部的星形。我们想要用黄色填充的红线

color('red')
fillcolor('yellow')

正如 up() 和 down() 决定是否绘制线条一样，填充也可以打开和关闭

begin_fill()

接下来我们将创建一个循环

while True:
    forward(200)
    left(170)
    if abs(pos()) < 1:
        break

abs(pos()) < 1 是一个很好的方法，可以知道海龟何时回到原点。

最后，完成填充

end_fill()

（请注意，只有在你给出 end_fill() 命令时才会实际进行填充。）

如何…

本节介绍了一些典型的海龟用例和方法。

尽快上手

海龟绘图的乐趣之一是可以从简单的命令中获得即时的视觉反馈 - 这是一种以最小的开销向儿童介绍编程思想的绝佳方式（当然，不仅仅是儿童）。

turtle 模块通过将所有基本功能作为函数公开，并使用 from turtle import * 提供，从而使这成为可能。海龟绘图教程 涵盖了这种方法。

值得注意的是，许多海龟命令还有更简洁的等效命令，例如 fd() 对应 forward()。这些在与那些打字不是技能的学习者一起工作时特别有用。

你需要在你的系统上安装 Tk 接口包，海龟绘图才能工作。请注意，这并不总是那么简单，所以如果你打算与学习者一起使用海龟绘图，请提前检查这一点。

使用 turtle 模块命名空间

使用 from turtle import * 很方便 - 但请注意，它会导入大量的对象，如果你正在做的事情不是海龟绘图，你就有名称冲突的风险（如果你在可能导入其他模块的脚本中使用海龟绘图，这个问题就会变得更加严重）。

解决方案是使用 import turtle - fd() 变为 turtle.fd()，width() 变为 turtle.width()，等等。（如果一遍又一遍地输入“turtle”变得 tedious，可以使用例如 import turtle as t 代替。）

在脚本中使用海龟绘图

建议使用上面介绍的 turtle 模块命名空间，例如

import turtle as t
from random import random

for i in range(100):
    steps = int(random() * 100)
    angle = int(random() * 360)
    t.right(angle)
    t.fd(steps)

不过，还需要另一个步骤 - 脚本一结束，Python 也会关闭海龟的窗口。添加

t.mainloop()

到脚本的末尾。脚本现在将等待被关闭，并且在被终止之前不会退出，例如通过关闭海龟图形窗口。

使用面向对象的龟图形

另请参阅

面向对象接口的说明

除了非常基本的入门目的，或者为了尽快尝试，使用面向对象的方法来处理龟图形更为常见，也更加强大。例如，这允许在屏幕上同时出现多个海龟。

在这种方法中，各种海龟命令是对象的方法（主要是 Turtle 对象）。您*可以*在 shell 中使用面向对象的方法，但这在 Python 脚本中更为典型。

上面的例子就变成了

from turtle import Turtle
from random import random

t = Turtle()
for i in range(100):
    steps = int(random() * 100)
    angle = int(random() * 360)
    t.right(angle)
    t.fd(steps)

t.screen.mainloop()

注意最后一行。 t.screen 是 Turtle 实例所在的 Screen 的实例；它与海龟一起自动创建。

海龟的屏幕可以自定义，例如

t.screen.title('Object-oriented turtle demo')
t.screen.bgcolor("orange")

龟图形参考

注意

在以下文档中，给出了函数的参数列表。当然，方法还有第一个附加参数 *self*，这里省略了。

龟方法

海龟运动
移动和绘制
forward() | fd()
backward() | bk() | back()
right() | rt()
left() | lt()
goto() | setpos() | setposition()
teleport()
setx()
sety()
setheading() | seth()
home()
circle()
dot()
stamp()
clearstamp()
clearstamps()
undo()
speed()
获取海龟状态
position() | pos()
towards()
xcor()
ycor()
heading()
distance()
设置和测量
degrees()
radians()
画笔控制
绘图状态
pendown() | pd() | down()
penup() | pu() | up()
pensize() | width()
pen()
isdown()
颜色控制
color()
pencolor()
fillcolor()
填充
filling()
begin_fill()
end_fill()
更多绘图控制
reset()
clear()
write()
海龟状态
可见性
showturtle() | st()
hideturtle() | ht()
isvisible()
外观
shape()
resizemode()
shapesize() | turtlesize()
shearfactor()
settiltangle()
tiltangle()
tilt()
shapetransform()
get_shapepoly()
使用事件
onclick()
onrelease()
ondrag()
特殊的 Turtle 方法
begin_poly()
end_poly()
get_poly()
clone()
getturtle() | getpen()
getscreen()
setundobuffer()
undobufferentries()

TurtleScreen/Screen 的方法

窗口控制
bgcolor()
bgpic()
clearscreen()
resetscreen()
screensize()
setworldcoordinates()
动画控制
delay()
tracer()
update()
使用屏幕事件
listen()
onkey() | onkeyrelease()
onkeypress()
onclick() | onscreenclick()
ontimer()
mainloop() | done()
设置和特殊方法
mode()
colormode()
getcanvas()
getshapes()
register_shape() | addshape()
turtles()
window_height()
window_width()
输入方法
textinput()
numinput()
Screen 特有的方法
bye()
exitonclick()
setup()
title()

RawTurtle/Turtle 的方法和对应的函数

本节中的大多数示例都引用了一个名为 turtle 的 Turtle 实例。

海龟运动

turtle.forward(distance)
turtle.fd(distance)
参数：

distance – 一个数字（整数或浮点数）

让海龟朝当前方向前进指定的 distance 距离。

>>> turtle.position()
(0.00,0.00)
>>> turtle.forward(25)
>>> turtle.position()
(25.00,0.00)
>>> turtle.forward(-75)
>>> turtle.position()
(-50.00,0.00)
turtle.back(distance)
turtle.bk(distance)
turtle.backward(distance)
参数：

distance – 一个数字

让海龟后退 distance 距离，方向与海龟朝向相反。不要改变海龟的朝向。

>>> turtle.position()
(0.00,0.00)
>>> turtle.backward(30)
>>> turtle.position()
(-30.00,0.00)
turtle.right(angle)
turtle.rt(angle)
参数：

angle – 一个数字（整数或浮点数）

让海龟右转 angle 个单位。（单位默认为度，但可以通过 degrees() 和 radians() 函数设置。）角度方向取决于海龟模式，请参阅 mode()。

>>> turtle.heading()
22.0
>>> turtle.right(45)
>>> turtle.heading()
337.0
turtle.left(angle)
turtle.lt(angle)
参数：

angle – 一个数字（整数或浮点数）

让海龟左转 angle 个单位。（单位默认为度，但可以通过 degrees() 和 radians() 函数设置。）角度方向取决于海龟模式，请参阅 mode()。

>>> turtle.heading()
22.0
>>> turtle.left(45)
>>> turtle.heading()
67.0
turtle.goto(x, y=None)
turtle.setpos(x, y=None)
turtle.setposition(x, y=None)
参数：

  • x – 一个数字或一对/向量数字

  • y – 一个数字或 None

如果 y 是 None，则 x 必须是一对坐标或一个 Vec2D（例如由 pos() 返回的）。

将海龟移动到绝对位置。如果画笔落下，则绘制线条。不要改变海龟的方向。

>>> tp = turtle.pos()
>>> tp
(0.00,0.00)
>>> turtle.setpos(60,30)
>>> turtle.pos()
(60.00,30.00)
>>> turtle.setpos((20,80))
>>> turtle.pos()
(20.00,80.00)
>>> turtle.setpos(tp)
>>> turtle.pos()
(0.00,0.00)
turtle.teleport(x, y=None, *, fill_gap=False)
参数：

  • x – 一个数字或 None

  • y – 一个数字或 None

  • fill_gap – 一个布尔值

将海龟移动到绝对位置。与 goto(x, y) 不同，不会绘制线条。海龟的方向不会改变。如果当前正在填充，则传送后的多边形将在离开后填充，并在传送后再次开始填充。可以使用 fill_gap=True 禁用此功能，这会使传送期间行进的假想线充当填充障碍，就像在 goto(x, y) 中一样。

>>> tp = turtle.pos()
>>> tp
(0.00,0.00)
>>> turtle.teleport(60)
>>> turtle.pos()
(60.00,0.00)
>>> turtle.teleport(y=10)
>>> turtle.pos()
(60.00,10.00)
>>> turtle.teleport(20, 30)
>>> turtle.pos()
(20.00,30.00)

在 3.12 版本中添加。

turtle.setx(x)
参数：

x – 一个数字（整数或浮点数）

将海龟的第一个坐标设置为 x，第二个坐标保持不变。

>>> turtle.position()
(0.00,240.00)
>>> turtle.setx(10)
>>> turtle.position()
(10.00,240.00)
turtle.sety(y)
参数：

y – 一个数字（整数或浮点数）

将海龟的第二个坐标设置为 y，第一个坐标保持不变。

>>> turtle.position()
(0.00,40.00)
>>> turtle.sety(-10)
>>> turtle.position()
(0.00,-10.00)
turtle.setheading(to_angle)
turtle.seth(to_angle)
参数：

to_angle – 一个数字（整数或浮点数）

将海龟的方向设置为 to_angle。以下是一些常见的度数方向

标准模式

logo 模式

0 - 东

0 - 北

90 - 北

90 - 东

180 - 西

180 - 南

270 - 南

270 - 西

 
>>> turtle.setheading(90)
>>> turtle.heading()
90.0
turtle.home()

将海龟移动到原点 – 坐标 (0,0) – 并将其朝向设置为其起始方向（这取决于模式，请参阅 mode()）。

>>> turtle.heading()
90.0
>>> turtle.position()
(0.00,-10.00)
>>> turtle.home()
>>> turtle.position()
(0.00,0.00)
>>> turtle.heading()
0.0
turtle.circle(radius, extent=None, steps=None)
参数：

  • radius – 一个数字

  • extent – 一个数字（或 None）

  • steps – 一个整数（或 None）

绘制一个给定 radius 的圆。圆心位于海龟左侧 radius 个单位处；extent – 一个角度 – 确定绘制圆的哪一部分。如果未给出 extent，则绘制整个圆。如果 extent 不是一个完整的圆，则圆弧的一个端点是当前的画笔位置。如果 radius 为正，则按逆时针方向绘制圆弧，否则按顺时针方向绘制。最后，海龟的方向改变 extent 的量。

由于圆是由内接正多边形近似的，因此 steps 确定要使用的步数。如果未给出，则将自动计算。可用于绘制正多边形。

>>> turtle.home()
>>> turtle.position()
(0.00,0.00)
>>> turtle.heading()
0.0
>>> turtle.circle(50)
>>> turtle.position()
(-0.00,0.00)
>>> turtle.heading()
0.0
>>> turtle.circle(120, 180)  # draw a semicircle
>>> turtle.position()
(0.00,240.00)
>>> turtle.heading()
180.0
turtle.dot(size=None, *color)
参数：

  • size – 大于等于 1 的整数（如果给出）

  • color – 颜色字符串或数字颜色元组

使用 color 绘制直径为 size 的圆点。如果未给出 size，则使用 pensize+4 和 2*pensize 中的最大值。

>>> turtle.home()
>>> turtle.dot()
>>> turtle.fd(50); turtle.dot(20, "blue"); turtle.fd(50)
>>> turtle.position()
(100.00,-0.00)
>>> turtle.heading()
0.0
turtle.stamp()

在当前海龟位置，将海龟形状的副本印在画布上。返回该印章的 stamp_id，可以使用该 ID 通过调用 clearstamp(stamp_id) 删除它。

>>> turtle.color("blue")
>>> stamp_id = turtle.stamp()
>>> turtle.fd(50)
turtle.clearstamp(stampid)
参数：

stampid – 整数，必须是之前 stamp() 调用的返回值

删除具有给定 stampid 的印章。

>>> turtle.position()
(150.00,-0.00)
>>> turtle.color("blue")
>>> astamp = turtle.stamp()
>>> turtle.fd(50)
>>> turtle.position()
(200.00,-0.00)
>>> turtle.clearstamp(astamp)
>>> turtle.position()
(200.00,-0.00)
turtle.clearstamps(n=None)
参数：

n – 整数（或 None）

删除所有或第一个/最后 n 个海龟印章。如果 n 为 None，则删除所有印章；如果 n > 0，则删除前 n 个印章；否则，如果 n < 0，则删除最后 n 个印章。

>>> for i in range(8):
...     unused_stamp_id = turtle.stamp()
...     turtle.fd(30)
>>> turtle.clearstamps(2)
>>> turtle.clearstamps(-2)
>>> turtle.clearstamps()
turtle.undo()

撤消（重复）最后的海龟操作。可用撤消操作的数量由撤消缓冲区的大小决定。

>>> for i in range(4):
...     turtle.fd(50); turtle.lt(80)
...
>>> for i in range(8):
...     turtle.undo()
turtle.speed(speed=None)
参数：

speed – 0 到 10 范围内的整数或速度字符串（见下文）

将海龟的速度设置为 0 到 10 范围内的整数值。如果没有给出参数，则返回当前速度。

如果输入的数字大于 10 或小于 0.5，则速度设置为 0。速度字符串映射到速度值，如下所示：

  • “fastest”：0

  • “fast”：10

  • “normal”：6

  • “slow”：3

  • “slowest”：1

速度从 1 到 10，强制执行越来越快的线条绘制和海龟转向动画。

注意：speed = 0 表示*不*进行动画。forward/back 使海龟跳跃，同样 left/right 使海龟立即转向。

>>> turtle.speed()
3
>>> turtle.speed('normal')
>>> turtle.speed()
6
>>> turtle.speed(9)
>>> turtle.speed()
9

告知海龟的状态

turtle.position()
turtle.pos()

返回海龟的当前位置 (x,y)（作为 Vec2D 向量）。

>>> turtle.pos()
(440.00,-0.00)
turtle.towards(x, y=None)
参数：

  • x – 数字或数字对/向量或海龟实例

  • y – 如果 x 是数字，则为数字，否则为 None

返回从海龟位置到 (x,y) 指定的位置、向量或其他海龟的直线之间的角度。这取决于海龟的起始方向，而起始方向又取决于模式 - “standard”/”world” 或 “logo”。

>>> turtle.goto(10, 10)
>>> turtle.towards(0,0)
225.0
turtle.xcor()

返回海龟的 x 坐标。

>>> turtle.home()
>>> turtle.left(50)
>>> turtle.forward(100)
>>> turtle.pos()
(64.28,76.60)
>>> print(round(turtle.xcor(), 5))
64.27876
turtle.ycor()

返回海龟的 y 坐标。

>>> turtle.home()
>>> turtle.left(60)
>>> turtle.forward(100)
>>> print(turtle.pos())
(50.00,86.60)
>>> print(round(turtle.ycor(), 5))
86.60254
turtle.heading()

返回海龟的当前朝向（值取决于海龟模式，请参阅 mode()）。

>>> turtle.home()
>>> turtle.left(67)
>>> turtle.heading()
67.0
turtle.distance(x, y=None)
参数：

  • x – 数字或数字对/向量或海龟实例

  • y – 如果 x 是数字，则为数字，否则为 None

以海龟步长单位返回从海龟到 (x,y)、给定向量或给定其他海龟的距离。

>>> turtle.home()
>>> turtle.distance(30,40)
50.0
>>> turtle.distance((30,40))
50.0
>>> joe = Turtle()
>>> joe.forward(77)
>>> turtle.distance(joe)
77.0

测量设置

turtle.degrees(fullcircle=360.0)
参数：

fullcircle – 数字

设置角度测量单位，即设置整圆的“度数”。默认值为 360 度。

>>> turtle.home()
>>> turtle.left(90)
>>> turtle.heading()
90.0

Change angle measurement unit to grad (also known as gon,
grade, or gradian and equals 1/100-th of the right angle.)
>>> turtle.degrees(400.0)
>>> turtle.heading()
100.0
>>> turtle.degrees(360)
>>> turtle.heading()
90.0
turtle.radians()

将角度测量单位设置为弧度。等效于 degrees(2*math.pi)。

>>> turtle.home()
>>> turtle.left(90)
>>> turtle.heading()
90.0
>>> turtle.radians()
>>> turtle.heading()
1.5707963267948966

画笔控制

绘图状态

turtle.pendown()
turtle.pd()
turtle.down()

放下画笔 - 移动时绘图。

turtle.penup()
turtle.pu()
turtle.up()

抬起画笔 - 移动时不绘图。

turtle.pensize(width=None)
turtle.width(width=None)
参数：

width – 正数

将线条粗细设置为 width 或返回线条粗细。如果 resizemode 设置为“auto”且 turtleshape 为多边形，则使用相同的线条粗细绘制该多边形。如果未给出参数，则返回当前画笔大小。

>>> turtle.pensize()
1
>>> turtle.pensize(10)   # from here on lines of width 10 are drawn
turtle.pen(pen=None, **pendict)
参数：

  • pen – 包含以下部分或全部键的字典

  • pendict – 一个或多个关键字参数，其中包含以下列出的键作为关键字

在包含以下键/值对的“画笔字典”中返回或设置画笔的属性

  • “shown”：True/False

  • “pendown”：True/False

  • “pencolor”：颜色字符串或颜色元组

  • “fillcolor”：颜色字符串或颜色元组

  • “pensize”：正数

  • “speed”：0..10 范围内的数字

  • “resizemode”：“auto”、“user”或“noresize”

  • “stretchfactor”：（正数，正数）

  • “outline”：正数

  • “tilt”：数字

此字典可用作后续调用 pen() 的参数，以恢复之前的画笔状态。此外，还可以将一个或多个属性作为关键字参数提供。这可用于在一个语句中设置多个画笔属性。

>>> turtle.pen(fillcolor="black", pencolor="red", pensize=10)
>>> sorted(turtle.pen().items())
[('fillcolor', 'black'), ('outline', 1), ('pencolor', 'red'),
 ('pendown', True), ('pensize', 10), ('resizemode', 'noresize'),
 ('shearfactor', 0.0), ('shown', True), ('speed', 9),
 ('stretchfactor', (1.0, 1.0)), ('tilt', 0.0)]
>>> penstate=turtle.pen()
>>> turtle.color("yellow", "")
>>> turtle.penup()
>>> sorted(turtle.pen().items())[:3]
[('fillcolor', ''), ('outline', 1), ('pencolor', 'yellow')]
>>> turtle.pen(penstate, fillcolor="green")
>>> sorted(turtle.pen().items())[:3]
[('fillcolor', 'green'), ('outline', 1), ('pencolor', 'red')]
turtle.isdown()

如果画笔落下，则返回 True，如果画笔抬起，则返回 False。

>>> turtle.penup()
>>> turtle.isdown()
False
>>> turtle.pendown()
>>> turtle.isdown()
True

颜色控制

turtle.pencolor(*args)

返回或设置画笔颜色。

允许使用四种输入格式

pencolor()

以颜色规范字符串或元组形式返回当前画笔颜色（参见示例）。可用作其他 color/pencolor/fillcolor 调用的输入。

pencolor(colorstring)

将画笔颜色设置为 colorstring，它是 Tk 颜色规范字符串，例如 "red"、"yellow" 或 "#33cc8c"。

pencolor((r, g, b))

将画笔颜色设置为由 r、g 和 b 元组表示的 RGB 颜色。r、g 和 b 中的每一个都必须在 0..colormode 范围内，其中 colormode 为 1.0 或 255（参见 colormode()）。

pencolor(r, g, b)

将画笔颜色设置为由 r、g 和 b 表示的 RGB 颜色。r、g 和 b 中的每一个都必须在 0..colormode 范围内。

如果 turtleshape 是多边形，则使用新设置的画笔颜色绘制该多边形的轮廓。

>>> colormode()
1.0
>>> turtle.pencolor()
'red'
>>> turtle.pencolor("brown")
>>> turtle.pencolor()
'brown'
>>> tup = (0.2, 0.8, 0.55)
>>> turtle.pencolor(tup)
>>> turtle.pencolor()
(0.2, 0.8, 0.5490196078431373)
>>> colormode(255)
>>> turtle.pencolor()
(51.0, 204.0, 140.0)
>>> turtle.pencolor('#32c18f')
>>> turtle.pencolor()
(50.0, 193.0, 143.0)
turtle.fillcolor(*args)

返回或设置填充颜色。

允许使用四种输入格式

fillcolor()

以颜色规范字符串形式返回当前填充颜色，可能采用元组格式（参见示例）。可用作其他 color/pencolor/fillcolor 调用的输入。

fillcolor(colorstring)

将填充颜色设置为 colorstring，它是 Tk 颜色规范字符串，例如 "red"、"yellow" 或 "#33cc8c"。

fillcolor((r, g, b))

将填充颜色设置为由 r、g 和 b 元组表示的 RGB 颜色。r、g 和 b 中的每一个都必须在 0..colormode 范围内，其中 colormode 为 1.0 或 255（参见 colormode()）。

fillcolor(r, g, b)

将填充颜色设置为由 r、g 和 b 表示的 RGB 颜色。r、g 和 b 中的每一个都必须在 0..colormode 范围内。

如果 turtleshape 是多边形，则使用新设置的填充颜色绘制该多边形的内部。

>>> turtle.fillcolor("violet")
>>> turtle.fillcolor()
'violet'
>>> turtle.pencolor()
(50.0, 193.0, 143.0)
>>> turtle.fillcolor((50, 193, 143))  # Integers, not floats
>>> turtle.fillcolor()
(50.0, 193.0, 143.0)
>>> turtle.fillcolor('#ffffff')
>>> turtle.fillcolor()
(255.0, 255.0, 255.0)
turtle.color(*args)

返回或设置画笔颜色和填充颜色。

允许使用多种输入格式。它们使用 0 到 3 个参数，如下所示

color()

以一对颜色规范字符串或 pencolor() 和 fillcolor() 返回的元组形式返回当前画笔颜色和当前填充颜色。

color(colorstring), color((r,g,b)), color(r,g,b)

与 pencolor() 中的输入相同，将填充颜色和画笔颜色都设置为给定值。

color(colorstring1, colorstring2), color((r1,g1,b1), (r2,g2,b2))

等效于 pencolor(colorstring1) 和 fillcolor(colorstring2)，如果使用其他输入格式，则类似。

如果 turtleshape 是多边形，则使用新设置的颜色绘制该多边形的轮廓和内部。

>>> turtle.color("red", "green")
>>> turtle.color()
('red', 'green')
>>> color("#285078", "#a0c8f0")
>>> color()
((40.0, 80.0, 120.0), (160.0, 200.0, 240.0))

另请参阅：屏幕方法 colormode()。

填充

turtle.filling()

返回填充状态（如果正在填充，则为 True，否则为 False）。

>>> turtle.begin_fill()
>>> if turtle.filling():
...    turtle.pensize(5)
... else:
...    turtle.pensize(3)
turtle.begin_fill()

在绘制要填充的形状之前调用。

turtle.end_fill()

填充上次调用 begin_fill() 后绘制的形状。

自相交多边形或多个形状的重叠区域是否填充取决于操作系统图形、重叠类型和重叠次数。例如，上面的 Turtle 星星可能全部为黄色，也可能包含一些白色区域。

>>> turtle.color("black", "red")
>>> turtle.begin_fill()
>>> turtle.circle(80)
>>> turtle.end_fill()

更多绘图控制

turtle.reset()

从屏幕中删除 turtle 的绘图，将 turtle 重新居中，并将变量设置为默认值。

>>> turtle.goto(0,-22)
>>> turtle.left(100)
>>> turtle.position()
(0.00,-22.00)
>>> turtle.heading()
100.0
>>> turtle.reset()
>>> turtle.position()
(0.00,0.00)
>>> turtle.heading()
0.0
turtle.clear()

从屏幕中删除 turtle 的绘图。不要移动 turtle。turtle 的状态和位置以及其他 turtle 的绘图不受影响。

turtle.write(arg, move=False, align='left', font=('Arial', 8, 'normal'))
参数：

  • arg – 要写入 TurtleScreen 的对象

  • move – True/False

  • align – 字符串 “left”、“center” 或 “right” 之一

  • font – 三元组 (fontname, fontsize, fonttype)

写入文本 - arg 的字符串表示形式 - 根据 align（“left”，“center” 或 “right”）在当前海龟位置使用给定字体。如果 move 为 true，则将笔移动到文本的右下角。默认情况下，move 为 False。

>>> turtle.write("Home = ", True, align="center")
>>> turtle.write((0,0), True)

海龟状态

可见性

turtle.hideturtle()
turtle.ht()

使海龟不可见。在进行一些复杂的绘图时，最好这样做，因为隐藏海龟可以明显加快绘图速度。

>>> turtle.hideturtle()
turtle.showturtle()
turtle.st()

使海龟可见。

>>> turtle.showturtle()
turtle.isvisible()

如果显示海龟，则返回 True，如果隐藏海龟，则返回 False。

>>> turtle.hideturtle()
>>> turtle.isvisible()
False
>>> turtle.showturtle()
>>> turtle.isvisible()
True

外观

turtle.shape(name=None)
参数：

name – 一个字符串，它是有效的形状名称

将海龟形状设置为具有给定 name 的形状，或者，如果没有给出名称，则返回当前形状的名称。具有 name 的形状必须存在于 TurtleScreen 的形状字典中。最初有以下多边形形状：“arrow”、“turtle”、“circle”、“square”、“triangle”、“classic”。要了解如何处理形状，请参阅屏幕方法 register_shape()。

>>> turtle.shape()
'classic'
>>> turtle.shape("turtle")
>>> turtle.shape()
'turtle'
turtle.resizemode(rmode=None)
参数：

rmode – 字符串 “auto”、“user”、“noresize” 之一

将 resizemode 设置为以下值之一：“auto”、“user”、“noresize”。如果没有给出 rmode，则返回当前的 resizemode。不同的 resizemode 具有以下效果

  • “auto”：根据 pensize 的值调整海龟的外观。

  • “user”：根据 stretchfactor 和 outlinewidth（轮廓）的值调整海龟的外观，这些值由 shapesize() 设置。

  • “noresize”：不调整海龟的外观。

当 shapesize() 与参数一起使用时，将调用 resizemode("user")。

>>> turtle.resizemode()
'noresize'
>>> turtle.resizemode("auto")
>>> turtle.resizemode()
'auto'
turtle.shapesize(stretch_wid=None, stretch_len=None, outline=None)
turtle.turtlesize(stretch_wid=None, stretch_len=None, outline=None)
参数：

  • stretch_wid – 正数

  • stretch_len – 正数

  • outline – 正数

返回或设置笔的属性 x/y 拉伸因子和/或轮廓。将 resizemode 设置为 “user”。当且仅当 resizemode 设置为 “user” 时，海龟才会根据其拉伸因子进行拉伸显示：stretch_wid 是垂直于其方向的拉伸因子，stretch_len 是沿其方向的拉伸因子，outline 确定形状轮廓的宽度。

>>> turtle.shapesize()
(1.0, 1.0, 1)
>>> turtle.resizemode("user")
>>> turtle.shapesize(5, 5, 12)
>>> turtle.shapesize()
(5, 5, 12)
>>> turtle.shapesize(outline=8)
>>> turtle.shapesize()
(5, 5, 8)
turtle.shearfactor(shear=None)
参数：

shear – 数字（可选）

设置或返回当前的剪切因子。根据给定的剪切因子 shear 对 turtleshape 进行剪切，剪切因子是剪切角的正切。不要更改海龟的朝向（移动方向）。如果没有给出 shear：返回当前的剪切因子，即与海龟朝向平行的线被剪切的剪切角的正切。

>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.shearfactor(0.5)
>>> turtle.shearfactor()
0.5
turtle.tilt(angle)
参数：

angle – 数字

将 turtleshape 从其当前倾斜角旋转 angle，但不要更改海龟的朝向（移动方向）。

>>> turtle.reset()
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.tilt(30)
>>> turtle.fd(50)
>>> turtle.tilt(30)
>>> turtle.fd(50)
turtle.settiltangle(angle)
参数：

angle – 数字

旋转 turtleshape 以指向 angle 指定的方向，而不管其当前的倾斜角。不要更改海龟的朝向（移动方向）。

>>> turtle.reset()
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.settiltangle(45)
>>> turtle.fd(50)
>>> turtle.settiltangle(-45)
>>> turtle.fd(50)

自 3.1 版起弃用。

turtle.tiltangle(angle=None)
参数：

angle – 数字（可选）

设置或返回当前的倾斜角。如果给出了 angle，则旋转 turtleshape 以指向 angle 指定的方向，而不管其当前的倾斜角。不要更改海龟的朝向（移动方向）。如果没有给出 angle：返回当前的倾斜角，即 turtleshape 的方向与海龟的朝向（其移动方向）之间的角度。

>>> turtle.reset()
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.tilt(45)
>>> turtle.tiltangle()
45.0
turtle.shapetransform(t11=None, t12=None, t21=None, t22=None)
参数：

  • t11 – 数字（可选）

  • t12 – 数字（可选）

  • t21 – 数字（可选）

  • t12 – 数字（可选）

设置或返回海龟形状的当前变换矩阵。

如果没有给出任何矩阵元素，则返回一个包含 4 个元素的元组作为变换矩阵。否则，设置给定的元素，并根据由第一行 t11、t12 和第二行 t21、t22 组成的矩阵变换海龟形状。行列式 t11 * t22 - t12 * t21 不能为零，否则会引发错误。根据给定的矩阵修改拉伸因子、剪切因子和倾斜角度。

>>> turtle = Turtle()
>>> turtle.shape("square")
>>> turtle.shapesize(4,2)
>>> turtle.shearfactor(-0.5)
>>> turtle.shapetransform()
(4.0, -1.0, -0.0, 2.0)
turtle.get_shapepoly()

以坐标对元组的形式返回当前形状多边形。这可用于定义新形状或复合形状的组成部分。

>>> turtle.shape("square")
>>> turtle.shapetransform(4, -1, 0, 2)
>>> turtle.get_shapepoly()
((50, -20), (30, 20), (-50, 20), (-30, -20))

使用事件

turtle.onclick(fun, btn=1, add=None)
参数：

  • fun – 一个有两个参数的函数，它将使用画布上点击点的坐标进行调用

  • btn – 鼠标按钮的编号，默认为 1（鼠标左键）

  • add – True 或 False – 如果为 True，则添加新的绑定，否则将替换以前的绑定

将 fun 绑定到此海龟上的鼠标点击事件。如果 fun 为 None，则删除现有绑定。匿名海龟的示例，即过程方式

>>> def turn(x, y):
...     left(180)
...
>>> onclick(turn)  # Now clicking into the turtle will turn it.
>>> onclick(None)  # event-binding will be removed
turtle.onrelease(fun, btn=1, add=None)
参数：

  • fun – 一个有两个参数的函数，它将使用画布上点击点的坐标进行调用

  • btn – 鼠标按钮的编号，默认为 1（鼠标左键）

  • add – True 或 False – 如果为 True，则添加新的绑定，否则将替换以前的绑定

将 fun 绑定到此海龟上的鼠标按钮释放事件。如果 fun 为 None，则删除现有绑定。

>>> class MyTurtle(Turtle):
...     def glow(self,x,y):
...         self.fillcolor("red")
...     def unglow(self,x,y):
...         self.fillcolor("")
...
>>> turtle = MyTurtle()
>>> turtle.onclick(turtle.glow)     # clicking on turtle turns fillcolor red,
>>> turtle.onrelease(turtle.unglow) # releasing turns it to transparent.
turtle.ondrag(fun, btn=1, add=None)
参数：

  • fun – 一个有两个参数的函数，它将使用画布上点击点的坐标进行调用

  • btn – 鼠标按钮的编号，默认为 1（鼠标左键）

  • add – True 或 False – 如果为 True，则添加新的绑定，否则将替换以前的绑定

将 fun 绑定到此海龟上的鼠标移动事件。如果 fun 为 None，则删除现有绑定。

备注：海龟上的每个鼠标移动事件序列之前都会有一个该海龟上的鼠标点击事件。

>>> turtle.ondrag(turtle.goto)

随后，点击并拖动海龟将在屏幕上移动它，从而产生手绘图（如果画笔已落下）。

特殊的海龟方法

turtle.begin_poly()

开始记录多边形的顶点。当前海龟位置是多边形的第一个顶点。

turtle.end_poly()

停止记录多边形的顶点。当前海龟位置是多边形的最后一个顶点。这将与第一个顶点相连。

turtle.get_poly()

返回最后记录的多边形。

>>> turtle.home()
>>> turtle.begin_poly()
>>> turtle.fd(100)
>>> turtle.left(20)
>>> turtle.fd(30)
>>> turtle.left(60)
>>> turtle.fd(50)
>>> turtle.end_poly()
>>> p = turtle.get_poly()
>>> register_shape("myFavouriteShape", p)
turtle.clone()

创建并返回具有相同位置、朝向和海龟属性的海龟的克隆。

>>> mick = Turtle()
>>> joe = mick.clone()
turtle.getturtle()
turtle.getpen()

返回海龟对象本身。唯一合理的用途：作为返回“匿名海龟”的函数

>>> pet = getturtle()
>>> pet.fd(50)
>>> pet
<turtle.Turtle object at 0x...>
turtle.getscreen()

返回海龟正在绘制的 TurtleScreen 对象。然后可以为该对象调用 TurtleScreen 方法。

>>> ts = turtle.getscreen()
>>> ts
<turtle._Screen object at 0x...>
>>> ts.bgcolor("pink")
turtle.setundobuffer(size)
参数：

size – 整数或 None

设置或禁用撤消缓冲区。如果 size 是整数，则安装给定大小的空撤消缓冲区。size 给出了可以通过 undo() 方法/函数撤消的海龟操作的最大数量。如果 size 为 None，则禁用撤消缓冲区。

>>> turtle.setundobuffer(42)
turtle.undobufferentries()

返回撤消缓冲区中的条目数。

>>> while undobufferentries():
...     undo()

复合形状

要使用由多个不同颜色的多边形组成的复合海龟形状，您必须按照以下说明明确使用辅助类 Shape

  1. 创建一个类型为“复合”的空 Shape 对象。

  2. 使用 addcomponent() 方法向此对象添加任意数量的组件。

    例如

    >>> s = Shape("compound")
>>> poly1 = ((0,0),(10,-5),(0,10),(-10,-5))
>>> s.addcomponent(poly1, "red", "blue")
>>> poly2 = ((0,0),(10,-5),(-10,-5))
>>> s.addcomponent(poly2, "blue", "red")

  3. 现在将形状添加到屏幕的形状列表中并使用它

    >>> register_shape("myshape", s)
>>> shape("myshape")

注意

register_shape() 方法以不同的方式在内部使用 Shape 类。应用程序员仅在使用如上所示的复合形状时才需要处理 Shape 类！

TurtleScreen/Screen 的方法和相应的函数

本节中的大多数示例都引用了一个名为 screen 的 TurtleScreen 实例。

窗口控制

turtle.bgcolor(*args)
参数：

args – 颜色字符串或 0..colormode 范围内的三个数字，或此类数字的 3 元组

设置或返回 TurtleScreen 的背景颜色。

>>> screen.bgcolor("orange")
>>> screen.bgcolor()
'orange'
>>> screen.bgcolor("#800080")
>>> screen.bgcolor()
(128.0, 0.0, 128.0)
turtle.bgpic(picname=None)
参数：

picname – 字符串，gif 文件名或 "nopic"，或 None

设置背景图片或返回当前背景图片的名称。如果 picname 是文件名，则将相应的图像设置为背景。如果 picname 是 "nopic"，则删除背景图像（如果存在）。如果 picname 是 None，则返回当前背景图像的文件名。

>>> screen.bgpic()
'nopic'
>>> screen.bgpic("landscape.gif")
>>> screen.bgpic()
"landscape.gif"
turtle.clear()

注意

此 TurtleScreen 方法仅在名称 clearscreen 下作为全局函数可用。全局函数 clear 是从 Turtle 方法 clear 派生的另一个函数。

turtle.clearscreen()

从 TurtleScreen 中删除所有绘图和所有海龟。将现在为空的 TurtleScreen 重置为其初始状态：白色背景，无背景图像，无事件绑定且跟踪打开。

turtle.reset()

注意

此 TurtleScreen 方法仅在名称 resetscreen 下作为全局函数可用。全局函数 reset 是从 Turtle 方法 reset 派生的另一个函数。

turtle.resetscreen()

将屏幕上的所有海龟重置为其初始状态。

turtle.screensize(canvwidth=None, canvheight=None, bg=None)
参数：

  • canvwidth – 正整数，画布的新宽度（以像素为单位）

  • canvheight – 正整数，画布的新高度（以像素为单位）

  • bg – 颜色字符串或颜色元组，新的背景颜色

如果没有给出参数，则返回当前的 (canvaswidth, canvasheight)。否则，调整海龟绘制的画布的大小。不要更改绘图窗口。要观察画布的隐藏部分，请使用滚动条。使用此方法，可以使以前位于画布外部的绘图部分可见。

>>> screen.screensize()
(400, 300)
>>> screen.screensize(2000,1500)
>>> screen.screensize()
(2000, 1500)

例如，为了搜索错误地逃逸的海龟 ;-)

turtle.setworldcoordinates(llx, lly, urx, ury)
参数：

  • llx – 数字，画布左下角的 x 坐标

  • lly – 数字，画布左下角的 y 坐标

  • urx – 数字，画布右上角的 x 坐标

  • ury – 数字，画布右上角的 y 坐标

设置用户定义的坐标系，并在必要时切换到“世界”模式。这将执行 screen.reset()。如果“世界”模式已经处于活动状态，则根据新坐标重新绘制所有图形。

注意：在用户定义的坐标系中，角度可能会出现扭曲。

>>> screen.reset()
>>> screen.setworldcoordinates(-50,-7.5,50,7.5)
>>> for _ in range(72):
...     left(10)
...
>>> for _ in range(8):
...     left(45); fd(2)   # a regular octagon

动画控制

turtle.delay(delay=None)
参数：

delay – 正整数

设置或返回以毫秒为单位的绘图 delay。（这大约是两个连续画布更新之间的时间间隔。）绘图延迟越长，动画越慢。

可选参数

>>> screen.delay()
10
>>> screen.delay(5)
>>> screen.delay()
5
turtle.tracer(n=None, delay=None)
参数：

  • n – 非负整数

  • delay – 非负整数

打开/关闭海龟动画并设置更新绘图的延迟。如果给定了 n，则仅实际执行每 n 次常规屏幕更新。（可用于加速复杂图形的绘制。）在不带参数的情况下调用时，返回当前存储的 n 值。第二个参数设置延迟值（请参阅 delay()）。

>>> screen.tracer(8, 25)
>>> dist = 2
>>> for i in range(200):
...     fd(dist)
...     rt(90)
...     dist += 2
turtle.update()

执行 TurtleScreen 更新。要在关闭跟踪器时使用。

另请参阅 RawTurtle/Turtle 方法 speed()。

使用屏幕事件

turtle.listen(xdummy=None, ydummy=None)

在 TurtleScreen 上设置焦点（以便收集按键事件）。提供虚拟参数是为了能够将 listen() 传递给 onclick 方法。

turtle.onkey(fun, key)
turtle.onkeyrelease(fun, key)
参数：

  • fun – 没有参数的函数或 None

  • key – 字符串：键（例如“a”）或键符号（例如“space”）

将 fun 绑定到 key 的按键释放事件。如果 fun 是 None，则删除事件绑定。备注：为了能够注册按键事件，TurtleScreen 必须具有焦点。（请参阅方法 listen()。）

>>> def f():
...     fd(50)
...     lt(60)
...
>>> screen.onkey(f, "Up")
>>> screen.listen()
turtle.onkeypress(fun, key=None)
参数：

  • fun – 没有参数的函数或 None

  • key – 字符串：键（例如“a”）或键符号（例如“space”）

如果给定了 key，则将 fun 绑定到 key 的按键事件；如果没有给定 key，则绑定到任何按键事件。备注：为了能够注册按键事件，TurtleScreen 必须具有焦点。（请参阅方法 listen()。）

>>> def f():
...     fd(50)
...
>>> screen.onkey(f, "Up")
>>> screen.listen()
turtle.onclick(fun, btn=1, add=None)
turtle.onscreenclick(fun, btn=1, add=None)
参数：

  • fun – 一个有两个参数的函数，它将使用画布上点击点的坐标进行调用

  • btn – 鼠标按钮的编号，默认为 1（鼠标左键）

  • add – True 或 False – 如果为 True，则添加新的绑定，否则将替换以前的绑定

将 fun 绑定到此屏幕上的鼠标点击事件。如果 fun 是 None，则删除现有绑定。

名为 screen 的 TurtleScreen 实例和名为 turtle 的 Turtle 实例的示例

>>> screen.onclick(turtle.goto) # Subsequently clicking into the TurtleScreen will
>>>                             # make the turtle move to the clicked point.
>>> screen.onclick(None)        # remove event binding again

注意

此 TurtleScreen 方法仅以 onscreenclick 的名称作为全局函数提供。全局函数 onclick 是从 Turtle 方法 onclick 派生的另一个函数。

turtle.ontimer(fun, t=0)
参数：

  • fun – 无参数的函数

  • t – 一个数字 >= 0

安装一个计时器，该计时器在 t 毫秒后调用 fun。

>>> running = True
>>> def f():
...     if running:
...         fd(50)
...         lt(60)
...         screen.ontimer(f, 250)
>>> f()   ### makes the turtle march around
>>> running = False
turtle.mainloop()
turtle.done()

启动事件循环 - 调用 Tkinter 的 mainloop 函数。必须是 turtle 图形程序中的最后一条语句。如果在 -n 模式（无子进程）下从 IDLE 中运行脚本，则*不得*使用 - 用于 turtle 图形的交互式使用。

>>> screen.mainloop()

输入方法

turtle.textinput(title, prompt)
参数：

  • title – 字符串

  • prompt – 字符串

弹出一个对话框窗口，用于输入字符串。参数 title 是对话框窗口的标题，prompt 是主要描述要输入哪些信息的文本。返回输入的字符串。如果对话框被取消，则返回 None。

>>> screen.textinput("NIM", "Name of first player:")
turtle.numinput(title, prompt, default=None, minval=None, maxval=None)
参数：

  • title – 字符串

  • prompt – 字符串

  • default – 数字（可选）

  • minval – 数字（可选）

  • maxval – 数字（可选）

弹出一个对话框窗口，用于输入数字。title 是对话框窗口的标题，prompt 是主要描述要输入哪些数字信息的文本。default：默认值，minval：输入的最小值，maxval：输入的最大值。如果给出了 minval 和 maxval，则输入的数字必须在 minval .. maxval 范围内。如果没有给出，则会发出提示，并且对话框保持打开状态以供更正。返回输入的数字。如果对话框被取消，则返回 None。

>>> screen.numinput("Poker", "Your stakes:", 1000, minval=10, maxval=10000)

设置和特殊方法

turtle.mode(mode=None)
参数：

mode – 字符串 “standard”、“logo” 或 “world” 之一

设置 turtle 模式（“standard”、“logo” 或 “world”）并执行重置。如果没有给出 mode，则返回当前模式。

模式 “standard” 与旧的 turtle 兼容。模式 “logo” 与大多数 Logo turtle 图形兼容。模式 “world” 使用用户定义的“世界坐标”。**注意**：在此模式下，如果 x/y 单位比率不等于 1，则角度会显得失真。

模式

初始 turtle 朝向

正角度

“standard”

向右（东）

逆时针

“logo”

向上（北）

顺时针

 
>>> mode("logo")   # resets turtle heading to north
>>> mode()
'logo'
turtle.colormode(cmode=None)
参数：

cmode – 值 1.0 或 255 之一

返回颜色模式或将其设置为 1.0 或 255。随后，颜色三元组的 r、g、b 值必须在 0..*cmode* 范围内。

>>> screen.colormode(1)
>>> turtle.pencolor(240, 160, 80)
Traceback (most recent call last):
     ...
TurtleGraphicsError: bad color sequence: (240, 160, 80)
>>> screen.colormode()
1.0
>>> screen.colormode(255)
>>> screen.colormode()
255
>>> turtle.pencolor(240,160,80)
turtle.getcanvas()

返回此 TurtleScreen 的 Canvas。对于知道如何处理 Tkinter Canvas 的内部人员很有用。

>>> cv = screen.getcanvas()
>>> cv
<turtle.ScrolledCanvas object ...>
turtle.getshapes()

返回当前可用的所有 turtle 形状的名称列表。

>>> screen.getshapes()
['arrow', 'blank', 'circle', ..., 'turtle']
turtle.register_shape(name, shape=None)
turtle.addshape(name, shape=None)

有三种不同的方法可以调用此函数

  1. name 是 gif 文件的名称，shape 是 None：安装相应的图像形状。

    >>> screen.register_shape("turtle.gif")

    注意

    图像形状在旋转 turtle 时*不会*旋转，因此它们不会显示 turtle 的朝向！

  2. name 是一个任意字符串，shape 是一个坐标对元组：安装相应的形状。

    >>> screen.register_shape("triangle", ((5,-3), (0,5), (-5,-3)))

  3. name 是一个任意字符串，shape 是一个（复合）Shape 对象：安装相应的复合形状。

将乌龟形状添加到 TurtleScreen 的形状列表中。只有这样注册的形状才能通过发出命令 shape(shapename) 来使用。

turtle.turtles()

返回屏幕上的乌龟列表。

>>> for turtle in screen.turtles():
...     turtle.color("red")
turtle.window_height()

返回乌龟窗口的高度。

>>> screen.window_height()
480
turtle.window_width()

返回乌龟窗口的宽度。

>>> screen.window_width()
640

Screen 特有的方法，并非从 TurtleScreen 继承

turtle.bye()

关闭乌龟图形窗口。

turtle.exitonclick()

将 bye() 方法绑定到屏幕上的鼠标点击。

如果配置字典中的值“using_IDLE”为 False（默认值），则还会进入主循环。备注：如果使用带有 -n 开关（无子进程）的 IDLE，则应在 turtle.cfg 中将此值设置为 True。在这种情况下，IDLE 自身的主循环对客户端脚本也是活动的。

turtle.setup(width=_CFG['width'], height=_CFG['height'], startx=_CFG['leftright'], starty=_CFG['topbottom'])

设置主窗口的大小和位置。参数的默认值存储在配置字典中，可以通过 turtle.cfg 文件进行更改。

参数：

  • width – 如果是整数，则表示像素大小；如果是浮点数，则表示屏幕的比例；默认值为屏幕的 50%

  • height – 如果是整数，则表示像素高度；如果是浮点数，则表示屏幕的比例；默认值为屏幕的 75%

  • startx – 如果为正数，则表示距屏幕左边缘的起始位置（以像素为单位）；如果为负数，则表示距屏幕右边缘的起始位置；如果为 None，则表示水平居中窗口

  • starty – 如果为正数，则表示距屏幕上边缘的起始位置（以像素为单位）；如果为负数，则表示距屏幕下边缘的起始位置；如果为 None，则表示垂直居中窗口

>>> screen.setup (width=200, height=200, startx=0, starty=0)
>>>              # sets window to 200x200 pixels, in upper left of screen
>>> screen.setup(width=.75, height=0.5, startx=None, starty=None)
>>>              # sets window to 75% of screen by 50% of screen and centers
turtle.title(titlestring)
参数：

titlestring – 在乌龟图形窗口的标题栏中显示的字符串

将乌龟窗口的标题设置为 titlestring。

>>> screen.title("Welcome to the turtle zoo!")

公共类

class turtle.RawTurtle(canvas)
class turtle.RawPen(canvas)
参数：

canvas – 一个 tkinter.Canvas、一个 ScrolledCanvas 或一个 TurtleScreen

创建一个乌龟。该乌龟具有上述所有描述为“Turtle/RawTurtle 的方法”的方法。

class turtle.Turtle

RawTurtle 的子类，具有相同的接口，但在需要时自动创建的默认 Screen 对象上绘图。

class turtle.TurtleScreen(cv)
参数：

cv – 一个 tkinter.Canvas

提供面向屏幕的方法，例如上述的 bgcolor() 等。

class turtle.Screen

TurtleScreen 的子类，添加了四种方法。

class turtle.ScrolledCanvas(master)
参数：

master – 一些包含 ScrolledCanvas 的 Tkinter 小部件，即添加了滚动条的 Tkinter 画布

由 Screen 类使用，该类自动提供一个 ScrolledCanvas 作为乌龟的游乐场。

class turtle.Shape(type_, data)
参数：

type_ – 字符串“polygon”、“image”、“compound”之一

对形状进行建模的数据结构。对 (type_, data) 必须遵循以下规范

type_

data

“polygon”

多边形元组，即坐标对的元组

“image”

图像（此形式仅在内部使用！）

“compound”

None（必须使用 addcomponent() 方法构造复合形状）
addcomponent(poly, fill, outline=None)
参数：

  • poly – 多边形，即数字对的元组

  • fill – poly 将填充的颜色

  • outline – poly 轮廓的颜色（如果给出）

示例

>>> poly = ((0,0),(10,-5),(0,10),(-10,-5))
>>> s = Shape("compound")
>>> s.addcomponent(poly, "red", "blue")
>>> # ... add more components and then use register_shape()

请参阅 复合形状。

class turtle.Vec2D(x, y)

二维向量类，用作实现海龟图形的辅助类。 也许对海龟图形程序也很有用。 从元组派生，所以向量是一个元组！

提供（对于 a、b 向量，k 数字）

  • a + b 向量加法

  • a - b 向量减法

  • a * b 内积

  • k * a 和 a * k 与标量的乘法

  • abs(a) a 的绝对值

  • a.rotate(angle) 旋转

说明

海龟对象在屏幕对象上绘制，并且海龟面向对象接口中有许多关键类可用于创建它们并将它们彼此关联。

如果 Screen 实例尚不存在，则 Turtle 实例将自动创建一个。

Turtle 是 RawTurtle 的子类，它*不会*自动创建绘图表面 - 需要为其提供或创建*画布*。 *画布*可以是 tkinter.Canvas、ScrolledCanvas 或 TurtleScreen。

TurtleScreen 是海龟的基本绘图表面。 Screen 是 TurtleScreen 的子类，并且包含 一些额外的方法 来管理其外观（包括大小和标题）和行为。 TurtleScreen 的构造函数需要一个 tkinter.Canvas 或一个 ScrolledCanvas 作为参数。

海龟图形的函数式接口使用 Turtle 和 TurtleScreen/Screen 的各种方法。 在幕后，只要调用从 Screen 方法派生的函数，就会自动创建一个屏幕对象。 同样，只要调用从 Turtle 方法派生的任何函数，就会自动创建一个海龟对象。

要在屏幕上使用多个海龟，必须使用面向对象的接口。

帮助和配置

如何使用帮助

Screen 和 Turtle 类的公共方法通过文档字符串进行了广泛的记录。 因此，这些可以通过 Python 帮助工具用作在线帮助

  • 使用 IDLE 时，工具提示会显示输入的函数/方法调用的文档字符串的签名和第一行。

  • 对方法或函数调用 help() 会显示文档字符串

    >>> help(Screen.bgcolor)
Help on method bgcolor in module turtle:

bgcolor(self, *args) unbound turtle.Screen method
    Set or return backgroundcolor of the TurtleScreen.

    Arguments (if given): a color string or three numbers
    in the range 0..colormode or a 3-tuple of such numbers.


    >>> screen.bgcolor("orange")
    >>> screen.bgcolor()
    "orange"
    >>> screen.bgcolor(0.5,0,0.5)
    >>> screen.bgcolor()
    "#800080"

>>> help(Turtle.penup)
Help on method penup in module turtle:

penup(self) unbound turtle.Turtle method
    Pull the pen up -- no drawing when moving.

    Aliases: penup | pu | up

    No argument

    >>> turtle.penup()

  • 从方法派生的函数的文档字符串具有修改后的形式

    >>> help(bgcolor)
Help on function bgcolor in module turtle:

bgcolor(*args)
    Set or return backgroundcolor of the TurtleScreen.

    Arguments (if given): a color string or three numbers
    in the range 0..colormode or a 3-tuple of such numbers.

    Example::

      >>> bgcolor("orange")
      >>> bgcolor()
      "orange"
      >>> bgcolor(0.5,0,0.5)
      >>> bgcolor()
      "#800080"

>>> help(penup)
Help on function penup in module turtle:

penup()
    Pull the pen up -- no drawing when moving.

    Aliases: penup | pu | up

    No argument

    Example:
    >>> penup()

这些修改后的文档字符串是在导入时与从方法派生的函数定义一起自动创建的。

将文档字符串翻译成不同的语言

有一个实用程序可以创建一个字典，其键是方法名称，其值是 Screen 和 Turtle 类的公共方法的文档字符串。

turtle.write_docstringdict(filename='turtle_docstringdict')
参数：

filename – 字符串，用作文件名

创建文档字符串字典并将其写入具有给定文件名的 Python 脚本。 必须显式调用此函数（海龟图形类不使用它）。 文档字符串字典将被写入 Python 脚本 filename.py。 它旨在作为将文档字符串翻译成不同语言的模板。

如果您（或您的学生）想使用您的母语在线帮助使用 turtle，您必须翻译文档字符串并将结果文件另存为例如 turtle_docstringdict_german.py。

如果您的 turtle.cfg 文件中有相应的条目，则此字典将在导入时读入并替换原始的英文文档字符串。

在撰写本文时，有德语和意大利语的文档字符串字典。 （请发送请求至 glingl@aon.at。）

如何配置屏幕和海龟

内置的默认配置模仿了旧的海龟模块的外观和行为，以便与其保持最佳兼容性。

如果您想使用更好地反映此模块的功能或更适合您的需求的不同配置，例如在课堂上使用，您可以准备一个配置文件 turtle.cfg，该文件将在导入时读取并根据其设置修改配置。

内置配置对应于以下 turtle.cfg

width = 0.5
height = 0.75
leftright = None
topbottom = None
canvwidth = 400
canvheight = 300
mode = standard
colormode = 1.0
delay = 10
undobuffersize = 1000
shape = classic
pencolor = black
fillcolor = black
resizemode = noresize
visible = True
language = english
exampleturtle = turtle
examplescreen = screen
title = Python Turtle Graphics
using_IDLE = False

选定条目的简要说明

  • 前四行对应于 Screen.setup 方法的参数。

  • 第 5 行和第 6 行对应于方法 Screen.screensize 的参数。

  • shape 可以是任何内置形状，例如：arrow、turtle 等。有关更多信息，请尝试 help(shape)。

  • 如果要使用无填充颜色（即使乌龟透明），则必须编写 fillcolor = ""（但所有非空字符串在 cfg 文件中都不能包含引号）。

  • 如果要反映乌龟的状态，则必须使用 resizemode = auto。

  • 如果设置例如 language = italian，则文档字符串字典 turtle_docstringdict_italian.py 将在导入时加载（如果存在于导入路径上，例如与 turtle 相同的目录中）。

  • 条目 *exampleturtle* 和 *examplescreen* 定义了这些对象在文档字符串中出现的名称。将方法文档字符串转换为函数文档字符串将从文档字符串中删除这些名称。

  • using_IDLE：如果您经常使用 IDLE 及其 -n 开关（“无子进程”），请将其设置为 True。这将阻止 exitonclick() 进入主循环。

在存储 turtle 的目录中可以有一个 turtle.cfg 文件，在当前工作目录中可以有另一个。后者将覆盖前者的设置。

Lib/turtledemo 目录包含一个 turtle.cfg 文件。您可以将其作为示例进行研究，并在运行演示时查看其效果（最好不要从演示查看器中运行）。

turtledemo — 演示脚本

turtledemo 软件包包含一组演示脚本。可以使用提供的演示查看器运行和查看这些脚本，如下所示

python -m turtledemo

或者，您可以单独运行演示脚本。例如，

python -m turtledemo.bytedesign

turtledemo 软件包目录包含

  • 一个演示查看器 __main__.py，可用于查看脚本的源代码并同时运行它们。

  • 多个脚本演示了 turtle 模块的不同功能。可以通过“示例”菜单访问示例。它们也可以独立运行。

  • 一个 turtle.cfg 文件，作为如何编写和使用此类文件的示例。

演示脚本是

名称

描述

特征

bytedesign

复杂的经典乌龟图形图案

tracer()，延迟，update()

chaos

绘制 Verhulst 动力学图，表明计算机的计算结果有时可能与常识预期相悖

世界坐标

clock

模拟时钟，显示计算机的时间

乌龟作为时钟的指针，ontimer

colormixer

使用 r、g、b 进行实验

ondrag()

forest

3 棵广度优先树

随机化

fractalcurves

希尔伯特和科赫曲线

递归

lindenmayer

民族数学（印度科拉姆）

L 系统

minimal_hanoi

汉诺塔

矩形乌龟作为汉诺塔圆盘（形状，shapesize）

nim

与计算机玩经典的尼姆游戏，使用三堆棍子。

乌龟作为尼姆棍，事件驱动（鼠标，键盘）

paint

超级简约的绘图程序

onclick()

peace

基本

乌龟：外观和动画

penrose

使用风筝和飞镖的非周期性平铺

stamp()

planet_and_moon

引力系统模拟

复合形状，Vec2D

rosette

维基百科关于乌龟图形文章中的图案

clone()，undo()

round_dance

跳舞的乌龟成对反向旋转

复合形状，克隆 shapesize，倾斜，get_shapepoly，更新

sorting_animate

不同排序方法的可视化演示

简单对齐，随机化

tree

（图形）广度优先树（使用生成器）

clone()

two_canvases

简单设计

两个画布上的乌龟

yinyang

另一个基本示例

circle()

祝您玩得开心！

Python 2.6 之后的变化

  • 方法 Turtle.tracer、Turtle.window_width 和 Turtle.window_height 已被删除。具有这些名称和功能的方法现在仅作为 Screen 的方法提供。从这些方法派生的函数仍然可用。（实际上，在 Python 2.6 中，这些方法仅仅是相应 TurtleScreen/Screen 方法的复制品。）

  • 方法 Turtle.fill() 已被删除。begin_fill() 和 end_fill() 的行为略有变化：现在每个填充过程都必须使用 end_fill() 调用来完成。

  • 已添加方法 Turtle.filling。它返回一个布尔值：如果填充过程正在进行中，则返回 True，否则返回 False。此行为对应于 Python 2.6 中不带参数的 fill() 调用。

Python 3.0 之后的变化