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

最新推荐文章于 2024-10-01 10:00:00 发布
最新推荐文章于 2024-10-01 10:00:00 发布
阅读量1.7k 收藏 9
点赞数 1
文章标签： python pycharm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46034116/article/details/127131086
版权

整理自 文档_链接

步骤：

  • 示例代码整理
  • 整理一遍文档： 笔记整理，敲代码(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()

在这里插入图片描述

Gaogaogaoshu
关注
专栏目录
python海龟绘图笔记.docx
05-09
Python 海龟绘图笔记 Python 的 Turtle 库是一种流行的绘制图像的标准库函数库。它提供了一个简单的绘图接口，允许用户使用 Python 语言创建图形和动画。下面是 Turtle 库的详细介绍和使用方法。 Turtle 库介绍 ...
Python Turtle 海龟画图 官方文档
leleprogrammer的博客
01-20 3580
转载于Python 3官方文档Turtle
【Python绘图】turtle库乌龟绘图官方文档详细整理
Bitdancing的专栏
10-02 4083
【函数表格整理在最下方】 Turtle库是Python语言中一个很流行的绘制图像的函数库，想象一个小乌龟，在一个横轴为x、纵轴为y的坐标系原点，(0,0)位置开始，它根据一组函数指令的控制，在这个平面坐标系中移动，从而在它爬行的路径上绘制了图形。 官方文档网址 turtle 绘图窗口 turtle.setup(width, height, startx, starty) 参数：width, height: 输入宽和高为整数时, 表示像素; 为小数时, 表示占据电脑屏幕的比例，(startx, starty
Python绘图库----turtle（海龟）
最新发布
m0_47449012的博客
10-01 360
turtle绘图
turtle使用文档
Aaron_liu1的博客
12-28 470
Turtle简介 Turtle库是Python语言中一个很流行的绘制图像的函数库，想象一个小乌龟，在一个横轴为x、纵轴为y的坐标系原点，(0,0)位置开始，它根据一组函数指令的控制，在这个平面坐标系中移动，从而在它爬行的路径上绘制了图形。 Turtle基本操作 画布 画布就是turtle为我们展开用于绘图区域，我们可以使用以下代码设置它的大小和初始位置： turtle.screensize(canvwidth=None,canvheight=None,bg=None) # 参数分别为画布的宽(单位像素),高
Python——turtle库（海龟绘图）介绍与使用
Smile的博客
02-16 1万+
在 Python 中，海龟绘图提供了一个实体“海龟”形象（带有画笔的小机器动物），假定它在地板上平铺的纸张上画线。
python模块 — turtle
个人博客
09-08 3954
turtle模块是Python的一个标准库，用于绘制图形。它基于一个图形窗口和一个虚拟的海龟，通过控制海龟的运动，可以实现各种图形的绘制。
python代码利用turtle库生成爱心代码
05-11
turtle库是Python标准库的一部分，不需要额外安装，只需在Python环境中即可直接使用。 在提供的压缩包文件中，"爱心.py"很可能是包含上述示例代码的Python脚本，而"python代码利用turtle库生成爱心代码.docx"则可能...
有趣的Python turtle绘图.pdf
06-28
在这个背景之下，turtle模块作为Python标准库的一部分，为初学者提供了一个简单而有趣的方式来学习编程和理解基本的图形绘制概念。 turtle模块深受LOGO语言的影响，LOGO语言是1960年代在欧美地区广泛推广的教育编程...
turtle：孩子们学习python的项目
02-14
turtle模块是Python编程语言中的一个标准库，特别适合初学者，尤其是孩子们，来学习编程基础知识。这个"turtle：孩子们学习python的项目"很可能是包含了一系列使用turtle库制作图形和动画的示例代码，旨在帮助孩子们...
python的turtle库和蟒蛇绘制程序.docx
12-05
`turtle` 是 Python 的一个标准库之一，主要用于绘制图形。它通过提供一个虚拟的画布和一个可以在画布上移动并绘制图形的“画笔”（通常称为海龟）来实现图形的绘制。在本文档中，我们将探讨如何使用 `turtle` 库来...
python库之turtle库官方文档入门
热门推荐
sandalphon4869的博客
08-15 8万+
文章目录一、turtle库1.基本介绍2.turtle绘图原理3.官方文档二、函数纵览1.Turtle methods（1）Turtle motion三、turtle绘图窗体布局三、turtle空间坐标体系四、turtle角度坐标体系五、RGB色彩模式：六、turtle画笔控制函数七、其他命令八、例子1.太阳花2.七段数码管 一、turtle库 1.基本介绍 turtle库： （1）1969...
Python turtle---海龟绘图
若有博文对您有帮助，欢迎点赞关注，收藏评论。
04-28 8346
Python turtle---海龟绘图：概述：可用的 Turtle 和 Screen 方法概览：Turtle方法：海龟动作：移动和绘制：获取海龟的状态：设置与度量单位：画笔控制：绘图状态：颜色控制：填充:更多绘图控制：海龟状态：可见性：外观：使用事件：特殊海龟方法：Screen方法：窗口控制：动画控制：使用屏幕事件：设置与特殊方法：输入方法：Screen专有方法： 概述： 海龟绘图很适合用来引导孩子学习编程。 最初来自于 Wally Feurzeig, Seymour Papert 和 Cynthia S
Python游戏
hsling
02-08 3573
大佬今天教你用python制作五款简单又好玩的Python游戏 ​今天给大家带来几个Python小游戏，找回童年的同时学习编程 玩法介绍：吃金币，控制左右键，有手就行。 源码分享 import os import cfg import sys import pygame import random from modules import * '''游戏初始化''' def initGame(): # 初始化pygame, 设置展示窗口 pygame.init() .
python之turtle海龟绘图篇
SUOYUEのBLOG
10-17 6万+
海龟绘图，想什么，画什么：七段数码管、谢尔帕斯基三角形、玫瑰花和小猪佩奇都不是问题
Python的海龟 turtle 库使用详细介绍（画任意多边形，全网最详细）
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
12-05 1万+
Turtle库是Python中一个很有趣的库，可以用来绘制各种图形，比如直线、圆、正方形等等。掌握Turtle库的意义在于可以培养孩子的创造力和想象力，让他们通过编写代码来实现自己的创意，同时也可以提高他们的编程能力和逻辑思维能力。此外，Turtle库还能够帮助孩子更好地理解几何学和数学概念，比如角度、比例、几何图形的性质等等，学Turtle库其实就是学数学。
用Python创建海龟图形（turtle 库用法）
Python热爱者的博客
07-07 5730
徽标编程是一种基本的编程语言，可以使用基本命令创建形状和数字。它被介绍给孩子们，让他们对编程有一个基本的了解。在Python中，我们可以使用turtle 库来处理模拟Logo编程语言的海龟图形。这个预装的库可以让我们用像Logo编程一样的简单命令来创建和处理海龟图形。本教程将讨论一些Python中的海龟图形的例子。
Turtle海龟画图
json_li的博客
04-27 1242
python的一个简单窗口绘图工具。
Python图形库adafruit-circuitpython-turtle发布2.0.0版本
Turtle 是 Python 的一个标准库模块，最初被集成在 Python 的教育发行版——PythonTurtle 中。Turtle 模块提供了一个绘图板和一个小海龟（turtle），海龟可以理解为一个机器人，它可以通过一系列的命令在屏幕上进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值