# `turtle` --- 龜圖學 (Turtle graphics)¶

## 教學¶

### 啟動一個烏龜環境¶

```from turtle import *
```

### 基本繪圖¶

```forward(100)
```

```left(120)
```

```forward(100)
left(120)
forward(100)
```

#### 海龟的位置¶

```home()
```

The home position is at the center of the turtle's screen. If you ever need to know them, get the turtle's x-y coordinates with:

```pos()
```

```clearscreen()
```

### 使用算法绘制图案¶

```for steps in range(100):
for c in ('blue', 'red', 'green'):
color(c)
forward(steps)
right(30)
```

- 当然，这仅受限于你的想象力！

```color('red')
fillcolor('yellow')
```

```begin_fill()
```

```while True:
forward(200)
left(170)
if abs(pos()) < 1:
break
```

`abs(pos()) < 1` 是确定海龟何时回到初始点的好办法。

```end_fill()
```

（请注意只有在你给出 `end_fill()` 命令时才会实际进行填充。）

## 如何...¶

### 在脚本中使用海龟绘图¶

```import turtle as t
from random import random

for i in range(100):
steps = int(random() * 100)
angle = int(random() * 360)
t.right(angle)
t.fd(steps)
```

```t.mainloop()
```

### 使用面向对象的海龟绘图¶

```from turtle import Turtle
from random import random

t = Turtle()
for i in range(100):
steps = int(random() * 100)
angle = int(random() * 360)
t.right(angle)
t.fd(steps)

t.screen.mainloop()
```

```t.screen.title('Object-oriented turtle demo')
t.screen.bgcolor("orange")
```

Screen 专有方法

## RawTurtle/Turtle 方法和对应函数¶

### 海龟动作¶

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

distance -- 一个数值 (整型或浮点型)

```>>> turtle.position()
(0.00,0.00)
>>> turtle.forward(25)
>>> turtle.position()
(25.00,0.00)
>>> turtle.forward(-75)
>>> turtle.position()
(-50.00,0.00)
```
turtle.back(distance)
turtle.bk(distance)
turtle.backward(distance)

distance -- 一个数值

```>>> turtle.position()
(0.00,0.00)
>>> turtle.backward(30)
>>> turtle.position()
(-30.00,0.00)
```
turtle.right(angle)
turtle.rt(angle)

angle -- 一个数值 (整型或浮点型)

```>>> turtle.heading()
22.0
>>> turtle.right(45)
337.0
```
turtle.left(angle)
turtle.lt(angle)

angle -- 一个数值 (整型或浮点型)

```>>> turtle.heading()
22.0
>>> turtle.left(45)
67.0
```
turtle.goto(x, y=None)
turtle.setpos(x, y=None)
turtle.setposition(x, y=None)

• x -- 一个数值或数值对/向量

• y -- 一个数值或 `None`

```>>> 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.teleport(x, y=None, *, fill_gap=False)

• x -- 一个数值或 `None`

• y -- 一个数值或 `None`

• fill_gap -- 布尔

```>>> tp = turtle.pos()
>>> tp
(0.00,0.00)
>>> turtle.teleport(60)
>>> turtle.pos()
(60.00,0.00)
>>> turtle.teleport(y=10)
>>> turtle.pos()
(60.00,10.00)
>>> turtle.teleport(20, 30)
>>> turtle.pos()
(20.00,30.00)
```

turtle.setx(x)

x -- 一个数值 (整型或浮点型)

```>>> turtle.position()
(0.00,240.00)
>>> turtle.setx(10)
>>> turtle.position()
(10.00,240.00)
```
turtle.sety(y)

y -- 一个数值 (整型或浮点型)

```>>> turtle.position()
(0.00,40.00)
>>> turtle.sety(-10)
>>> turtle.position()
(0.00,-10.00)
```
turtle.seth(to_angle)

to_angle -- 一个数值 (整型或浮点型)

logo 模式

0 - 东

0 - 北

90 - 北

90 - 东

180 - 西

180 - 南

270 - 南

270 - 西

```>>> turtle.setheading(90)
90.0
```
turtle.home()

```>>> turtle.heading()
90.0
>>> turtle.position()
(0.00,-10.00)
>>> turtle.home()
>>> turtle.position()
(0.00,0.00)
0.0
```

• extent -- 一个数值 (或 `None`)

• steps -- 一个整型数 (或 `None`)

```>>> turtle.home()
>>> turtle.position()
(0.00,0.00)
0.0
>>> turtle.circle(50)
>>> turtle.position()
(-0.00,0.00)
0.0
>>> turtle.circle(120, 180)  # draw a semicircle
>>> turtle.position()
(0.00,240.00)
180.0
```
turtle.dot(size=None, *color)

• size -- 一个整型数 >= 1 (如果指定)

• color -- 一个颜色字符串或颜色数值元组

```>>> turtle.home()
>>> turtle.dot()
>>> turtle.fd(50); turtle.dot(20, "blue"); turtle.fd(50)
>>> turtle.position()
(100.00,-0.00)
0.0
```
turtle.stamp()

```>>> turtle.color("blue")
>>> stamp_id = turtle.stamp()
>>> turtle.fd(50)
```
turtle.clearstamp(stampid)

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

```>>> for i in range(8):
...     unused_stamp_id = turtle.stamp()
...     turtle.fd(30)
>>> turtle.clearstamps(2)
>>> turtle.clearstamps(-2)
>>> turtle.clearstamps()
```
turtle.undo()

```>>> 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 范围内的整型数或速度字符串 (见下)

• "fastest": 0 最快

• "fast": 10 快

• "normal": 6 正常

• "slow": 3 慢

• "slowest": 1 最慢

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

### 获取海龟的状态¶

turtle.position()
turtle.pos()

```>>> turtle.pos()
(440.00,-0.00)
```
turtle.towards(x, y=None)

• x -- 一个数值或数值对/矢量，或一个海龟实例

• y -- 一个数值——如果 x 是一个数值，否则为 `None`

```>>> turtle.goto(10, 10)
>>> turtle.towards(0,0)
225.0
```
turtle.xcor()

```>>> turtle.home()
>>> turtle.left(50)
>>> turtle.forward(100)
>>> turtle.pos()
(64.28,76.60)
>>> print(round(turtle.xcor(), 5))
64.27876
```
turtle.ycor()

```>>> turtle.home()
>>> turtle.left(60)
>>> turtle.forward(100)
>>> print(turtle.pos())
(50.00,86.60)
>>> print(round(turtle.ycor(), 5))
86.60254
```

```>>> turtle.home()
>>> turtle.left(67)
67.0
```
turtle.distance(x, y=None)

• x -- 一个数值或数值对/矢量，或一个海龟实例

• y -- 一个数值——如果 x 是一个数值，否则为 `None`

```>>> turtle.home()
>>> turtle.distance(30,40)
50.0
>>> turtle.distance((30,40))
50.0
>>> joe = Turtle()
>>> joe.forward(77)
>>> turtle.distance(joe)
77.0
```

### 度量单位设置¶

turtle.degrees(fullcircle=360.0)

fullcircle -- 一个数值

```>>> turtle.home()
>>> turtle.left(90)
90.0

Change angle measurement unit to grad (also known as gon,
>>> turtle.degrees(400.0)
100.0
>>> turtle.degrees(360)
90.0
```

```>>> turtle.home()
>>> turtle.left(90)
90.0
1.5707963267948966
```

### 画笔控制¶

#### 绘图状态¶

turtle.pendown()
turtle.pd()
turtle.down()

turtle.penup()
turtle.pu()
turtle.up()

turtle.pensize(width=None)
turtle.width(width=None)

width -- 一个正数值

```>>> 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": 颜色字符串或颜色元组

• "fillcolor": 颜色字符串或颜色元组

• "pensize": 正数值

• "speed": 0..10 范围内的数值

• "resizemode": "auto" 或 "user" 或 "noresize"

• "stretchfactor": (正数值, 正数值)

• "outline": 正数值

• "tilt": 数值

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

```>>> turtle.penup()
>>> turtle.isdown()
False
>>> turtle.pendown()
>>> turtle.isdown()
True
```

#### 颜色控制¶

turtle.pencolor(*args)

`pencolor()`

`pencolor(colorstring)`

`pencolor((r, g, b))`

`pencolor(r, g, b)`

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

`fillcolor((r, g, b))`

`fillcolor(r, g, b)`

```>>> turtle.fillcolor("violet")
>>> turtle.fillcolor()
'violet'
>>> turtle.pencolor()
(50.0, 193.0, 143.0)
>>> turtle.fillcolor((50, 193, 143))  # Integers, not floats
>>> turtle.fillcolor()
(50.0, 193.0, 143.0)
>>> turtle.fillcolor('#ffffff')
>>> turtle.fillcolor()
(255.0, 255.0, 255.0)
```
turtle.color(*args)

`color()`

`color(colorstring)`, `color((r,g,b))`, `color(r,g,b)`

`color(colorstring1, colorstring2)`, `color((r1,g1,b1), (r2,g2,b2))`

```>>> turtle.color("red", "green")
>>> turtle.color()
('red', 'green')
>>> color("#285078", "#a0c8f0")
>>> color()
((40.0, 80.0, 120.0), (160.0, 200.0, 240.0))
```

#### 填充¶

turtle.filling()

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

turtle.end_fill()

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

#### 更多绘图控制¶

turtle.reset()

```>>> turtle.goto(0,-22)
>>> turtle.left(100)
>>> turtle.position()
(0.00,-22.00)
100.0
>>> turtle.reset()
>>> turtle.position()
(0.00,0.00)
0.0
```
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)

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

### 海龟状态¶

#### 可见性¶

turtle.hideturtle()
turtle.ht()

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

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

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

#### 外观¶

turtle.shape(name=None)

name -- 一个有效的形状名字符串

```>>> turtle.shape()
'classic'
>>> turtle.shape("turtle")
>>> turtle.shape()
'turtle'
```
turtle.resizemode(rmode=None)

rmode -- 字符串 "auto", "user", "noresize" 其中之一

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

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

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

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

```>>> turtle.resizemode()
'noresize'
>>> turtle.resizemode("auto")
>>> turtle.resizemode()
'auto'
```
turtle.shapesize(stretch_wid=None, stretch_len=None, outline=None)
turtle.turtlesize(stretch_wid=None, stretch_len=None, outline=None)

• stretch_wid -- 正数值

• stretch_len -- 正数值

• outline -- 正数值

```>>> 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 -- 数值 (可选)

```>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.shearfactor(0.5)
>>> turtle.shearfactor()
0.5
```
turtle.tilt(angle)

angle -- 一个数值

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

angle -- 一个数值

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

turtle.tiltangle(angle=None)

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 -- 一个数值 (可选)

• t12 -- 一个数值 (可选)

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

### 使用事件¶

• fun -- 一个函数，调用时将传入两个参数表示在画布上点击的坐标。

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

• fun -- 一个函数，调用时将传入两个参数表示在画布上点击的坐标。

• btn -- 鼠标按钮编号，默认值为 1 (鼠标左键)

• add -- `True``False` -- 如为 `True` 则将添加一个新绑定，否则将取代先前的绑定

fun 指定的函数绑定到在此海龟上释放鼠标按键事件。如果 fun 值为 `None`，则移除现有的绑定。

```>>> class MyTurtle(Turtle):
...     def glow(self,x,y):
...         self.fillcolor("red")
...     def unglow(self,x,y):
...         self.fillcolor("")
...
>>> turtle = MyTurtle()
>>> turtle.onclick(turtle.glow)     # clicking on turtle turns fillcolor red,
>>> turtle.onrelease(turtle.unglow) # releasing turns it to transparent.
```

• fun -- 一个函数，调用时将传入两个参数表示在画布上点击的坐标。

• btn -- 鼠标按钮编号，默认值为 1 (鼠标左键)

• add -- `True``False` -- 如为 `True` 则将添加一个新绑定，否则将取代先前的绑定

fun 指定的函数绑定到在此海龟上移动鼠标事件。如果 fun 值为 `None`，则移除现有的绑定。

```>>> turtle.ondrag(turtle.goto)
```

### 特殊海龟方法¶

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

```>>> pet = getturtle()
>>> pet.fd(50)
>>> pet
<turtle.Turtle object at 0x...>
```
turtle.getscreen()

```>>> ts = turtle.getscreen()
>>> ts
<turtle._Screen object at 0x...>
>>> ts.bgcolor("pink")
```
turtle.setundobuffer(size)

size -- 一个整型数值或 `None`

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

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

### 复合形状¶

1. 创建一个空 Shape 对象，类型为 "compound"。

2. 可根据需要使用 `addcomponent()` 方法向此对象添加多个组件。

舉例來說：

```>>> s = Shape("compound")
>>> poly1 = ((0,0),(10,-5),(0,10),(-10,-5))
>>> poly2 = ((0,0),(10,-5),(-10,-5))
```
3. 接下来将 Shape 对象添加到 Screen 对象的形状列表并使用它:

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

`Shape` 类在 `register_shape()` 方法的内部以多种方式使用。应用程序编写者 只有 在使用上述的复合形状时才需要处理 Shape 类。

## TurtleScreen/Screen 方法及对应函数¶

### 窗口控制¶

turtle.bgcolor(*args)

args -- 一个颜色字符串或三个取值范围 0..colormode 内的数值或一个取值范围相同的数值3元组

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

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

turtle.clearscreen()

turtle.reset()

turtle.resetscreen()

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

• canvwidth -- 正整型数，以像素表示画布的新宽度值

• canvheight -- 正整型数，以像素表示画面的新高度值

• bg -- 颜色字符串或颜色元组，新的背景颜色

```>>> 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.setworldcoordinates(-50,-7.5,50,7.5)
>>> for _ in range(72):
...     left(10)
...
>>> for _ in range(8):
...     left(45); fd(2)   # a regular octagon
```

### 动画控制¶

turtle.delay(delay=None)

delay -- 正整型数

```>>> screen.delay()
10
>>> screen.delay(5)
>>> screen.delay()
5
```
turtle.tracer(n=None, delay=None)

• n -- 非负整型数

• delay -- 非负整型数

```>>> screen.tracer(8, 25)
>>> dist = 2
>>> for i in range(200):
...     fd(dist)
...     rt(90)
...     dist += 2
```
turtle.update()

### 使用屏幕事件¶

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

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

• fun -- 一个无参数的函数或 `None`

• key -- 一个字符串: 键 (例如 "a") 或键标 (例如 "space")

```>>> def f():
...     fd(50)
...     lt(60)
...
>>> screen.onkey(f, "Up")
>>> screen.listen()
```
turtle.onkeypress(fun, key=None)

• fun -- 一个无参数的函数或 `None`

• key -- 一个字符串: 键 (例如 "a") 或键标 (例如 "space")

```>>> def f():
...     fd(50)
...
>>> screen.onkey(f, "Up")
>>> screen.listen()
```

• fun -- 一个函数，调用时将传入两个参数表示在画布上点击的坐标。

• btn -- 鼠标按钮编号，默认值为 1 (鼠标左键)

• add -- `True``False` -- 如为 `True` 则将添加一个新绑定，否则将取代先前的绑定

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

turtle.ontimer(fun, t=0)

• fun -- 一个无参数的函数

• t -- 一个数值 >= 0

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

```>>> screen.mainloop()
```

### 输入方法¶

turtle.textinput(title, prompt)

• title -- string（字串）

• prompt -- string（字串）

```>>> screen.textinput("NIM", "Name of first player:")
```
turtle.numinput(title, prompt, default=None, minval=None, maxval=None)

• title -- string（字串）

• prompt -- string（字串）

• default -- 数值 (可选)

• minval -- 数值 (可选)

• maxval -- 数值 (可选)

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

### 设置与特殊方法¶

turtle.mode(mode=None)

mode -- 字符串 "standard", "logo" 或 "world" 其中之一

"standard" 模式与旧的 `turtle` 兼容。"logo" 模式与大部分 Logo 海龟绘图兼容。"world" 模式使用用户自定义的 "世界坐标系"。注意: 在此模式下，如果 `x/y` 单位比率不等于 1 则角度会显得扭曲。

"standard"

"logo"

```>>> mode("logo")   # resets turtle heading to north
>>> mode()
'logo'
```
turtle.colormode(cmode=None)

cmode -- 数值 1.0 或 255 其中之一

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

```>>> cv = screen.getcanvas()
>>> cv
<turtle.ScrolledCanvas object ...>
```
turtle.getshapes()

```>>> screen.getshapes()
['arrow', 'blank', 'circle', ..., 'turtle']
```
turtle.register_shape(name, shape=None)

1. name 为一个 gif 文件的文件名， shape`None`: 安装相应的图像形状。:

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

備註

当海龟转向时图像形状 不会 转动，因此无法显示海龟的朝向!

2. name 为指定的字符串，shape 为由坐标值对构成的元组: 安装相应的多边形形状。

```>>> screen.register_shape("triangle", ((5,-3), (0,5), (-5,-3)))
```
3. name 为任意字符串而 shape 为 (复合) `Shape` 对象：安装相应的复合形状。Install the corresponding compound shape.

turtle.turtles()

```>>> for turtle in screen.turtles():
...     turtle.color("red")
```
turtle.window_height()

```>>> screen.window_height()
480
```
turtle.window_width()

```>>> screen.window_width()
640
```

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

turtle.bye()

turtle.exitonclick()

`bye()` 方法绑定到 Screen 上的鼠标点击事件。

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

• width -- 如为一个整型数值，表示大小为多少像素，如为一个浮点数值，则表示屏幕的占比；默认为屏幕的 50%

• height -- 如为一个整型数值，表示高度为多少像素，如为一个浮点数值，则表示屏幕的占比；默认为屏幕的 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 -- 一个字符串，显示为海龟绘图窗口的标题栏文本

```>>> screen.title("Welcome to the turtle zoo!")
```

## 公共类¶

class turtle.RawTurtle(canvas)
class turtle.RawPen(canvas)

canvas -- 一个 `tkinter.Canvas`, `ScrolledCanvas``TurtleScreen`

class turtle.Turtle

RawTurtle 的子类，具有相同的接口，但其绘图场所为默认的 `Screen` 类对象，在首次使用时自动创建。

class turtle.TurtleScreen(cv)

cv -- 一个 `tkinter.Canvas`

class turtle.Screen

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

class turtle.ScrolledCanvas(master)

master -- 可容纳 ScrolledCanvas 的 Tkinter 部件，即添加了滚动条的 Tkinter-canvas

class turtle.Shape(type_, data)

type_ -- 字符串 "polygon", "image", "compound" 其中之一

type_

data

"polygon"

"image"

"compound"

`None` (复合形状必须使用 `addcomponent()` 方法来构建)

• poly -- 一个多边形，即由数值对构成的元组

• fill -- 一种颜色，将用来填充 poly 指定的多边形

• outline -- 一种颜色，用于多边形的轮廓 (如有指定)

```>>> poly = ((0,0),(10,-5),(0,10),(-10,-5))
>>> s = Shape("compound")
>>> # ... add more components and then use register_shape()
```

class turtle.Vec2D(x, y)

• `a + b` 矢量加法

• `a - b` 矢量减法

• `a * b` 内积

• `k * a``a * k` 与标量相乘

• `abs(a)` a 的绝对值

• `a.rotate(angle)` 旋转

## 说明¶

`Turtle` 实例将自动创建一个 `Screen` 实例，如果它还未创建的话。

`Turtle``RawTurtle` 的子类，它 不会 自动创建绘图区域 —— 需要为其提供或创建一个 canvascanvas 可以是一个 `tkinter.Canvas`, `ScrolledCanvas``TurtleScreen`

`TurtleScreen` 是基本的海龟绘图区域。 `Screen``TurtleScreen` 的子类，并包括 一些额外方法 用来管理其外观（包括大小和标题）及行为。 `TurtleScreen` 的构造器需要一个 `tkinter.Canvas``ScrolledCanvas` 作为参数。

## 帮助与配置¶

### 如何使用帮助¶

Screen 和 Turtle 类的公用方法以文档字符串提供了详细的文档。因此可以利用 Python 帮助工具获取这些在线帮助信息:

• 当使用 IDLE 时，输入函数/方法调用将弹出工具提示显示其签名和文档字符串的头几行。

• 对文法或函数调用 `help()` 将显示其文档字符串:

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

### 文档字符串翻译为不同的语言¶

turtle.write_docstringdict(filename='turtle_docstringdict')

filename -- 一个字符串，表示文件名

### 如何配置 Screen 和 Turtle¶

```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 可以是任何内置形状，即: arrow, turtle 等。更多信息可用 `help(shape)` 查看。

• 如果你想使用无填充色（即让海龟变透明），则你必须写 `fillcolor = ""` (但在but all nonempty strings must not have quotes in the cfg 文件中所有非空字符串都不可加引号)。

• 如果你想令海龟反映其状态，你必须使用 `resizemode = auto`

• 例如当你设置了 `language = italian` 则文档字符串字典 `turtle_docstringdict_italian.py` 将在导入时被加载（如果它存在于导入路径，即与 `turtle` 相同的目录中）。

• exampleturtleexamplescreen 条目定义了相应对象在文档字符串中显示的名称。方法文档字符串转换为函数文档字符串时将从文档字符串中删去这些名称。

• using_IDLE: 如果你经常使用 IDLE 及其 `-n` 开关选项（"无子进程"）则将此项设为 `True`。 这将阻止 `exitonclick()` 进入主事件循环。

`turtle.cfg` 文件可以保存于 `turtle` 所在目录，当前工作目录也可以有一个同名文件。后者会重载覆盖前者的设置。

`Lib/turtledemo` 目录中也有一个 `turtle.cfg` 文件。你可以将其作为示例进行研究，并在运行演示时查看其作用效果 (但最好不要在演示查看器中运行)。

## `turtledemo` --- 演示脚本集¶

`turtledemo` 包汇集了一组演示脚本。这些脚本可以通过以下命令打开所提供的演示查看器运行和查看:

```python -m turtledemo
```

```python -m turtledemo.bytedesign
```

`turtledemo` 包目录中的内容:

• 一个演示查看器 `__main__.py`，可用来查看脚本的源码并即时运行。

• 多个脚本文件，演示 `turtle` 模块的不同特性。所有示例可通过 Examples 菜单打开。也可以单独运行每个脚本。

• 一个 `turtle.cfg` 文件，作为说明如何编写并使用模块配置文件的示例模板。

bytedesign

chaos

clock

colormixer

`ondrag()`

forest

fractalcurves

lindenmayer

L-系统

minimal_hanoi

nim

paint

`onclick()`

peace

penrose

`stamp()`

planet_and_moon

rosette

round_dance

sorting_animate

tree

`clone()`

two_canvases

yinyang

`circle()`