[toc]

一,Python绘图Turtle

1,简介

1.Anaconda3下载与安装

为了使用Turtle库绘制图形,我们首先需要安装Anaconda。Anaconda是一个开源的Python发行版本,其包含了conda、Python等180多个科学包及其依赖项。因为包含了大量的科学包,Anaconda 的下载文件比较大(约 531 MB)。如果只需要某些包或者需要节省带宽和存储空间,也可以使用miniconda这个较小的发行版(仅包含conda和 Python)。本门课程以Windows64位系统的Python 3.7 版本为例。下载地址:https://www.anaconda.com/distribution/

2,Turtle的模块和元素

turtle模块安装

Anaconda 中Python3已经默认安装了Turtle, 所以可以直接使用Turtle, 不需要安装。

1. 打开命令处理程序

2. 可以尝试 import turtle 如果没有报错说明 Turtle 已经安装成功。

如果你的版本中没有安装 turtle,可以在命令行中使用以下命令进行安装:

C:\Users\Administrator>pip install turtle

或者

C:\Users\Administrator>pip3 install turtle

2,基础概念

1,画布

画布是turtle为我们展开用于绘图的区域,我们可以设置它的大小和初始位置。

在操作系统上表现为一个窗口,也是turtle的一个画布空间,最小单位是像素。

设置画布大小

class="python3">turtle.screensize(canvwidth=None, canvheight=None, bg=None)

参数

canvwidth: 画布的宽度(单位:像素)

canvheight:画布的高度(单位:像素)

bg:背景颜色

注: 若以上不设置值,默认参数为(400,300,None)

2,画笔的状态

在画布上,默认有一个坐标原点为画布中心的坐标轴,坐标原点上有一只面朝x轴正方向的小海龟。

以上描述中使用了两个词语:坐标原点(位置)、面朝x轴正方向(方向)。

在turtle绘图中,正是使用位置、方向来描述小海龟(画笔)的状态。

画笔的熟悉

画笔的属性包括颜色、画线的宽度等。

turtle.pensize():设置画笔的宽度;

turtle.pencolor():没有参数传入,则返回当前画笔颜色。传入参数设置画笔颜色,可以是字符串,如:"green", "red"等,也可以是RGB色值。

turtle.speed(speed):设置画笔移动速度,画笔绘制的速度范围是[0,10]的整数,数字越大速度越快。

3,移动命令

命令说明
turtle.forward(distance)向当前画笔方向移动distance像素长度
turtle.backward(distance)向当前画笔相反方向移动distance像素长度
turtle.right(degree)顺时针移动degree°
turtle.left(degree)逆时针移动degree°
turtle.pendown()移动时绘制图形,缺省时也为绘制
turtle.goto(x,y)将画笔移动到坐标为x,y的位置
turtle.penup()提起笔移动,不绘制图形,用于另起一个地方绘制
turtle.circle()画圆,半径为正(负),表示圆心在画笔的左边(右边)画圆
setx( )将当前x轴移动到指定位置
sety( )将当前y轴移动到指定位置
setheading(angle)设置当前朝向为angle角度
home()设置当前画笔位置为原点,朝向东。
dot(r)绘制一个指定直径和颜色的圆点

4,颜色命令

命令说明
turtle.fillcolor(colorstring)绘制图形的填充颜色
turtle.color(color1, color2)同时设置pencolor=color1, fillcolor=color2
turtle.filling()返回当前是否在填充状态
turtle.begin_fill()准备开始填充图形
turtle.end_fill()填充完成
turtle.hideturtle()隐藏画笔的turtle形状
turtle.showturtle()显示画笔的turtle形状

turtle.pencolor():没有参数传入,返回当前画笔颜色,传入参数设置画笔颜色,可以是字符串如"green", "red",也可以是RGB色值。

5,全局控制命令

命令说明
turtle.clear()清空turtle窗口,但是turtle的位置和状态不会改变
turtle.reset()清空窗口,重置turtle状态为起始状态
turtle.undo()撤销上一个turtle动作
turtle.isvisible()返回当前turtle是否可见
stamp()复制当前图形
turtle.write(s [,font=("font-name",font_size,"font_type")])写文本,s为文本内容,font是字体的参数,分别为字体名称,大小和类型;font为可选项,font参数也是可选项

6,其他命令

命令说明
turtle.mainloop()或turtle.done()启动事件循环 -调用Tkinter的mainloop函数。必须是海龟图形程序中的最后一个语句。
turtle.mode(mode=None)设置海龟模式(“standard”,“logo”或“world”)并执行重置。如果没有给出模式,则返回当前模式。模式初始龟标题正角度standard向右(东)逆时针logo向上(北)顺时针
turtle.delay(delay=None)设置或返回以毫秒为单位的绘图延迟。
turtle.begin_poly()开始记录多边形的顶点。当前的海龟位置是多边形的第一个顶点。
turtle.end_poly()停止记录多边形的顶点。当前的海龟位置是多边形的最后一个顶点。将与第一个顶点相连。
turtle.get_poly()返回最后记录的多边形。

7,绘制五角星

绘图思路及函数解析

绘制五角星的注意事项:**

1.新建wjx.py的文件,导入绘图模块

import turtle
# 导入绘图模块

2.设置画布属性

turtle.screensize(canvwidth=None, canvheight=None, bg=None)
# canvwidth:画布的宽度(单位:像素)、canvheight:画布的高度(单位:像素)、bg:背景颜色

3.设置画笔属性

turtle.pensize(size) 
# 设置画笔的大小

turtle.fillcolor(color) 
# 设置画笔填充颜色color可以是字符串如"green", "red"

turtle.speed(speed) 
# 设置画笔速度为speed

4.提笔、移动和落笔

turtle.penup() 
# 提笔

turtle.pendown() 
# 落笔

5.绘制线条

turtle.left(angle)
# 笔的角度向左转angle

turtle.right(angle)
# 笔的角度向右转angle

turtle.forward(distance)
# 向当前画笔方向移动distance像素长度

6.绘制标志

turtle.begin_fill()
# 准备开始填充图形

turtle.end_fill()
# 填充完成

7.绘图结束调用done()函数保持窗口停留

turtle.done() 
# 保持窗口停留

源码

# coding: utf-8
import turtle                 #导入turtle库包
turtle.screensize(200, 150)      #设置画布大小
turtle.speed(2) #设置画笔速度为2
turtle.fillcolor("black")        #填充颜色
turtle.begin_fill()              #开始画,类似起笔
turtle.up()                      #提笔
count = 1                        #计时器,用于计录次数
while count <= 5:                #控制绘制次数
    turtle.forward(250)             #画笔绘制的方向,向前移动指定的距离
    turtle.right(144)         #向右转144度
    count += 1                   #循环绘制
    turtle.down()                #下笔
turtle.end_fill()                #完成填充图片的绘制
turtle.done()                    #保持窗口停留

8 绘制小蟒蛇

1.新建xms.py的文件,导入绘图模块

import turtle
导入绘图模块

2.设置画布属性

turtle.screensize(canvwidth=None, canvheight=None, bg=None)
# canvwidth:画布的宽度(单位:像素)、canvheight:画布的高度(单位:像素)、bg:背景颜色

turtle.setup(width=0.5, height=0.75, startx=None, starty=None)
# width,height:输入宽和高为整数时, 表示像素; 为小数时, 表示占据电脑屏幕的比例、(startx,starty):这一坐标表示矩形窗口左上角顶点的位置。如果为空,则窗口位于屏幕中心

3.设置画笔属性

turtle.pensize(size) 
# 设置画笔的大小

turtle.color(color1, color2) 
# 设置画笔颜色color1和填充色color2,可以是字符串如"green", "red",也可以是RGB 3元组

turtle.speed(speed) 
# 设置画笔速度为speed

4.提笔、移动和落笔

turtle.penup() 
# 提笔

turtle.pendown() 
# 落笔

5.绘制线条

turtle.seth(angle)
# 更改笔的角度为angle

turtle.forward(distance)
# 向当前画笔方向移动distance像素长度

turtle.circle(radius, extent=None, steps=None)
# radius(半径):半径为正(负),表示圆心在画笔的左边(右边)画圆;
# extent(弧度) (optional);
# steps (optional) (做半径为radius的圆的内切正多边形,多边形边数为steps)

6.绘制标志

turtle.end_fill()
# 填充完成

7.绘图结束调用done()函数保持窗口停留

turtle.done() 
# 保持窗口停留

总结:首先设置画布、画笔的属性。再运用以上函数依次画出小蟒蛇的身子与头。

源码

# coding: utf-8
import turtle #引用绘图库 turtle
turtle.screensize(500, 300)#设置画布大小
turtle.setup(800, 400, 300, 300) # 设置主窗口的大小和位置,后两个参数可选
turtle.speed(2) #设置画笔速度为2
turtle.penup() #提起笔移动,不绘制图形
turtle.fd(-330)# 画笔向绘制方向的当前方向移动distance(integer or float)的pixels距离
turtle.pendown()#落下画笔
turtle.pensize(20) #设置画笔的宽度;
turtle.pencolor("green") #画笔颜色设成绿色
turtle.seth(-45) # 只改变行进方向(角度按逆时针),但不行进
for i in range(5):
    turtle.circle(40, 90) #画圆,半径为正(负),表示圆心在画笔的左边(右边)画圆
    turtle.circle(-40, 90)
turtle.circle(40, 80/2)
turtle.fd(40)
turtle.circle(16, 180)
turtle.fd(40 * 2/3)
turtle.end_fill() #完成填充图片的绘制
turtle.done() #保持窗口停留

3,海龟绘图实例解析与源码

1,绘制太阳花

绘制太阳花的注意事项:

1.新建sunflower.py的文件,导入绘图模块

import turtle
# 导入绘图模块

2.设置画布属性

turtle.screensize(canvwidth=None, canvheight=None, bg=None)
# canvwidth:画布的宽度(单位:像素)、canvheight:画布的高度(单位:像素)、bg:背景颜色

turtle.setup(width=0.5, height=0.75, startx=None, starty=None)
# width,height:输入宽和高为整数时, 表示像素; 为小数时, 表示占据电脑屏幕的比例、(startx,starty):这一坐标表示矩形窗口左上角顶点的位置。如果为空,则窗口位于屏幕中心

3.设置画笔属性

turtle.pensize(size) 
# 设置画笔的大小

turtle.color(color1, color2) 
# 设置画笔颜色color1和填充色color2,可以是字符串如"green", "red",也可以是RGB 3元组

turtle.speed(speed) 
# 设置画笔速度为speed

4.提笔、移动和落笔

turtle.penup() 
# 提笔

turtle.goto(x, y)
# 画笔移动到画布的(x,y)坐标点

turtle.pendown() 
# 落笔

5.绘制线条``

turtle.left(angle)
# 笔的角度向左转angle

turtle.forward(distance)
# 向当前画笔方向移动distance像素长度

6.判别当前坐标与任意坐标距离

turtle.distance(x, y=None)
# x,y为任意的坐标点(x,y)

7.填充标志

turtle.begin_fill()
# 准备开始填充图形

turtle.end_fill()
# 填充完成

8.绘图结束调用done()函数保持窗口停留

turtle.done() 
# 保持窗口停留

总结:

首先设置画布、画笔的属性,为保持图案居中,将出发点左移。

编写一个While循环,沿着画笔方向画一条长为300像素点的线段(花的直径)。

每画一条线段,画笔角度左转170度。如果坐标点与出发点(-150,0)距离相差小于1(坐标点与出发点重合),则跳出该循环。

绘制结束,闭合填充。

源码

# -*- coding: utf-8 -*-

import turtle as t

#准备设置
t.screensize(400, 300) #设置画布大小
t.setup(840,500) #设置主窗口的大小为840*500
t.pensize(2) #设置画笔的大小
t.color('red','yellow') #设置画笔颜色和填充颜色(pink)
t.speed(10) #设置画笔速度为10

t.penup() #提笔
t.goto(-150,0) #画笔前往坐标(-150,0)
t.pendown() #下笔

t.begin_fill() #准备绘制
while True:
    t.forward(300) #画笔前进300个像素
    t.left(170) #画笔左转170度
    if t.distance(-150, 0) < 1: #如果当前坐标点距离出发点(150,0)小于1,则跳出循环
        break
t.end_fill() #依据轮廓填充颜色

#保持窗口停留
t.done()

2,绘制四叶草

绘制四叶草的注意事项:

1.新建leaf.py的文件,导入绘图模块

import turtle
# 导入绘图模块

2.设置画布属性

turtle.screensize(canvwidth=None, canvheight=None, bg=None)
# canvwidth:画布的宽度(单位:像素)、canvheight:画布的高度(单位:像素)、bg:背景颜色

turtle.setup(width=0.5, height=0.75, startx=None, starty=None)
# width,height:输入宽和高为整数时, 表示像素; 为小数时, 表示占据电脑屏幕的比例、(startx,starty):这一坐标表示矩形窗口左上角顶点的位置。如果为空,则窗口位于屏幕中心

3.设置画笔属性

turtle.pensize(size) 
# 设置画笔的大小

turtle.color(color1, color2) 
# 设置画笔颜色color1和填充色color2,可以是字符串如"green", "red",也可以是RGB 3元组

turtle.speed(speed) 
# 设置画笔速度为speed

4.绘制线条

turtle.seth(angle)
# 更改笔的角度为angle

turtle.forward(distance)
# 向当前画笔方向移动distance像素长度

turtle.circle(radius, extent=None, steps=None)
# radius(半径):半径为正(负),表示圆心在画笔的左边(右边)画圆;
# extent(弧度) (optional);
# steps (optional) (做半径为radius的圆的内切正多边形,多边形边数为steps)

5.绘制标志

turtle.begin_fill()
# 准备开始填充图形

turtle.end_fill()
# 填充完成

6.绘图结束调用done()函数保持窗口停留

turtle.done() 
# 保持窗口停留

总结:

首先设置画布、画笔的属性。

整体思路是以for循环来完成四叶草的绘制:

1.首先创建一个包括用于控制叶子大小和叶子旋转角度的两个参数的方法;

2.在该方法内,第一层for循环控制四片叶子的角度和叶边长度,第二层嵌套的for循环来控制每片叶子的叶尖花边以及叶内花边的弧度和长度;

3.颜色填充在整个for循环结束之后完成。

源码

# -*- coding: utf-8 -*-

import turtle as t

#准备设置
t.screensize(400, 300) #设置画布大小
t.setup(840, 500) #设置主窗口的大小为840*500
t.pensize(5) #设置外花边的大小
t.color('mediumseagreen', 'forestgreen') #设置画笔颜色和填充颜色
t.speed(10) #设置画笔速度为10

def draw_clover(radius, rotate): #参数radius控制叶子的大小,rotate控制叶子的旋转
    t.begin_fill() #外形填充开始标志
    for i in range(4): #从0到3开始的for循环,共四片花瓣
        direction = i * 90
        t.seth(60 + direction + rotate)   #控制叶子根部的角度为60度
        t.fd(4 * radius) 
        for j in range(2):
            t.seth(90 + direction + rotate)
            t.circle(radius, 180)
        t.seth(-60 + direction + rotate)
        t.fd(4 * radius)
        t.seth(60 + direction+rotate)   #控制叶子根部的角度为60度
        t.fd(2 * radius)
        for j in range(2): #从0到1开始的for循环,画内花边
            t.pencolor("whitesmoke") #设置内花边颜色
            t.pensize(8) #设置内花边的大小
            t.seth(90 + direction + rotate)
            t.circle(radius/2, 180)
            t.color('mediumseagreen', 'forestgreen')
            t.pensize(5)
        t.seth(-60 + direction + rotate)
        t.fd(2 * radius)
    t.end_fill() #依据轮廓填充颜色
    t.seth(-110)
    t.fd(6 * radius)

draw_clover(40, 25) 
t.done() #保持窗口停留

3,绘制狮子头

注意事项

1.新建loin.py的文件,导入绘图模块

import turtle
# 导入绘图模块

2.设置画布属性

turtle.screensize(canvwidth=None, canvheight=None, bg=None)
# canvwidth:画布的宽度(单位:像素)、canvheight:画布的高度(单位:像素)、bg:背景颜色

turtle.setup(width=0.5, height=0.75, startx=None, starty=None)
# width,height:输入宽和高为整数时, 表示像素; 为小数时, 表示占据电脑屏幕的比例、(startx,starty):这一坐标表示矩形窗口左上角顶点的位置。如果为空,则窗口位于屏幕中心

3.设置画笔属性``

turtle.fillcolor(color) 
# 设置填充色color,可以是字符串如"green", "red",也可以是RGB 3元组

turtle.speed(speed) 
# 设置画笔速度为speed

4.提笔、移动和落笔

turtle.penup() 
# 提笔

turtle.goto(x, y)
# 画笔移动到画布的(x,y)坐标点

turtle.pendown() 
# 落笔

5.绘制线条

turtle.seth(angle)
# 更改笔的角度为angle

turtle.forward(distance)
# 向当前画笔方向移动distance像素长度

turtle.circle(radius, extent=None, steps=None)
# radius(半径):半径为正(负),表示圆心在画笔的左边(右边)画圆;
# extent(弧度) (optional);
# steps (optional) (做半径为radius的圆的内切正多边形,多边形边数为steps)

6.绘制标志

turtle.begin_fill()
# 准备开始填充图形

turtle.end_fill()
# 填充完成

7.绘图结束调用done()函数保持窗口停留

turtle.done() 
# 保持窗口停留

总结:

首先设置画布、画笔的属性。再运用以上函数分别定义画狮子的头发、耳朵、脸、眼睛、嘴巴和鼻子的方法,再调用即可。

源码

# -*- coding: utf-8 -*-

import turtle as t

#准备设置
t.screensize(400, 300) #设置画布大小
t.setup(840, 500) #设置主窗口的大小为840*500
t.speed(10) #设置画笔速度为10

#画头发
def hair():  
    t.penup()
    t.goto(-70, 125)
    t.pendown()
    t.fillcolor('saddlebrown') #设置填充色
    t.begin_fill()
    for j in range(12):
        t.setheading(60 - (j * 30)) #每次调整画笔角度
        t.circle(-50, 90) #画120度的弧
    t.end_fill()
    
#画耳朵,dir用来设置方向,左右耳对称
def ears(dir):  
    t.penup()
    t.goto((0 - dir) * 25, 75)
    t.setheading(90)
    t.pendown()
    t.fillcolor('peru')
    t.begin_fill()
    t.circle(dir * 28)
    t.end_fill()
    t.penup()
    t.goto((0 - dir) * 30, 68)
    t.setheading(90)
    t.pendown()
    t.fillcolor('white')
    t.begin_fill()
    t.circle(dir * 18)
    t.end_fill()

#画脸
def face():  
    t.penup()
    t.goto(0, 80)
    t.pendown()
    t.fillcolor('peru')
    t.begin_fill()
    t.setheading(180)
    t.circle(80)
    t.end_fill()
    # 下巴
    t.circle(80, 125)
    t.fillcolor('white')
    t.begin_fill()
    t.circle(80, 110)
    t.setheading(145)
    t.circle(110, 72)
    t.end_fill()
    
#画眼睛,dir用来设置方向,左右眼对称
def eye(dir):  
    t.penup()
    t.goto((0 - dir) * 30, 20)
    t.setheading(0)
    t.pendown()
    t.fillcolor('black')
    t.begin_fill()
    t.circle(10)
    t.end_fill()  
 
#画嘴巴    
def mouth():  
    t.penup()
    t.goto(0, 0)
    t.setheading(-90)
    t.pendown()
    t.forward(50)
    t.setheading(0)
    t.circle(80, 25)
    t.penup()
    t.goto(0, -50)
    t.setheading(180)
    t.pendown()
    t.circle(-80, 25)
    
#画鼻子
def nose():  
    t.penup()
    t.goto(15, 0)
    t.setheading(90)
    t.pendown()
    t.fillcolor('saddlebrown')
    t.begin_fill()
    t.circle(15)
    t.end_fill()
    
hair()
ears(1)
ears(-1)
face()
eye(1)
eye(-1)
mouth()
nose()

t.done() #保持窗口停留

4,绘制皮卡丘

绘制眨眼睛的皮卡丘注意事项

1.新建pikachu.py的文件,导入绘图模块

import turtle
# 导入绘图模块

2.设置画布属性

turtle.screensize(canvwidth=None, canvheight=None, bg=None)
# canvwidth:画布的宽度(单位:像素)、canvheight:画布的高度(单位:像素)、bg:背景颜色

turtle.setup(width=0.5, height=0.75, startx=None, starty=None)
# width,height:输入宽和高为整数时, 表示像素; 为小数时, 表示占据电脑屏幕的比例、(startx,starty):这一坐标表示矩形窗口左上角顶点的位置。如果为空,则窗口位于屏幕中心

3.设置画笔属性

turtle.pensize(size) 
# 设置画笔的大小

turtle.color(color1, color2) 
# 设置画笔颜色color1和填充色color2,可以是字符串如"green", "red",也可以是RGB 3元组

turtle.speed(speed) 
# 设置画笔速度为speed

4.提笔、移动和落笔

turtle.penup() 
# 提笔

turtle.goto(x, y)
# 画笔移动到画布的(x,y)坐标点

turtle.pendown() 
# 落笔

5.绘制线条

turtle.seth(angle)
# 更改笔的角度为angle

turtle.left(angle)
# 笔的角度向左转angle

turtle.right(angle)
# 笔的角度向右转angle

turtle.forward(distance)
# 向当前画笔方向移动distance像素长度

turtle.circle(radius, extent=None, steps=None)
# radius(半径):半径为正(负),表示圆心在画笔的左边(右边)画圆;
# extent(弧度) (optional);
# steps (optional) (做半径为radius的圆的内切正多边形,多边形边数为steps)

6.绘制标志

turtle.begin_fill()
# 准备开始填充图形

turtle.end_fill()
# 填充完成

7.绘图结束调用done()函数保持窗口停留

turtle.done() 
# 保持窗口停留

8.绘图动画的设置

turtle.tracer(True/False) 
# 开启/关闭绘图动画。关闭后,剩下的绘图语句不再显示过程

9.清空当前窗口

turtle.reset() 
# 清空窗口

10.隐藏画笔

turtle.hideturtle() 
# 隐藏画笔

11.更新窗口

turtle.update() 
# 更新窗口

12.线程休眠

time.sleep(second) 
# 当前线程休眠second秒

总结:

首先设置画布、画笔的属性。

编写一个画椭圆的函数,分别用于定义画耳朵、脚、尾巴、身体、脸、手的方法。

由于图案较为复杂,因此上述方法需要耐心地进行反复调试。

本案例关键在于图案是一只会眨眼睛的皮卡丘,因此需要额外定义一个闭眼方法,用一条线段代替眼睛即可。

把画图用函数合并成三个函数:初始化睁眼皮卡丘、闭眼皮卡丘、睁眼皮卡丘。

在主方法中,首先调用初始化方法绘制睁眼皮卡丘,之后调用tracer(False)函数关闭之后的绘制动画。

定义一个0到49的for循环:

当i为偶:清空窗口->关闭画笔->调用闭眼皮卡丘函数->通知系统更新窗口->线程休眠0.3秒(闭眼0.3秒)

当i为奇:清空窗口->关闭画笔->调用睁眼皮卡丘函数->通知系统更新窗口->线程休眠0.3秒(睁眼0.3秒)

这样一来,通过连续进行清空窗口、调用函数、更新窗口三大步骤,就可以控制图案的重绘,实现皮卡丘的眨眼效果。

源码

# -*- coding: utf-8 -*-

import turtle as t
import time

#准备设置
t.screensize(400, 300)
t.pensize(3) #设置画笔的大小
t.setup(840,500) #设置主窗口的大小为840*500
t.speed(10) #设置画笔速度为10

#画左偏曲线函数
def radian_left(angle, distance, step, n):
    for i in range(n):
        distance += step #dis每次增大step
        t.left(angle) #向左转ang度
        t.fd(distance) #向前走dis的步长
#画右偏曲线函数       
def radian_right(angle, distance, step, n):
    for i in range(n):
        distance += step #dis每次增大step
        t.right(angle) #向左转ang度
        t.fd(distance) #向前走dis的步长
        
#画耳朵
def InitEars():
    #左耳朵
    t.color("black", "yellow")
    t.penup() #提笔
    t.goto(-50, 100) #笔头初始位置
    t.pendown() #下笔
    t.seth(70) #画笔角度
    t.begin_fill()
    radian_left(1.5, 2, 0.1, 32)
    t.seth(235) #画笔角度
    radian_left(1.5, 2, 0.1, 35)
    t.seth(30) #画笔角度
    t.fd(28)
    t.end_fill()
    #黑左耳朵尖
    t.penup() #提笔
    t.goto(-50, 175) #笔头初始位置
    t.pendown() #下笔
    t.seth(110) #画笔角度
    t.begin_fill()
    t.fillcolor("black")
    radian_left(0.5, 2, 0.1, 15)
    t.seth(245) #画笔角度
    radian_left(0.5, 2, 0.1, 15)
    t.seth(5) #画笔角度
    t.fd(20)
    t.end_fill()
    
    #右耳朵
    t.color("black", "yellow")
    t.penup() #提笔
    t.goto(50, 100) #笔头初始位置
    t.pendown() #下笔
    t.seth(45) #画笔角度
    t.begin_fill()
    radian_right(1.5, 2, 0.1, 35)
    t.seth(230) #画笔角度
    radian_right(1.5, 2, 0.1, 33)
    t.seth(145) #画笔角度
    t.fd(18)
    t.end_fill()
    #黑右耳朵尖
    t.fillcolor("black")
    t.penup() #提笔
    t.goto(135, 131) #笔头初始位置
    t.pendown() #下笔
    t.seth(13) #画笔角度
    t.begin_fill()
    radian_right(2, 2, 0.1, 14)
    t.seth(230) #画笔角度
    radian_right(2, 2, 0.1, 10)
    t.seth(130) #画笔角度
    t.fd(25)
    t.end_fill()
    
#画脚
def InitFoots():
    t.fillcolor("yellow")
    t.penup() #提笔
    t.goto(-65, -200) #笔头初始位置
    t.pendown() #下笔
    t.begin_fill()
    t.seth(225) #画笔角度
    radian_left(0.5, 1.2, 0, 12)
    radian_left(35, 0.6, 0, 4)
    radian_left(1, 1.2, 0, 18)
    t.seth(160) #画笔角度
    t.fd(13)
    t.end_fill()
    t.penup() #提笔
    t.goto(65, -200) #笔头初始位置
    t.pendown() #下笔
    t.seth(315) #画笔角度
    t.begin_fill()
    radian_right(0.5, 1.2, 0, 12)
    radian_right(35, 0.6, 0, 4)
    radian_right(1, 1.2, 0, 18)
    t.seth(20) #画笔角度
    t.fd(13)
    t.end_fill()
    
#画尾巴
def InitTail():
    t.fillcolor("yellow")
    t.penup() #提笔
    t.goto(65, -140) #笔头初始位置
    t.pendown() #下笔
    t.begin_fill()
    t.seth(10) #画笔角度
    t.fd(20)
    t.seth(90) #画笔角度
    t.fd(20)
    t.seth(10) #画笔角度
    t.fd(10)
    t.seth(80) #画笔角度
    t.fd(100)
    t.seth(35) #画笔角度
    t.fd(80)
    t.seth(260) #画笔角度
    t.fd(100)
    t.seth(205) #画笔角度
    t.fd(40)
    t.seth(260) #画笔角度
    t.fd(37)
    t.seth(205) #画笔角度
    t.fd(20)
    t.seth(260) #画笔角度
    t.fd(25)
    t.seth(175) #画笔角度
    t.fd(30)
    t.seth(100) #画笔角度
    t.fd(13)
    t.end_fill()
    
#画身体
def InitBody():
    t.pu() #提笔
    t.goto(95, 25) #笔头初始位置
    t.pd() #下笔
    t.seth(90) #画笔角度
    t.begin_fill()
    t.circle(95, 180)
    t.seth(260) #画笔角度
    radian_left(0.5, 1, 0, 35)
    radian_left(2, 1.8, 0, 35)
    t.seth(255) #画笔角度
    radian_left(0.4, 2, 0.2, 27)
    radian_left(2.8, 1, 0, 45)
    radian_right(0.9, 1.45, 0, 31)
    t.seth(355) #画笔角度
    radian_right(0.9, 1.45, 0, 31)
    radian_left(2.8, 1, 0, 45)
    radian_left(0.4, 2, 0.2, 27)
    t.seth(9) #画笔角度
    radian_left(2, 1.8, 0, 35)
    radian_left(0.5, 1, 0, 36)
    t.end_fill()

#画脸
def InitFace():
    t.fillcolor("red")
    t.penup() #提笔
    t.goto(-63, -10) #笔头初始位置
    t.pendown() #下笔
    t.seth(90) #画笔角度
    t.begin_fill()
    t.circle(10, 360)
    t.end_fill()
    t.fillcolor("red")
    t.penup() #提笔
    t.goto(63, -10) #笔头初始位置
    t.pendown() #下笔
    t.seth(-90) #画笔角度
    t.begin_fill()
    t.circle(10, 360)
    t.end_fill()
    t.penup() #提笔
    t.goto(0, 0) #笔头初始位置
    t.pendown() #下笔
    t.seth(235) #画笔角度
    radian_right(5, 0.8, 0, 30)
    t.penup() #提笔
    t.goto(0, 0) #笔头初始位置
    t.pendown() #下笔
    t.seth(305) #画笔角度
    radian_left(5, 0.8, 0, 30)
    
#画手
def InitHands():
    t.penup() #提笔
    t.goto(-45, -100) #笔头初始位置
    t.pendown() #下笔
    t.seth(285) #画笔角度
    radian_right(0.4, 1.2, 0, 26)
    radian_right(5, 0.35, 0, 26)
    radian_right(0.3, 1.2, 0, 15)
    t.penup() #提笔
    t.goto(45, -100)  #笔头初始位置
    t.pendown() #下笔
    t.seth(255) #画笔角度
    radian_left(0.4, 1.2, 0, 26)
    radian_left(5, 0.35, 0, 26)
    radian_left(0.3, 1.2, 0, 15)
    
#画眼睛
def InitEyes():
    #左眼睛
    t.fillcolor("black")
    t.penup() #提笔
    t.goto(-45, 20) #笔头初始位置
    t.pendown() #下笔
    t.seth(90) #画笔角度
    t.begin_fill()
    t.circle(8, 360)
    t.end_fill()
    # 右眼睛
    t.fillcolor("black")
    t.penup() #提笔
    t.goto(45, 20) #笔头初始位置
    t.pendown() #下笔
    t.seth(-90) #画笔角度
    t.begin_fill()
    t.circle(8, 360)
    t.end_fill()

#画闭眼
def CloseEyes():
    t.penup() #提笔
    t.goto(-45, 20) #笔头初始位置
    t.pendown() #下笔
    t.seth(180) #画笔角度
    t.fd(10)
    t.penup() #提笔
    t.goto(45, 20) #笔头初始位置
    t.pendown() #下笔
    t.seth(0) #画笔角度
    t.fd(10)
    
#初始化
def Init():
    InitEars()
    InitFoots()
    InitTail()
    InitBody()
    InitFace()
    InitHands()
    InitEyes()
    
#闭眼
def Upgarde():
    InitEars()
    InitFoots()
    InitTail()
    InitBody()
    InitFace()
    InitHands()
    CloseEyes()
 
#睁眼 
def Upgarde_Init():
    InitEars()
    InitFoots()
    InitTail()
    InitBody()
    InitFace()
    InitHands()
    InitEyes()
    
def main():
    Init()
    t.tracer(False) #关闭绘图动画,下面采用直接画完
    # 眨眼睛动画
    for i in range(50):
        if i % 2 == 0:
            t.reset() #清空窗口
            t.hideturtle() #隐藏画笔
            Upgarde() #闭眼
            t.update() #更新窗口
            time.sleep(0.3) #线程休眠0.3秒
        else:
            t.reset() #清空窗口
            t.hideturtle() #隐藏画笔
            Upgarde_Init() #睁眼
            t.update() #更新窗口
            time.sleep(0.3) #线程休眠0.3秒
main()
t.done()


5,绘制小猪佩奇

1.新建peki.py的文件,导入绘图模块

import turtle
# 导入绘图模块

2.设置画布属性

turtle.screensize(canvwidth=None, canvheight=None, bg=None)
# canvwidth:画布的宽度(单位:像素)、canvheight:画布的高度(单位:像素)、bg:背景颜色

turtle.setup(width=0.5, height=0.75, startx=None, starty=None)
# width,height:输入宽和高为整数时, 表示像素; 为小数时, 表示占据电脑屏幕的比例、(startx,starty):这一坐标表示矩形窗口左上角顶点的位置。如果为空,则窗口位于屏幕中心

3.设置画笔属性

turtle.pensize(size) 
# 设置画笔的大小

turtle.colormode(size) 
# 设置GBK颜色范围为0-255

turtle.color(color1, color2) 
# 设置画笔颜色color1和填充色color2,可以是字符串如"green", "red",也可以是RGB 3元组

turtle.speed(speed) 
# 设置画笔速度为speed

4.提笔、移动和落笔

turtle.penup() 
# 提笔

turtle.goto(x, y)
# 画笔移动到画布的(x,y)坐标点

turtle.pendown() 
# 落笔

5.绘制线条

turtle.seth(angle)
# 更改笔的角度为angle

turtle.left(angle)
# 笔的角度向左转angle

turtle.right(angle)
# 笔的角度向右转angle

turtle.forward(distance)
# 向当前画笔方向移动distance像素长度

turtle.circle(radius, extent=None, steps=None)
# radius(半径):半径为正(负),表示圆心在画笔的左边(右边)画圆;
# extent(弧度) (optional);
# steps (optional) (做半径为radius的圆的内切正多边形,多边形边数为steps)

6.绘制标志

turtle.begin_fill()
# 准备开始填充图形

turtle.end_fill()
# 填充完成

7.绘图结束调用done()函数保持窗口停留

turtle.done() 
# 保持窗口停留

总结:首先设置画布、画笔的属性。再运用以上函数依次画出佩奇的鼻子、头部、耳朵、眼睛、腮部、嘴部、身体、手部、脚部和尾巴。

源码

# coding: utf-8
 
import turtle as t
 
#准备设置
t.screensize(400, 300) #设置画布大小
t.pensize(4) #设置画笔的大小
t.colormode(255) #设置GBK颜色范围为0-255
t.color((255,155,192),"pink") #设置画笔颜色和填充颜色(pink)
t.setup(840,500) #设置主窗口的大小为840*500
t.speed(10) #设置画笔速度为10

#画鼻子
t.penup() #提笔
t.goto(-100,100) #画笔前往坐标(-100,100)
t.pendown() #下笔
t.seth(-30) #笔的角度为-30°(鼻子向右倾斜30度),但未行进
t.begin_fill() #外形填充的开始标志
a = 0.4 #设置初始步长
for i in range(120): #循环一个从0开始到119的列表
   if 0 <= i < 30 or 60 <= i < 90:
       a = a + 0.08
       t.lt(3) #向左转3度
       t.fd(a) #向前走a的步长
   else:
       a = a - 0.08
       t.lt(3) #向左转3度
       t.fd(a) #向前走a的步长
t.end_fill() #依据轮廓填充颜色
t.penup() #提笔
t.seth(90) #笔的角度为90度
t.fd(25) #向前移动25
t.seth(0) #转换画笔的角度为0
t.fd(10) #向前移动10
t.pendown() #下笔
t.pencolor(255,155,192) #设置画笔颜色
t.seth(10) #转换画笔的角度为10
t.begin_fill() #外形填充开始标志
t.circle(5) #画一个半径为5的圆
t.color(160,82,45) #设置填充颜色
t.end_fill() #依据轮廓填充颜色
t.penup() #提笔
t.seth(0) #转换画笔的角度为0
t.fd(20) #向前移动25
t.pendown() #下笔
t.pencolor(255,155,192) #设置画笔和填充颜色
t.seth(10) #转换画笔的角度为10
t.begin_fill() #外形填充开始标志
t.circle(5) #画一个半径为5的圆
t.color(160,82,45) #设置填充颜色
t.end_fill() #依据轮廓填充颜色

#以此类推,画头
t.color((255,155,192),"pink")
t.penup()
t.seth(90)
t.fd(41)
t.seth(0)
t.fd(0)
t.pendown()
t.begin_fill()
t.seth(180)
t.circle(300,-30) #顺时针画一个半径为300,圆心角为30°的不完整圆
t.circle(100,-60) #接上去
t.circle(80,-100) 
t.circle(150,-20) 
t.circle(60,-95) 
t.seth(161)
t.circle(-300,15) 
t.penup()
t.goto(-100,100)
t.pendown()
t.seth(-30)
a = 0.4
for i in range(60):
   if 0 <= i < 30 or 60 <= i < 90:
       a = a + 0.08
       t.lt(3) #向左转3度
       t.fd(a) #向前走a的步长
   else:
       a = a -0.08
       t.lt(3)
       t.fd(a)
t.end_fill() #回到画头出发点,闭合填充背景色

#画耳朵
t.color((255,155,192),"pink")
t.penup()
t.seth(90)
t.fd(-7)
t.seth(0)
t.fd(70)
t.pendown()
t.begin_fill()
t.seth(100)
t.circle(-50,50)
t.circle(-10,120)
t.circle(-50,54)
t.end_fill()
t.penup()
t.seth(90)
t.fd(-12)
t.seth(0)
t.fd(30)
t.pendown()
t.begin_fill()
t.seth(100)
t.circle(-50,50)
t.circle(-10,120)
t.circle(-50,56)
t.end_fill()

#画眼睛
t.color((255,155,192),"white")
t.penup()
t.seth(90)
t.fd(-20)
t.seth(0)
t.fd(-95)
t.pendown()
t.begin_fill()
t.circle(15)
t.end_fill()
t.color("black")
t.penup()
t.seth(90)
t.fd(12)
t.seth(0)
t.fd(-3)
t.pendown()
t.begin_fill()
t.circle(3)
t.end_fill()
t.color((255,155,192),"white")
t.penup()
t.seth(90)
t.fd(-25)
t.seth(0)
t.fd(40)
t.pendown()
t.begin_fill()
t.circle(15)
t.end_fill()
t.color("black")
t.penup()
t.seth(90)
t.fd(12)
t.seth(0)
t.fd(-3)
t.pendown()
t.begin_fill()
t.circle(3)
t.end_fill()

#画腮
t.color((255,155,192))
t.penup()
t.seth(90)
t.fd(-95)
t.seth(0)
t.fd(65)
t.pendown()
t.begin_fill()
t.circle(30)
t.end_fill()

#画嘴
t.color(239,69,19)
t.penup()
t.seth(90)
t.fd(15)
t.seth(0)
t.fd(-100)
t.pendown()
t.seth(-80)
t.circle(30,40)
t.circle(40,80)

#画身体
t.color("red",(255,99,71))
t.penup()
t.seth(90)
t.fd(-20)
t.seth(0)
t.fd(-78)
t.pendown()
t.begin_fill()
t.seth(-130)
t.circle(100,10)
t.circle(300,30)
t.seth(0)
t.fd(230)
t.seth(90)
t.circle(300,30)
t.circle(100,3)
t.color((255,155,192),(255,100,100))
t.seth(-135)
t.circle(-80,63)
t.circle(-150,24)
t.end_fill()

#画手
t.color((255,155,192))
t.penup()
t.seth(90)
t.fd(-40)
t.seth(0)
t.fd(-27)
t.pendown()
t.seth(-160)
t.circle(300,15)
t.penup()
t.seth(90)
t.fd(15)
t.seth(0)
t.fd(0)
t.pendown()
t.seth(-10)
t.circle(-20,90)
t.penup()
t.seth(90)
t.fd(30)
t.seth(0)
t.fd(237)
t.pendown()
t.seth(-20)
t.circle(-300,15)
t.penup()
t.seth(90)
t.fd(20)
t.seth(0)
t.fd(0)
t.pendown()
t.seth(-170)
t.circle(20,90)

#画脚
t.pensize(10)
t.color((240,128,128))
t.penup()
t.seth(90)
t.fd(-75)
t.seth(0)
t.fd(-180)
t.pendown()
t.seth(-90)
t.fd(40)
t.seth(-180)
t.color("black")
t.pensize(15)
t.fd(20)
t.pensize(10)
t.color((240,128,128))
t.penup()
t.seth(90)
t.fd(40)
t.seth(0)
t.fd(90)
t.pendown()
t.seth(-90)
t.fd(40)
t.seth(-180)
t.color("black")
t.pensize(15)
t.fd(20)

#画尾巴
t.pensize(4)
t.color((255,155,192))
t.penup()
t.seth(90)
t.fd(70)
t.seth(0)
t.fd(95)
t.pendown()
t.seth(0)
t.circle(70,20)
t.circle(10,330)
t.circle(70,30)

t.done() #画布窗口停留

6绘制谢尔宾斯基三角形

1.新建triangle.py的文件,导入绘图模块

import turtle
# 导入绘图模块

2.设置画布属性

turtle.screensize(canvwidth=None, canvheight=None, bg=None)
# canvwidth:画布的宽度(单位:像素)、canvheight:画布的高度(单位:像素)、bg:背景颜色

turtle.setup(width=0.5, height=0.75, startx=None, starty=None)
# width,height:输入宽和高为整数时, 表示像素; 为小数时, 表示占据电脑屏幕的比例、(startx,starty):这一坐标表示矩形窗口左上角顶点的位置。如果为空,则窗口位于屏幕中心

3.设置画笔属性

turtle.speed(speed) 
# 设置画笔速度为speed

4.提笔、移动和落笔

turtle.penup() 
# 提笔

turtle.goto(x, y)
# 画笔移动到画布的(x,y)坐标点

turtle.pendown() 
# 落笔

5.绘制线条

turtle.left(angle)
# 笔的角度向左转angle

turtle.forward(distance)
# 向当前画笔方向移动distance像素长度

6.绘图结束调用done()函数保持窗口停留

turtle.done() 
# 保持窗口停留

总结:

首先设置画布、画笔的属性。

由于谢尔宾斯基三角形由很多组不同大小的三角形组成,所以建议使用递归算法来绘制。

递归的核心是不断调用自身

那么,我们需要定义三个方法:绘制三角形、获取任意两点中间坐标、递归的方法。

递归第一轮:

​ 根据给定的坐标列表1绘制三角形1;

​ 调用获取坐标方法来创建新的坐标列表2;

​ 将新的坐标列表2和递归的返回条件减1传入到递归的方法。

递归第二轮:

​ 根据给定的坐标列表2绘制三角形2;

​ 调用获取坐标方法来创建新的坐标列表3;

​ 将新的坐标列表3和递归的返回条件减1传入到递归的方法。

…………

以此类推,递归5轮绘制出谢尔宾斯基三角形。

源码

# -*- coding: utf-8 -*-

import turtle as t

#准备设置
t.screensize(400, 300) #设置画布大小
t.setup(840,500) #设置主窗口的大小为840*500
t.speed(10) #设置画笔速度为10

def draw_triangle(size): #传入列表中三个点的坐标,绘制三角形
    t.penup()
    t.goto(size[0])
    t.pendown()
    t.goto(size[1])
    t.goto(size[2])
    t.goto(size[0])
 
def get_mid(a, b): #计算返回任意2个点的中间点坐标
    x = (a[0] + b[0]) / 2
    y = (a[1] + b[1]) / 2
    return [x, y]
 
def draw_s(size, times): #递归times次,调用绘制函数draw_triangle(size)
    draw_triangle(size) #绘制三角形
    if times > 1:
        # 绘制左边小三角形
        size2 = [size[0], get_mid(size[0], size[1]), get_mid(size[0], size[2])]
        draw_s(size2, times - 1)
 
        # 绘制上边的小三角形
        size3 = [get_mid(size[0], size[2]), get_mid(size[1], size[2]), size[2]]
        draw_s(size3, times - 1)
        
        # 绘制右边的小三角形
        size4 = [get_mid(size[0], size[1]), size[1], get_mid(size[1], size[2])]
        draw_s(size4, times - 1)
 
t.left(90) #向左转90度
points = [[-200,-150], [200, -150], [0, 150]] #初始三角形坐标
count = 5 #递归5次
draw_s(points, count) #调用绘制谢尔宾斯基三角形函数
t.done() #保持窗口停留

7,绘制唯美樱花树

1.新建cherrytree.py的文件,导入随机数、运算、绘图模块

from random import *
from math import *
import turtle
# 导入随机数、运算、绘图模块

2.设置画布属性

turtle.screensize(canvwidth=None, canvheight=None, bg=None)
# canvwidth:画布的宽度(单位:像素)、canvheight:画布的高度(单位:像素)、bg:背景颜色

turtle.setup(width=0.5, height=0.75, startx=None, starty=None)
width,height:输入宽和高为整数时, 表示像素; 为小数时, 表示占据电脑屏幕的比例、(startx,starty):这一坐标表示矩形窗口左上# 角顶点的位置。如果为空,则窗口位于屏幕中心
turtle.bgcolor(0.5, 0.5, 0.5) 
# 设置背景色,可以是字符串如"green", "red",也可以是RGB 3元组

3.设置画笔属性

turtle.pensize(size) 
# 设置画笔的大小

turtle.pencolor(color1) 
# 设置画笔颜色color1,可以是字符串如"green", "red",也可以是RGB 3元组

turtle.speed(speed) 
# 设置画笔速度为speed

4.提笔和落笔

turtle.penup() 
# 提笔

turtle.pendown() 
# 落笔

5.绘制线条

turtle.seth(angle)
# 更改笔的角度为angle

turtle.left(angle)
# 笔的角度向左转angle

turtle.right(angle)
# 笔的角度向右转angle

turtle.forward(distance)
# 向当前画笔方向移动distance像素长度

turtle.circle(radius, extent=None, steps=None)
# radius(半径):半径为正(负),表示圆心在画笔的左边(右边)画圆;
# extent(弧度) (optional);
# steps (optional) (做半径为radius的圆的内切正多边形,多边形边数为steps)

6.隐藏画笔

t.hideturtle() 
# 隐藏画笔

7.窗口刷新

turtle.tracer(n=None, delay=None) 
# 窗口每隔delay秒刷新n次

8.生成随机数

random()
# 随机生成范围在0-1的非负数

9.绘图结束调用done()函数保持窗口停留

turtle.done() 
# 保持窗口停留

总结:

首先设置画布、画笔的属性。

由于樱花树是由不规则的树枝、樱花和飘落的花瓣构成,所以本次绘制使用递归算法和随机运算一起完成。

定义一个接收树枝层次和树枝长度参数的画树方法,其中包括两部分:

第一部分 画树枝:

当前树枝角度(画笔方向)来控制树枝颜色的变化;当前树枝层次来控制树枝的粗细(画笔大小);当前形参即为树枝长度。

连续递归画树方法:

当树枝层次大于0时,画右子树和左子树,树枝角度受到随机角度的影响。

先画右子树,直至右树枝层次画尽,末端画樱花,本轮递归终止;

回退上轮递归,画左子树,然后判断树枝层次,大于0则从右到左递归画树方法,小于0则末端画樱花;

第二部分 画樱花:

当树枝层次小于0时,在当前树枝末端画樱花及随机生成相应位置的飘落花瓣。

根据当前树枝角度(画笔方向)来设置末端樱花的颜色。

例如: 在画树方法中传入实参(1,75),先画出长度为75的树根;

​ 第一轮递归,因为层次1>0(画树枝),调用画树方法传入(1-1, 随机长度)。

​ 画实参(1-1,随机长度)的右偏树枝,左偏树枝代码未执行。

​ 第二轮递归,因为层次0==0(画右樱花),返回第一轮递归。

​ 回到第一轮,执行画左偏树代码,调用画树方法传入(1-1, 随机长度)。

​ 画实参(1-1,随机长度)的左偏树枝。

​ 第三轮递归,因为层次0==0(画左樱花)。

​ 递归结束。

由于本案例递归次数较多,请结合源码进行理解。

源码

from turtle import *
from random import *
from math import *
class Tree:
    def __init__(self):
        setup(1000, 700)
        bgcolor(1, 1, 1)  # 背景色
        # ht()  # 隐藏turtle
        speed(10)  # 速度 1-10渐进,0 最快
        # tracer(1, 100)    # 设置绘图屏幕刷新频率,参数1设置在正常刷新频次的第参数1次刷新,参数2设置每次刷新的时延
        tracer(0, 0)
        pu()  # 抬笔
        backward(100)
        # 保证笔触箭头方向始终不向下,此处使其左转90度,而不是右转
        left(90)  # 左转90度
        backward(300)  # 后退300
    def tree(self, n, l):
        pd()  # 下笔
        # 阴影效果
        t = cos(radians(heading() + 45)) / 8 + 0.25
        pencolor(t, t, t)
        pensize(n / 1.2)
        forward(l)  # 画树枝
        if n > 0:
            b = random() * 15 + 10  # 右分支偏转角度
            c = random() * 15 + 10  # 左分支偏转角度
            d = l * (random() * 0.25 + 0.7)  # 下一个分支的长度
            # 右转一定角度,画右分支
            right(b)
            self.tree(n - 1, d)
            # 左转一定角度,画左分支
            left(b + c)
            self.tree(n - 1, d)
            # 转回来
            right(c)
        else:
            # 画叶子
            right(90)
            n = cos(radians(heading() - 45)) / 4 + 0.5
            pencolor(n, n * 0.8, n * 0.8)
            fillcolor(n, n * 0.8, n * 0.8)
            begin_fill()
            circle(3)
            left(90)
            end_fill()
            # 添加0.3倍的飘落叶子
            if random() > 0.7:
                pu()
                # 飘落
                t = heading()
                an = -40 + random() * 40
                setheading(an)
                dis = int(800 * random() * 0.5 + 400 * random() * 0.3 + 200 * random() * 0.2)
                forward(dis)
                setheading(t)
                # 画叶子
                pd()
                right(90)
                n = cos(radians(heading() - 45)) / 4 + 0.5
                pencolor(n * 0.5 + 0.5, 0.4 + n * 0.4, 0.4 + n * 0.4)
                fillcolor(n, n * 0.8, n * 0.8)
                begin_fill()
                circle(2)
                left(90)
                end_fill()
                pu()
                # 返回
                t = heading()
                setheading(an)
                backward(dis)
                setheading(t)
                # pass
        pu()
        backward(l)  # 退回
def main():
    tree = Tree()
    tree.tree(12, 100)  # 递归7层
    done()
if __name__ == '__main__':
    main()

8,绘制闹钟

1.新建clock.py的文件,导入绘图模块与datetime模块

import turtle
from datetime import *
# 导入绘图模块与datetime模块

2.设置画布属性

turtle.screensize(canvwidth=None, canvheight=None, bg=None)
# canvwidth:画布的宽度(单位:像素)、canvheight:画布的高度(单位:像素)、bg:背景颜色

turtle.setup(width=0.5, height=0.75, startx=None, starty=None)
# width,height:输入宽和高为整数时, 表示像素; 为小数时, 表示占据电脑屏幕的比例、(startx,starty):这一坐标表示矩形窗口左上角顶点的位置。如果为空,则窗口位于屏幕中心

3.设置画笔属性

turtle.pensize(size) 
# 设置画笔的大小

turtle.pencolor()
# 设置画笔的颜色为黑色,可以是字符串如"green", "red",也可以是RGB 3元组

turtle.fillcolor()
# 设置填充颜色,可以是字符串如"green", "red",也可以是RGB 3元组
turtle.speed(speed) 
# 设置画笔速度为speed

turtle.hideturtle()
# 隐藏画笔的turtle形状

4.提笔、移动和落笔

turtle.penup() 
# 提笔

turtle.pendown() 
# 落笔

5.绘制线条

turtle.forward(distance)
# 向当前画笔方向移动distance像素长度

turtle.right(angle)
# 笔的角度向右转angle

turtle.dot(x)
# 绘制一个指定直径为x的圆点

6.重置turtle状态为初始状态

turtle.reset()
# 重置turtle状态为初始状态

7.记录多边形形状

turtle.begin_poly()
# 开始记录多边形的顶点
turtle.end_poly()
# 停止记录多边形的顶点

turtle.get_poly()
# 返回最后记录的多边形

8.注册合法的turtle外形

turtle.register_shape(x,y)
# 注册合法的turtle外形

9.重置Turtle指向

turtle.mode(mode=None)
# 设置乌龟模式(“standard”,“logo”或“world”)并执行重置,standard为向右(东)或逆时针,logo为向上(北)或顺时针

10.写文本

turtle.write(abc, align, [font=("font-name", font_size, "font_type")])
# 写文本,其中abc为文本内容,align为水平对齐方式,font是字体的参数,分别为字体名称,大小和类型;font为可选项,font参数也是可选项

11.打开/关闭快速绘图动画

turtle.tracer(True/False)
# 打开/关闭龟动画,True为打开,False为关闭

12.在规定时间后继续调用某一方法

turtle.ontimer(x,y)
# 在y毫秒后继续调用x方法

13.启动事件循环

turtle.mainloop()
# 启动事件循环,调用Tkinter的mainloop函数。必须是乌龟图形程序中的最后一个语句。

总结:

首先设置画布属性,然后定义一个方法Skip(),需要根据后面传入的参数不断抬起画笔,放下画笔。

开始绘画,

第一步 ,先定义指针几何形状。

第二步,定义一个Init()方法,用来画出三个表针,即秒针、分针和时针,一开始为三个长度不同的指针且重合在一起绘画。

第三步,定义一个SetupClock()方法,用来绘画闹钟中60分钟的各个点,编写一个for i in range(60)循环,产生60个整数序列并遍历它们,在for循环中加入if 条件语句,使得能够在整5分钟的点将绘画的点加粗与写下数字,遍历完60个整数序列,则跳出循环。绘画闹钟表盘结束。

第四步,获取表针的动态显示,使用datetime模块来获取。

第五步,定义执行先前步骤的方法,在其中给定参数radius的值为180,即闹钟表盘的半径为180像素,启动事件循环。

最后,结束动态闹钟的绘制。

源码

# coding=utf-8

 

import turtle

from datetime import *# 导入datetime模块


#准备设置

turtle.screensize(400, 300) #设置画布大小

turtle.setup(840,500) #设置主窗口的大小为840*500

#抬起画笔,向前运动一段距离放下

def Skip(step): #由于表盘刻度不连续,需频繁抬起画笔,放下画笔

    turtle.penup() #落笔

    turtle.forward(step) #向当前画笔方向移动"step"像素长度,具体的参数由后面方法传入

    turtle.pendown() #提笔

 

#定义指针几何形状。

def mkHand(name, length):

    turtle.reset() #重置turtle状态为初始状态

    Skip(-length * 0.1) #调用Skip()方法,移动的长度为"-length*0.1"像素

    turtle.begin_poly() #开始记录多边形的顶点。当前的乌龟位置是多边形的第一个顶点。

    turtle.forward(length * 1.1) #向当前画笔方向移动"length*1.1"像素长度

    turtle.end_poly() #停止记录多边形的顶点。当前的乌龟位置是多边形的最后一个顶点。将与第一个顶点相连。

    handForm = turtle.get_poly() #返回最后记录的多边形。

    turtle.register_shape(name, handForm) #注册handForm为合法的turtle外形

 

#初始化表针和文本对象

def Init():

    global secHand, minHand, hurHand, printer

    turtle.mode("logo") #重置Turtle指向北

    mkHand("secHand", 145) #建立三个表针Turtle并初始化,设置secHand即秒针长度为135像素

    mkHand("minHand", 120) #设置minHand即分针长度为125像素

    mkHand("hurHand", 90) #设置hurHand即时针长度为90像素

    secHand = turtle.Turtle()

    secHand.shape("secHand")

    minHand = turtle.Turtle()

    minHand.shape("minHand")

    hurHand = turtle.Turtle()

    hurHand.shape("hurHand")

 

    for hand in secHand, minHand, hurHand:# 遍历secHand, minHand, hurHand三个序列

        hand.shapesize(1, 1, 3) #设置表征形状大小为3像素

        hand.speed(0) #设置表针的速度为0

    printer = turtle.Turtle() #建立输出文字Turtle

    printer.hideturtle() #隐藏画笔的turtle形状

    printer.penup() #下笔

 

def SetupClock(radius): #建立表的外框,表盘半径radius为参数

    turtle.reset() #重置turtle状态为初始状态

    turtle.pensize(7) #设置画笔的大小为7像素

    turtle.pencolor("#0A0A0A") #设置画笔的颜色为黑色

    turtle.fillcolor("green") #绘制图形的填充颜色为绿色

 

#定义一个i值,遍历i值,根据条件画出钟的各个点与1到12的数字

    for i in range(60): #创建一个从0到59的整数列表

        Skip(radius) #调用Skip()方法,radius为参数

        if i % 5 == 0: #“%”运算符为返回除法的余数,则如果i除以5余数为0

            turtle.forward(20) #向当前画笔方向移动20像素长度

            Skip(-radius - 20) #调用Skip()方法,向当前画笔方向移动"-radius-20"像素长度,即效果图中粗的点

            Skip(radius + 20) #调用Skip()方法,向当前画笔方向移动"radius + 20"像素长度,即返回原位

            

            if i == 0: #如果i等于0

                turtle.write(int(12), align="center", font=("Courier", 14, "bold")) #写下数字12,水平居中,font(字体名称,大小,加粗)为设置字体参数

            elif i == 30: #elif语句,当遍历到对应的条件语句后,后面所有的elif和else都不会再被执行。如果i等于30

                Skip(25) #调用Skip()方法,向当前画笔方向移动25像素长度

                turtle.write(int(i / 5), align="center", font=("Courier", 14, "bold")) #写下数字6,水平居中,font(字体名称,大小,加粗)为设置字体参数

                Skip(-25) #调用Skip()方法,向当前画笔方向移动-25像素长度,即返回原位

            elif (i == 25 or i == 35): #“or”为布尔"或",如果i等于25,它返回i等于25,否则它返回 i等于35。

                Skip(20) #调用Skip()方法,向当前画笔方向移动20像素长度

                turtle.write(int(i / 5), align="center", font=("Courier", 14, "bold")) #写下数字5/7,水平居中,font(字体名称,大小,加粗)为设置字体参数

                Skip(-20) #调用Skip()方法,向当前画笔方向移动-20像素长度,即返回原位

            else:

                turtle.write(int(i / 5), align="center", font=("Courier", 14, "bold")) #写下数字1、2、3、4、8、9、10、11,水平居中,font(字体名称,大小,加粗)为设置字体参数

            Skip(-radius - 20) #调用Skip()方法,向当前画笔方向移动"-radius-20"像素长度

        else:

            turtle.dot(5) #绘制一个指定直径为5的圆点

            Skip(-radius) #调用Skip()方法,向当前画笔方向移动"-radius"像素长度

        turtle.right(6) #画笔的角度向右转6度


#绘制表针的动态显示

def Tick():

    t = datetime.today() #获取时间

    second = t.second + t.microsecond * 0.000001

    minute = t.minute + second / 60.0

    hour = t.hour + minute / 60.0

    secHand.setheading(6 * second)

    minHand.setheading(6 * minute)

    hurHand.setheading(30 * hour) 

    turtle.tracer(False)

    printer.home()

    turtle.tracer(True) 

    turtle.ontimer(Tick, 100) #100ms后继续调用tick


#定义执行的程序的main()方法

def main():

    turtle.tracer(True) #打开/关闭快速绘图动画,并为更新图纸设置延迟,False为不显示绘画过程,True为显示绘画过程

    Init() #执行定义的Init()方法

    SetupClock(180) #执行定义的SetupClock()方法,设置钟表盘半径参数radius为180

    Tick() #执行定义的Tick()方法

    turtle.mainloop() #启动事件循环


if __name__ == "__main__":

    main() #执行定义的main()方法

总结

本课程在介绍海龟库基本知识的基础上,通过多个绘图案例进一步加强和巩固了海龟库函数的应用。

总结全课,以下知识点,请重点掌握:

Canvas(画布)

turtle.screensize(canvwith=None, canvheith=None, bg=None)

turtle.setup(width=0.5, height=0.75, startx=None, starty=None)

Pen Attribute(画笔的属性)

turtle.pensize()
turtle.pencolor()
turle.speed()

Pen Attribute Movement(画笔属性的转向)

turtle.forward(distance)
turtle.backward(distance)
turtle.right(degree)
turtle.left(degree)
turtle.pendown()
turtle.penup()
turtle.goto(x,y)
turtle.speed(speed)
turtle.circle(radius, extent=None,step=None)

Pen Command Control(画笔的命令控制)

turtle.pensize(width)
turtle.pencolor()
turtle.fillcolor(colorstring)
turtle.color(color1,color2)
turtle.filling()
turtle.begin_fill()
turtle.end_fill()
turtle.hideturtle()
turtle.showturtle()

Pen Command Global Control(画笔命令的全局控制)

turtle.clear()
turtle.undo()
turtle.isvisible()
stamp()
turtle.write(s[,fon=(“fon-name",fon_side,“fon_type")])
Last modification:April 27th, 2020 at 06:57 pm
如果觉得我的文章对你有用,请随意赞赏