• 1 turtle.setheading(angle):海龟朝向,angle为度数【注意：与当前海龟的朝向没有关系，90度就一定向上】

turtle.setheading(90)#海龟的朝向为90度即向上
turtle.setheading(-90)#海龟的朝向为-90度即向下

• 2 turtle.left(angle) | lt(angle):绘制方向向左旋转angle度

turtle.lt(45)#向左转45度
turtle.lt(-45)#向右转45度

• 3 turtle.right(angle) | rt(angle):在海龟当前头的方向上再向右转

turtle.rt(45) #向右转45度
turtle.rt(-90)#向左转90度

• 4 turtle.forward(distance) | fd(distance) :前进；distance为整型或者浮点型

turtle.forward(100)#前进100像素
turtle.forward(-100)#后退100像素

• 5 turtle.backward(distance) | bk(distance) | back(distance):后退；distance为整型或者浮点型

turtle.backward(200)#画笔向绘制方向的相反方向移动200像素
turtle.backward(-200)#画笔向绘制方向的方向移动200像素

• 6 turtle.goto(x, y=None) | setpos(x, y=None) | setposition(x, y=None) ：移动到某个位置；参数为对应点的坐标

参数x(一个数字或者一个二维的数组)
参数y(一个数字或者为None)
如果y为None,x必须是一个二维的数组
turtle.setpos((20,80)) #移动到位置(20,80)
turtle.setposition(-120,20)#移动到位置(-120,20)
turtle.goto(60,30)#移动到位置(60,30)
turtle.goto(60,-30)#移动到位置(60,-30)

• 7 turtle.setx(x):设置x坐标,x的值为整型或者浮点型

import turtle
turtle.penup()
turtle.setx(-200)
turtle.pendown()
turtle.left(90)
turtle.forward(100)
turtle.done()

[注意：在使用goto()和setx()、sety()的时候要记得先提笔，然后再移动，最后再落笔]

• 8 turtle.sety(y):设置y坐标，y的值为整型或者浮点型

import turtle
turtle.penup()
turtle.sety(-200)
turtle.pendown()
turtle.left(90)
turtle.forward(100)
turtle.done()

• 9 turtle.home()：将位置和方向恢复到初始状态，位置初始坐标为(0,0)

turtle.home()

• 10 turtle.circle(radius, extent=None, steps=None)：

参数：
radius : 圆半径，数值为整型或者浮点型，为正数则逆时针画，为负数则顺时针画，方向随着轨迹的变化而变化

import turtle
turtle.circle(5.5)

extent : 一个角度,其值可以是整型、浮点型或者None,决定哪部分圆圈被绘制，不提供extent表示画完整的圆,值为正是沿着画笔方向画，值为负沿着画笔反方向画

import turtle
turtle.circle(100, 120)
turtle.done()

import turtle
turtle.circle(100, -120)
turtle.done()

steps:边数，其值为整型或者None,指定半径radius前提下，完成extent的角度时，分了几步

#逆时针方向半径为40画五边形(5步画接近整圆的图形)
turtle.circle(40, None, 5)

• 11 turtle.dot(size=None, color)：绘制一个直径为size，颜色为color的圆点
  参数：
  size:一个整型数，如果指定时，size>=1;如果未指定，即为None,那么取pensize+4 和 2pensize中的最大值
  color：一个颜色字符串或颜色数值元组，未指定则是画笔颜色

import turtle
turtle.dot(50, "blue")
turtle.done()

• 12 turtle.stamp()和turtle.clearstamp(stamp_id)和turtle.clearstamp(n=None)
  turtle.stamp(): 是在当前位置拷贝一份此时箭头的形状，返回一个stamp_id(int型)
  turtle.clearstamp(stamp_id): 用来删除指定stamp_id的箭头形状
  turtle.clearstamps(n=None),n为None时表示删除所有拷贝的箭头形状；n=0不删除；n>0表示删除前n个；n<0表示删除后n个；

#让我们先看一下turtle.stamp()的作用
import turtle
#画笔颜色设为红色
turtle.color("red")
#定义一个颜色列表
color = ['blue', 'yellow', 'red', 'green', 'gray']
num = 0
while num < 5:
    #当前位置拷贝一份箭头形状,也就是在当前的位置留下一个箭头的形状
    stamp_id = turtle.stamp()
    #在这里我们为了识别方便改变一下画笔的颜色
    turtle.color(color[num])
    #前进100像素
    turtle.fd(100)
    num += 1
turtle.done()

#接下来，我们来看一下turtle.clearstamp(stamp_id)的作用
import turtle
#画笔颜色设为红色
turtle.color("red")
#定义一个颜色列表
color = ['blue', 'yellow', 'red', 'green', 'gray']
num = 0
while num < 5:
    #当前位置拷贝一份箭头形状,也就是在当前的位置留下一个箭头的形状
    stamp_id = turtle.stamp()
    #在这里我们为了识别方便改变一下画笔的颜色
    turtle.color(color[num])
    #前进100像素
    turtle.fd(100)
    num += 1
#删除拷贝的箭头形状(此处id最后一次复制的stamp_id)
turtle.clearstamp(stamp_id)
turtle.done()

#还可以这样实现
import turtle
#画笔颜色设为红色
turtle.color("red")
#定义一个颜色列表
color = ['blue', 'yellow', 'red', 'green', 'gray']
num = 0
while num < 5:
    #当前位置拷贝一份箭头形状,也就是在当前的位置留下一个箭头的形状
    stamp_id = turtle.stamp()
    #在这里我们为了识别方便改变一下画笔的颜色
    turtle.color(color[num])
    #前进100像素
    turtle.fd(100)
    num += 1
#检查stamp_id
print(stamp_id) #12
#删除拷贝的箭头形状(此处id最后一次复制的stamp_id)
turtle.clearstamp(12)
turtle.done()

turtle.clearstamp(stamp_id)的图

#最后我们再来看一下turtle.clearstamps(n)的作用
import turtle
#画笔颜色设为红色
turtle.color("red")
#定义一个颜色列表
color = ['blue', 'yellow', 'red', 'green', 'gray']
num = 0
while num < 5:
    #当前位置拷贝一份箭头形状,也就是在当前的位置留下一个箭头的形状
    stamp_id = turtle.stamp()
    #在这里我们为了识别方便改变一下画笔的颜色
    turtle.color(color[num])
    #前进100像素
    turtle.fd(100)
    num += 1
#删除前一个
turtle.clearstamps(1)#删除第一个拷贝的形状
turtle.done()

turtle.clearstamps(1)

import turtle
#画笔颜色设为红色
turtle.color("red")
#定义一个颜色列表
color = ['blue', 'yellow', 'red', 'green', 'gray']
num = 0
while num < 5:
    #当前位置拷贝一份箭头形状,也就是在当前的位置留下一个箭头的形状
    stamp_id = turtle.stamp()
    #在这里我们为了识别方便改变一下画笔的颜色
    turtle.color(color[num])
    #前进100像素
    turtle.fd(100)
    num += 1
#删除后一个
turtle.clearstamps(-1)#删除最后一个拷贝形状
turtle.done()

turtle.clearstamps(-1)

import turtle
#画笔颜色设为红色
turtle.color("red")
#定义一个颜色列表
color = ['blue', 'yellow', 'red', 'green', 'gray']
num = 0
while num < 5:
    #当前位置拷贝一份箭头形状,也就是在当前的位置留下一个箭头的形状
    stamp_id = turtle.stamp()
    #在这里我们为了识别方便改变一下画笔的颜色
    turtle.color(color[num])
    #前进100像素
    turtle.fd(100)
    num += 1
#全部删除
turtle.clearstamps()#删除全部拷贝形状
turtle.done()

turtle.clearstamps()

import turtle
#画笔颜色设为红色
turtle.color("red")
#定义一个颜色列表
color = ['blue', 'yellow', 'red', 'green', 'gray']
num = 0
while num < 5:
    #当前位置拷贝一份箭头形状,也就是在当前的位置留下一个箭头的形状
    stamp_id = turtle.stamp()
    #在这里我们为了识别方便改变一下画笔的颜色
    turtle.color(color[num])
    #前进100像素
    turtle.fd(100)
    num += 1
#不删除
turtle.clearstamps(0)
turtle.done()

turtle.clearstamps(0)

• 13 turtle.undo()：每调用一次就撤销最后的一次动作，需要撤销所有可通过while turtle.undobufferentries()，turtle.undobufferentries():返回当前可撤销的次数

import turtle
#画笔颜色设为红色
turtle.color("red")
#定义一个颜色列表
color = ['blue', 'yellow', 'red', 'green', 'gray']
num = 0
while num < 5:
    #当前位置拷贝一份箭头形状,也就是在当前的位置留下一个箭头的形状
    stamp_id = turtle.stamp()
    #在这里我们为了识别方便改变一下画笔的颜色
    turtle.color(color[num])
    #前进100像素
    turtle.fd(100)
    num += 1
#不删除
turtle.clearstamps(0)
#一直撤销最后一个动作直到不可撤销
while turtle.undobufferentries():
    #撤销最后的一次动作
    turtle.undo()
turtle.done()

• 14 turtle.speed(speed=None)
  参数：
  speed:是0-10的整数(1-10越来越快，0表示最快，参数为小数会被自动置为整数)或者如下内置的速度字符串;(1)如果>10或者<0.5则被置换为0，(2)为>=0.5的小数时被置为四舍五入的值。(3)speed未设置则返回当前速度

内置的速度字符串：
“fastest”:0
“fast”:10
“normal”:6
“slow”:3
“slowest”:1

• 15 turtle.position() | pos()：返回(海龟)箭头当前位置坐标

import turtle
print(turtle.pos())#(0.00,0.00)

• 16 turtle.towards(x, y=None)：返回(海龟)箭头当前位置指向(x,y)位置连线的向量的角度(取决于当前模式,“standard”/”world”默认方向向右(即东)逆时针开始;“logo”模式默认方向向上(即北)顺时针开始)

参数：
x：x可以是一个number或者一个二维的数组或者一个turtle instence(海龟实例)
y：x是一个number,y就是一个number;否则y为None

import turtle
turtle.goto(20, 20)
#移动后，位置为(20,20),两个向量分别是(20,20)点到(0,0)点的向量和(20,20)点到箭头当前方向的向量
angle = turtle.towards(0, 0)
print("两向量角度:", angle)#225.0

angle = turtle.towards((0, 0))
print("两向量角度:", angle)#225.0

turtle1 = turtle.Turtle()
turtle1.setpos(0, 0)
angle = turtle.towards(turtle1)
print("两向量角度:", angle)#225.0

turtle1 = turtle.Turtle()
turtle1.setpos(0, 0)
angle = turtle1.towards(turtle1)
print("两向量角度:", angle)#0.0

turtle2 = turtle.Turtle()
turtle2.setpos(50, 50)
angle = turtle1.towards(turtle2)
print("两向量角度:", angle) #45.0

• 17 turtle.xcor()：返回箭头的x坐标；turtle.ycor()：返回箭头的y坐标；

import turtle
turtle.lt(50)
turtle.fd(100)
#打印箭头当前坐标
print(turtle.pos())  #(64.28,76.60)
print(round(turtle.xcor(), 5))#保留5位读取x坐标 64.27876
print(round(turtle.ycor(), 5))#保留5位读取y坐标 76.60444

• 18 turtle.heading()：返回当前(海龟)箭头方向角度

import turtle
turtle.lt(50)
turtle.fd(100)
print(turtle.heading()) #50.0

• 19 turtle.distance(x, y=None)：返回当前(海龟)箭头坐标与坐标(x,y)间距离或者当前(海龟)箭头坐标与另一个(海龟)箭头坐标间距离

参数：
x : x可以是一个number或一个二维数组，或者一个turtle instance(海龟实例)
y : x是一个number，y就是一个number,否则y为None

import turtle
turtle.home()
print(turtle.distance(30, 40))#距离为50.0
print(turtle.distance((30, 40)))#距离为50.0
joe = turtle.Turtle()
joe.setpos(30, 40)
print(turtle.distance(joe))#距离为50.0

• 20 turtle.degrees(fullcircle=360.0) 和 turtle.radians()
  turtle.degrees：表示设置一个完整圆的“度数”。默认为360度，参数fullcircle(number类型)，如果是360度的90度，改整圆为400度，则此时角度为100度；

turtle.radians()：表示将一个完整圆的“度数”设置成2π，如果是360度的90度，那么此时的角度时π/2;

import turtle
turtle.home()
turtle.left(90)
print(turtle.heading())#90.0
turtle.degrees(400.0)#100.0
print(turtle.heading())#90.0
turtle.degrees(360)
print(turtle.heading())
turtle.radians()
print(turtle.heading())#1.5707963267948966

• 21 turtle.penup() | turtle.up() | turtle.pu()：画笔抬起，此时移动不会进行绘制操作

turtle.pu()

• 22 turtle.pendown() | turtle.down() | turtle.pd()：画笔按下，此时移动会进行绘制操作

turtle.pd()

• 23 turtle.width(width=None) | turtle.pensize(width=None)：设置或返回线的粗细(width=None时表示返回，不为None表示设置)，注意如果resizemode设置成“auto”并且绘制的是多边形，则多边形绘制时使用的是粗细相同的线条

import turtle
#设置画笔的尺寸
turtle.pensize(5)
#打印返回画笔尺寸的大小
print(turtle.pensize()) #5

• 24 turtle.pen(pen=None, **pendict)：设置或返回画笔字典中对应的画笔属性(一个键值对)

参数：
pen：画笔的样式，默认None是初始的状态，可以将别的画笔的实例对象作为画笔的样式
pendict(画笔字典键值对):如下
"fillcolor": color-string or color-tuple
"outline"：positive number
"pencolor": color-string or color-tuple
"pendown":True/False
"pensize": positive number
"resizemode":"auto" or "user" or "noresize"
"shearfactor":number
"shown":True/False
"speed":number in range 0..10
"stretchfactor" : (positive number, positive number)
"tilt":number

import turtle
#默认情况
print(turtle.pen())#{'shown': True, 'pendown': True, 'pencolor': 'black', 'fillcolor': 'black', 'pensize': 1, 'speed': 3, 'resizemode': 'noresize', 'stretchfactor': (1.0, 1.0), 'shearfactor': 0.0, 'outline': 1, 'tilt': 0.0}
#进行设置
turtle.pen(fillcolor="black", pencolor="red", pensize=10)
#设置后的结果
print(turtle.pen())#{'shown': True, 'pendown': True, 'pencolor': 'red', 'fillcolor': 'black', 'pensize': 10, 'speed': 3, 'resizemode': 'noresize', 'stretchfactor': (1.0, 1.0), 'shearfactor': 0.0, 'outline': 1, 'tilt': 0.0}
turtle.fd(100)
penstate=turtle.pen()#创建画笔的实例对象
#设置画笔的属性
turtle.pen(penstate, fillcolor="green")

• 25 turtle.isdown()：获取画笔是否按下，按下返回True,否则返回False

import turtle
turtle.penup()#抬笔
print(turtle.isdown())#False
turtle.pendown()#落笔
print(turtle.isdown())#True

• 26 turtle.pencolor(*args)：设置或返回画笔的颜色(设置后海龟箭头的外轮廓也是这个颜色)

import turtle
#返回画笔颜色
print(turtle.pencolor())
#设置画笔的颜色
turtle.pencolor("red")
turtle.fd(50)
#设置画笔颜色
turtle.pencolor("#33cc8c")
turtle.fd(50)
#pencolor(r,g,b)或pencolor((r,g,b))语法设置画笔颜色，取决于颜色模式，colormode为1.0时r,g,b取值范围在0-1.0小数，colormode为255时r,g,b取值范围在0-255的整数
turtle.getscreen().colormode(1.0)
#打印颜色模式
print(turtle.getscreen().colormode())
turtle.pencolor(0.1, 0.2, 0)
turtle.fd(50)
turtle.getscreen().colormode(255)
#打印颜色模式
print(turtle.getscreen().colormode())
turtle.pencolor(30, 210, 180)
turtle.fd(50)

• 27 turtle.fillcolor(*args) ：返回或设置画笔填充颜色(设置后海龟箭头内部填充也是这个颜色)

import turtle
print(turtle.fillcolor())
screen = turtle.getscreen()
#设置填充颜色
turtle.fillcolor("red")
turtle.fd(50)
#设置填充颜色
turtle.fillcolor("#33cc8c")
turtle.fd(50)
# fillcolor(r, g, b)fillcolor((r, g, b))语法设置画笔颜色,取决于颜色模式,colormode颜色模式取值1.0或255,colormode为1.0时r,g,b取值范围0-1.0小数;colormode为255时r,g,b取值范围0-255的整数
#设置填充颜色模式
screen.colormode(1.0)
#打印颜色模式
print(screen.colormode())
turtle.fillcolor(0.1, 0.2, 0)
turtle.fd(50)
#设置填充颜色模式
screen.colormode(255)
#打印填充颜色模式
print(screen.colormode())
turtle.fillcolor(30, 210, 180)
turtle.fd(50)

• 28 turtle.color(*args)：设置或返回pencolor和fillcolor

import turtle
#返回pencolor和fillcolor()
print(turtle.color()) #('black', 'black')
turtle.color("red")
print(turtle.color()) #('red', 'red')
turtle.color("#285078", "#a0c8f0")
print(turtle.color()) #((0.1568627450980392, 0.3137254901960784, 0.47058823529411764), (0.6274509803921569, 0.7843137254901961, 0.9411764705882353))
turtle.color("red", "green")
print(turtle.color())#('red', 'green')

• 29 turtle.filling()返回填充状态(填充状态则返回True,否则返回False)、开始填充图形之前先调用turtle.begin_fill()、填充完图形后调用turtle.end_fill()

import turtle
#返回填充状态False
print(turtle.filling())
#绘制shape之前先准备开始fill
turtle.begin_fill()
#返回填充状态True
print(turtle.filling())
turtle.circle(20, None, 6)
#绘制完shape之后结束fill
turtle.end_fill()
#返回False
print(turtle.filling())

[注意：screen其实是TurtleScreen对象的实例，使用screen是要通过screen = turtle.getscreen()得到]

• 30 turtle.reset() | turtle.resetscreen() | screen.reset() | screen.resetscreen()：从屏幕中删除指定海龟的绘图，海龟回到原点并设置所有变量为默认值，即位置恢复到原点（0, 0）位置，“standard”/"world"模式方向恢复到默认的向右；“logo”模式方向恢复到默认的向上

import turtle
#返回填充状态False
print(turtle.filling())
#绘制shape之前先准备开始fill
turtle.begin_fill()
#返回填充状态True
print(turtle.filling())
turtle.circle(20, None, 6)
#绘制完shape之后结束fill
turtle.end_fill()
#返回False
print(turtle.filling())
#turtle.reset()
screen = turtle.getscreen()
screen.reset()
turtle.done()

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

import turtle
#返回填充状态False
print(turtle.filling())
#绘制shape之前先准备开始fill
turtle.begin_fill()
#返回填充状态True
print(turtle.filling())
turtle.circle(20, None, 6)
#绘制完shape之后结束fill
turtle.end_fill()
turtle.rt(90)
turtle.forward(100)

turtle1 = turtle.Turtle()
turtle1.goto(100, 200)
turtle1.forward(100)
#返回False
print(turtle.filling())
turtle.clear()
turtle1.reset()
turtle.done()

• 32 turtle.write(arg, move=False, align="left", font=("Arial", 8, "normal"))：绘制文本
  参数：
  arg：书写的内容
  move：True/False：如果move为True，则画笔会移动到文本的右下角，这样文字就不会叠在一起了
  align： 指定对齐方式("left","center"或"right")
  font： 一个三元组 (fontname, fontsize, fonttype)设置字体

import turtle
turtle.write("home=", True, align="center")
turtle.write((0,500000), True)
turtle.write("hellohhhhh", True)
turtle.done()

import turtle
turtle.write("home=", True, align="center")
turtle.write((0,500000), False)
turtle.write("hellohhhhh", False)
turtle.done()

• 33 turtle.hideturtle() | turtle.ht()：隐藏画笔(即海龟箭头)，此时只要画笔是按下状态，虽然隐藏了但是还是能绘制图形的，复杂的快速绘图时效果显著

turtle.hideturtle()

• 34 turtle.showturtle() | turtle.st()：显示画笔(即海龟箭头)

turtle.showturtle()

• 35 turtle.isvisible()：返回(海龟)画笔当前是否是可见状态，可见返回True,否则返回False

import turtle
turtle.hideturtle()
print(turtle.isvisible())#False
turtle.showturtle()
print(turtle.isvisible())#True

• 36 turtle.shape(name=None)：设置或返回(海龟)画笔箭头形状名
  参数：name---形状名，必须在TurtleScreen的形状字典中，如(粗细箭头1)“arrow”,(海龟箭头)“turtle”,(实心圆箭头)“circle”,(实心方形箭头)“square”,(粗大箭头2)“triangle”,默认的箭头“classic”

import turtle
print(turtle.shape())#classic
turtle.shape("turtle")
print(turtle.shape())#turtle

• 37 turtle.resizemode(rmode=None)：设置或返回(海龟)画笔箭头大小的缩放模式
  参数：
  rmode---"auto", "user","noresize",3选1，具体说明如下：
  “auto”:此模式下(海龟)画笔箭头随pensize变化而变化
  “user”:此模式(海龟)画笔箭头大小取决于【通过shapesize()进行设置的】
  “noresize”:此模式下(海龟)画笔箭头大小不变
• 38 turtle.shapesize(stretch_wid=None, stretch_len=None, outline=None) | turtle.turtlesize(stretch_wid=None, stretch_len=None, outline=None)：返回或设置画笔x/y方向拉伸值和shape轮廓宽度，仅当resizemode为“user”模式时有有效

import turtle
import time
#设置外轮廓颜色为red,填充色为black
turtle.pen(pencolor="red", fillcolor="black")
print(turtle.shapesize())#(1.0, 1.0, 1)表示垂直方向缩放到原来1倍，水平方向缩放到原来1倍，外轮廓宽度为1
#设置resizemode为“user”模式
turtle.resizemode("user")
#表示垂直方向缩放到原来5倍，水平方向缩放到原来5倍，外轮廓宽度12
turtle.shapesize(5, 5, 12)
time.sleep(2)
print(turtle.shapesize())
#设置轮廓宽度为8
turtle.shapesize(outline=8)
time.sleep(2)
print(turtle.shapesize())

• 39 turtle.shearfactor(shear=None)：设置或返回剪切因子
  参数：
  shear---number(optional)

import turtle
import time
#箭头改成圆形
turtle.shape("circle")
#垂直缩放到5倍，水平缩放到2倍
turtle.shapesize(5, 2)
print(turtle.shearfactor())
time.sleep(2)
#创建另一个(海龟)箭头，和原来的拉开距离
t1 = turtle.Turtle()
t1.pu()
t1.fd(100)
t1.pd()
t1.shape("circle")
#垂直缩放到5倍，水平缩放到2倍
t1.shapesize(5, 2)
#设置shearfactor为1
t1.shearfactor(1)#设置箭头与x轴的正切值为1,箭头与x轴的夹角为45度
print(t1.shearfactor())
turtle.done()

• 40 turtle.tilt(angle)：保持箭头方向不变的前提下，旋转箭头形状
  参数：
  angle---a number箭头图标在现有角度基础上再旋转的角度，比如当前为45度，此基础45度变成90度

import turtle
#清屏并恢复原始坐标位置(0,0)，恢复默认方向向右
turtle.reset()
#改变箭头形状为圆形
turtle.shape("circle")
#垂直缩放到5倍，水平缩放到2倍
turtle.shapesize(5, 2)
#保持方向向右，圆形箭头图标旋转45度
turtle.tilt(45)
#画线
turtle.fd(100)
#拷贝一份箭头形状
turtle.stamp()
#保持方向向右，圆形箭头图标旋转45度
turtle.tilt(45)
#画线
turtle.fd(100)
turtle.done()

• 41 turtle.tiltangle(angle=None)：获取或设置(保持箭头方向不变的前提下)旋转箭头形状的角度

import turtle
#清屏并恢复原始坐标位置(0,0)，恢复默认方向向右
turtle.reset()
#改变箭头形状为圆形
turtle.shape("circle")
#垂直缩放到5倍，水平缩放到2倍
turtle.shapesize(5, 2)
#保持方向向右，圆形箭头图标旋转45度
turtle.tilt(45)
#画线
turtle.fd(100)
#拷贝一份箭头形状
turtle.stamp()
#保持方向向右,忽略当前箭头旋转的角度，圆形箭头图标旋转45度
turtle.tiltangle(45)
print(turtle.tiltangle())
#画线
turtle.fd(100)
turtle.done()

• 42 turtle.shapetransform(t11=None, t12=None, t21=None, t22=None)：返回或设置箭头形状的当前变换矩阵
  参数：
  t11--- a number(optional)
  t12--- a number(optional)
  t21--- a number(optional)
  t22--- a number(optional)

import turtle
print(turtle.shapetransform())#(1.0, 0.0, 0.0, 1.0)
turtle.shape("square")
#垂直方向缩放到4倍，水平缩放到2倍，正方形变长方形
turtle.shapesize(4, 2)
turtle.shearfactor(0.5)
print(turtle.shapetransform())#(4.0, 1.0, -0.0, 2.0)
turtle.done()

• 43 turtle.get_shapepoly()：返回当前多边形的坐标对，一般用来定义一个新形状或作为一个复合形状的一部分

import turtle
turtle.shape("square")
print(turtle.get_shapepoly())#((10, -10), (10, 10), (-10, 10), (-10, -10))
turtle.shapetransform(4, -1, 0, 2)
print(turtle.get_shapepoly())#((50, -20), (30, 20), (-50, 20), (-30, -20))

• 44 turtle.onclick(fun, btn=1, add=None)：首先绑定函数，画布上鼠标左键在当前海龟箭头位置按下时触发调用函数；如果函数为None,则移除存在的绑定；
  参数：
  fun---一个有两个参数x,y的函数，画布上鼠标左键在当前海龟箭头位置按下时将点击的坐标作为参数，调用该方法；
  btn---鼠标按钮，默认为1(鼠标左键，2,3分别对应鼠标中键和右键)
  add---True或False,如果是True,将添加一个新的绑定；否则将替换之前绑定

import turtle
def turn(x, y):
    turtle.lt(90)
    #打印当前坐标
    print('x=', x, 'y=', y)
    #打印当前方向
    print(turtle.heading())
    #清除绑定关系
    turtle.onclick(None)
    #再次绑定
    turtle.onclick(turn)
turtle.onclick(turn)
turtle.done()

• 45 turtle.onrelease(fun, btn=1, add=None)：首先绑定函数，然后画布上鼠标左键在当前海龟箭头位置松开时触发调用一个函数；如果函数为None，则移除存在的绑定
  参数：
  fun---一个有两个参数x,y的函数，画布上鼠标左键在当前海龟箭头位置按下时将点击的坐标作为参数，调用该方法；
  btn---鼠标按钮，默认为1(鼠标左键，2,3分别对应鼠标中键和右键)
  add---True或False,如果是True,将添加一个新的绑定；否则将替换之前绑定

import turtle
def turn(x, y):
    turtle.lt(90)
    #打印当前坐标
    print('x=', x, 'y=', y)
    #打印当前方向
    print(turtle.heading())
    #清除绑定关系
    turtle.onrelease(None)
    #再次绑定
    turtle.onrelease(turn)
#绑定turn方法
turtle.onrelease(turn)
turtle.done()

【注意：当调用onclick和onrelease方法时就完成了绑定，当鼠标点击或松开就会触发对应的函数事件】

• 46 turtle.ondrag(fun, btn=1, add=None)：当调用时首先完成绑定，然后画布上鼠标左键在当前箭头位置按下并拖动时触发调用一个函数；如果函数为None,则移除存在的绑定
  参数：
  fun---一个有两个参数x,y的函数，画布上鼠标左键在当前海龟箭头位置按下时将点击的坐标作为参数，调用该方法；
  btn---鼠标按钮，默认为1(鼠标左键，2,3分别对应鼠标中键和右键)
  add---True或False,如果是True,将添加一个新的绑定；否则将替换之前绑定

import turtle
def move(x, y):
    #海龟箭头移动到当前拖动位置
    turtle.goto(x, y)
    #清除绑定关系
    turtle.ondrag(None)
    #再次绑定
    turtle.ondrag(move)
#绑定turn方法
turtle.ondrag(move)
turtle.done()

• 47 turtle.begin_poly()、turtle.end_poly()和turtle.get_poly()配合使用
  turtle.begin_poly()：表示开始记录多边形第一个顶点
  turtle.end_poly()：表示结束记录多边形顶点
  turtle.get_poly()：表示获取最后记录的多边形(返回的是多边形的各个顶点的坐标)

import turtle
turtle.home()
#开始记录
turtle.begin_poly()
turtle.fd(100)
turtle.lt(20)
turtle.fd(30)
turtle.lt(60)
turtle.fd(50)
#结束记录
turtle.end_poly()
#返回记录的多边形
p = turtle.get_poly()
print(p) #((0.00,0.00), (100.00,0.00), (128.19,10.26), (136.87,59.50))
#将"myFavouriteShape"Shape添加TurtleScreen对象的shapelist中
turtle.register_shape("myFavouriteShape", p)
#使用新添加的shape
turtle.shape("myFavouriteShape")
turtle.done()

• 48 turtle.clone()：创建和返回具有相同位置、方向和海龟箭头属性的海龟的克隆

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

• 49 turtle.getturtle() | turtle.getpen()：返回当前海龟屏幕上第一个海龟对象本身

import turtle
pet = turtle.getturtle()
pet.fd(50)
print(pet)#<turtle.Turtle object at 0x00000000025482E8>

• 50 turtle.getscreen()：返回绘制这海龟的海龟屏幕对象，获取该对象后就可以调用海龟屏幕对象的一些方法了

import turtle
#获取海龟屏幕TurtleScreen对象
ts = turtle.getscreen()
print(ts)#<turtle._Screen object at 0x000000000258C898>
#调用海龟屏幕对象的bgcolor方法，设置背景颜色为粉红色
ts.bgcolor("pink")
turtle.done()

• 51 turtle.setundobuffer(size)：设置或者禁止撤销功能，size为None表示禁止撤销功能；否则设置多大，就可以通过调用undo()方法撤销多少次
  参数：
  size---an integer[设置undo()可撤销的最大次数]或None[禁止undo()撤销功能]

turtle.setundobuffer(42)

• 52 turtle.undobufferentries()：获取当前剩余可撤销次数

import turtle
print(turtle.undobufferentries())#0
turtle.setundobuffer(42)
while turtle.undobufferentries():#判断是否可撤销
    turtle.undo()#执行撤销操作

【海龟屏幕(TurtleScreen/Screen)的相关方法：首先需要通过screen = turtle.getscreen()获取到海龟屏幕TurtleScreen的对象并赋值给变量screen,下文中screen均表示该海龟屏幕TurtleScreen的对象】

• 53 screen.bgcolor(*args)：设置或返回海龟屏幕TurtleScreen的背景色
  args---一个颜色字符串或3个范围是0-colormode的数字或三个元组

import turtle
screen = turtle.getscreen()
screen.bgcolor("orange")
#打印‘orange’
print(screen.bgcolor())
screen.bgcolor("#800080")
print(screen.bgcolor())

• 54 screen.bgpic(picname=None)：设置/删除背景图片或返回当前的背景图片名
  参数：
  picname--- 一个gif的字符串名字或"nopic"字符串或None
  git图片名：表示设置海龟屏幕TurtleScreen的背景图像
  "nopic"：表示删除海龟屏幕TurtleScreen的背景图像
  "None"：表示返回海龟屏幕TurtleScreen的背景图像的名称

import turtle
screen = turtle.getscreen()
#打印当前背景图像名，打印结果为'nopic'
print(screen.bgpic())
#设置背景图像，h.gif需要提前放到该文件同级目录
screen.bgpic("h.gif")
#打印当前背景图像名，打印结果为"h.gif"
print(screen.bgpic())
# screen.bgpic('nopic')
#打印当前背景图像名，打印结果为'nopic'
# print(screen.bgpic())
turtle.done()

【注意：背景图片只能是gif格式，所以我们需要预先下载gif格式的照片，通过更改后缀的方式，并不能完成图片格式的更改】

• 55 screen.screensize(canvwidth=None, canvheight, bg=None)：如果没给出参数，则返回当前的画布大小(canvwidth, canvheight);否则表示调整画布的大小

import turtle
screen = turtle.getscreen()
#打印当前画布大小，结果为(400,300)
print(screen.screensize())
#调整画布大小，变大后出现了滚动条，可通过滑动滑块查看画布隐藏的部分
screen.screensize(2000, 1500)
#打印当前画布大小，结果为(2000,1500)
print(screen.screensize())
turtle.done()

• 56 screen.setworldcoordinates(llx, lly, urx, ury)：设置用户自定义的坐标系统，如果必要的话需要切换到“world”模式，如果"world"模式已经是活动，则会根据新的坐标绘制图纸
  参数：
  llx---画布左下角x坐标(number型)
  lly---画布左下角y坐标(number型)
  urx--画布右上角x坐标(number型)
  ury--画布右上角y坐标(number型)
  【注意：在用户自定义的坐标系统中，角度可能会出现扭曲】

import turtle
screen = turtle.getscreen()
# 获取当前海龟模式,打印结果为 logo
print(screen.mode())
turtle.shape("turtle")
# 清屏,位置方向恢复初始状态,保持海龟箭头形状不变
screen.reset()
# 设置海龟模式为"world"模式,感觉设不设置"world"模式展现效果没啥区别
screen.mode("world")
screen.setworldcoordinates(-50, -7.5, 50, 7.5)
for _ in range(72):
    turtle.lt(10)
for _ in range(8):
    turtle.lt(45)
    turtle.fd(2)

• 57 turtle.delay(delay=None)：设置或返回绘图延迟(单位：毫秒)，绘图延迟越长，动画的速度越慢
  参数：
  delay---正整数

import turtle
screen =turtle.getscreen()
#获取绘图延迟毫秒数，打印结果为10
print(screen.delay())
#设置绘图延迟
screen.delay(5)
#获取绘图延迟毫秒数，打印结果为5
print(screen.delay())

• 58 screen.tracer(n=None, delay=None)：启用/禁用海龟动画并设置刷新图形的延迟时间;n=None/1时开启动画效果，n>=2时关闭动画效果
  参数：
  n---非负整型数，如果指定 n 值，则只有每第 n 次屏幕刷新会实际执行。(可被用来加速复杂图形的绘制。)如果调用时不带参数，则返回当前保存的 n 值。
  delay---非负整型数，设置延迟值

import turtle
screen =turtle.getscreen()
# screen.tracer(1, 25)
# screen.tracer(None, 25)
screen.tracer(2, 25)
dist = 2
for i in range(200):
    turtle.fd(dist)
    turtle.rt(90)
    dist += 2

turtle.done()

• 59 screen.update()：更新海龟屏幕TurtleScreen对象，tracer关闭时使用；执行一次TurtleScreen刷新
• 60 screen.listen(xdummy=None, ydummy=None)：监听键盘的点击操作，与键盘的点击操作，与键盘点击事件一起用；没有监听，键盘操作无效果
• 61 screen.onkey(fun, key) | screen.onkeyrelease(fun, key)：首先绑定一个无参函数(如果第一个参数fun为None,则移除绑定的函数),然后当键盘上key键按下并抬起后触发函数事件；
  参数：
  fun –-- 一个无参函数或None
  key –-- 一个字符串键值: 普通按键 (例如：“a”) 或功能键 (例如：“space”)

import turtle
def f():
    turtle.fd(50)
    turtle.lt(60)
screen = turtle.getscreen()
#点击up键触发函数
screen.onkey(f, "Up")
#屏幕监听
screen.listen()
turtle.done()

• 62 screen.onkeypress(fun, key=None)：首先绑定，当键盘上key键(如果key为None时表示任意按键)按下时即触发无参函数；如果打一个参数fun为None,则移除绑定的函数；
  参数：
  fun---一个无参函数或None
  key--- 一个字符串键值: 普通按键 (例如：“a”) 或功能键 (例如：“space”),key为None表示任何按键按下都会触发

import turtle
def f():
    turtle.fd(50)
    turtle.lt(60)
screen = turtle.getscreen()
#按下up键触发函数
screen.onkeypress(f, "Up")
#按下任意键时绑定f函数
screen.onkeypress(f, None)
#屏幕监听
screen.listen()
turtle.done()

• 63 screen.onclick(fun, btn=1, add=None) | screen.onscreeclick(fun, btn=1, add=None)：首先在调用的时候完成函数事件的绑定，在鼠标左键按下时触发函数事件；如果函数为None,则移除存在的绑定；
  参数：
  fun – 一个有两个参数x,y的函数,画布上鼠标左键按下时将点击的坐标作为参数,调用该方法
  btn --鼠标按钮，默认为1（鼠标左键）
  add – True或False.如果是True,将添加一个新的绑定;否则将替换前绑定

import turtle
screen = turtle.getscreen()
def turn(x, y):
    turtle.lt(90)
    # 打印当前坐标
    print('x=', x, 'y=', y)
    print(turtle.heading())
# 清除绑定关系
screen.onclick(None)
# 再次绑定
# screen.onclick(turn)
#screen.onclick(turn, 3)
screen.onclick(turn, 2)
turtle.done()

• 64 screen.ontimer(fun, t=0)：开启一个计时器，t毫秒后调用函数fun
  参数：
  fun---一个无参的函数
  t ---一个>=0的number

"""
点击屏幕画多边形，再次点击停止绘制
"""
import turtle
#定义全局变量
running = False
def demo1():
    screen = turtle.getscreen()
    def f():
        #内部函数想修改或使用全局变量需要加global,否则认为是局部变量
        global running
        if running:
            turtle.fd(100)
            turtle.lt(45)
        #开启计数器，250毫秒后执行f函数
        screen.ontimer(f, 250)
    def change_status(x, y):
        #内部函数想修改或使用全局变量需要加global，否则认为是局部变量
        global running
        #bool取反操作
        running = not running
    f()
    screen.onclick(change_status)
def my_main():
    demo1()
    turtle.mainloop()

if __name__ == '__main__':
    my_main()

• 65 screen.textinput(title, prompt)：弹出一个输入文本的弹出框，点击Cancel取消按钮返回None,点击ok按钮返回输入的字符串
  参数：
  title --- 弹框标题(一个string字符串)
  prompt---弹框提示(一个string字符串)

import turtle
screen = turtle.getscreen()
#弹出输入文本的弹出框
name = screen.textinput("欢迎框", "你的姓名是")
if (name != None and name != ""):
    print(name, ",您好")

• 66 screen.numinput(title, prompt, default=None, minval=None, maxval=None)：弹出一个输入数字的弹出框，点击Cancel取消按钮则返回None,点击OK按钮返回输入的number
  参数：
  title---弹框标题(一个string字符串)
  prompt---弹框提示(一个string字符串)
  default---默认值number类型(可选)
  minval---最小值number类型(可选)
  maxval---最大值number类型(可选)

import turtle
screen = turtle.getscreen()
#弹出输入数字的弹出框
age = screen.numinput("身高", "请输入您的身高(单位:米)", 0, 0, 2.5)
#判断容错处理
if age != None and age > 0:
    print("身高", age, "米")

• 67 screen.mode(mode) | turtle.mode(mode=None)：设置或返回海龟模式，默认是"standard"标准模式。"standard"模式是兼容旧版本；“logo”模式兼容大部分海龟图形标志；"world"模式使用用户自定义的“世界坐标”该模式下x/y的单位比不为1会出现扭曲
• 68 screen.colormode(cmode=None) | turtle.colormode(cmode=Node)：返回或设置colormode的值为1.0或255,随后调用turtle.fillcolor(args)、turtle.pencolor(args)、turtle.color(*args)等方法设置画笔颜色时R,G,B三组颜色值范围必须是0-colormode值之间的数,否则会报异常
  参数：
  cmode---1.0或255，二选一
• 69 screen.getcanvas() | turtle.getcanvas()：返回海龟屏幕TurtleScreen的画布对象实例

import turtle
screen = turtle.getscreen()
print(screen.getcanvas())

• 70 screen.getshapes() | turtle.getshapes()：获取当前可用海龟形状的名称列表

import turtle
#获取当前可用海龟形状的名称列表
print(turtle.getscreen().getshapes())#['arrow', 'blank', 'circle', 'classic', 'square', 'triangle', 'turtle']

• 71 screen.register_shape(name, shape=None) | screen.addshape(name, shape=None) | turtle.register_shape(name, shape=None) | turtle.addshape(name, shape=None)：内存中添加注册海龟图形

import turtle
screen = turtle.getscreen()
#方法一：
screen.register_shape("h.gif")
turtle.shape("h.gif")
turtle.fd(100)
turtle.done()
import turtle
screen = turtle.getscreen()
#方法二：
screen.register_shape("triangle",((5, -3), (0, 5), (-5, -3)))
turtle.forward(100)
turtle.done()
#方法3：shape_obj是一个shape对象见【turtle.begin_poly()、turtle.end_poly()和turtle.get_poly()配合使用】中例子
screen.register_shape("myFavouriteShape", shape_obj)

• 72 screen.turtles() | turtle.turtles()：返回海龟屏幕TurtleScreen中所有的海龟箭头对象列表

print(screen.turtles())#[<turtle.Turtle object at 0x00000000025DC400>]
for turtle in screen.turtles():
    print(turtle)

• 73 screen.window_height() | turtle.window_height() 和 screen.window_width() | turtle.window_width()：返回海龟绘图窗口的高/宽(单位:像素)

import turtle
#获取海龟绘图窗口高度(单位:像素)
print(turtle.window_height())#576
#获取海龟绘图窗口宽度(单位：像素)
print(turtle.window_width())#683

• 74 screen.bye() | turtle.bye()：关闭海龟图形窗口

import turtle
import time
turtle.forward(100)
time.sleep(1)
turtle.bye()
turtle.done()

• 75 screen.exitonclick() | turtle.exitonclick()：调用此方法后屏幕会保持，直到点击屏幕才会关闭海龟图形窗口

import turtle
turtle.exitonclick()

• 76 screen.mainloop() | screen.done() | turtle.mainloop() | turtle.done()：启动循环事件，调用此方法后屏幕会保持，直到主动关闭当前窗口；想使用的话必须作为图形绘制程序的最后一条语句

turtle.mainloop()

• 77 screen.setup(width=_CFG["width"], height=_CFG["height"], startx=_CFG["leftright"], starty=_CFG["topbottom"]) | 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
screen = turtle.getscreen()
#海龟绘图窗口宽高分别为576和683,此时将默认展现的主窗口的大小设置成了576和100,垂直方向因为占不全会出现滚动条
# screen.setup(width=576, height=100, startx=0, starty=0)
screen.setup(width=0.75, height=0.5, startx=None, starty=None)
turtle.done()

• 78 screen.title(titlestring) | turtle.title(titlestring)

设置海龟窗口标题

import turtle
screen = turtle.getscreen()
#设置海龟窗口标题
screen.title("hello turtle")
turtle.done()