24.1. turtle(乌龟) — Turtle graphics(图形)

源代码： Lib / turtle.py

24.1.1. 简介

乌龟图形是一个不错的方式来为孩子们介绍编程。它是Wally Feurzig和Seymour Papert在1966年开发的原始Logo编程语言的一部分。

想象一只在x-y平面上，从（0,0）开始的海龟机器人。在import turtle之后，输入命令turtle.forward（15），然后它就在屏幕上动起来了！当它移动时会沿着他面向的方向画出一条15像素长的线。输入命令turtle.right(25)，然后它就会原地顺时针转25度。

Turtle star(星)

海龟可以重复简单动作来绘制复杂的图形。

from turtle import *
color('red', 'yellow')
begin_fill()
while True:
    forward(200)
    left(170)
    if abs(pos()) < 1:
        break
end_fill()
done()

通过将这些类似的命令组合在一起，可以很容易地绘制复杂的图形。

turtle模块是Python 2.5标准版以来同名模块的扩展版本。

既保持了原模块的优点，又（几乎）100％兼容旧版。当使用该模块时，在IDLE中使用-n开关能让初学者很容易使用到所含的全部命令，类和交互方法。

turtle模块基本类型同时支持面向对象和面向过程两种方式。由于它使用tkinter作为底层图形算法，所以它需要一个安装了Tk的Python版本支持。

面向对象接口基本上使用两个+两个类：

  1. TurtleScreen类将图形窗口定义为“绘图海龟”的“游乐场”。其构造函数需要tkinter.Canvas或ScrolledCanvas作为参数。当turtle作为某些应用程序的一部分时，应使用此类。

    函数Screen()会返回一个TurtleScreen子类的单例对象。当turtle用作执行图形的独立工具时，应使用此函数。作为单例对象，它的类继承是无效的。

    TurtleScreen / Screen的所有方法也作为函数存在，即作为面向过程的接口的一部分。

  2. RawTurtle（别名：RawPen）定义了在TurtleScreen上绘制的Turtle对象。它的构造函数需要一个Canvas，ScrolledCanvas或者TurtleScreen作为参数，来让RawTurtle对象知道在哪里绘制。

    源自RawTurtle的是子类Turtle（别名：Pen），它使用“Screen实例当下。

    RawTurtle / Turtle的所有方法也作为函数存在，即面向过程的接口的一部分。

过程接口提供从类Screen和Turtle的方法派生的函数。它们具有与相应方法相同的名称。每当调用从Screen方法派生的函数时，将自动创建Screen对象。每当调用来自Turtle方法的任何函数时，将自动创建一个（未命名的）turtle对象。

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

注意

在下面的文档中给出了函数的参数列表。当然，方法有额外的第一个参数self，在这里省略。

24.1.2. 可用的Turtle and Screen的方法

24.1.3. Methods of RawTurtle/Turtle and corresponding functions

本节中的大多数示例涉及一个名为turtle的Turtle实例。

24.1.3.1. Turtle motion

turtle.forward(distance)
turtle.fd(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 - 一个数字

将乌龟向后移动距离，与乌龟朝向的方向相反。不要改变乌龟的标题。

>>> turtle.position()
(0.00,0.00)
>>> turtle.backward(30)
>>> turtle.position()
(-30.00,0.00)
turtle.right(angle)
turtle.rt(angle)
参数：angle - 一个数字（整数或浮点数）

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

>>> turtle.heading()
22.0
>>> turtle.right(45)
>>> turtle.heading()
337.0
turtle.left(angle)
turtle.lt(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.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。以下是一些常用的度数方向：

标准模式标志模式
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）

用给定的半径绘制圆。中心为半径龟的左侧单位； extent - 一个角度 - 确定绘制圆的哪一部分。如果未给出extent，则绘制整个圆。如果extent不是一个完整的圆，圆弧的一个端点是当前笔位置。如果radius为正，则以逆时针方向绘制圆弧，否则为顺时针方向。最后，乌龟的方向改变了范围的量。

由于圆由内接的正多边形近似，步骤确定要使用的步数。如果没有给出，它会自动计算。可用于绘制正多边形。

>>> 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 - 一个颜色字符串或一个数字颜色元组

使用颜色绘制直径大小的圆点。如果未给出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")
>>> turtle.stamp()
11
>>> 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的乌龟的邮票。If n is None, delete all stamps, if n > 0 delete first n stamps, else if n < 0 delete last n stamps.

>>> for i in range(8):
...     turtle.stamp(); turtle.fd(30)
13
14
15
16
17
18
19
20
>>> turtle.clearstamps(2)
>>> turtle.clearstamps(-2)
>>> turtle.clearstamps()
turtle.undo()

撤消（重复）最后一次乌龟动作。可用撤消操作的数量由undobuffer的大小决定。

>>> 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
  • “正常”：6
  • “slow”：3
  • “最慢”：1

速度从1到10执行线描和海龟转动的动画越来越快。

注意：速度 = 0表示无动画发生。向前/向后使乌龟跳跃，同样左/右使乌龟立即转动。

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

24.1.3.2. Tell Turtle’s state

turtle.position()
turtle.pos()

返回乌龟的当前位置（x，y）（作为Vec2D向量）。

>>> turtle.pos()
(440.00,-0.00)
turtle.towards(x, y=None)
参数：
  • x - 数字或对/数字向量或turtle实例
  • y - 如果x是数字，则为数字，否则None

返回从乌龟位置到由（x，y）指定的位置，向量或其他乌龟之间的角度。这取决于海龟的起始方向，取决于模式 - “标准”/“世界”或“标志”）。

>>> 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 - 数字或对/数字向量或turtle实例
  • 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

24.1.3.3. Settings for measurement

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

24.1.3.4. Pen control

24.1.3.4.1. Drawing state

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是一个多边形，那么该多边形绘制的线粗度相同。如果没有给出参数，则返回当前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”
  • “拉伸因子”：（正数，正数）
  • “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

24.1.3.4.2. Color control

turtle.pencolor(*args)

返回或设置pencolor。

允许四种输入格式：

pencolor()
将当前pencolor返回为颜色规范字符串或元组（参见示例）。可以用作另一个颜色/ pencolor / fillcolor调用的输入。
pencolor(colorstring)
Set pencolor to colorstring, which is a Tk color specification string, such as "red", "yellow", or "#33cc8c".
pencolor（（r， g， b））
将pencolor设置为由r，g和b的元组表示的RGB颜色。Each of r, g, and b must be in the range 0..colormode, where colormode is either 1.0 or 255 (see colormode()).
pencolor（r， g， b）
Set pencolor to the RGB color represented by r, g, and b. Each of r, g, and b must be in the range 0..colormode.

如果turtleshape是一个多边形，那个多边形的轮廓是用新设置的pencolor绘制的。

>>> 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。

允许四种输入格式：

fillcolor()
将当前fillcolor返回为颜色规范字符串，可能是元组格式（参见示例）。可以用作另一个颜色/ pencolor / fillcolor调用的输入。
fillcolor(colorstring)
Set fillcolor to colorstring, which is a Tk color specification string, such as "red", "yellow", or "#33cc8c".
fillcolor（（r， g， b））
将fillcolor设置为由r，g和b的元组表示的RGB颜色。Each of r, g, and b must be in the range 0..colormode, where colormode is either 1.0 or 255 (see colormode()).
fillcolor（r， g， b）
Set fillcolor to the RGB color represented by r, g, and b. Each of r, g, and b must be in the range 0..colormode.

如果turtleshape是多边形，则该多边形的内部将使用新设置的fillcolor进行绘制。

>>> turtle.fillcolor("violet")
>>> turtle.fillcolor()
'violet'
>>> col = turtle.pencolor()
>>> col
(50.0, 193.0, 143.0)
>>> turtle.fillcolor(col)
>>> turtle.fillcolor()
(50.0, 193.0, 143.0)
>>> turtle.fillcolor('#ffffff')
>>> turtle.fillcolor()
(255.0, 255.0, 255.0)
turtle.color(*args)

返回或设置pencolor和fillcolor。

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

color()
将当前pencolor和当前fillcolor返回为pencolor()和fillcolor()返回的一对颜色规范字符串或元组。
color(colorstring)，color((r,g,b))，color(r,g,b)
输入如pencolor()，将fillcolor和pencolor设置为给定值。
color（colorstring1， colorstring2），color（（r1，g1，b1）， （r2，g2，b2））
Equivalent to pencolor(colorstring1) and fillcolor(colorstring2) and analogously if the other input format is used.

如果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()。

24.1.3.4.3. Filling

turtle.filling()

返回fillstate（True如果填充，False其他）。

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

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

turtle.end_fill()

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

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

24.1.3.4.4. More drawing control

turtle.reset()

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

>>> 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.write(arg, move=False, align="left", font=("Arial", 8, "normal"))
参数：
  • arg - 要写入TurtleScreen的对象
  • move - True / False
  • align - 字符串“left”，“center”或right“
  • 字体 - 一个三元组（fontname，fontsize，fonttype）

根据align（“left”，“center”或right“）和给定字体，在当前乌龟位置写入文本 - arg如果move为真，则笔将移动到文本的右下角。默认情况下，move是False。

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

24.1.3.5. Turtle state

24.1.3.5.1. Visibility

turtle.hideturtle()
turtle.ht()

使乌龟看不见。这是一个好主意，当你在做一些复杂的绘图，因为隐藏的海龟加快了绘图的可观察性。

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

使乌龟可见。

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

如果显示了Turtle，则返回True，如果隐藏，则返回False。

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

24.1.3.5.2. Appearance

turtle.shape(name=None)
参数：name - 一个字符串，它是一个有效的名称

使用给定的名称将龟形状设置为形状，或者，如果未指定name，则返回当前形状的名称。具有名称的形状必须存在于TurtleScreen的形状字典中。最初有以下多边形形状：“箭头”，“乌龟”，“圆圈”，“正方形”，“三角形”，“经典”。要了解如何处理形状，请参阅屏幕方法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”：根据由shapesize()设置的stretchfactor和outlinewidth（outline）的值来调整乌龟的外观。
  • “noresize”：没有适应乌龟的外观。

当与参数一起使用时，resizemode（“user”）由shapesize()调用。

>>> 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是拉伸方向，轮廓确定形状轮廓的宽度。

>>> 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 - number（可选）

设置或返回当前剪切因子。根据给定的剪切因子剪切剪切龟形，剪切剪切是剪切角的切线。不要更改乌龟的标题（移动方向）。如果不给出剪切：返回当前剪切因子， e。剪切角的切线，由此剪切与龟的航向平行的线。

>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.shearfactor(0.5)
>>> turtle.shearfactor()
0.5
turtle.tilt(angle)
参数：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 - 一个数字

无论当前的倾斜角度如何，旋转海龟以指向角度指定的方向。不要更改龟头的方向（运动方向）。

>>> 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 - 一个数字（可选）

设置或返回当前倾斜角度。如果给定角度，则旋转海龟以指向由角度指定的方向，而不管当前的倾斜角度。不要更改乌龟的标题（移动方向）。如果没有给出角度：返回当前倾斜角， e。海龟的方向和乌龟的方向（其运动方向）之间的角度。

>>> 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,22组成的矩阵变换形状。行列式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))

24.1.3.6. Using events

turtle.onclick(fun, btn=1, add=None)
参数：
  • fun - 具有两个参数的函数，它们将使用画布上点击的点的坐标来调用
  • num - 鼠标按钮的编号，默认为1（鼠标左键）
  • 添加 - 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 - 具有两个参数的函数，它们将使用画布上点击的点的坐标来调用
  • num - 鼠标按钮的编号，默认为1（鼠标左键）
  • 添加 - 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 - 具有两个参数的函数，它们将使用画布上点击的点的坐标来调用
  • num - 鼠标按钮的编号，默认为1（鼠标左键）
  • 添加 - True或False - 如果True，将添加新的绑定，否则将替换前者捆绑

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

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

>>> turtle.ondrag(turtle.goto)

随后，单击并拖动海龟会将其移动到屏幕上，从而生成手绘（如果钢笔向下）。

24.1.3.7. Special Turtle methods

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

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

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

返回undobuffer中的条目数。

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

24.1.3.8. Compound shapes

要使用由几个不同颜色的多边形组成的复合乌龟形状，必须如下所述明确使用辅助类Shape：

  1. 创建一个类型为“compound”的空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. 现在添加Shape到屏幕的shapelist并使用它：

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

注意

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

24.1.4. Methods of TurtleScreen/Screen and corresponding functions

本节中的大多数示例涉及名为screen的TurtleScreen实例。

24.1.4.1. Window control

turtle.bgcolor(*args)
参数：args - 颜色字符串或0..colormode范围内的三个数字或这些数字的三元组

设置或返回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.clearscreen()

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

注意

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

龟。 重置 （ ）
turtle.resetscreen()

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

注意

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

turtle.screensize(canvwidth=None, canvheight=None, bg=None)
参数：
  • canvwidth - 正整数，画布的新宽度（以像素为单位）
  • canvheight - 正整数，画布的新高度（以像素为单位）
  • bg - colorstring或color-tuple，新的背景颜色

如果没有给出参数，返回current（canvaswidth，canvasheight）。Else调整乌龟正在画的画布。不要更改绘图窗口。要观察画布的隐藏部分，请使用滚动条。使用这种方法，人们可以看到画布之前的那些部分。

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

24.1.4.2. Animation control

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

24.1.4.3. Using screen events

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

在TurtleScreen上设置焦点（以便收集关键事件）。提供了哑元参数，以便能够将listen()传递给onclick方法。

turtle.onkey(fun, key)
turtle.onkeyrelease(fun, key)
参数：
  • fun - 没有参数或None的函数
  • 键 - 字符串：key（例如，“a”）或键符号（例如。“空间”）

将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”）或键符号（例如。“空间”）

如果给定键，将fun绑定到键的按键事件，或者如果没有给出键，则键入任何键按下事件。备注：为了能够注册键事件，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 - 具有两个参数的函数，它们将使用画布上点击的点的坐标来调用
  • num - 鼠标按钮的编号，默认为1（鼠标左键）
  • 添加 - 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 - a number> = 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函数。必须是龟图形程序中的最后一个语句。如果在-n模式（无子过程）中的IDLE内运行脚本，则必须不 - 用于交互式使用龟图形。

>>> screen.mainloop()

24.1.4.4. Input methods

turtle.textinput(title, prompt)
参数：
  • title - 字符串
  • 提示 - 字符串

弹出对话框窗口以输入字符串。参数title是对话框窗口的标题，propmt是一个大多描述要输入什么信息的文本。返回字符串输入。如果对话框被取消，则返回None。

>>> screen.textinput("NIM", "Name of first player:")
turtle.numinput(title, prompt, default=None, minval=None, maxval=None)
参数：
  • title - 字符串
  • 提示 - 字符串
  • 默认 - number（可选）
  • minval - number（可选）
  • maxval - number（可选）

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

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

24.1.4.5. Settings and special methods

turtle.mode(mode=None)
参数：mode - 其中一个字符串“standard”，“logo”或“world”

设置海龟模式（“标准”，“标志”或“世界”）并执行重置。如果未给出模式，则返回当前模式。

模式“标准”与旧turtle兼容。模式“标志”与大多数标志龟图形兼容。模式“世界”使用用户定义的“世界坐标”。注意：在此模式下，如果x/y单位比率不等于1，则角度出现失真。

模式初始乌龟标题正角度
“标准”向右（东）逆时针
“商标”向上（北）顺时针
>>> mode("logo")   # resets turtle heading to north
>>> mode()
'logo'
turtle.colormode(cmode=None)
参数：cmode - 值为1.0或255之一

返回colormode或将其设置为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的画布。对于知道如何使用Tkinter画布的内部人员有用。

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

有三种不同的方法来调用此函数：

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

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

    注意

    图像形状不会在转动乌龟时旋转，因此它们不显示乌龟的标题！

  2. 名称是任意字符串，形状是坐标对的元组：安装相应的多边形形状。

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

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

添加龟形状到TurtleScreen的shapelist。通过发出命令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

24.1.4.6. Methods specific to Screen, not inherited from TurtleScreen

turtle.bye()

关闭turtlegraphics窗口。

turtle.exitonclick()

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

如果配置字典中的值“use_IDLE”为False（默认值），也应输入mainloop。备注：如果使用带有-n开关（无子过程）的IDLE，则此值应在turtle.cfg中设置为True。在这种情况下，IDLE自己的mainloop也为客户端脚本活动。

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

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

参数：
  • width - 如果是整数，大小以像素为单位，如果是float，则为屏幕的一部分；默认为屏幕的50％
  • height - 如果为整数，高度以像素为单位，如果为float，则为屏幕的一部分；默认为屏幕的75％
  • startx - 如果为正，从屏幕左边缘开始的位置（以像素为单位），如果从右边缘为负，如果为None，则中心窗口水平
  • starty - 如果为正，从屏幕上边缘起的像素开始位置（如果为负），如果为无，则垂直居中窗口
>>> 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!")

24.1.5. Public classes

class turtle.RawTurtle(canvas)
class turtle.RawPen(canvas)
参数：canvas - a tkinter.Canvas，ScrolledCanvas或TurtleScreen

创建一个乌龟。乌龟有上述所有方法“乌龟/ RawTurtle的方法”。

class turtle.Turtle

RawTurtle的子类，具有相同的界面，但是绘制在第一次需要时自动创建的默认Screen对象。

class turtle.TurtleScreen(cv)
参数：cv - a tkinter.Canvas

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

class turtle.Screen

TurtleScreen的子类，four methods added。

class turtle.ScrolledCanvas(master)
参数：master - 一些Tkinter小部件包含ScrolledCanvas，即添加了滚动条的Tkinter-canvas

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

class turtle.Shape(type_, data)
参数：type _ - 字符串“polygon”，“image”，“compound”

数据结构建模形状。对（类型_， 数据）必须遵循此规范：

type _data
“polygon”多边形元组一组元组的坐标
“图片”一个图像（在这种形式只在内部使用！）
“复合”None（必须使用addcomponent()方法构造复合形状）
addcomponent(poly, fill, outline=None)
参数：
  • 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()

请参阅Compound shapes。

class turtle.Vec2D(x, y)

一个二维向量类，用作实现海龟图形的助手类。也可能对龟图形程序有用。派生自tuple，所以一个向量是一个元组！

提供（用于a，b向量，k数字）：

  • a + b矢量加法
  • a - b矢量减法
  • a * b内部产品
  • k * a和a * t6 > k乘以标量
  • abs(a) a的绝对值
  • a.rotate(angle)旋转

24.1.6. Help and configuration

24.1.6.1. How to use help

Screen和Turtle类的公共方法通过docstrings广泛记录。所以这些可以作为在线帮助通过Python帮助设施：

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

  • 调用方法或函数上的help()显示docstrings：

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

这些修改的docstrings与在导入时从方法派生的函数定义一起自动创建。

24.1.6.2. Translation of docstrings into different languages

有一个实用程序来创建一个字典，其中的键是方法名称，其值是类和屏幕和海龟的公共方法的文档字符串。

turtle.write_docstringdict(filename="turtle_docstringdict")
参数：filename - 用作文件名的字符串

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

如果您（或您的学生）想要使用母语的在线帮助使用turtle，您必须翻译docstrings并将生成的文件保存为。turtle_docstringdict_german.py。

如果您在turtle.cfg文件中有适当的条目，此字典将在导入时读入，并将替换原始的英语docstrings。

在写这篇文章的时候，有德语和意大利语的docstring词典。（请至glingl @ aon 。在。）

24.1.6.3. How to configure Screen and Turtles

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

如果您想使用不同的配置，更好地反映此模块的功能或更好地适合您的需求，例如。要在教室中使用，可以准备一个配置文件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()的参数。
  • 形状可以是任何内建形状，例如：箭头，乌龟等。有关详情，请尝试help(shape)。
  • 如果您想使用无fillcolor（即使龟变得透明），你必须写fillcolor = “”在cfg文件中的引号）。
  • 如果你想反映乌龟的状态，你必须使用resizemode = auto。
  • 如果您设置了language = italian the docstringdict turtle_docstringdict_italian.py will be loaded at import time (if present on the import path, e.g. 在与turtle相同的目录中。
  • 条目exampleturtle和examplescreen定义这些对象在docstrings中出现的名称。方法docstrings到函数docstrings的转换将从docstrings中删除这些名称。
  • use_IDLE：如果您经常使用IDLE及其-n开关（“无子流程”），请将此设置为True。这将阻止exitonclick()进入主循环。

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

Lib/turtledemo目录包含一个turtle.cfg文件。你可以研究它作为一个例子，并看到它的效果，当运行演示（最好不是从演示观众）。

24.1.7. turtledemo - 演示脚本

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

python -m turtledemo

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

python -m turtledemo.bytedesign

turtledemo包目录包含：

  • 演示查看器__main__.py可用于查看脚本的源代码并同时运行它们。
  • 多个脚本演示turtle模块的不同功能。示例可以通过Examples菜单访问。它们也可以独立运行。
  • turtle.cfg文件，用作如何写入和使用这些文件的示例。

演示脚本是：

名称描述特征
bytedesign复杂的经典乌龟图形模式tracer()，delay，update()
混沌图形Verhulst动态，显示计算机的计算可以产生结果有时反对常识预期世界坐标
时钟显示您计算机时间的模拟时钟海龟作为时钟的手，ontimer
混色器实验用r，g，bondrag()
森林3个宽度优先的树随机化
分形曲线Hilbert＆Koch曲线递归
林登迈尔民族学L系统
minimal_hanoi河内塔矩形海龟作为河内盘（形状，shapeize）
nim玩三次堆的古典尼姆游戏对计算机。海龟作为n，事件驱动（鼠标，键盘）
涂料超简约绘图程序onclick()
和平初级龟：外观和动画
penrose非洲平铺与风筝和飞镖stamp()
planet_and_moon模拟重力系统复合形状，Vec2D
round_dance跳舞的海龟在相反方向成对旋转复合形状，克隆shapesize，倾斜，get_shapepoly，更新
排序动画不同排序方法的可视化演示简单对齐，随机化
画一棵树a（graphical）breadth第一树（使用生成器）clone()
two_canvases简单的设计在两个帆布的海龟
维基百科从乌龟图形的维基百科文章的模式clone()，undo()
阴阳八卦鱼图一个副圆的基本示例circle()

玩的开心！

24.1.8. Changes since 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()。

24.1.9. Changes since Python 3.0

  • 已添加方法Turtle.shearfactor()，Turtle.shapetransform()和Turtle.get_shapepoly()。因此，全范围的规则线性变换现在可用于变换龟形状。Turtle.tiltangle()功能已增强：现在可用于获取或设置tiltangle。Turtle.settiltangle()已被弃用。
  • 方法Screen.onkeypress()已作为对Screen.onkey()的补充添加，实际上将操作绑定到keyrelease事件。因此后者有一个别名：Screen.onkeyrelease()。
  • 已添加方法Screen.mainloop()。因此，当只使用Screen和Turtle对象时，不能再导入mainloop()。
  • 已添加Screen.textinput()和Screen.numinput()的两种输入方法。这些弹出式输入对话框，分别返回字符串和数字。
  • 两个示例脚本tdemo_nim.py和tdemo_round_dance.py已添加到Lib/turtledemo目录中。