文档整理：python标准库_turtle --- 海龟绘图

整理自 文档_链接

步骤：

• 示例代码整理
• 整理一遍文档： 笔记整理，敲代码(IDE平台： PyCharm)
• 遇到不熟悉的模块， 官网和整理好的文档中分别查找相应函数，补充完善。Ctrl + F

---

使用海龟绘图可以编写重复执行简单动作的程序画出精细复杂的形状。

import turtle

turtle.forward(200)
turtle.right(25)

turtle.done()  ## 加上这句在PyCharm可以看到图， 不然图像显示框会闪退

from turtle import *

color('red', 'yellow')  ## 线的颜色， 填充颜色
begin_fill()
while True:
    forward(200)
    left(170)
    if abs(pos()) < 1:
        break
end_fill()
done()

使用 tkinter 实现基本图形界面，因此需要安装了 Tk 支持的 Python 版本。

如果屏幕上需要有多个海龟，就必须使用面向对象的接口。

海龟动作_移动和绘制

turtle.forward(distance)
turtle.fd(distance)

• 参数distance – 一个数值 (整型或浮点型)
  海龟前进 distance 指定的距离，方向为海龟的朝向。

import turtle

print(turtle.position())  ## 返回海龟当前的坐标 (x,y)
turtle.forward(200)
print(turtle.position())
turtle.forward(-250)
print(turtle.position())

turtle.done()

turtle.back(distance)
turtle.bk(distance)
turtle.backward(distance)

• 参数distance – 一个数值
  海龟后退 distance 指定的距离，方向与海龟的朝向相反。不改变海龟的朝向。

import turtle

print(turtle.position())
turtle.backward(30)
print(turtle.position())

turtle.done()  ## 用于显示 图像

turtle.right(angle)
turtle.rt(angle)

• 参数angle – 一个数值 (整型或浮点型)
  海龟右转 angle 个单位。(单位默认为角度，但可通过 degrees() 和 radians() 函数改变设置。) 角度的正负由海龟模式确定，参见 mode()。

import turtle

print(turtle.heading())  ##返回海龟当前的朝向
turtle.right(45)
print(turtle.heading())

###
turtle.done()  ## 用于显示 图像

turtle.left(angle)
turtle.lt(angle)

• 参数angle – 一个数值 (整型或浮点型)
  海龟左转 angle 个单位。(单位默认为角度，但可通过 degrees() 和 radians() 函数改变设置。) 角度的正负由海龟模式确定，参见 mode()。

import turtle

print(turtle.heading())  ##返回海龟当前的朝向
turtle.left(45) ## 默认朝右为0， 逆时针为左
print(turtle.heading())

###
turtle.done()  ## 用于显示 图像

turtle.goto(x, y=None)
turtle.setpos(x, y=None)
turtle.setposition(x, y=None)

• 参数: x – 一个数值或数值对/向量, y – 一个数值或 None
• 如果 y 为 None，x 应为一个表示坐标的数值对或 Vec2D 类对象 (例如 pos() 返回的对象).
• 海龟移动到一个绝对坐标。如果画笔已落下将会画线。不改变海龟的朝向。

import turtle

tp = turtle.pos()    ## 返回当前的坐标   记录原点位置
print(tp)

turtle.setpos(60, 30)
print(turtle.pos())

turtle.setpos(20, 80)
print(turtle.pos())

turtle.setpos(tp)   ## 相当于回到原点
print(turtle.pos())
###
turtle.done()  ## 用于显示 图像

从一个点到下一点，默认会画成直线

turtle.setx(x)

• 参数x – 一个数值 (整型或浮点型)
  设置海龟的横坐标为 x，纵坐标保持不变。

import turtle

print(turtle.position())
turtle.setx(10)    ### 设置海龟的横坐标为 10，纵坐标保持不变。
print(turtle.position())

###
turtle.done()  ## 用于显示 图像

turtle.sety(y)

• 参数y – 一个数值 (整型或浮点型)
  设置海龟的纵坐标为 y，横坐标保持不变。

import turtle

print(turtle.position())
turtle.sety(-10)    ### 设置海龟的纵坐标为 -10，横坐标保持不变。
print(turtle.position())

###
turtle.done()  ## 用于显示 图像

turtle.setheading(to_angle)
turtle.seth(to_angle)

• 参数to_angle – 一个数值 (整型或浮点型)
  设置海龟的朝向为 to_angle。

import turtle

print(turtle.heading())
turtle.setheading(90)    ### 朝北
print(turtle.heading())

###
turtle.done()  ## 用于显示 图像

turtle.home()
海龟移至初始坐标 (0,0)，并设置朝向为初始方向 (由海龟模式确定，参见 mode())。
相当于重置

import turtle

turtle.setposition(60, 30)
turtle.setheading(270)
print(turtle.heading())   ## 当前朝向
print(turtle.position())   ## 当前位置
turtle.home()
print(turtle.position())
print(turtle.heading())

###
turtle.done()  ## 用于显示 图像

turtle.circle(radius, extent=None, steps=None)

• 参数
  radius – 一个数值
  extent – 一个数值 (或 None)
  steps – 一个整型数 (或 None)
• 绘制一个 radius 指定半径的圆。圆心在海龟左边 radius 个单位；extent 为一个夹角，用来决定绘制圆的一部分。如未指定 extent*则绘制整个圆。如果 *extent 不是完整圆周，则以当前画笔位置为一个端点绘制圆弧。如果 radius 为正值则朝 逆时针方向绘制圆弧，否则朝顺时针方向。最终海龟的朝向会依据 extent 的值而改变。
• 圆实际是以其内切正多边形来近似表示的，其边的数量由 steps 指定。如果未指定边数则会自动确定。此方法也可用来绘制正多边形。

import turtle

turtle.home()
print(turtle.position())
print(turtle.heading())

turtle.circle(50)  ## 半径为50的圆
print(turtle.position())  ## 画圆  后  乌龟回到原位
print(turtle.heading())

turtle.circle(120, 180)   ## 半径为 120， 逆时针绘制1/4圆弧
print(turtle.position())
print(turtle.heading())

###
turtle.done()  ## 用于显示 图像

turtle.dot(size=None, *color)

• 参数
  size – 一个整型数 >= 1 (如果指定)
  color – 一个颜色字符串或颜色数值元组
• 绘制一个直径为 size，颜色为 color 的圆点。如果 size 未指定，则直径取 pensize+4 和 2*pensize 中的较大值。

import turtle

turtle.home()
turtle.dot()   ## 原点半径：取 pensize+4 和 2*pensize 中的较大值。
turtle.fd(50)   ## 向前走 50
turtle.dot(20, "blue")   ## 画一个半径为20， 颜色为蓝色的圆点
turtle.fd(50)    ## 向前走50

print(turtle.position())
print(turtle.heading())

###
turtle.done()  ## 用于显示 图像

turtle.stamp()

• 在海龟当前位置印制一个海龟形状。返回该印章的 stamp_id，印章可以通过调用 clearstamp(stamp_id) 来删除。

import turtle

turtle.color("blue")   ## 颜色设置
turtle.stamp()

turtle.fd(50)   ## 朝前50

###
turtle.done()  ## 用于显示 图像

turtle.clearstamp(stampid)

• 参数
  stampid – 一个整型数，必须是之前 stamp() 调用的返回值
  删除 stampid 指定的印章。

import turtle

print(turtle.position())

turtle.color("blue")
astamp = turtle.stamp()
turtle.fd(50)

print(turtle.position())

turtle.clearstamp(astamp)   ## 删除指定的印章

print(turtle.position())


###
turtle.done()  ## 用于显示 图像

turtle.clearstamps(n=None)

• 参数
  n – 一个整型数 (或 None)
• 删除全部或前/后 n 个海龟印章。如果 n 为 None 则删除全部印章，如果 n > 0 则删除前 n 个印章，否则如果 n < 0 则删除后 n 个印章。

import turtle

for i in range(8):
    turtle.stamp()
    turtle.fd(30)

turtle.clearstamps(2)  ## 1   删除前2个海龟印章
turtle.clearstamps(-2)   ## 2   删除后2个  海龟印章
turtle.clearstamps()    ## 3 删除全部印章


###
turtle.done()  ## 用于显示 图像

——————————

turtle.undo()
撤消 (或连续撤消) 最近的一个 (或多个) 海龟动作。可撤消的次数由撤消缓冲区的大小决定。

import turtle

for i in range(4):
    turtle.fd(50); turtle.lt(80)  ## 向前50， 左转80

for i in range(8):  ## 相当于之前的操作全部撤销
    turtle.undo()
###
turtle.done()  ## 用于显示 图像

turtle.speed(speed=None)

• 参数
  speed – 一个 0…10 范围内的整型数或速度字符串 (见下)
• 设置海龟移动的速度为 0..10 表示的整型数值。如未指定参数则返回当前速度。
• 如果输入数值大于 10 或小于 0.5 则速度设为 0。

速度字符串与速度值的对应关系如下:

• “fastest”: 0 最快
• “fast”: 10 快
• “normal”: 6 正常
• “slow”: 3 慢 默认
• “slowest”: 1 最慢

速度值从 1 到 10，画线和海龟转向的动画效果逐级加快。

注意: speed = 0 表示 没有 动画效果。forward/back 将使海龟向前/向后跳跃，同样的 left/right 将使海龟立即改变朝向。

import turtle

print(turtle.speed() ) ## 返回当前的速度  默认为3
turtle.speed('normal')  ## 6
print(turtle.speed())   ## 返回当前的速度

turtle.speed(9)
print(turtle.speed())

###
turtle.done()  ## 用于显示 图像

海龟动作_获取海龟的状态

turtle.position()
turtle.pos()
返回海龟当前的坐标 (x,y) (为 Vec2D 矢量类对象)。

import turtle

print(turtle.pos())   ## 返回海龟当前的坐标 (x,y)


###
turtle.done()  ## 用于显示 图像

——————————

turtle.towards(x, y=None)

• 参数
  x – 一个数值或数值对/矢量，或一个海龟实例
  y – 一个数值——如果 x 是一个数值，否则为 None
• 返回从海龟位置到由 (x,y)、矢量或另一海龟所确定位置的连线的夹角。 此数值依赖于海龟的初始朝向，这又取决于 “standard”/“world” 或 “logo” 模式设置。

import turtle

turtle.stamp()  ## 在初始位置  印制一个 海龟  印章
turtle.goto(200, 200)   ## turtle.setposition(200, 200) 等效
print(turtle.towards(0, 0))  ##  要 回原点   海龟方向需要逆时针旋转 225°


###
turtle.done()  ## 用于显示 图像

————————

turtle.xcor()
返回海龟的 x 坐标。

import turtle

turtle.home()
turtle.left(50)
turtle.forward(100)
print(turtle.pos())

print(round(turtle.xcor(), 5))

###
turtle.done()  ## 用于显示 图像

————————————

turtle.ycor()
返回海龟的 y 坐标。

import turtle

turtle.home()
turtle.left(60)
turtle.forward(100)
print(turtle.pos())

print(round(turtle.ycor(), 5))

###
turtle.done()  ## 用于显示 图像

——————————

turtle.heading()
返回海龟当前的朝向 (数值依赖于海龟模式参见 mode())。

import turtle

turtle.home()
turtle.left(67)
print(turtle.heading())   ## 返回海龟当前的朝向

###
turtle.done()  ## 用于显示 图像

————————————

turtle.distance(x, y=None)

• 参数
  x – 一个数值或数值对/矢量，或一个海龟实例
  y – 一个数值——如果 x 是一个数值，否则为 None
• 返回从海龟位置到由 (x,y)，适量或另一海龟对应位置的单位距离。

import turtle

turtle.home()
print(turtle.distance(30, 40))   ## 从原点  到 点(30, 40)之间的距离
print(turtle.distance((30, 40)))  ## 给坐标加括号也可以

joe = turtle.Turtle()
joe.forward(77)
print(turtle.distance(joe))
###
turtle.done()  ## 用于显示 图像

海龟动作_设置与度量单位

turtle.degrees(fullcircle=360.0)

• 参数
  fullcircle – 一个数值
• 设置角度的度量单位，即设置一个圆周为多少 "度"。默认值为 360 度。

import turtle

turtle.home()
turtle.left(90)  ## 默认  一个圆周  值为 360 度。
print(turtle.heading())

turtle.degrees(400.0)  ## 设置一个圆周为  400度
print(turtle.heading())
print(90 * 400/ 360)   ## x : 90 = 400: 360

turtle.degrees(360)
print(turtle.heading())  ## 默认情况

###
turtle.done()  ## 用于显示 图像

——————

turtle.radians()
设置角度的度量单位为弧度。其值等于 degrees(2*math.pi)。

import turtle

turtle.home()
turtle.left(90)
print(turtle.heading())

turtle.radians()   ## 设置角度的度量单位为  弧度。
print(turtle.heading())  ## 返回90对应的弧度。

import math
print(90 * math.pi/180)  ## 角度转弧度  弧度= 角度 * π / 180

###
turtle.done()  ## 用于显示 图像

---

画笔控制

绘图状态

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。

import turtle

print(turtle.pensize() )  ## 返回线条的width  默认为1
turtle.forward(100)
turtle.pensize(10)
turtle.forward(100)

###
turtle.done()  ## 用于显示 图像

turtle.pen(pen=None, **pendict)

• 参数
  pen – 一个包含部分或全部下列键的字典
  pendict – 一个或多个以下列键为关键字的关键字参数
• 返回或设置画笔的属性，以一个包含以下键值对的 “画笔字典” 表示:

“shown”: True/False
“pendown”: True/False
“pencolor”: 颜色字符串或颜色元组
“fillcolor”: 颜色字符串或颜色元组
“pensize”: 正数值
“speed”: 0…10 范围内的数值
“resizemode”: “auto” 或 “user” 或 “noresize”
“stretchfactor”: (正数值, 正数值)
“outline”: 正数值
“tilt”: 数值

此字典可作为后续调用 pen() 时的参数，以恢复之前的画笔状态。另外还可将这些属性作为关键词参数提交。使用此方式可以用一条语句设置画笔的多个属性。

import turtle

turtle.pen(fillcolor="black", pencolor="red", pensize=10)
print(sorted(turtle.pen().items())) ## fillcolor="black", pencolor="red",

penstate = turtle.pen()
turtle.color("yellow", "")  
turtle.penup()
print(sorted(turtle.pen().items())[:3])  ## fillcolor="", pencolor="yellow",

turtle.pen(penstate, fillcolor='green')  ### 注意这里的penstate = turtle.pen()是第一个
print(sorted(turtle.pen().items())[:3]) ## ## fillcolor='green', pencolor="red",


###
turtle.done()  ## 用于显示 图像

turtle.isdown()
如果画笔落下返回 True，如果画笔抬起返回 False。

import turtle

turtle.penup()
print(turtle.isdown())

turtle.pendown()
print(turtle.isdown())

###
turtle.done()  ## 用于显示 图像

---

颜色控制

turtle.pencolor(*args)
返回或设置画笔颜色。

允许以下四种输入格式:

• pencolor()
  返回以颜色描述字符串或元组 (见示例) 表示的当前画笔颜色。可用作其他 color/pencolor/fillcolor 调用的输入。

• pencolor(colorstring)
  设置画笔颜色为 colorstring 指定的 Tk 颜色描述字符串，例如 “red”、“yellow” 或 “#33cc8c”。

• pencolor((r, g, b))
  设置画笔颜色为以 r, g, b 元组表示的 RGB 颜色。r, g, b 的取值范围应为 0…colormode，colormode 的值为 1.0 或 255 (参见 colormode())。

• pencolor(r, g, b)
  设置画笔颜色为以 r, g, b 表示的 RGB 颜色。r, g, b 的取值范围应为 0…colormode。

如果 turtleshape 为多边形，该多边形轮廓也以新设置的画笔颜色绘制。

import turtle

print(turtle.colormode())
print(turtle.pencolor())

turtle.pencolor("brown")
print(turtle.pencolor())

tup = (0.2, 0.8, 0.55)
turtle.pencolor(tup)
print(turtle.pencolor())

turtle.colormode(255)  ## 更改 颜色模式
print(turtle.pencolor())

turtle.pencolor('#32c18f')
print(turtle.pencolor())

###
# turtle.done()  ## 用于显示 图像

turtle.fillcolor(*args)
返回或设置填充颜色。

允许以下四种输入格式:

• fillcolor()
  返回以颜色描述字符串或元组 (见示例) 表示的当前填充颜色。可用作其他 color/pencolor/fillcolor 调用的输入。

• fillcolor(colorstring)
  设置填充颜色为 colorstring 指定的 Tk 颜色描述字符串，例如 “red”、“yellow” 或 “#33cc8c”。

• fillcolor((r, g, b))
  设置填充颜色为以 r, g, b 元组表示的 RGB 颜色。r, g, b 的取值范围应为 0…colormode，colormode 的值为 1.0 或 255 (参见 colormode())。

• fillcolor(r, g, b)
  设置填充颜色为 r, g, b 表示的 RGB 颜色。r, g, b 的取值范围应为 0…colormode。

如果 turtleshape 为多边形，该多边形内部也以新设置的填充颜色填充。

import turtle

turtle.fillcolor("violet")
print(turtle.fillcolor())

turtle.home()
turtle.begin_fill()  ## 1  需要加这句才会染色
turtle.goto(100,0)
turtle.goto(100,-100)
turtle.goto(0, -100)
turtle.goto(0, 0)
turtle.end_fill()


###
turtle.done()  ## 用于显示 图像

import turtle

turtle.fillcolor("violet")
print(turtle.fillcolor())
print(turtle.pencolor())
# turtle.fillcolor((50, 193, 143))  ## 报错

turtle.fillcolor('#ffffff')
print(turtle.fillcolor())

###
turtle.done()  ## 用于显示 图像

turtle.color(*args)
返回或设置画笔颜色和填充颜色。

允许多种输入格式。使用如下 0 至 3 个参数:

• color()
  返回以一对颜色描述字符串或元组表示的当前画笔颜色和填充颜色，两者可分别由 pencolor() 和 fillcolor() 返回。

• color(colorstring), color((r,g,b)), color(r,g,b)
  输入格式与 pencolor() 相同，同时设置填充颜色和画笔颜色为指定的值。

• color(colorstring1, colorstring2), color((r1,g1,b1), (r2,g2,b2))
  相当于 pencolor(colorstring1) 加 fillcolor(colorstring2)，使用其他输入格式的方法也与之类似。

如果 turtleshape 为多边形，该多边形轮廓与填充也使用新设置的颜色。

import turtle

turtle.color("red", "green")  ## 当前  画笔颜色  和  填充颜色

turtle.home()
turtle.begin_fill()  ## 1  需要加这句才会染色
turtle.goto(100,0)
# turtle.begin_fill()  ## 1
turtle.goto(100,-100)
# turtle.begin_fill()  ## 2
turtle.goto(0, -100)
turtle.goto(0, 0)
turtle.end_fill()

print(turtle.color())

turtle.color("#285078", "#a0c8f0")
print(turtle.color())

###
turtle.done()  ## 用于显示 图像

(‘red’, ‘green’)
((0.1568627450980392, 0.3137254901960784, 0.47058823529411764), (0.6274509803921569, 0.7843137254901961, 0.9411764705882353))

填充

turtle.filling()
返回填充状态 (填充为 True，否则为 False)。

import turtle

turtle.begin_fill()    ## 开始填充
if turtle.filling():
    turtle.pensize(5)
else:
    turtle.pensize(3)

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

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

自相交多边形或多个形状间的重叠区域是否填充取决于操作系统的图形引擎、重叠的类型以及重叠的层数。 例如上面的 Turtle 多芒星可能会全部填充为黄色，也可能会有一些白色区域。

import turtle

turtle.color("black", "red")  ## 笔的颜色   填充颜色
turtle.begin_fill()
turtle.circle(80)
turtle.end_fill()

###
turtle.done()  ## 用于显示 图像

更多绘图控制

turtle.reset()
从屏幕中删除海龟的绘图，海龟回到原点并设置所有变量为默认值。

import turtle

turtle.goto(0, -22)
turtle.left(100)
print(turtle.position())
print(turtle.heading())


turtle.reset()   ## 重置
print(turtle.position())
print(turtle.heading())
###
turtle.done()  ## 用于显示 图像

turtle.clear()
从屏幕中删除指定海龟的绘图。不移动海龟。海龟的状态和位置以及其他海龟的绘图不受影响。

turtle.write(arg, move=False, align=“left”, font=(“Arial”, 8, “normal”))

• 参数
  arg – 要书写到 TurtleScreen 的对象
  move – True/False
  align -- 字符串 "left", "center" 或 "right"
  font – 一个三元组 (fontname, fontsize, fonttype)
• 基于 align (“left”, “center” 或 “right”) 并使用给定的字体将文本 —— arg 的字符串表示形式 —— 写到当前海龟位置。 如果 move 为真值，画笔会移至文本的右下角。 默认情况下 move 为 False。

import turtle

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

###
turtle.done()  ## 用于显示 图像

海龟状态(可见性、外观)

可见性

turtle.hideturtle()
turtle.ht()
使海龟不可见。当你绘制复杂图形时这是个好主意，因为隐藏海龟可显著加快绘制速度。

turtle.showturtle()
turtle.st()
使海龟可见。

turtle.isvisible()
如果海龟显示返回 True，如果海龟隐藏返回 False。

import turtle

turtle.hideturtle()
print(turtle.isvisible())

turtle.showturtle()
print(turtle.isvisible())


###
turtle.done()  ## 用于显示 图像

外观

turtle.shape(name=None)

• 参数
  name – 一个有效的形状名字符串
• 设置海龟形状为 name 指定的形状名，如未指定形状名则返回当前的形状名。name 指定的形状名应存在于 TurtleScreen 的 shape 字典中。多边形的形状初始时有以下几种: "arrow", "turtle", "circle", "square", "triangle", "classic"。要了解如何处理形状请参看 Screen 方法 register_shape()。

import turtle

print(turtle.shape())
turtle.shape("turtle")
print(turtle.shape())


###
turtle.done()  ## 用于显示 图像

——————————

turtle.resizemode(rmode=None)

• 参数
  rmode – 字符串 “auto”, “user”, “noresize” 其中之一
  设置大小调整模式为以下值之一: “auto”, “user”, “noresize”。如未指定 rmode 则返回当前的大小调整模式。

不同的大小调整模式的效果如下:

• “auto”: 根据画笔粗细值调整海龟的外观。

• “user”: 根据拉伸因子和轮廓宽度 (outline) 值调整海龟的外观，两者是由 shapesize() 设置的。

• “noresize”: 不调整海龟的外观大小。

resizemode(“user”) 会由 shapesize() 带参数使用时被调用。

import turtle

print(turtle.resizemode())
turtle.resizemode("auto")
print(turtle.resizemode())

###
turtle.done()  ## 用于显示 图像

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-拉伸因子和/或轮廓。设置大小调整模式为 “user”。当且仅当大小调整模式设为 “user” 时海龟会基于其拉伸因子调整外观: stretch_wid 为垂直于其朝向的宽度拉伸因子，stretch_len 为平等于其朝向的长度拉伸因子，决定形状轮廓线的粗细。

import turtle

print(turtle.shapesize())
turtle.resizemode("user")
turtle.shapesize(5, 5, 12)
print(turtle.shapesize())
turtle.shapesize(outline=8)
print(turtle.shapesize())

###
turtle.done()  ## 用于显示 图像

turtle.shearfactor(shear=None)

• 参数
  shear – 数值 (可选)
• 设置或返回当前的剪切因子。根据 share 指定的剪切因子即剪切角度的切线来剪切海龟形状。不 改变海龟的朝向 (移动方向)。如未指定 shear 参数: 返回当前的剪切因子即剪切角度的切线，与海龟朝向平行的线条将被剪切。

import turtle

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

###
turtle.done()  ## 用于显示 图像

turtle.tilt(angle)

• 参数
  angle – 一个数值
• 海龟形状自其当前的倾角转动 angle 指定的角度，但 不 改变海龟的朝向 (移动方向)。

import turtle

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

###
turtle.done()  ## 用于显示 图像

turtle.settiltangle(angle)

• 参数
  angle – 一个数值
• 旋转海龟形状使其指向 angle 指定的方向，忽略其当前的倾角，不 改变海龟的朝向 (移动方向)。

import turtle

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

###
turtle.done()  ## 用于显示 图像

turtle.tiltangle(angle=None)

• 参数
  angle – 一个数值 (可选)
• 设置或返回当前的倾角。如果指定 angle 则旋转海龟形状使其指向 angle 指定的方向，忽略其当前的倾角。不 改变海龟的朝向 (移动方向)。如果未指定 angle: 返回当前的倾角，即海龟形状的方向和海龟朝向 (移动方向) 之间的夹角。

import turtle

turtle.reset()
turtle.shape("circle")
turtle.shapesize(5, 2)
turtle.tilt(45)
print(turtle.tiltangle())

###
turtle.done()  ## 用于显示 图像

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。

from turtle import *

turtle = Turtle()
turtle.shape("square")
turtle.shapesize(4, 2)
turtle.shearfactor(-0.5)
print(turtle.shapetransform())

###
done()  ## 用于显示 图像

turtle.get_shapepoly()

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

import turtle


turtle.shape("square")
turtle.shapetransform(4, -1, 0, 2)
print(turtle.get_shapepoly())

###
turtle.done()  ## 用于显示 图像

！！！事件

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

• 参数
  fun – 一个函数，调用时将传入两个参数表示在画布上点击的坐标。
  btn – 鼠标按钮编号，默认值为 1 (鼠标左键)
  add – True 或 False – 如为 True 则将添加一个新绑定，否则将取代先前的绑定
• 将 fun 指定的函数绑定到鼠标点击此海龟事件。如果 fun 值为 None，则移除现有的绑定。以下为使用匿名海龟即过程式的示例:

import turtle


def turn(x, y):
    turtle.left(180)

turtle.onclick(turn)   ## 点击海龟后将向左旋转180
# turtle.onclick(None)  ## 运行后  删除事件绑定
###
turtle.done()  ## 用于显示 图像

点击海龟后

turtle.onrelease(fun, btn=1, add=None)

• 参数
  fun – 一个函数，调用时将传入两个参数表示在画布上点击的坐标。
  btn – 鼠标按钮编号，默认值为 1 (鼠标左键)
  add – True 或 False – 如为 True 则将添加一个新绑定，否则将取代先前的绑定
• 将 fun 指定的函数绑定到在此海龟上释放鼠标按键事件。如果 fun 值为 None，则移除现有的绑定。

import turtle
from turtle import *
class MyTurtle(Turtle):
    def glow(self, x, y):
        self.fillcolor("red")
    def unglow(self, x, y):
        self.fillcolor("")

turtle = MyTurtle()
turtle.onclick(turtle.glow)  ## 鼠标点击状态   填充颜色为   红色
turtle.onrelease(turtle.unglow)  ## 鼠标释放状态  透明

###
done()  ## 用于显示 图像

鼠标点击状态

鼠标释放状态

turtle.ondrag(fun, btn=1, add=None)

• 参数
  fun – 一个函数，调用时将传入两个参数表示在画布上点击的坐标。
  btn – 鼠标按钮编号，默认值为 1 (鼠标左键)
  add – True 或 False – 如为 True 则将添加一个新绑定，否则将取代先前的绑定
• 将 fun 指定的函数绑定到在此海龟上移动鼠标事件。如果 fun 值为 None，则移除现有的绑定。

注: 在海龟上移动鼠标事件之前应先发生在此海龟上点击鼠标事件。

import turtle

###  在此之后点击并拖动海龟可在屏幕上手绘线条 (如果画笔为落下)。
turtle.ondrag(turtle.goto)

###
turtle.done()  ## 用于显示 图像

特殊海龟方法

turtle.begin_poly()

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

turtle.end_poly()

• 停止记录多边形的顶点。当前海龟位置为多边形的最后一个顶点。它将连线到第一个顶点。

turtle.get_poly()

• 返回最新记录的多边形。

import turtle
from turtle import *

turtle.home()
turtle.begin_poly()   ### 开始绘制多边形
turtle.fd(100)   ## 定方向  + 移动
turtle.left(20)  ## 左转20
turtle.fd(30)
turtle.left(60)
turtle.fd(50)
turtle.end_poly()   ## 结束绘制 多边形
p = turtle.get_poly()
register_shape("myFavoriteShape", p)  ##
shape("myFavoriteShape")

###
turtle.done()  ## 用于显示 图像

turtle.clone()

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

import turtle
from turtle import *

mick = Turtle()
joe = mick.clone()

###
turtle.done()  ## 用于显示 图像

turtle.getturtle()
turtle.getpen()

• 返回海龟对象自身。唯一合理的用法: 作为一个函数来返回 “匿名海龟”:

import turtle
from turtle import *

pet = getturtle()
pet.fd(50)
print(pet)

###
turtle.done()  ## 用于显示 图像

turtle.getscreen()
返回作为海龟绘图场所的 TurtleScreen 类对象。该对象将可调用 TurtleScreen 方法。

import turtle
from turtle import *

ts = turtle.getscreen()
print(ts)
turtle.bgcolor("pink")

###
turtle.done()  ## 用于显示 图像

turtle.setundobuffer(size)
参数

• size – 一个整型数值或 None
• 设置或禁用撤销缓冲区。 如果 size 为整数，则开辟一个给定大小的空撤销缓冲区。 size 给出了可以通过 undo() 方法/函数撤销海龟动作的最大次数。 如果 size 为 None，则禁用撤销缓冲区。

turtle.setundobuffer(42)

turtle.undobufferentries()
返回撤销缓冲区里的条目数。

while undobufferentries():
    undo()

复合形状:
要使用由多个不同颜色多边形构成的复合海龟形状，你必须明确地使用辅助类 Shape，具体步骤如下:

1、创建一个空 Shape 对象，类型为 “compound”。
2、按照需要使用 addcomponent() 方法向此对象添加多个部件。

from turtle import *

s = Shape("compound")   ## 1
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")

register_shape("myshape", s)
shape("myshape")
###
done()  ## 用于显示 图像

TurtleScreen/Screen 方法

窗口控制

TurtleScreen 类的一个实例，命名为 screen。

turtle.bgcolor(*args)

• 参数
  args – 一个颜色字符串或三个取值范围 0…colormode 内的数值或一个取值范围相同的数值3元组
• 设置或返回 TurtleScreen 的背景颜色。

import turtle

screen = turtle.Screen()  ## 要加这句调用
screen.bgcolor("orange")
print(screen.bgcolor())

###
turtle.done()  ## 用于显示 图像

import turtle

screen = turtle.Screen()  ## 要加这句调用
screen.bgcolor("#800080")
print(screen.bgcolor())

###
turtle.done()  ## 用于显示 图像

turtle.bgpic(picname=None)

• 参数
  picname – 一个字符串, gif-文件名, “nopic”, 或 None
• 设置背景图片或返回当前背景图片名称。如果 picname 为一个文件名，则将相应图片设为背景。如果 picname 为 “nopic”，则删除当前背景图片。如果 picname 为 None，则返回当前背景图片文件名。:

import turtle

screen = turtle.Screen()  ## 要加这句调用
print(screen.bgpic())

screen.bgpic("C:/Users/12919/Desktop/GIF_picture.gif")   ## 只能识别gif文件
print(screen.bgpic())
###
turtle.done()  ## 用于显示 图像

turtle.clear()
turtle.clearscreen()

• 从中删除所有海龟的全部绘图。将已清空的 TurtleScreen 重置为初始状态: 白色背景，无背景片，无事件绑定并启用追踪。

• 此 TurtleScreen 方法作为全局函数时只有一个名字 clearscreen。全局函数 clear 所对应的是 Turtle 方法 clear。

turtle.reset()
turtle.resetscreen()

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

• 此 TurtleScreen 方法作为全局函数时只有一个名字 resetscreen。全局函数 reset 所对应的是 Turtle 方法 reset。

turtle.screensize(canvwidth=None, canvheight=None, bg=None)

• 参数
  canvwidth – 正整型数，以像素表示画布的新宽度值
  canvheight – 正整型数，以像素表示画面的新高度值
  bg – 颜色字符串或颜色元组，新的背景颜色
• 如未指定任何参数，则返回当前的 (canvaswidth, canvasheight)。否则改变作为海龟绘图场所的画布大小。不改变绘图窗口。要观察画布的隐藏区域，可以使用滚动条。通过此方法可以令之前绘制于画布之外的图形变为可见。

import turtle

screen = turtle.Screen()  ## 要加这句调用

print(screen.screensize())
screen.screensize(2000, 1500)
print(screen.screensize())

###
turtle.done()  ## 用于显示 图像

turtle.setworldcoordinates(llx, lly, urx, ury)

• 参数
  llx – 一个数值, 画布左下角的 x-坐标
  lly – 一个数值, 画布左下角的 y-坐标
  urx – 一个数值, 画面右上角的 x-坐标
  ury – 一个数值, 画布右上角的 y-坐标
• 设置用户自定义坐标系并在必要时切换模式为 “world”。这会执行一次 screen.reset()。如果 "world" 模式已激活，则所有图形将根据新的坐标系重绘。

注意: 在用户自定义坐标系中，角度可能显得扭曲。

import turtle
from turtle import *

screen = turtle.Screen()  ## 要加这句调用

screen.reset()
screen.setworldcoordinates(-50,-7.5,50,7.5)
for _ in range(72):
    left(10)

for _ in range(8):
    left(45); fd(2)

###
turtle.done()  ## 用于显示 图像

动画控制

turtle.delay(delay=None)

• 参数
  delay – 正整型数
• 设置或返回以毫秒数表示的延迟值 delay。(这约等于连续两次画布刷新的间隔时间。) 绘图延迟越长，动画速度越慢。

import turtle
from turtle import *

screen = turtle.Screen()  ## 要加这句调用

print(screen.delay())
screen.delay(5)  ## 5毫秒
print(screen.delay())

###
turtle.done()  ## 用于显示 图像

turtle.tracer(n=None, delay=None)

• 参数
  n – 非负整型数
  delay – 非负整型数
• 启用/禁用海龟动画并设置刷新图形的延迟时间。如果指定 n 值，则只有每第 n 次屏幕刷新会实际执行。(可被用来加速复杂图形的绘制。) 如果调用时不带参数，则返回当前保存的 n 值。第二个参数设置延迟值 (参见 delay())。

import turtle
from turtle import *

screen = turtle.Screen()  ## 要加这句调用

screen.tracer(8, 25)  ## 第8次屏幕刷新延迟25毫秒

dist = 2
for i in range(200):
    fd(dist)
    rt(90)  ## right()  右转
    dist += 2

###
turtle.done()  ## 用于显示 图像

turtle.update()
执行一次 TurtleScreen 刷新。在禁用追踪时使用。

使用屏幕事件(这里的所有screen调用直接用turtle调用就可以)

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

• 设置焦点到 TurtleScreen (以便接收按键事件)。使用两个 Dummy 参数以便能够传递 listen() 给 onclick 方法。

turtle.onkey(fun, key)
turtle.onkeyrelease(fun, key)

• 参数
  fun – 一个无参数的函数或 None
  key – 一个字符串: 键 (例如 "a") 或键标 (例如 "space")
• 绑定 fun 指定的函数到按键释放事件。如果 fun 值为 None，则移除事件绑定。注: 为了能够注册按键事件，TurtleScreen 必须得到焦点。(参见 method listen() 方法。)

import turtle
from turtle import *

def f():
    fd(50)
    lt(60)  ## 左转60

screen = turtle.Screen()
screen.onkey(f, "Up")  ## 按一次上移键， 就运行一次f
screen.listen()      ## 开始监听  设置焦点到 TurtleScreen (以便接收按键事件)。

###
turtle.done()  ## 用于显示 图像

上移键：

turtle.onkeypress(fun, key=None)

• 参数
  fun – 一个无参数的函数或 None
  key – 一个字符串: 键 (例如 “a”) 或键标 (例如 “space”)
• 绑定 fun 指定的函数到指定键的按下事件。如未指定键则绑定到任意键的按下事件。注: 为了能够注册按键事件，必须得到焦点。(参见 listen() 方法。)

和上面的去别在于这个的触发操作是按下，上一个的触发操作是按键释放。

import turtle
from turtle import *

def f():
    fd(50)

screen = turtle.Screen()
screen.onkey(f, "Up")  ## 按下一次上移键， 就运行一次f
screen.listen()      ## 开始监听  设置焦点到 TurtleScreen (以便接收按键事件)。

###
turtle.done()  ## 用于显示 图像

等效代码：

import turtle
from turtle import *

def f():
    fd(50)

turtle.onkey(f, "Up")  ## 按下一次上移键， 就运行一次f
turtle.listen()      ## 开始监听  设置焦点到 TurtleScreen (以便接收按键事件)。

###
turtle.done()  ## 用于显示 图像

turtle.onclick(fun, btn=1, add=None)
turtle.onscreenclick(fun, btn=1, add=None)

• 参数
  fun – 一个函数，调用时将传入两个参数表示在画布上点击的坐标。
  btn – 鼠标按钮编号，默认值为 1 (鼠标左键)
  add – True 或 False – 如为 True 则将添加一个新绑定，否则将取代先前的绑定
• 绑定 fun 指定的函数到鼠标点击屏幕事件。如果 fun 值为 None，则移除现有的绑定。

import turtle
from turtle import *

screen = turtle.Screen()

screen.onclick(turtle.goto)  ##  当前位置 和 鼠标点击的地方 之间 画一条直线

###
turtle.done()  ## 用于显示 图像

• 注意到，这里不需要屏幕监听
  

turtle.ontimer(fun, t=0)

• 参数
  fun – 一个无参数的函数
  t – 一个数值 >= 0
• 安装一个计时器，在 t 毫秒后调用 fun 函数。

import turtle
from turtle import *


screen = turtle.Screen()
running = True   ## 设置一个 旗子
def f():
    if running:
        fd(50)
        lt(60)
        screen.ontimer(f, 250)   ## 250毫秒

f()
running = False

###
turtle.done()  ## 用于显示 图像

turtle.mainloop()
turtle.done()
开始事件循环 - 调用 Tkinter 的 mainloop 函数。必须作为一个海龟绘图程序的结束语句。如果一个脚本是在以 -n 模式 (无子进程) 启动的 IDLE 中运行时 不可 使用 - 用于实现海龟绘图的交互功能。:

screen.mainloop()

对话框输入： 文本、数字

turtle.textinput(title, prompt)

• 参数
  title – string
  prompt – string
• 弹出一个对话框窗口用来输入一个字符串。形参 title 为对话框窗口的标题，prompt 为一条文本，通常用来提示要输入什么信息。返回输入的字符串。如果对话框被取消则返回 None。:

import turtle
from turtle import *


screen = turtle.Screen()
screen.textinput("NIM", "Name of first player:")

###
turtle.done()  ## 用于显示 图像

turtle.numinput(title, prompt, default=None, minval=None, maxval=None)

• 参数
  title – string
  prompt – string
  default – 数值 (可选)
  minval – 数值 (可选)
  maxval – 数值 (可选)
• 弹出一个对话框窗口用来输入一个数值。title 为对话框窗口的标题，prompt 为一条文本，通常用来描述要输入的数值信息。default: 默认值, minval: 可输入的最小值, maxval: 可输入的最大值。输入数值的必须在指定的 minval … maxval 范围之内，否则将给出一条提示，对话框保持打开等待修改。返回输入的数值。如果对话框被取消则返回 None。:

import turtle
from turtle import *


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

###
turtle.done()  ## 用于显示 图像

模式设置与特殊方法

turtle.mode(mode=None)

• 参数
  mode – 字符串 “standard”, “logo” 或 “world” 其中之一
• 设置海龟模式 ("standard", "logo" 或 "world") 并执行重置。如未指定模式则返回当前的模式。
  “standard” 模式与旧的 turtle 兼容。“logo” 模式与大部分 Logo 海龟绘图兼容。“world” 模式使用用户自定义的 “世界坐标系”。注意: 在此模式下，如果 x/y 单位比率不等于 1 则角度会显得扭曲。

import turtle
from turtle import *

mode("logo")
print(mode())

###
turtle.done()  ## 用于显示 图像

turtle.colormode(cmode=None)

• 参数
  cmode – 数值 1.0 或 255 其中之一
• 返回颜色模式或将其设为 1.0 或 255。构成颜色三元组的 r, g, b 数值必须在 0…cmode 范围之内。

import turtle
from turtle import *

screen = turtle.Screen()
screen.colormode(1)
# turtle.pencolor(240, 160, 80)   ## 运行将报错， 与当前的颜色模式不匹配
print(screen.colormode())
screen.colormode(255)
print(screen.colormode())
turtle.pencolor(240, 160, 80)

###
turtle.done()  ## 用于显示 图像

turtle.getcanvas()

turtle.getcanvas()

• 返回此 TurtleScreen 的 Canvas 对象。供了解 Tkinter 的 Canvas 对象内部机理的人士使用。

import turtle
from turtle import *

screen = turtle.Screen()
cv = screen.getcanvas()
print(cv)

###
turtle.done()  ## 用于显示 图像

turtle.getshapes()

• 返回所有当前可用海龟形状的列表。

import turtle
from turtle import *

screen = turtle.Screen()
print(screen.getshapes())

###
turtle.done()  ## 用于显示 图像

turtle.register_shape(name, shape=None)
turtle.addshape(name, shape=None)
调用此函数有三种不同方式:
1、name 为一个 gif 文件的文件名， shape 为 None: 安装相应的图像形状。:
2、name 为指定的字符串，shape 为由坐标值对构成的元组: 安装相应的多边形形状。
3、name 为指定的字符串， 为一个 (复合) Shape 类对象: 安装相应的复合形状。

将一个海龟形状加入 TurtleScreen 的形状列表。只有这样注册过的形状才能通过执行 shape(shapename) 命令来使用。

• 这里的shapename就是turtle.register_shape(name, shape=None)这里的name

import turtle
from turtle import *

screen = turtle.Screen()
gif_path = 'C:/Users/12919/Desktop/GIF_picture.gif'
screen.register_shape(gif_path)  ## 1、name 为一个 gif 文件的文件名， shape 为 None: 安装相应的图像形状。
shape(gif_path)
###
turtle.done()  ## 用于显示 图像

import turtle
from turtle import *

screen = turtle.Screen()
screen.register_shape("triangle", ((50, -30), (0, 50), (-50, -30)))
shape("triangle")  ## 注册过的形状才能通过执行 shape(shapename) 命令来使用。
###
turtle.done()  ## 用于显示 图像

turtle.turtles()

• 返回屏幕上的海龟列表。

import turtle
from turtle import *

screen = turtle.Screen()
for turtle in screen.turtles():
    turtle.color("red")
    
###
turtle.done()  ## 用于显示 图像

import turtle
from turtle import *

# screen = turtle.Screen()
for turtle in turtle.turtles():
    turtle.color("red")

###
turtle.done()  ## 用于显示 图像

turtle.window_height()

• 返回海龟窗口的高度。

import turtle
from turtle import *

screen = turtle.Screen()
print(screen.window_width())

###
turtle.done()  ## 用于显示 图像

等效代码：

import turtle
from turtle import *

# screen = turtle.Screen()
print(turtle.window_width())

###
turtle.done()  ## 用于显示 图像

Screen 专有方法, 而非继承自 TurtleScreen

turtle.bye()
关闭海龟绘图窗口。

turtle.exitonclick()
将 bye() 方法绑定到 Screen 上的鼠标点击事件。
如果配置字典中 “using_IDLE” 的值为 False (默认值) 则同时进入主事件循环。注: 如果启动 IDLE 时使用了 -n 开关 (无子进程)，turtle.cfg 中此数值应设为 True。在此情况下 IDLE 本身的主事件循环同样会作用于客户脚本。

turtle.setup(width=_CFG[“width”], height=_CFG[“height”], startx=_CFG[“leftright”], starty=_CFG[“topbottom”])
设置主窗口的大小和位置。默认参数值保存在配置字典中，可通过 turtle.cfg 文件进行修改。

• 参数
  width – 如为一个整型数值，表示大小为多少像素，如为一个浮点数值，则表示屏幕的占比；默认为屏幕的 50%
  height – 如为一个整型数值，表示高度为多少像素，如为一个浮点数值，则表示屏幕的占比；默认为屏幕的75%
  startx – 如为正值，表示初始位置距离屏幕左边缘多少像素，负值表示距离右边缘，None 表示窗口水平居中
  starty – 如为正值，表示初始位置距离屏幕上边缘多少像素，负值表示距离下边缘，None 表示窗口垂直居中

import turtle
from turtle import *

turtle.setup(width=200, height=200,startx=0, starty=0)
# turtle.setup(width=.75, height=0.5, startx=None, starty=None)

###
turtle.done()  ## 用于显示 图像

位于电脑屏幕左上角

import turtle
from turtle import *

# turtle.setup(width=200, height=200,startx=0, starty=0)  ## 宽度为200像素，高度为200像素， 左边角&& 上边角
turtle.setup(width=.75, height=0.5, startx=None, starty=None)  ## 屏幕宽度占比75%，高度占比50%，水平居中，垂直居中

###
turtle.done()  ## 用于显示 图像

turtle.title(titlestring)

• 参数
  titlestring – 一个字符串，显示为海龟绘图窗口的标题栏文本
• 设置海龟窗口标题为 titlestring 指定的文本。

import turtle
from turtle import *

screen = turtle.Screen()
screen.title("欢迎来到开心的世界！")

###
turtle.done()  ## 用于显示 图像

等效代码：

import turtle
from turtle import *

turtle.title("欢迎来到开心的世界！")

###
turtle.done()  ## 用于显示 图像

公共类

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 类对象
• 提供面向屏幕的方法例如 setbg() 等。说明见上文。

class turtle.Screen
TurtleScreen 的子类，增加了四个方法.

class turtle.ScrolledCanvas(master)

• 参数
  master – 可容纳 ScrolledCanvas 的 Tkinter 部件，即添加了滚动条的 Tkinter-canvas
  由 Screen 类使用，使其能够自动提供一个 ScrolledCanvas 作为海龟的绘图场所。

class turtle.Shape(type_, data)

• 参数
  type_ – 字符串 “polygon”, “image”, “compound” 其中之一

实现形状的数据结构。(type_, data) 必须遵循以下定义:

函数：

addcomponent(poly, fill, outline=None)

• 参数
  poly – 一个多边形，即由数值对构成的元组
  fill – 一种颜色，将用来填充 poly 指定的多边形
  outline – 一种颜色，用于多边形的轮廓 (如有指定)

import turtle
from turtle import *

poly = ((0,0),(100,-50),(0,100),(-100,-50))
s = Shape("compound")   ## 定义复合形状
s.addcomponent(poly, "red", "blue")  ## 填充颜色， 轮廓颜色

###
turtle.done()  ## 用于显示 图像

class turtle.Vec2D(x, y)
一个二维矢量类，用来作为实现海龟绘图的辅助类。也可能在海龟绘图程序中使用。派生自元组，因此矢量也属于元组!
提供的运算 (a, b 为矢量, k 为数值):

• a + b 矢量加法
  a - b 矢量减法
  a * b 内积
  k * a 和 a * k 与标量相乘
  abs(a) a 的绝对值
  a.rotate(angle) 旋转

---

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

一些示例

cmd环境
1、 win+ R
2、输入 cmd， 回车
3、输入下面的命令

python -m turtledemo

### 单独运行其中的演示脚本
python -m turtledemo.bytedesign

LOGO设计：

#!/usr/bin/env python3
"""      turtle-example-suite:

        tdemo_bytedesign.py

An example adapted from the example-suite
of PythonCard's turtle graphics.

It's based on an article in BYTE magazine
Problem Solving with Logo: Using Turtle
Graphics to Redraw a Design
November 1982, p. 118 - 134

-------------------------------------------

Due to the statement

t.delay(0)

in line 152, which sets the animation delay
to 0, this animation runs in "line per line"
mode as fast as possible.
"""

from turtle import Turtle, mainloop
from time import perf_counter as clock

# wrapper for any additional drawing routines
# that need to know about each other
class Designer(Turtle):

    def design(self, homePos, scale):
        self.up()
        for i in range(5):
            self.forward(64.65 * scale)
            self.down()
            self.wheel(self.position(), scale)
            self.up()
            self.backward(64.65 * scale)
            self.right(72)
        self.up()
        self.goto(homePos)
        self.right(36)
        self.forward(24.5 * scale)
        self.right(198)
        self.down()
        self.centerpiece(46 * scale, 143.4, scale)
        self.getscreen().tracer(True)

    def wheel(self, initpos, scale):
        self.right(54)
        for i in range(4):
            self.pentpiece(initpos, scale)
        self.down()
        self.left(36)
        for i in range(5):
            self.tripiece(initpos, scale)
        self.left(36)
        for i in range(5):
            self.down()
            self.right(72)
            self.forward(28 * scale)
            self.up()
            self.backward(28 * scale)
        self.left(54)
        self.getscreen().update()

    def tripiece(self, initpos, scale):
        oldh = self.heading()
        self.down()
        self.backward(2.5 * scale)
        self.tripolyr(31.5 * scale, scale)
        self.up()
        self.goto(initpos)
        self.setheading(oldh)
        self.down()
        self.backward(2.5 * scale)
        self.tripolyl(31.5 * scale, scale)
        self.up()
        self.goto(initpos)
        self.setheading(oldh)
        self.left(72)
        self.getscreen().update()

    def pentpiece(self, initpos, scale):
        oldh = self.heading()
        self.up()
        self.forward(29 * scale)
        self.down()
        for i in range(5):
            self.forward(18 * scale)
            self.right(72)
        self.pentr(18 * scale, 75, scale)
        self.up()
        self.goto(initpos)
        self.setheading(oldh)
        self.forward(29 * scale)
        self.down()
        for i in range(5):
            self.forward(18 * scale)
            self.right(72)
        self.pentl(18 * scale, 75, scale)
        self.up()
        self.goto(initpos)
        self.setheading(oldh)
        self.left(72)
        self.getscreen().update()

    def pentl(self, side, ang, scale):
        if side < (2 * scale): return
        self.forward(side)
        self.left(ang)
        self.pentl(side - (.38 * scale), ang, scale)

    def pentr(self, side, ang, scale):
        if side < (2 * scale): return
        self.forward(side)
        self.right(ang)
        self.pentr(side - (.38 * scale), ang, scale)

    def tripolyr(self, side, scale):
        if side < (4 * scale): return
        self.forward(side)
        self.right(111)
        self.forward(side / 1.78)
        self.right(111)
        self.forward(side / 1.3)
        self.right(146)
        self.tripolyr(side * .75, scale)

    def tripolyl(self, side, scale):
        if side < (4 * scale): return
        self.forward(side)
        self.left(111)
        self.forward(side / 1.78)
        self.left(111)
        self.forward(side / 1.3)
        self.left(146)
        self.tripolyl(side * .75, scale)

    def centerpiece(self, s, a, scale):
        self.forward(s); self.left(a)
        if s < (7.5 * scale):
            return
        self.centerpiece(s - (1.2 * scale), a, scale)

def main():
    t = Designer()
    t.speed(0)
    t.hideturtle()
    t.getscreen().delay(0)
    t.getscreen().tracer(0)
    at = clock()
    t.design(t.position(), 2)
    et = clock()
    return "runtime: %.2f sec." % (et-at)

if __name__ == '__main__':
    msg = main()
    print(msg)
    mainloop()

画树

#!/usr/bin/env python3
"""     turtlegraphics-example-suite:

             tdemo_forest.py

Displays a 'forest' of 3 breadth-first-trees
similar to the one in tree.
For further remarks see tree.py

This example is a 'breadth-first'-rewrite of
a Logo program written by Erich Neuwirth. See
http://homepage.univie.ac.at/erich.neuwirth/
"""
from turtle import Turtle, colormode, tracer, mainloop
from random import randrange
from time import perf_counter as clock

def symRandom(n):
    return randrange(-n,n+1)

def randomize( branchlist, angledist, sizedist ):
    return [ (angle+symRandom(angledist),
              sizefactor*1.01**symRandom(sizedist))
                     for angle, sizefactor in branchlist ]

def randomfd( t, distance, parts, angledist ):
    for i in range(parts):
        t.left(symRandom(angledist))
        t.forward( (1.0 * distance)/parts )

def tree(tlist, size, level, widthfactor, branchlists, angledist=10, sizedist=5):
    # benutzt Liste von turtles und Liste von Zweiglisten,
    # fuer jede turtle eine!
    if level > 0:
        lst = []
        brs = []
        for t, branchlist in list(zip(tlist,branchlists)):
            t.pensize( size * widthfactor )
            t.pencolor( 255 - (180 - 11 * level + symRandom(15)),
                        180 - 11 * level + symRandom(15),
                        0 )
            t.pendown()
            randomfd(t, size, level, angledist )
            yield 1
            for angle, sizefactor in branchlist:
                t.left(angle)
                lst.append(t.clone())
                brs.append(randomize(branchlist, angledist, sizedist))
                t.right(angle)
        for x in tree(lst, size*sizefactor, level-1, widthfactor, brs,
                      angledist, sizedist):
            yield None


def start(t,x,y):
    colormode(255)
    t.reset()
    t.speed(0)
    t.hideturtle()
    t.left(90)
    t.penup()
    t.setpos(x,y)
    t.pendown()

def doit1(level, pen):
    pen.hideturtle()
    start(pen, 20, -208)
    t = tree( [pen], 80, level, 0.1, [[ (45,0.69), (0,0.65), (-45,0.71) ]] )
    return t

def doit2(level, pen):
    pen.hideturtle()
    start(pen, -135, -130)
    t = tree( [pen], 120, level, 0.1, [[ (45,0.69), (-45,0.71) ]] )
    return t

def doit3(level, pen):
    pen.hideturtle()
    start(pen, 190, -90)
    t = tree( [pen], 100, level, 0.1, [[ (45,0.7), (0,0.72), (-45,0.65) ]] )
    return t

# Hier 3 Baumgeneratoren:
def main():
    p = Turtle()
    p.ht()
    tracer(75,0)
    u = doit1(6, Turtle(undobuffersize=1))
    s = doit2(7, Turtle(undobuffersize=1))
    t = doit3(5, Turtle(undobuffersize=1))
    a = clock()
    while True:
        done = 0
        for b in u,s,t:
            try:
                b.__next__()
            except:
                done += 1
        if done == 3:
            break

    tracer(1,10)
    b = clock()
    return "runtime: %.2f sec." % (b-a)

if __name__ == '__main__':
    main()
    mainloop()