python3.5 turtle笔记

由于项目需要,现通篇读python3.5的turtle文档,过程中,记录笔记,基本上用的多的都翻译了。

部分翻译比较随意,本人英语也比较渣。。。

官方文档

1.介绍

turtle绘图是一种向孩子们介绍编程很流行的方式,bulabula

相像一个机器龟在xy坐标平面的原点,在 import turtle 之后,给他一个命令,turtle.forward(15) 然后他在屏幕上按指定方向移动15个像素,当它移动时,他画出一条线,再给他 turtle.right(25) 命令,他在原地旋转25度

通过结合这些相似的命令,错综复杂的图像或图像也能简单的画出来。

这个turtle模块是从python2.5那里继承改进得到的,都使用了相同的名字。

它与老龟几乎百分百兼容。。bulabula

turtle模块提供turtle图形原语,以面向对象和面向过程的方式。因为它使用tkinter用于底层图形,所以它需要一个带有Tk支持的Python版本

面向对象的接口主要使用两个+两个类:

  1. TurtleScreen 类定义图形窗口作为turtle绘图的画板,他的构造函数需要tkinter.Canvas或者ScrolledCanvas作为参数,当turtle用在一些应用里时这是应当使用的。 函数 Screen() 返回一个单独的TurtleScreen的子类,这个函数应当使用在turtle被用来作为一个单独的图形工具。作为单体对象,继承它的类是不可能的。所有的TurtleScreen/Screen的方法也作为函数存在,即作为面向过程的接口的一部分。
  2. RawTurtle(别名:RawPen)定义了画在画板上的turtle对象。它的构造函数需要一个Canvas、ScrolledCanvas或TurtleScreen作为参数,因此RawTurtle对象知道在哪里绘制。 来自RawTurtle的是turtle(别名:pen)的子类,它绘制在“屏幕”实例上,如果不存在的话,屏幕实例是自动创建的。
    所有的RawTurtle/Turtle方法也作为函数存在,即部分面向过程的接口。

程序接口提供了从Screen和Turtle导出的函数,它们具有与相应方法相同的名称,每当调用来自Screen方法的函数时,就会自动创建screen对象,每当从龟方法调用的函数被调用时,一个(未命名的)turtle对象被自动创建

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

2 RawTurtle/Turtle方法和相应函数

大多数例子基于一个Turtle实例——turtle

1.turtle 运动

1 移动和绘图
  • turtle.forward(dis) | turtle.fd(dis)
    • 参数是移动距离,可以是整数或浮点
    • 表示小乌龟向前爬动一定距离
>>> 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(dis) | turtle.bk(dis) | turtle.backword(dis)
    • 参数是移动距离,可以是整数或浮点
    • 表示小乌龟向后移动一定距离
>>> turtle.position()
(0.00,0.00)
>>> turtle.backward(30)
>>> turtle.position()
(-30.00,0.00)
  • turtle.right(angle) | turtle.rt(angle)
    • 参数是一个角度,可以是整数或浮点
    • 小乌龟朝向向右偏转一定角度,这个角度默认是那个0-360°的角度,不是弧度角,可以使用 degrees() and radians() 这两函数转换。角度方向取决于turtle 模式,详见 mode()
>>> turtle.heading()
22.0
>>> turtle.right(45)
>>> turtle.heading()
337.0
  • turtle.left(angle) | turtle.lt(angle)
    • 同turtle.right(),只是这个是向左偏转
>>> 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(后见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_angley一个数作为角度
    • 设置小乌龟头的朝向到指定角度
    • standard模式:正东为0°,北为90°,依次。。。(逆时针)
    • logo模式:正北为0°,东为90°,依次。。。(顺时针)
>>> 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,画多少,一般是一个度数,比如180就是画个半圆,没有给就是画整个圆
    • 参数steps,由于圆是由内接的正多边形近似的,所以步骤决定要使用的步骤的数量。如果没有给出,它将自动计算。可以用来绘制规则多边形。比如circle(100,None,5),就会画出一个五边形
    • 半径为正,那么按逆时针方向画,否则为顺时针,并且小乌龟的位置和朝向都会根据extent的参数而不同,具体可能需要算一下,position()和heading()方法可查看具体值
>>> 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,一个颜色的字串或者rgb元组
    • 画出一个给定直径(size)和颜色(color)的点,size没给就取max(pensize+4,pensize*2)
>>> 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()
    • 在当前位置将小乌龟的轮廓画在画板上,并返回一个id,使用clearstamp(stampid)可清除
>>> turtle.color("blue")
>>> turtle.stamp()
11
>>> turtle.fd(50)
  • turtle.clearstamp(stampid)
    • 参数stampid,一个数必须是stamp()函数返回的某个值
    • 删除对应stampid的一个stamp
>>> 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个stamps或后n个stamps,当n为None时删除所以,n>0删除前n个,n<0删除后n个
>>> for i in range(8):
...     turtle.stamp()
...     turtle.fd(30)
...
5
6
7
8
9
10
11
12
>>> turtle.clearstamps(2)
>>> turtle.clearstamps(-2)
>>> turtle.clearstamps()
  • turtle.undo()
    • 撤销上一步turtle操作,可用撤消操作的数量取决于释放缓冲区的大小。
>>> for i in range(4):
...     turtle.fd(50)
...     turtle.lt(80)
...
>>> for i in range(8):
...     turtle.undo()
...
  • turtle.speed(speed=None)
    • 参数speed,一个数0到10,或者速度字串
    • 设置小乌龟画图速度,值为0到10,没有给的话为当前速度,当大于10或小于0.5,系统设为0,速度字串和值对应关系如下:
      • “fastest”: 0
      • “fast”: 10
      • “normal”: 6
      • “slow”: 3
      • “slowest”: 1
    • 速度从1到10执行越来越快的画线和旋转动画
    • 速度=0意味着没有动画发生。向前/向后使龟跳跃,同样左/右使海龟立即转动,即动画是瞬时实现
>>> turtle.speed()
3
>>> turtle.speed('normal')
>>> turtle.speed()
6
>>> turtle.speed(9)
>>> turtle.speed()
9
2 查询turtle状态
  • turtle.position() | turtle.pos()
    • 获取当前坐标
>>> turtle.pos()
(440.00,-0.00)
  • turtle.towards(x,y=None)
    • 参数x,一个数或者坐标对或者turtle实例
    • 参数y,x是一个数,y也是一个数,否则y为None
    • 返回当前位置到参数指定的位置之间的角度,取决于选择的模式
>>> turtle.goto(10, 10)
>>> turtle.towards(0,0)
225.0
  • turtle.xcor()
    • 返回turtle的x坐标
>>> turtle.home()
>>> turtle.left(50)
>>> turtle.forward(100)
>>> turtle.pos()
(64.28,76.60)
>>> print(round(turtle.xcor(), 5))
64.27876
  • turtle.ycor()
    • 返回turtle的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()
    • 返回小乌龟当前头部朝向角度,取决于选择的模式
>>> turtle.home()
>>> turtle.left(67)
>>> turtle.heading()
67.0
  • turtle.distance(x,y=None)
    • 参数x,一个数或者坐标对或者turtle实例
    • 参数y,x是一个数,y也是一个数,否则y为None
    • 返回turtle当前位置到指定位置的直线距离
>>> turtle.home()
>>> turtle.distance(30,40)
50.0
>>> turtle.distance((30,40))
50.0
>>> joe = Turtle()
>>> joe.forward(77)
>>> turtle.distance(joe)
77.0
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()
    • 将角度测量单位设置为弧度角,即以弧度角表示
>>> turtle.home()
>>> turtle.left(90)
>>> turtle.heading()
90.0
>>> turtle.radians()
>>> turtle.heading()
1.5707963267948966

2. 画笔控制

1 绘画状态
  • turtle.pendown() | turtle.pd() | turtle.down()
    • 将画笔放下,即移动画笔会绘制出图线
  • turtle.penup() | turtle.pu() | turtle.up()
    • 将画笔拿起,当移动时没有图线
  • turtle.pensize(width=None) | turtle.width(width=None)
    • 参数width,一个整数或者空
    • 设置画笔的粗细,并返回值,如果resizemode(什么东东?)设置为‘auto’,并且turtleshape是多边形,那么多边形将使用同样粗细的笔绘制,没有参数返回当前笔粗细
>>> turtle.pensize()
1
>>> turtle.pensize(10)   # from here on lines of width 10 are drawn
  • turtle.pen(pen=None,**pendict)
    • 参数pen,一个包含以下部分或全部列出的key的字典
    • 参数pendict,一个或多个关键字参数,如下列出的key
    • 说白了就是可以传递多个参数,这个参数可以是一个定义为pen的字典,或者一系列的键值对
    • 可用键值对:
      • “shown”: True/False
      • “pendown”: True/False
      • “pencolor”: color-string or color-tuple
      • “fillcolor”: color-string or color-tuple
      • “pensize”: positive number
      • “speed”: number in range 0…10
      • “resizemode”: “auto” or “user” or “noresize”
      • “stretchfactor”: (positive number, positive number)
      • “outline”: positive number
      • “tilt”: number
    • 无参数时也可返回一个当前画笔属性键值对列表,即可用来作为参数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
2 颜色控制
  • turtle.pencolor(*args)
    • 返回或者设置画笔颜色
    • 四种输入参数格式如下:
      • pencolor():返回当前画笔颜色作为一个特定字串或者元组,他可能再被用在别的地方
      • pencolor(colorstring):设置画笔为输入的字串对应的颜色,如"red",“yellow”,"#33cc8c"
      • pencolor((r,g,b)):设置rgb元组,r,g,b的值为0到colormode,colormode可以为1.0或者255,详见colormode()
      • pencolor(r,g,b):直接三个参数放入,同样值为0到colormode
    • 如果turtleshape是多边形,则多边形轮廓是用最新设定的颜色画的。
>>> colormode()
1.0
>>> turtle.pencolor()
'red'
>>> turtle.pencolor("brown")
>>> turtle.pencolor()
'brown'
>>> tup = (0.2, 0.8, 0.55)
>>> turtle.pencolor(tup)
>>> turtle.pencolor()
(0.2, 0.8, 0.5490196078431373)
>>> colormode(255)
>>> turtle.pencolor()
(51.0, 204.0, 140.0)
>>> turtle.pencolor('#32c18f')
>>> turtle.pencolor()
(50.0, 193.0, 143.0)
  • turtle.fillcolor(*args)
    • 返回或者设置填充颜色
    • 四种输入参数格式同上
>>> 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()
    • color()没有参数传入,返回一个元组,第一个是pencolor()值,第二个是fillcolor()值
    • color(colorstring),color((r,g,b)),color(r,g,b),同时设置pencolor和fillcolor为一个颜色
    • color(colorstring1,colorstring2),color((r1,g1,b1),(r2,g2,b2))相当于pencolor(color1),fillcolor(color2),即pencolor为第一个颜色,fillcolor为第二个颜色
>>> turtle.color("red", "green")
>>> turtle.color()
('red', 'green')
>>> color("#285078", "#a0c8f0")
>>> color()
((40.0, 80.0, 120.0), (160.0, 200.0, 240.0))
3 填充
  • turtle.filling()
    • 返回填充状态,正在填充返回True,否则返回False
>>> turtle.begin_fill()
>>> if turtle.filling():
...    turtle.pensize(5)
... else:
...    turtle.pensize(3)
  • turtle.begin_fill()
    • 要填充一个图形之前调用这个方法
  • turtle.end_fill()
    • 在最后一次调用begin_fill()之间的图像进行填充
>>> turtle.color("black", "red")
>>> turtle.begin_fill()
>>> turtle.circle(80)
>>> turtle.end_fill()
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,True/False
    • align,‘left’/‘right’/‘center’
    • font,一个元组(字体名,字大小,字体类型)
    • 根据font参数将arg写入画板,align控制写入的位置(当前画笔的左、中、右),如果move为True,画笔会移动到写入文本的右下角,默认move为False
>>> turtle.write("Home = ", True, align="center")
>>> turtle.write((0,0), True)

3.turtle状态

1 可见性
  • turtle.hideturtle() | turtle.ht()
    • 使turtle不可见,当绘制一些复杂的图形时,隐藏turtle可以加快绘图速度
>>> turtle.hideturtle()
>>> turtle.showturtle()
  • turtle.isvisible()
    • 如果turtle可见返回Ture,否则返回False
>>> turtle.hideturtle()
>>> turtle.isvisible()
False
>>> turtle.showturtle()
>>> turtle.isvisible()
True
2 外观
  • turtle.shape(name=None)
    • 参数name,一个有效的形状名字字串
    • 设置turtle形状,就是stamp画出的形状,如果没有给,返回当前形状名称,这个参数必须是TurtleScreen形状库中存在的,初始的有:“arrow”, “turtle”, “circle”, “square”, “triangle”, “classic”。学习更多如何处理形状详见Screen方法register_shape()
>>> turtle.shape()
'classic'
>>> turtle.shape("turtle")
>>> turtle.shape()
'turtle'
  • turtle.resizemode(rmode=None)(之前好像提到这个东西了)
    • 参数rmode,‘auto’/‘user’/‘noresize’
    • 设置resizemode,无参数返回当前值,不同resizemode如下:
      • “auto”:根据pensize值自动调整tutle形状外观
      • “user”:根据shapesize()设置的拉伸因子和轮廓宽度来修改turtle图形外观
      • “noresize”:turtle外观没有任何调整
    • 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是水平方向,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,数
    • 设置或返回当前shearfactor,shear(貌似翻译为剪切wiki,是一类特殊现线变换,反转就是将turtle图形变换了以下,但是朝向不改变,读者可以试试这个函数看看效果,有点扭曲拉伸的意思)
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.shearfactor(0.5)
>>> turtle.shearfactor()
0.5
  • turtle.tilt(angle)
    • 参数angle,一个数
    • 就是旋转了turtle图形,根据指定的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图形到指定角度,与当前旋转的角度无关
>>> turtle.reset()
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.settiltangle(45)
>>> turtle.fd(50)
>>> turtle.settiltangle(-45)
>>> turtle.fd(50)
  • turtle.tiltangle(angle=None)
    • 参数angle,一个数
    • 给定angle,作用等同于settiltangle(),无参数返回当前tilt angle
>>> turtle.reset()
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.tilt(45)
>>> turtle.tiltangle()
45.0
  • turtle.shapetransform(t11=None,t12=None,t21=None,t22=None)
    • t11,t12,t21,t22,都是数
    • 设置或返回当前turtle图形的转换矩阵,无参数返回一个元组为当前转换矩阵信息
    • 给了四个参数就根据这四个参数构成的矩阵进行转换, t11 * t22 - t12 * t21不能为0,否则报错,根据给定的矩阵修改拉伸因子、剪切因子和倾角,就是前面几个函数的作用,具体怎么变的不了解,数学渣渣。。。可以百度一波
>>> 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))

4.使用事件

  • turtle.onclick(fun,btn=1,add=None)
    • 参数fun,一个有两个参数的函数,单点画布时调用,这两个参数是点击画布后传入的点击point的坐标,注意,点击turtle图形才有效。。。
    • btn,鼠标按键的标号,默认为1,左键
    • add,True/False,为True,一个新的绑定将会添加,否则是之前的绑定
    • 绑定fun到鼠标点击事件,fun为None,存在的绑定移除
>>> def turn(x, y):
...     left(180)
...
>>> onclick(turn)  # Now clicking into the turtle will turn it.
>>> onclick(None)  # event-binding will be removed
  • turtle.onrelease(fun,btn=1,add=None)
    • 参数同上
    • 当释放鼠标按键时调用
>>> 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
    • 每一个鼠标移动事件序列都是在turtle上的鼠标点击事件之前进行的
turtle.ondrag(turtle.goto)

上面代码作用:点击和拖拽turtle会将它移动到屏幕上,从而产生手绘(如果钢笔是向下的)(还是有点bug的,想通过这种方式做个手绘板基本不可能)

5.特殊Turtle方法

  • turtle.begin_ploy()
    • 开始记录多边形的顶点。当turtle的位置是多边形的第一顶点。
  • turtle.end_ploy()
    • 停止记录多边形顶点,当前turtle位置是多边形最后一个顶点
  • 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()
    • 创建并返回一个turtle的一个克隆,具有相同属性
>>> mick = Turtle()
>>> joe = mick.clone()
  • turtle.getturtle() | turtle.getpen()
    • 返回turtle对象本身,只有合理使用:作为一个函数返回一个“匿名龟”
>>> pet = turtle.getturtle()
>>> pet.fd(100)
>>> pet
<turtle.Turtle object at 0x...>
  • turtle.getscreen()
    • 返回turtle绘制图像的TurtleScreen对象,就是那个画笔,TurtleScreen方法也可以被这个对象调用
>>> ts = turtle.getscreen()
>>> ts
<turtle._Screen object at 0x...>
>>> ts.bgcolor("pink")
  • turtle.setundobuffer(size)
    • 参数size,一个整数或None
    • 设置或者禁用undo缓冲区,参数是个数,则给定一个改大小的缓冲区,表示可通过undo()方法撤销最大的turtle操作,如果为空就是不允许undo()操作
>>> turtle.setundobuffer(42)
  • turtle.undobufferentries()
    • 返回缓冲区中的条目数。
>>> while undobufferentries():
...     undo()

6.复合图形

使用一个较复杂的turtle图形,拥有不同形状和颜色,需要使用Shape类

  1. 创建一个Shape对象
  2. 按需向这个对象添加不同模块,使用addcomponent()方法
>>> s = Shape("compound")
>>> poly1 = ((0,0),(10,-5),(0,10),(-10,-5))
>>> s.addcomponent(poly1, "red", "blue")
>>> poly2 = ((0,0),(10,-5),(-10,-5))
>>> s.addcomponent(poly2, "blue", "red")
  1. 现在添加图形到Screen图形列表并使用它
>>> register_shape("myshape", s)
>>> shape("myshape")

注:register_shape()方法以不同的方式在内部使用Shape类程序需要处理Shape类只有当使用compound shape的时候

3.TurtleScreen/Screen相关方法函数

大多数例子使用的TurtleScreen实例的名字叫screen

1.窗口控制

  • turtle.bgcolor(*args)
    • 参数agrs,传入的颜色参数,像之前一样的可以是字串,元组(根据colormode不同大小)
    • 设置或者返回背景颜色
>>> 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
    • 设置背景图片或返回背景图片名字,有图片名字就将图片设为背景,nopic会取消背景图片,None返回当前背景图片
>>> screen.bgpic()
'nopic'
>>> screen.bgpic("landscape.gif")
>>> screen.bgpic()
"landscape.gif"
  • turtle.clear() | turtle.clearscreen()
    • 清空画板所有,所有都重置
      注:使用clearscreen()时是一个全局方法,clear()不同于Turtle的clear
  • turtle.reset() | turtle.resetscreen()
    • 重置画板上的Turtles到初始状态
  • turtle.screensize(canvwidth=None,canvheight=None,bg=None)
    • 参数canvwidth,正整数,新画布宽度
    • canvheight,正整数,新画板高度
    • bg,颜色,新背景颜色
    • 没有参数返回当前(canvaswidth,canvasheight),有参数就重置画板大小,但不改变窗口大小,观察窗口外画布上的图形可以使用滚动条
>>> screen.screensize()
(400, 300)
>>> screen.screensize(2000,1500)
>>> screen.screensize()
(2000, 1500)

寻找逃跑的龟龟:-)

  • turtle.setworldcoordinates(llx,lly,urx,ury)
    • 参数llx,一个数,左下角x坐标
    • lly,左下角y坐标
    • urx,右上角x坐标
    • ury,右上角y坐标
    • 设置用户定义的坐标系统,必要时切换到world模式,这将执行一个screen.reset(),如果world模式被激活,则根据新的坐标重新绘制所有绘图
    • 注意:在用户定义的系统,角度可能出现畸变
>>> 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

2.动画控制

  • turtle.delay(delay=None)
    • 参数delay,正整数
    • 设置或返回绘画延迟,毫秒单位。(这大约是两个连续画布更新之间的时间间隔。)绘制延迟越长,动画就越慢。
>>> screen.delay()
10
>>> screen.delay(5)
>>> screen.delay()
5
  • turtle.tracer(n=None,delay=None)
    • 参数n,非负数
    • delay,非负数
    • 打开turtle动画,并设置延迟更新图纸,n给定,则只有第n次规则屏幕更新(用来加速复杂图形绘制)。在没有参数情况下调用返回当前存储的n。第二个参数等同delay()作用
>>> screen.tracer(8, 25)
>>> dist = 2
>>> for i in range(200):
...     fd(dist)
...     rt(90)
...     dist += 2
  • turtle.update()
    • 展示TurtleScreen更新,当tracer关闭使用
      也可参见RawTurtle/turtle的方法speed()(感觉跟这个差不多。。。)

3.使用屏幕事件

  • turtle.listen(xdummy=None,ydummy=None)
    • 聚焦在TurtleScreen(为了收集key-event),dummy参数提供是为了传递listen()到onclick方法
  • turtle.onkey(fun,key)
  • turtle.onkeyrelease(fun,key)
    • 参数fun,一个函数或无参数
    • key,字串,按键(如‘a’)或按键标识(如‘space’)
    • 绑定函数到按键释放事件,如果fun为None,事件绑定移除,为了注册事件,TurtleScreen必须聚集就是使用listen()函数
>>> def f():
...     fd(50)
...     lt(60)
...
>>> screen.onkey(f, "Up")
>>> screen.listen()
  • turtle.onkeypress(fun,key=None)
    • 跟上个函数差不多,这个是按下按键触发,同时key可以为空,为空就是注册所有按键
    • 同样需要使用listen()方法聚焦
>>> def f():
...     fd(50)
...
>>> screen.onkey(f, "Up")
>>> screen.listen()

onkey()方法貌似是这两个函数的结合体。。。

  • turtle.onclick(fun,btn=1,add=None) | turtle.onscreenclick(fun,btn=1,add=None)
    • 参数:fun,绑定的函数,有两个参数,是点击point的坐标
    • num,鼠标按键标号,默认1,为左键
    • add,True/False,True:一个新绑定将会添加,就是绑定多个函数,False:替代原先的方法
>>> 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

screen是TurtleScreen实例,可以用getscreen()方法得到,turtle是turtle实例,可以用getturtle()方法得到

注:This TurtleScreen method is available as a global function only under the name onscreenclick. The global function onclick is another one derived from the Turtle method onclick.

  • turtle.ontimer(fun,t=0)
    • 参数:fun,无参数的的函数
    • t,非负数
    • 声明一个定时器,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主循环函数,必须是Turtle程序最后一个语句,如果脚本运行在IDLE在-n模式(无子进程)则不能使用,以交互使用Turtle图形(貌似就是使用在用一个文件保存程序的最后)
>>> screen.mainloop()

4.输入方法

  • turtle.textinput(title, prompt)
    • 参数title,prompt都是字串
    • 弹出一个对话框输入字符串。参数标题是对话框窗口的标题,提示是一个文本,主要描述要输入什么信息。返回字符串输入。如果取消对话,则返回None。
>>> screen.textinput("NIM", "Name of first player:")
  • turtle.numinput(title, prompt, default=None, minval=None, maxval=None)
    • 前两个跟上面一样
    • default,minval,maxval都是数,可选
    • 大体功能跟上面一样,就是这个是输入的数字,而且,有一个默认值,一个最大最小,输入的数要在最大最小之间。
>>> screen.numinput("Poker", "Your stakes:", 1000, minval=10, maxval=10000)

5.设置和特殊方法

  • turtle.mode(mode=None)
    • 参数mode,“standard”,“logo”,"world"中的一个
    • 设置模式并且重置,没有参数返回当前模式
    • world模式是自定义的坐标系
      • standard,初始heading为east,positive angles为逆时针
      • logo,初始heading为north,positive angles为顺时针
>>> mode("logo")   # resets turtle heading to north
>>> mode()
'logo'
  • turtle.colormode(cmode=None)
    • 参数cmode,1.0或255
    • 返回或者设置colormode,之后使用颜色的rgb就是0到colormode
>>> screen.colormode(1)
>>> turtle.pencolor(240, 160, 80)
Traceback (most recent call last):
     ...
TurtleGraphicsError: bad color sequence: (240, 160, 80)
>>> screen.colormode()
1.0
>>> screen.colormode(255)
>>> screen.colormode()
255
>>> turtle.pencolor(240,160,80)
  • turtle.getcanvas()
    • 返回TurtleScreen的Canvas,
    • 对那些知道如何使用Tkinter Canvas的内部人士来说很有用
>>> cv = screen.getcanvas()
>>> cv
<turtle.ScrolledCanvas object ...>
  • turtle.getshapes()
    • 返回一个列表包含当前所有可用的turtle形状
>>> screen.getshapes()
['arrow', 'blank', 'circle', ..., 'turtle']
  • turtle.register_shape(name,shape=None) | turtle.addshape(name,shape=None)
    • 有三种不同的方式调用在这个函数:
    • 1.name是一个gif文件,shape为None,直接保存相应的图片形状
>>> screen.register_shape("turtle.gif")
注:当转动turtle时,图片形状不会旋转,所有他们不显示turtle的朝向
+ 2.name是一个字串,shape是一系列坐标,直接保存相应的多边形图形
>>> screen.register_shape("triangle", ((5,-3), (0,5), (-5,-3)))
+ 3.name是一个字串,shape是一个Shape对象,直接保存对应shape

添加图形到turtle图形列表,只有这样注册图形才能使用通过shape(shapename)命令

  • turtle.turtles()
    • 在屏幕上返回所有turtle实例
>>> for turtle in screen.turtles():
...     turtle.color("red")
  • turtle.window_height()
    • 返回turtle窗口高度
>>> screen.window_height()
480
  • turtle.window_width()
    • 返回turtle窗口宽度
>>> screen.window_width()
640

6.Screen特有的方法,没有继承自TurtleScreen

  • turtle.bye()
  • turtle.exitonclick()
  • turtle.setup()
  • turtle.title(titlestring)

用的不多,需要自己看链接

4.公共类

  • class turtle.RawTurtle(canvas) | class turtle.RawPen(canvas)
    • 参数canvas,tkinter.Canvas,ScrolledCanvas,TurtleScreen
    • 创建一个实例,有"methods of Turtle/RawTurtle"下所有方法
  • class turtle.Turtle
    • RawTurtle的一个子类,有相同的接口,但是是绘制在一个特定的Screen对象上,第一次使用时会自动创建
  • class turtle.TurtleScreen(cv)
    • 参数cv,一个tkinter.Canvas
    • 提供如上描述的方法,如setbg()
  • class turtle.Screen
    • TurtleScreen的子类,有多的四个方法添加进去了
  • class turtle.ScrolledCanvas(master)
    • master – some Tkinter widget to contain the ScrolledCanvas, i.e. a Tkinter-canvas with scrollbars added
    • 被Screen类使用,从而提供一个供turtle绘画的滚动的Canvas
  • class turtle.Shape(type_,data)
    • 参数type_,“polygon”,“image”,"compound"中的一个
    • 使用不同type_对应的data如下:
      • polygon:一个多边形的tuple,比如一系列坐标构成的元组
      • image:一个图片
      • compound:None,但是需要再使用addcomponent(poly,fill,outline=None)方法
      • 参数ploy:一个多边形,一些了坐标元组
      • fill,填充的颜色
      • outline,一个外围轮廓的颜色
>>> poly = ((0,0),(10,-5),(0,10),(-10,-5))
>>> s = Shape("compound")
>>> s.addcomponent(poly, "red", "blue")
>>> # ... add more components and then use register_shape()
  • class turtle.Vec2D(x,y)
    • 一个二位向量组的类,用作辅助类,对turtle图形程序也有用,源自元组,所以向量是元组
    • 支持如下运算:
      • a + b vector addition
      • a - b vector subtraction
      • a * b inner product
      • k * a and a * k multiplication with scalar
      • abs(a) absolute value of a
      • a.rotate(angle) rotation

5.帮助与配置

链接

6.样例

链接
官方给出的一些demo

7.自python2.6的一些变化

链接

8.自python3.0的一些变化

链接

10-05 15:56