`turtle` — 海龟绘图¶

引言¶

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

开始使用¶

想象一只机器海龟从 x-y 平面上的 (0, 0) 开始。在 import turtle 之后，给它命令 turtle.forward(15)，它就会（在屏幕上！）向前移动 15 像素，并沿着它所面向的方向画一条线。给它命令 turtle.right(25)，它就会原地顺时针旋转 25 度。

在 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 * 使用，从而实现这一点。海龟绘图教程涵盖了这种方法。

值得注意的是，许多海龟命令也有更简洁的等价物，例如 forward() 的 fd()。这些在与打字不熟练的学习者一起工作时特别有用。

您需要在系统上安装 Tk 接口包 才能使海龟绘图正常工作。请注意，这并非总是那么简单，因此如果您计划与学习者一起使用海龟绘图，请提前检查。

自动开始和结束填充¶

从 Python 3.14 开始，您可以使用 fill() 上下文管理器，而不是 begin_fill() 和 end_fill() 来自动开始和结束填充。以下是一个示例

with fill():
    for i in range(4):
        forward(100)
        right(90)

forward(200)

上面的代码等价于

begin_fill()
for i in range(4):
    forward(100)
    right(90)
end_fill()

forward(200)

使用 `turtle` 模块命名空间¶

使用 from turtle import * 很方便——但请注意，它会导入大量对象，如果您除了海龟绘图之外还做其他事情，则可能会遇到名称冲突（如果您在导入其他模块的脚本中使用海龟绘图，则此问题会变得更加严重）。

解决方案是使用 import turtle —— fd() 变为 turtle.fd()，width() 变为 turtle.width() 等等。（如果重复输入“turtle”变得很麻烦，可以使用例如 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 是 Screen 的一个实例，一个 Turtle 实例存在于其上；它与海龟一起自动创建。

海龟的屏幕可以定制，例如

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()

fill()

begin_fill()

end_fill()
更多绘图控制: reset()

clear()

write()

海龟状态

可见性: showturtle() | st()

hideturtle() | ht()

isvisible()
外观: shape()

resizemode()

shapesize() | turtlesize()

shearfactor()

tiltangle()

tilt()

shapetransform()

get_shapepoly()

使用事件

onclick()
onrelease()
ondrag()

特殊的海龟方法

poly()
begin_poly()
end_poly()
get_poly()
clone()
getturtle() | getpen()
getscreen()
setundobuffer()
undobufferentries()

TurtleScreen/Screen 的方法¶

窗口控制: bgcolor()

bgpic()

clearscreen()

resetscreen()

screensize()

setworldcoordinates()
动画控制: no_animation()

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()

save()

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()¶

turtle.dot(size)

turtle.dot(color, /)

turtle.dot(size, color, /)

turtle.dot(size, r, g, b, /)

参数:

size – 一个整数 >= 1（如果给定）
color – 一个颜色字符串或一个数字颜色元组

绘制一个直径为 *size*，使用 *color* 的圆形点。如果未给出 *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，可用于通过调用 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 意味着 *没有* 动画发生。向前/向后使海龟跳跃，向左/向右使海龟立即转向。

>>> 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) 指定位置的线、向量或另一只海龟之间的角度。这取决于海龟的起始方向，起始方向又取决于模式——“标准”/“世界”或“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”且海龟形状为多边形，则该多边形将以相同的线条粗细绘制。如果未给出参数，则返回当前 pensize。

>>> 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”: color-string 或 color-tuple
“fillcolor”: color-string 或 color-tuple
“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()¶

turtle.pencolor(color, /)

turtle.pencolor(r, g, b, /)

返回或设置画笔颜色。

允许四种输入格式

pencolor(): 将当前画笔颜色作为颜色规范字符串或元组返回（参见示例）。可用作另一个 color/pencolor/fillcolor/bgcolor 调用的输入。
pencolor(颜色字符串): 将画笔颜色设置为 *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 范围内。

如果海龟形状是一个多边形，则该多边形的轮廓将以新设置的画笔颜色绘制。

>>> 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()¶

turtle.fillcolor(color, /)

turtle.fillcolor(r, g, b, /)

返回或设置填充颜色。

允许四种输入格式

fillcolor(): 将当前填充颜色作为颜色规范字符串返回，可能为元组格式（参见示例）。可用作另一个 color/pencolor/fillcolor/bgcolor 调用的输入。
fillcolor(颜色字符串): 将填充颜色设置为 *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 范围内。

如果海龟形状是一个多边形，则该多边形的内部将以新设置的填充颜色绘制。

>>> 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()¶

turtle.color(color, /)

turtle.color(r, g, b, /)

turtle.color(pencolor, fillcolor, /)

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

允许多种输入格式。它们使用 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)，如果使用其他输入格式则类似。

如果海龟形状是一个多边形，则该多边形的轮廓和内部将以新设置的颜色绘制。

>>> 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.fill()¶

填充在 with turtle.fill(): 块中绘制的形状。

>>> turtle.color("black", "red")
>>> with turtle.fill():
...     turtle.circle(80)

使用 fill() 等价于在填充块之前添加 begin_fill()，在填充块之后添加 end_fill()

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

在 3.14 版本加入。

turtle.begin_fill()¶: 在绘制要填充的形状之前调用。

turtle.end_fill()¶

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

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

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

海龟状态¶

可见性¶

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”。要了解如何处理形状，请参见 Screen 方法 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”：根据画笔大小的值调整海龟的外观。
“user”：根据由 shapesize() 设置的 stretchfactor 和 outlinewidth（轮廓）的值调整海龟的外观。
“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 剪切海龟形状，shear 是剪切角的正切。不*改变*海龟的航向（移动方向）。如果未给出 shear：返回当前的剪切因子，即剪切角的正切，通过该角度，平行于海龟航向的线条被剪切。

>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.shearfactor(0.5)
>>> turtle.shearfactor()
0.5

turtle.tilt(angle)¶

参数:: angle – 一个数字

将海龟形状从其当前倾斜角度旋转 *angle*，但 *不* 改变海龟的方向（移动方向）。

>>> turtle.reset()
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.tilt(30)
>>> turtle.fd(50)
>>> turtle.tilt(30)
>>> turtle.fd(50)

turtle.tiltangle(angle=None)¶

参数:: angle – 一个数字（可选）

设置或返回当前的倾斜角。如果给定了角度，则无论其当前倾斜角如何，都将海龟形状旋转到由角度指定的方向。不*改变*海龟的航向（移动方向）。如果未给出角度：返回当前的倾斜角，即海龟形状方向与海龟航向（其移动方向）之间的角度。

>>> 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 不得为零，否则会引发错误。根据给定矩阵修改 stretchfactor、shearfactor 和 tiltangle。

>>> 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.poly()¶

记录在 with turtle.poly(): 块中绘制的多边形的顶点。第一个和最后一个顶点将连接起来。

>>> with turtle.poly():
...     turtle.forward(100)
...     turtle.right(60)
...     turtle.forward(100)

在 3.14 版本加入。

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()¶

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

>>> 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，如下所述：

创建一个类型为“compound”的空 Shape 对象。

使用 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")

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

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

备注

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

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

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

窗口控制¶

turtle.bgcolor()¶

turtle.bgcolor(color, /)

turtle.bgcolor(r, g, b, /)

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

允许四种输入格式

bgcolor(): 将当前背景颜色作为颜色规范字符串或作为元组返回（参见示例）。可用作另一个 color/pencolor/fillcolor/bgcolor 调用的输入。
bgcolor(colorstring): 将背景颜色设置为 colorstring，这是一个 Tk 颜色规范字符串，例如 "red"、"yellow" 或 "#33cc8c"。
bgcolor((r, g, b)): 将背景颜色设置为由 r、g 和 b 的元组表示的 RGB 颜色。r、g 和 b 中的每一个都必须在 0..colormode 范围内，其中 colormode 是 1.0 或 255（参见 colormode()）。
bgcolor(r, g, b): 将背景颜色设置为由 r、g 和 b 表示的 RGB 颜色。r、g 和 b 中的每一个都必须在 0..colormode 范围内。

>>> screen.bgcolor("orange")
>>> screen.bgcolor()
'orange'
>>> screen.bgcolor("#800080")
>>> screen.bgcolor()
(128.0, 0.0, 128.0)

turtle.bgpic(picname=None)¶

参数:: picname – 一个字符串，图像文件（PNG、GIF、PGM 和 PPM）的名称或 "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.no_animation()¶

暂时禁用乌龟动画。no_animation 块内编写的代码将不会被动画；一旦代码块退出，绘图将出现。

>>> with screen.no_animation():
...     for dist in range(2, 400, 2):
...         fd(dist)
...         rt(90)

在 3.14 版本加入。

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 绑定到按键的松开事件。如果 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，则绑定到任何按键的按下事件。注意：为了能够注册按键事件，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 函数。必须是海龟绘图程序中的最后一条语句。如果脚本在 IDLE 的 -n 模式（无子进程）下运行 - 用于交互式使用海龟绘图，则不得使用此函数。

>>> 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 范围内。如果不是，将发出提示并保持对话框打开以进行更正。返回输入的数字。如果对话框被取消，则返回 None。

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

设置和特殊方法¶

turtle.mode(mode=None)¶

参数:: mode – 字符串之一：“standard”、“logo”或“world”

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

“standard”模式与旧的 turtle 兼容。“logo”模式与大多数 Logo 乌龟图形兼容。“world”模式使用用户定义的“世界坐标”。注意：在此模式下，如果 x/y 单位比率不等于 1，角度可能会出现扭曲。

模式	初始乌龟朝向	正角度
“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()¶

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

>>> screen.getshapes()
['arrow', 'blank', 'circle', ..., 'turtle']

turtle.register_shape(name, shape=None)¶

turtle.addshape(name, shape=None)¶

此函数有四种不同的调用方式：

name 是图像文件（PNG、GIF、PGM 和 PPM）的名称，shape 是 None：安装相应的图像形状。
```
>>> screen.register_shape("turtle.gif")
```
备注

图像形状在乌龟转向时不会旋转，因此它们不会显示乌龟的朝向！
name 是任意字符串，shape 是图像文件（PNG、GIF、PGM 和 PPM）的名称：安装相应的图像形状。
```
>>> screen.register_shape("turtle", "turtle.gif")
```
备注

图像形状在乌龟转向时不会旋转，因此它们不会显示乌龟的朝向！
name 是任意字符串，shape 是坐标对的元组：安装相应的多边形形状。
```
>>> screen.register_shape("triangle", ((5,-3), (0,5), (-5,-3)))
```
name 是任意字符串，shape 是（复合）Shape 对象：安装相应的复合形状。

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

版本 3.14 中已更改: 添加了对 PNG、PGM 和 PPM 图像格式的支持。可以指定形状名称和图像文件名。

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.save(filename, overwrite=False)¶

将当前乌龟绘图（和乌龟）保存为 PostScript 文件。

参数:

filename – 保存的 PostScript 文件的路径
overwrite – 如果为 False 且已存在具有给定文件名的文件，则函数将引发 FileExistsError。如果为 True，则将覆盖文件。

>>> screen.save("my_drawing.ps")
>>> screen.save("my_drawing.ps", overwrite=True)

在 3.14 版本加入。

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_	数据
“polygon”	多边形元组，即坐标对的元组
“image”	图像（此形式仅在内部使用！）
“compound”	`None`（复合形状必须使用 `addcomponent()` 方法构建）

addcomponent(poly, fill, outline=None)¶

参数:

poly – 多边形，即数字对的元组
fill – poly 将填充的颜色
outline – 多边形轮廓的颜色（如果给出）

示例

>>> 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 可以是任何内置形状，例如：箭头、乌龟等。有关更多信息，请尝试 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()`, delay, `update()`
chaos	绘制 Verhulst 动力学，表明计算机的计算有时会产生与常识预期相悖的结果	世界坐标
clock	显示您计算机时间的模拟时钟	乌龟作为时钟指针，ontimer
colormixer	r、g、b 实验	`ondrag()`
forest	3 棵广度优先树	随机化
fractalcurves	Hilbert & Koch 曲线	递归
lindenmayer	民族数学 (印度 kolams)	L-系统
minimal_hanoi	汉诺塔	矩形乌龟作为汉诺盘（形状，形状大小）
nim	与电脑玩经典的尼姆游戏，三堆火柴。	乌龟作为尼姆棒，事件驱动（鼠标，键盘）
paint	超级简约的绘图程序	`onclick()`
peace	基本	乌龟：外观和动画
penrose	用风筝和飞镖进行非周期性平铺	`stamp()`
planet_and_moon	引力系统模拟	复合形状，`Vec2D`
rosette	来自维基百科关于乌龟图形的文章中的图案	`clone()`, `undo()`
round_dance	跳舞的乌龟成对反向旋转	复合形状，克隆形状大小，倾斜，获取形状多边形，更新
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 以来的更改¶

已添加 Turtle 方法 shearfactor()、shapetransform() 和 get_shapepoly()。因此，现在可以使用完整范围的常规线性变换来变换乌龟形状。tiltangle() 的功能已增强：它现在可用于获取或设置倾斜角度。
已添加 Screen 方法 onkeypress() 作为 onkey() 的补充。由于后者将操作绑定到按键释放事件，因此也为其添加了一个别名：onkeyrelease()。
已添加 Screen.mainloop 方法，因此在使用 Screen 和 Turtle 对象时，不再需要使用独立的 mainloop() 函数。
已添加两种输入方法：Screen.textinput 和 Screen.numinput。这些方法会弹出输入对话框，并分别返回字符串和数字。

turtle — 海龟绘图¶

引言¶

开始使用¶

教程¶

启动海龟环境¶

基本绘图¶

笔控制¶

海龟的位置¶

制作算法图案¶

如何……¶

尽快开始¶

自动开始和结束填充¶

使用 turtle 模块命名空间¶

在脚本中使用海龟绘图¶

使用面向对象的海龟绘图¶

海龟绘图参考¶

海龟方法¶

TurtleScreen/Screen 的方法¶

RawTurtle/Turtle 的方法及相应的函数¶

海龟移动¶

告知海龟状态¶

测量设置¶

笔控制¶

绘图状态¶

颜色控制¶

填充¶

更多绘图控制¶

海龟状态¶

可见性¶

外观¶

使用事件¶

特殊海龟方法¶

复合形状¶

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

窗口控制¶

动画控制¶

使用屏幕事件¶

输入方法¶

设置和特殊方法¶

Screen 特有的方法，未从 TurtleScreen 继承¶

公共类¶

解释¶

帮助和配置¶

如何使用帮助¶

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

如何配置屏幕和乌龟¶

turtledemo — 演示脚本¶

自 Python 2.6 以来的更改¶

自 Python 3.0 以来的更改¶

`turtle` — 海龟绘图¶

使用 `turtle` 模块命名空间¶

`turtledemo` — 演示脚本¶