Skip to main content

24.1. turtle —龟图形

源代码: 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 模块是从Python标准分发到版本Python 2.5的同名模块的扩展重新实现。

它试图保持旧龟模块的优点,并(几乎)100%兼容。这意味着首先允许学习程序员在使用 -n 开关的IDLE运行模块时交互地使用所有的命令,类和方法。

龟模块以面向对象和面向过程的方式提供龟图形基元。因为它使用 tkinter 作为底层图形,它需要一个版本的Python安装与Tk支持。

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

  1. TurtleScreen 类定义图形窗口作为绘图海龟的游乐场。它的构造函数需要一个 tkinter.CanvasScrolledCanvas 作为参数。当 turtle 用作某些应用程序的一部分时,应使用它。

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

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

  2. RawTurtle (别名:RawPen)定义绘制在 TurtleScreen 上的乌龟对象。它的构造函数需要一个Canvas,ScrolledCanvas或者TurtleScreen作为参数,所以RawTurtle对象知道在哪里绘制。

    派生自RawTurtle是子类 Turtle (别名:Pen),它使用“自动创建的” Screen 实例(如果尚未存在)。

    原始龟/龟的所有方法也作为函数存在,即面向过程的接口的一部分。

过程接口提供从类 ScreenTurtle 的方法导出的函数。它们具有与相应方法相同的名称。每当调用从Screen方法派生的函数时,都会自动创建屏幕对象。每当调用从Turtle方法派生的任何函数时,将自动创建一个(未命名的)turtle对象。

要在屏幕上使用多个海龟,必须使用面向对象的界面。

注解

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

24.1.2. 可用的海龟和屏幕方法概述

24.1.3. RawTurtle/Turtle的方法和相应的函数

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

24.1.3.1. 乌龟运动

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

如果 yNone,则 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

用给定的 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,可以通过调用 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 的乌龟的邮票。如果 nNone,删除所有邮票,如果 n> 0删除第一个 n 邮票,否则如果 n <0删除最后 n 邮票。

>>> 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执行线描和海龟转动的动画越来越快。

注意:speed = 0表示 no 动画发生。向前/向后让乌龟跳跃,同样左/右使乌龟立即转动。

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

24.1.3.2. 告诉乌龟的状态

turtle.position()
turtle.pos()

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

>>> turtle.pos()
(440.00,-0.00)
turtle.towards(x, y=None)
参数:
  • x – 数字或数字/数字向量或龟实例
  • 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 – 数字或数字/数字向量或龟实例
  • 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. 测量设置

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. 笔控制

24.1.3.4.1. 绘图状态

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. 颜色控制

turtle.pencolor(*args)

返回或设置pencolor。

允许四种输入格式:

pencolor()

将当前pencolor返回为颜色规范字符串或元组(参见示例)。可以用作另一个颜色/pencolor/fillcolor调用的输入。

pencolor(colorstring)

将pencolor设置为 colorstring,它是一个Tk颜色规范字符串,例如 "red""yellow""#33cc8c"

pencolor((r, g, b))

将pencolor设置为由 rgb 的元组表示的RGB颜色。 rgb 中的每一个必须在0.colormode的范围内,其中colormode为1.0或255(参见 colormode())。

pencolor(r, g, b)

将pencolor设置为由 rgb 表示的RGB颜色。 rgb 中的每一个必须在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)

将fillcolor设置为 colorstring,它是一个Tk颜色规范字符串,例如 "red""yellow""#33cc8c"

fillcolor((r, g, b))

将fillcolor设置为由 rgb 的元组表示的RGB颜色。 rgb 中的每一个必须在0.colormode的范围内,其中colormode为1.0或255(参见 colormode())。

fillcolor(r, g, b)

将fillcolor设置为由 rgb 表示的RGB颜色。 rgb 中的每一个必须在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和当前填充颜色返回为 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))

等同于 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()

24.1.3.4.3. 填充

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. 更多绘图控制

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 – 真假
  • align – 其中一个字符串“左”,“中心”或右“
  • font – 一个三元组(fontname,fontsize,font type)

根据 align (“左”,“中心”或右“”)和给定字体在当前乌龟位置写入文本 - arg 的字符串表示形式如果 move 为真,则将笔移动到右下角的文本。默认情况下,moveFalse

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

24.1.3.5. 乌龟状态

24.1.3.5.1. 能见度

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

24.1.3.5.2. 出现

turtle.shape(name=None)
参数:name – 一个字符串,它是一个有效的名字

使用给定的 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”:没有适应乌龟的外观发生。

当与参数一起使用时,shapesize() 调用resizemode(“用户”)。

>>> 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 – number(可选)

设置或返回当前剪切因子。根据给定的剪切因子剪切剪切龟形,剪切剪切是剪切角的切线。做 not 改变乌龟的标题(运动方向)。如果不给出剪切:返回当前剪切因子, e。剪切角的切线,由此剪切与龟的航向平行的线。

>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.shearfactor(0.5)
>>> turtle.shearfactor()
0.5
turtle.tilt(angle)
参数:angle – 一个号码

通过 angle 从当前的倾斜角度旋转龟形,但是 not 改变龟头的方向(运动方向)。

>>> 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 – 一个号码

无论当前的倾斜角度如何,旋转海龟形状使其指向 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 – 数字(可选)

设置或返回当前倾斜角度。如果给定了角度,则旋转turtleshape以指向角度指定的方向,而不考虑当前的倾斜角度。做 not 改变乌龟的标题(运动方向)。如果没有给出角度:返回当前倾斜角, 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. 使用事件

turtle.onclick(fun, btn=1, add=None)
参数:
  • fun – 一个带有两个参数的函数,它们将使用画布上点击的点的坐标进行调用
  • num – 鼠标按钮的编号,默认为1(鼠标左键)
  • addTrueFalse - 如果 True,将添加新的绑定,否则将替换前一个绑定

fun 绑定到这个龟上的鼠标点击事件。如果 funNone,则删除现有绑定。匿名龟的例子,即程序方式:

>>> 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(鼠标左键)
  • addTrueFalse - 如果 True,将添加新的绑定,否则将替换前一个绑定

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

>>> 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(鼠标左键)
  • addTrueFalse - 如果 True,将添加新的绑定,否则将替换前一个绑定

绑定 fun 到鼠标移动事件在这只乌龟。如果 funNone,则删除现有绑定。

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

>>> turtle.ondrag(turtle.goto)

随后,单击并拖动乌龟会将其移动到屏幕上,从而产生手写(如果笔下降)。

24.1.3.7. 特殊龟方法

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() 方法/功能撤销的龟甲动作的最大数量。如果 sizeNone,则禁用undobuffer。

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

返回undobuffer中的条目数。

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

24.1.3.8. 复合形状

要使用由不同颜色的多个多边形组成的复合乌龟形状,必须按如下所述明确使用辅助类 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. 现在添加形状到屏幕的shapelist并使用它:

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

注解

Shape 类由 register_shape() 方法以不同的方式在内部使用。当使用如上所示的复合形状时,应用程序员必须处理Shape类 only

24.1.4. TurtleScreen/Screen的方法和相应的功能

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

24.1.4.1. 窗口控制

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",请删除背景图像(如果存在)。如果 picnameNone,则返回当前背景图像的文件名。

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

从海龟屏幕中删除所有图纸和所有海龟。重置现在空乌龟屏幕到其初始状态:白色背景,没有背景图像,没有事件绑定和跟踪。

注解

此TurtleScreen方法仅作为全局函数在名称 clearscreen 下可用。全局函数 clear 是从乌龟方法 clear 导出的不同的。

turtle.reset()
turtle.resetscreen()

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

注解

此TurtleScreen方法仅作为全局函数在名称 resetscreen 下可用。全局函数 reset 是从乌龟方法 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. 动画控制

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. 使用屏幕事件

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

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

turtle.onkey(fun, key)
turtle.onkeyrelease(fun, key)
参数:
  • fun – 一个没有参数或 None 的函数
  • key – 字符串:键(例如“a”)或键符号(例如“空格”)

fun 绑定到按键的释放事件。如果 funNone,则会除去事件绑定。备注:为了能够注册键事件,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(鼠标左键)
  • addTrueFalse - 如果 True,将添加新的绑定,否则将替换前一个绑定

fun 绑定到此屏幕上的鼠标单击事件。如果 funNone,则删除现有绑定。

名为 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 是从乌龟方法 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函数。必须是龟图形程序中的最后一个语句。如果在-n模式中的IDLE(无子过程)中运行脚本,则必须使用 not - 用于交互式使用龟图形。

>>> screen.mainloop()

24.1.4.4. 输入法

turtle.textinput(title, prompt)
参数:
  • title – string
  • prompt – string

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

>>> screen.textinput("NIM", "Name of first player:")
turtle.numinput(title, prompt, default=None, minval=None, maxval=None)
参数:
  • title – string
  • prompt – string
  • default – 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. 设置和特殊方法

turtle.mode(mode=None)
参数:mode – 其中一个字符串“标准”,“标志”或“世界”

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

模式“标准”与旧的 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.随后颜色三元组的 rgb 值必须在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. name 是gif文件的名称,shapeNone:安装相应的图像形状。

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

    注解

    图像形状 不要 在转动乌龟时旋转,因此它们不显示乌龟的标题!

  2. name 是任意字符串,shape 是坐标对的元组:安装相应的多边形形状。

    >>> screen.register_shape("triangle", ((5,-3), (0,5), (-5,-3)))
    
  3. name 是任意字符串,形状是(复合) 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. 特定于Screen的方法,不是从TurtleScreen继承的

turtle.bye()

关闭turtlegraphics窗口。

turtle.exitonclick()

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

如果配置字典中的值“using_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 – 如果为正,则从屏幕的顶边缘开始以像素为单位的开始位置,如果从底部边缘为负,如果 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!")

24.1.5. 公共类

class turtle.RawTurtle(canvas)
class turtle.RawPen(canvas)
参数:canvastkinter.CanvasScrolledCanvasTurtleScreen

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

class turtle.Turtle

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

class turtle.TurtleScreen(cv)
参数:cvtkinter.Canvas

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

class turtle.Screen

TurtleScreen子类,带 四种方法添加

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

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

class turtle.Shape(type_, data)
参数:type_ – 字符串“多边形”,“图像”,“复合”

数据结构建模形状。 (type_, data) 对必须遵循此规范:

type_

data

“polygon”

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

“图片”

一个图像(在这种形式只在内部使用!)

“复合”

None (复合形状必须使用 addcomponent() 方法构造)

addcomponent(poly, fill, outline=None)
参数:
  • poly – 多边形,即数字对的元组
  • fillpoly 将填充的颜色
  • 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)

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

提供(对于 ab 向量,k 编号):

  • a + b 载体添加

  • a - b 向量减法

  • a * b 内部产物

  • k * aa * k 乘法与标量

  • abs(a) 绝对值a

  • a.rotate(angle) 旋转

24.1.6. 帮助和配置

24.1.6.1. 如何使用帮助

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

  • 当使用IDLE时,工具提示显示输入的函数/方法调用的docstrings的签名和第一行。

  • 在方法或函数上调用 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. docstrings翻译成不同的语言

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

turtle.write_docstringdict(filename="turtle_docstringdict")
参数:filename – 一个字符串,用作文件名

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

如果您(或您的学生)想要使用 turtle 在线帮助您的母语,您必须翻译文档字符串,并保存生成的文件,例如。 turtle_docstringdict_german.py

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

在写这篇文章的时候,有德语和意大利语的docstring词典。 (请请 glingl@aon.at。)

24.1.6.3. 如何配置屏幕和海龟

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

如果您想使用不同的配置,更好地反映此模块的功能,或更好地适合您的需求,例如。为了在教室中使用,您可以准备配置文件 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(即使龟透明),你必须编写 fillcolor = "" (但所有非空字符串不能在cfg文件中有引号)。

  • 如果你想反映它的状态,你必须使用 resizemode = auto

  • 如果您设置了 language = italian 将在导入时加载docstringdict turtle_docstringdict_italian.py (如果存在于导入路径上,例如在与 turtle 相同的目录中)。

  • 条目 exampleturtleexamplescreen 定义这些对象的名称,因为它们出现在docstrings中。方法docstrings到函数docstrings的转换将从docstrings中删除这些名称。

  • using_IDLE:如果您经常使用IDLE及其-n开关(“无子过程”),请将其设置为 True。这将防止 exitonclick() 进入主环路。

在存储 turtle 的目录中可以有一个 turtle.cfg 文件,在当前工作目录中有一个附加的 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(),延迟,update()

混沌

图形Verhulst动态,显示计算机的计算可以产生结果有时反对常识预期

世界坐标

时钟

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

海龟作为时钟的手,ontimer

混色器

实验用r,g,b

ondrag()

森林

3个宽度优先的树

随机化

分形曲线

Hilbert & Koch曲线

递归

林登迈尔

民族学

L系统

minimal_hanoi

河内塔

矩形海龟作为河内圆盘(形状,shapeize)

nim

玩三个堆的古典尼姆游戏棍子对计算机。

海龟作为n,事件驱动(鼠标,键盘)

涂料

超简约绘图程序

onclick()

和平

初级

龟:外观和动画

penrose

非洲平铺与风筝和飞镖

stamp()

planet_and_moon

模拟重力系统

复合形状,Vec2D

round_dance

跳舞的海龟在相反方向成对旋转

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

sorted_animate

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

简单对齐,随机化

(图形)宽度第一树(使用生成器)

clone()

two_canvases

简单的设计

在两个帆布的海龟

维基百科

从乌龟图形维基百科文章的模式

clone()undo()

阴阳

另一个基本的例子

circle()

玩的开心!

24.1.8. 自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. 自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.pytdemo_round_dance.py 已添加到 Lib/turtledemo 目录中。