第九章 Python标准库概览

第九章 Python标准库概览

9.1 turtle库概述

turtle（海龟）是Python重要的标准库之一，它能够进行基本的图像绘制。

turtle库绘制图形有一个基本框架：一个小海龟在坐标系爬行，其爬行轨迹形成了绘制图形。对于小海龟来说，有“前进”、“后退”、“旋转”等爬行行为，对坐标系的探索也通过“前进方向”、“后退方向”、“左侧方向”和“右侧方向”等小海龟自身角度方位来完成。

使用import保留字对turtle库的引用有如下是三种方式：

1. import turtle，则对turtle库中函数调用采用turtle.<函数名>()形式
2. **from turtle import ***，则对turtle库中函数调用直接采用<函数名>()形式，不在使用turtle.作为前导。
3. import turtle as t，则对turtle库中函数调用采用更简洁的t.<函数名>()形式，保留字as的作用是将turtle库给予别名t。

9.2 turtle库与基本绘图

turtle库包含100多个功能函数，主要包括窗体函数、画笔状态函数、画笔运动函数等三类。

9.2.1 窗体函数

1、turtle.setup

语法格式：turtle.setup(width, height, startx, starty)

作用：设置主窗体的大小和位置。

参数如下：

参数	描述
width	窗口宽度，如果值是整数，表示的像素值；如果值是小数，表示窗口与屏幕的比例
height	窗口高度，如果值是整数，表示的像素值；如果值是小数，表示窗口与屏幕的比例
startx	窗口左侧与屏幕左侧的像素距离，如果值是None，窗口位于屏幕水平中央
starty	窗口顶部与屏幕顶部的像素距离，如果值是None，窗口位于屏幕水平中央

9.2.2 画笔状态函数

1、画笔状态函数

函数	描述
pendown()	放下画笔
penup()	提起画笔，与pendown()配对使用
pensize(width)	设置画笔线条的粗细为指定大小
pencolor()	设置画笔的颜色
color()	设置画笔和填充颜色
begin_fill()	填充图形前，调用该方法
end_fill()	填充图形结束
filling()	返回填充状态，True为填充，False为未填充
clear()	清空当前窗口，但不改变当前画笔的位置
reset()	清空当前窗口，并重置位置等状态为默认值
screensize()	设置画布窗口的宽度、高度和背景颜色
hideturtle()	隐藏画笔的turtle形状
showturtle()	显示画笔的turtle形状
isvisible()	如果turtle可见，则返回True
write(str,font=None)	输出font字体的字符串

2、turtle.penup

语法格式：turtle.penup()
别名：turtle.pu() 或 turtle.up()

作用：抬起画笔之后，移动画笔不绘制形状。

3、turtle.pendown

语法格式：turtle.down()
别名：turtle.pd() 或 turtle.down()

作用：放下画笔之后，移动画笔将绘制形状。

4、turtle.pensize

语法格式：turtle.pensize(width)
别名：turtle.width()

作用：设置画笔宽度，当无参数输入时，返回当前画笔宽度。

参数如下：

参数	描述
width	设置的画笔线条宽度，如果为None或者为空，函数返回当前画笔宽度

5、turtle.pencolor

语法格式：turtle.pencolor(colorsting)
别名：turtle.pencolor((r,g,b))

作用：设置画笔颜色，当无参数输入时，返回当前画笔颜色

参数如下：

参数	描述
colorstring	表示颜色的字符串，例如：“red”等
(r,g,b)	颜色对应RGB的01数值，例如：1，0.65，0

6、turtle.color

语法格式：turtle.color(colorstring1,colorstring2)
别名：turtle.color((r1,g1,b1),(r2,g2,b2))

作用：设置画笔和背景颜色，当无参数输入时，返回当前画笔和背景颜色

参数如下：

参数	描述
colorstring	表示颜色的字符串，例如：“red”等
(r,g,b)	颜色对应RGB的01数值，例如：1，0.65，0

7、turtle.begin_fill()

语法格式：turtle.begin_fill()

作用：设置填充区域色彩。在开始绘制拟填充背景图形前调用。

8、turtle.end_fill()

语法格式：turtle.end_fill()

作用：turtle.begin_fill()的配对函数。在结束绘制拟填充背景图形前调用。

9、turtle.filling()

语法格式：turtle.filling()

作用：返回当前图形背景颜色的填充状态，即如果当前代码在begin_fill()和end_fill()之间，则返回True，否则返回False。

9、turtle.clear()

语法格式：turtle.clear()

作用：清空当前海归对象绘制的图形，但不会改变其位置和角度。

10、turtle.reset()

语法格式：turtle.reset()

作用：清空当前绘制窗口，海龟对象绘图位置和角度归为原点。

11、turtle.screensize()

语法格式：turtle.screensize(width,heigh,bgcolor)

作用：设置当前画布窗口的宽度为width，高度为height，背景颜色为bgcolor；如果不给出参数，则以元组形式返回当前画布窗口的宽度和高度（width，height）。

参数如下：

参数	描述
width	窗体的宽度，以像素为单位
height	窗体的高度，以像素为单位
bgcolor	表示颜色的字符串或颜色对应的RGB的0-1数值

12、turtle.hideturtle()

语法格式：turtle.hideturtle()

作用：隐藏画笔的turtle形状。

13、turtle.showturtle()

语法格式：turtle.showturtle()

作用：显示画笔的turtle形状。

14、turtle.isvisible()

语法格式：turtle.isvisible()

作用：如果turtle画笔的状态显示，则返回True，否则返回False。

15、turtle.write()

语法格式：turtle.write(str,font=None)

作用：根据设置的字体font形式，将字符串str显示在画布上。

参数	描述
str	拟输出的字符串
font	字体名称、字体尺寸、字体类型三个元素构成的元组。该参数可选，省略是以默认参数显示。

9.2.3 画笔运动函数

1、画笔运动的函数

函数	描述
forward(distance)	沿着当前方向前进指定距离
backward(distance)	沿着当前相反方向后退指定距离
right(angle)	向右旋转angle角度
left(angle)	向左旋转angle角度
goto(x,y)	移动到绝对坐标（x,y）处
setx(x)	修改画笔的横坐标到x，纵坐标不变
sety(y)	修改画笔的纵坐标到y，横坐标不变
setheading(angle)	设置当前朝向为angle角度
home()	设置当前画笔位置为原点，朝向东
circle(radius,e)	绘制一个指定半径r和角度e的圆或弧形
dot(size,color)	绘制一个指定直径size和颜色color的圆点
undo()	撤销画笔最后一部动作
speed()	设置画笔的绘制速度，参数为0-10之间

2、turtle.forward()

语法格式：turtle.forward(distance)
别名：turtle.fd(distance)

作用：小海龟向前行进方向前进distance距离。

参数	描述
distance	行进距离的像素值，当值为负数时，表示向相反方向前进。

3、turtle.backward()

语法格式：turtle.backward(distance)
别名：turtle.bk(distance)

作用：小海龟向前行进的反方向运动distance距离，画笔放行不变。

参数	描述
distance	行进距离的像素值，当值为负数时，表示向相反方向前进。

4、turtle.right()

语法格式：turtle.right(angle)

作用：改变画笔行进方向为当前方向右侧angle度。angle是角度相对值。

参数	描述
angle	角度的整数值

5、turtle.left()

语法格式：turtle.left(angle)

作用：改变画笔行进方向为当前方向左侧angle度。angle是角度相对值。

参数	描述
angle	角度的整数值

6、turtle.goto()

语法格式：turtle.goto(x,y)

作用：移动画笔到画布中的特定位置，该位置以坐标(x,y)方向表达。如果当前画笔处于落下状态，则绘制当前位置到目标位置的线条。

参数	描述
x	画布中特定位置的横坐标
y	画布中特定位置的纵坐标

7、turtle.setyy()

语法格式：turtle.sety(y)

作用：修改画笔的纵坐标到y，横坐标不变。

参数	描述
y	画布中纵坐标的一个值

8、turtle.setheading()

语法格式：turtle.setheading(to_angle)
别名：turtle.seth(to_angle)

作用：设置小海龟当前行进方向为to_angle，该角度是绝对方向角度值。

参数	描述
to_angle	角度的整数值

9、turtle.home()

语法格式：turtle.home()

作用：移动画笔到坐标系原点，画笔方向为初始方向。

10、turtle.circle()

语法格式：turtle.circle(radius,extent=None)

作用：根据半径radius绘制extent角度的弧形。

参数	描述
radius	弧形半径。当值为正数时，半径在小海龟左侧，当值为负数时，半径在小海龟右侧
extent	绘制弧形的角度。当不给该参数或参数为None是，绘制整个圆形

11、turtle.dot()

语法格式：turtle.dot(size,color)

作用：绘制一个带有背景色color，直径为size的圆点。

参数	描述
size	圆点的直径，像素值
color	颜色字符串或RGB的0-1值，表示背景颜色

12、turtle.undo()

语法格式：turtle.undo()

作用：撤销绘图的最后一次动作。

13、turtle.speed()

语法格式：turtle.speed(s)

作用：设置画笔的绘制速度，参数为0-10整数，0表示没有绘制动作，1-10逐步增加绘制速度，超过10则等同于参数为零。

参数	描述
s	速度的设定值，0-10之间的整数

9.3 random库概述

随机数在计算机应用中十分常见，Python语言提供了random库用于产生各种分布的伪随机数序列。random库采用梅森旋转算法生成伪随机数序列，可用于除随机性要求更高的加解密算法外的大多数工程应用。

使用random库主要目的是生成随机数。

9.4 random库与随机数运用

1、random库常用的函数

函数	描述
seed(a=None)	初始化随机数种子，默认值为当前系统时间
random()	生成一个[0.0,1.0)之间的随机小数
randint(a,b)	生成一个[a.b]之间的整数
getrandbits(k)	生成一个k比特长度的随机整数
randrange(start,stop[,step])	生成一个[start,stop)之间以step为步数的随机整数
uniform(a,b)	生成一个[a,b]之间的随机小数
choice(seq)	从序列类型（例如：列表）中随即返回一个元素
shuffle(seq)	将序列类型中元素随机排列，返回打乱后的序列
sample(pop,k)	从pop类型中随机选取k个元素，以列表类型返回

9.5 time库概述

处理时间是程序最常用的功能之一，tiame库是Python提供的处理时间标准库。time库提供系统及精确计时去的计时功能，可以用来分析程序性能，也可以让程序暂停运行时间。

使用time库需要用import保留字，语法格式如下：

import time

time库的功能主要分为3个方面：时间处理、时间格式化和计时。

时间处理主要包括四个函数如下：

函数	描述
time.time()	获取当前时间戳
time.gmtime()	获取当前时间戳对应的struct_time对象
time.localtime()	获取当前时间戳对应的本地时间的struct_time对象
time.ctime()	获取当前时间戳对应的易读字符串表示，内湖会调用time.localtime()函数以输出当地时间

时间格式化主要包括3个函数如下：

函数	描述
time.mktime()	将struct_time对象t转换为时间戳，主要t代表当地时间
time.strftime()	以任何通用格式输出时间。该方法利用一个格式字符串对时间格式进行表示
time.strptime()	用于提取字符串中的时间时间来生成struct_time对象，可以很灵活的作为time模块的输入接口

struct_time对象的元素构成

下标	属性	值
0	tm_year	年份，整数
1	tm_mon	月份[1,12]
2	tm_mday	日期[1,31]
3	tm_hour	小时[1,23]
4	tm_min	分钟[0,59]
5	tm_sec	秒[0,61]
6	tm_wday	星期[0,6]（0表示星期一）
7	tm_yday	该年第几天[1,365]
8	tm_isdst	是否夏时令,0否，1是，-1未知

strftime()方法的格式化控制符

格式化字符串	日期/时间	值范围和实例
%Y	年份	0001-9999，例如：1900
%m	月份	01-12，例如：10
%B	月名	January-December，例如：April
%b	月名缩写	Jan-Dec，例如：Apr
%d	日期	01-31，例如：25
%A	星期	Monday-Sunday，例如：Wednesday
%a	星期缩写	Mon-Sun，例如：Wed
%H	小时（24h制）	00-23，例如：12
%I	小时（12h制）	01-12，例如：7
%p	上/下午	AM，PM，例如：PM
%M	分钟	00-59，例如：26
%S	秒	00-59，例如：26

计时主要包括3个函数如下：

参数	描述
time.sleep()	用于控制程序的执行速度
time.monotonic()	返回的是系统运行时间，不受系统时间修改的影响，单位是秒。它的主要用途是计算程序执行的时间
time.perf_counter()	返回的是程序运行的高精度计时器的值

9.6 time库与程序计时

程序计时是非常常用的功能，尤其是对于运行时间较长的程序，往往需要先进行小规模（短时间）的实验，并根据实验结果预估最终程序的大致运行时间。

程序计时主要包含三个要素：程序开始/结束时间、程序运行总时间、程序各核心模块运行时间。

import time


def coreLoop():
    limit = 10 ** 8
    while limit > 0:
        limit -= 1


def otherLoop1():
    time.sleep(0.2)


def otherLoop2():
    time.sleep(0.4)


def main():
    startTime = time.localtime()
    print('程序开始时间：', time.strftime('%Y-%m-%d %H:%M:%S', startTime))
    startPerfCounter = time.perf_counter()
    otherLoop1()
    otherLoop1PerfCounter = time.perf_counter()
    otherLoop1Perf = otherLoop1PerfCounter - startPerfCounter
    coreLoop()
    coreLoopPerfCounter = time.perf_counter()
    coreLoopPerf = coreLoopPerfCounter - otherLoop1PerfCounter
    otherLoop2()
    otherLoop2PerfCounter = time.perf_counter()
    otherLoop2Perf = otherLoop2PerfCounter - coreLoopPerfCounter
    endPerfCounter = time.perf_counter()
    totalPerf = endPerfCounter - startPerfCounter
    endTime = time.localtime()
    print("模块1运行时间是:{}秒".format(otherLoop1Perf))
    print("核心模块运行时间是:{}秒".format(coreLoopPerf))
    print("模块2运行时间是:{}秒".format(otherLoop2Perf))
    print("程序运行总时间是:{}秒".format(totalPerf))
    print('程序结束时间：', time.strftime('%Y-%m-%d %H:%M:%S', endTime))


main()

# 运行结果
程序开始时间： 2023-06-02 18:35:55
模块1运行时间是:0.20083110002451576秒
核心模块运行时间是:5.120116499980213秒
模块2运行时间是:0.4034179000009317秒
程序运行总时间是:5.724367200018605秒
程序结束时间： 2023-06-02 18:36:00

9.7 实例解析——雪景艺术绘图

from turtle import *
from random import *


def drawSnow():
    hideturtle()
    pensize(2)
    for i in range(100):
        r, g, b = random(), random(), random()
        pencolor(r, g, b)
        penup()
        setx(randint(-350, 350))
        sety(randint(1, 270))
        pendown()
        dens = randint(8, 12)
        snowsize = randint(10, 14)
        for j in range(dens):
            forward(snowsize)
            backward(snowsize)
            right(360 / dens)


def drawGround():
    hideturtle()
    for i in range(400):
        pensize(randint(5, 10))
        x = randint(-400, 350)
        y = randint(-280, -1)
        r, g, b = -y / 280, -y / 280, -y / 280
        pencolor((r, g, b))
        penup()
        goto(x, y)
        pendown()
        forward(randint(40, 100))


setup(800, 600, 200, 200)
tracer(False)
bgcolor("black")
drawSnow()
drawGround()
done()

习题9

一、选择题

1. 以下对turtle库最合适的描述是：______

   A 绘图库 B 数值计算库 C 爬虫库 D 时间库

   正确答案：A

2. turtle库中将画笔移动x像素的语句是：______

   A turtle.forward(x) B turtle.circle(x) C turtle.right(x) D turtle.left(x)

   正确答案：A

3. turtle.circle(50,180)的执行效果是：______

   A 绘制一个半径为50的圆

   B 绘制一个直径为50的半圆

   C 绘制一个半径为50的圆，分三次画完

   D 绘制一个半径为50的圆形

   正确答案：D

4. trutle.reset()方法的作用是：______

   A 撤销上一个turtle动作

   B 清空画笔的状态

   C 清空turtle窗口，重置turtle状态为起始状态

   D 设置turtle图形可见

   正确答案：C

5. random库用来生成随机数的算法是：______

   A 平方去中法 B 线性同余法 C 梅森旋转法 D 蒙特卡洛方法

   正确答案：C

6. random.uniform(a,b)的作用是：______

   A 生成一个[a,b]之间的随机整数

   B 生成一个[a,b]之间的随机小数

   C 生成一个均值为a，方差为b的正态分布

   D 生成一个(a,b)之间的随机数

   正确答案：B

7. 设置turtle画笔向左前方移动的可能函数是：______

   A turtle.left()

   B turtle.left()，turtle.fd()

   C turtle.penup()，turtle.fd()

   D turtle.circle()，turtle.penup()

   正确答案：B

8. 设置turtle窗口大小的函数是：______

   A turtle.setup() B turtle.window() C turtle.shape() D turtle.pensize()

   正确答案：A

9. 在turtle坐标体系中，（0，0）坐标位于窗口的：______

   A 左下角 B 正中央 C 左上角 D 右上角

   正确答案：B

10. random库中，random()函数的作用是：______

    A 生成随机数x且0 ≤x<100，x为整数

    B 生成随机数x且0 .0≤x<100.0

    C 将列表中的元素打乱顺序重新排列

    D 生成随机数x且0 .0≤x<1.0

    正确答案：D

二、编程题

1. 使用turtle库绘制一个蜂窝状六边形。

   import turtle
   
   # 设定turtle画笔和画布的参数
   turtle.speed(0)  # 设置画笔速度，0为最快
   turtle.bgcolor("black")  # 设置画布背景颜色
   turtle.color("white")  # 设置画笔颜色
   turtle.pensize(2)  # 设置画笔大小
   
   # 设定六边形的边长和间距
   side_length = 20
   gap = 10
   
   # 循环画出蜂窝状六边形
   for i in range(10):
       # 每行的偏移量
       offset = i % 2 * side_length / 2
       for j in range(10):
           # 移动画笔到六边形的起点
           turtle.penup()
           turtle.goto(j * side_length + offset, i * (side_length - gap))
   
           # 开始画六边形
           turtle.pendown()
           for k in range(6):
               turtle.forward(side_length)
               turtle.right(60)
   
   # 隐藏画笔
   turtle.hideturtle()
   
   # 等待用户关闭窗口
   turtle.done()
   

2. 使用turtle库绘制一朵玫瑰花。

   from turtle import *
   
   # 设置绘制起点
   setup(700, 700)
   # 画笔颜色
   pencolor("red")
   hideturtle()
   penup()
   goto(0, 280)
   pendown()
   left(135)
   speed(0)
   # 左侧弧形绘制
   a = 0.2
   for i in range(80):
       if i < 50:
           pensize(a)
           forward(2)
           a += 0.15
           if i < 10:
               left(0.7)
           elif 10 < i < 24:
               left(1)
           elif 24 < i < 40:
               left(3)
           elif 40 < i < 50:
               left(4)
       elif i >= 50:
           pensize(a)
           forward(2.2)
           a -= 0.25
           if 50 < i < 65:
               left(6.7)
           elif 65 < i < 80:
               left(2)
   setheading(0)
   penup()
   goto(40, 305)
   pendown()
   left(145)
   # 右侧弧形绘制
   a = 0.1
   for i in range(100):
       if i < 60:
           pensize(a)
           forward(3)
           a += 0.15
           if i < 10:
               left(0.8)
           elif 10 < i < 24:
               left(0.8)
           elif 24 < i < 40:
               left(1.7)
           elif 40 < i < 60:
               left(2.2)
       elif i >= 60:
           pensize(a)
           forward(2.4)
           a -= 0.15
           if 60 < i < 85:
               left(3.2)
           elif 85 < i < 90:
               left(4)
   setheading(0)
   penup()
   goto(45, 320)
   pendown()
   left(10)
   a = 0.1
   for i in range(100):
       if i < 60:
           pensize(a)
           forward(3)
           a += 0.15
           if i < 17:
               right(3.2)
           elif 17 < i < 20:
               right(3.5)
           elif 20 < i < 40:
               right(6.8)
           elif 40 < i < 50:
               right(0.6)
           elif 50 < i < 60:
               left(1)
       elif i >= 60:
           pensize(a)
           forward(2.4)
           a -= 0.16
           if 60 < i < 85:
               left(0.4)
           elif 85 < i < 90:
               left(1)
   setheading(0)
   penup()
   goto(-135, 265)
   pendown()
   left(160)
   a = 0.1
   for i in range(120):
       if i < 60:
           pensize(a)
           forward(3)
           a += 0.15
           if i < 10:
               left(2)
           elif 10 < i < 15:
               left(8)
           elif 15 < i < 35:
               left(6)
           elif 35 < i < 40:
               left(4)
           elif 40 < i < 60:
               left(1)
       elif i >= 60:
           pensize(a)
           forward(3)
           a -= 0.15
           if 60 < i < 90:
               right(0.4)
           elif 90 < i < 120:
               right(0.8)
   setheading(0)
   penup()
   goto(80, 250)
   pendown()
   left(245)
   a = 0.2
   for i in range(80):
       if i < 40:
           pensize(a)
           forward(1.2)
           a += 0.15
           if i < 15:
               left(0.6)
           elif 15 < i < 40:
               left(0.3)
       elif i >= 40:
           pensize(a)
           forward(1.2)
           a -= 0.15
           if 40 < i < 65:
               left(0.6)
           elif 65 < i < 80:
               left(0.35)
   setheading(0)
   penup()
   goto(-150, 195)
   pendown()
   left(300)
   a = 0.2
   for i in range(80):
       if i < 40:
           pensize(a)
           forward(1.2)
           a += 0.16
           if i < 15:
               right(0.6)
           elif 15 < i < 40:
               right(0.3)
       elif i >= 40:
           pensize(a)
           forward(1.2)
           a -= 0.16
           if 40 < i < 65:
               right(0.6)
           elif 65 < i < 80:
               right(0.35)
   setheading(0)
   penup()
   goto(-205, 225)
   pendown()
   left(194)
   a = 0.1
   for i in range(100):
       if i < 50:
           pensize(a)
           forward(3)
           a += 0.15
           if i < 10:
               left(7)
           elif 10 < i < 30:
               left(3)
           elif 30 < i < 50:
               left(0.1)
       elif i >= 50:
           pensize(a)
           forward(3)
           a -= 0.15
           if 50 < i < 80:
               right(0.3)
           elif 80 < i < 100:
               right(0.6)
   setheading(0)
   penup()
   goto(110, 280)
   pendown()
   left(6)
   a = 0.1
   for i in range(120):
       if i < 60:
           pensize(a)
           forward(3)
           a += 0.15
           if i < 10:
               right(4.5)
           elif 10 < i < 30:
               right(5)
           elif 30 < i < 60:
               right(0.1)
       elif i >= 60:
           pensize(a)
           forward(3)
           a -= 0.15
           if 50 < i < 80:
               left(0.6)
           elif 80 < i < 100:
               left(0.9)
   setheading(0)
   penup()
   goto(-160, 110)
   pendown()
   left(283)
   a = 0.2
   for i in range(80):
       if i < 40:
           pensize(a)
           forward(2.4)
           a += 0.15
           if i < 10:
               right(0.6)
           elif 15 < i < 40:
               right(0.1)
       elif i >= 40:
           pensize(a)
           forward(2.4)
           a -= 0.15
           if 40 < i < 65:
               left(2)
           elif 65 < i < 80:
               left(3)
   setheading(0)
   penup()
   goto(90, 155)
   pendown()
   left(258)
   a = 0.2
   for i in range(80):
       if i < 40:
           pensize(a)
           forward(3)
           a += 0.15
           if i < 10:
               left(0.8)
           elif 15 < i < 40:
               left(0.1)
       elif i >= 40:
           pensize(a)
           forward(3)
           a -= 0.15
           if 40 < i < 65:
               right(2)
           elif 65 < i < 80:
               right(3)
   setheading(0)
   penup()
   goto(-60, -45)
   pendown()
   right(9)
   a = 0.2
   for i in range(40):
       if i < 20:
           pensize(a)
           forward(1.3)
           a += 0.15
           if i < 5:
               left(0.7)
           elif 5 < i < 20:
               left(0.4)
       elif i >= 20:
           pensize(a)
           forward(1.3)
           a -= 0.15
           if 20 < i < 35:
               left(0.7)
           elif 35 < i < 40:
               left(0.4)
   setheading(0)
   penup()
   goto(-70, -55)
   pencolor("green")
   pendown()
   right(170)
   a = 0.2
   for i in range(80):
       if i < 40:
           pensize(a)
           forward(2)
           a += 0.15
           if i < 25:
               right(0.5)
           elif 25 < i < 40:
               right(1)
       elif i >= 40:
           pensize(a)
           forward(2.5)
           a -= 0.15
           if 40 < i < 55:
               right(1)
           elif 55 < i < 70:
               right(2)
           elif 70 < i < 80:
               right(1)
   setheading(270)
   left(30)
   a = 0.2
   for i in range(80):
       if i < 40:
           pensize(a)
           forward(2.5)
           a += 0.15
           if i < 25:
               left(0.5)
           elif 25 < i < 40:
               left(1)
       elif i >= 40:
           pensize(a)
           forward(3)
           a -= 0.15
           if 40 < i < 55:
               left(2)
           elif 55 < i < 70:
               left(1.3)
           elif 70 < i < 80:
               left(1)
   setheading(270)
   penup()
   goto(20, -55)
   pendown()
   left(65)
   a = 0.2
   for i in range(60):
       if i < 30:
           pensize(a)
           forward(2)
           a += 0.15
           if i < 15:
               left(1)
           elif 15 < i < 30:
               left(2)
       elif i >= 30:
           pensize(a)
           forward(2.5)
           a -= 0.15
           if 30 < i < 45:
               left(2)
           elif 45 < i < 50:
               left(2.5)
           elif 50 < i < 60:
               left(1.5)
   setheading(270)
   right(17)
   a = 0.2
   for i in range(80):
       if i < 40:
           pensize(a)
           forward(2.2)
           a += 0.15
           if i < 25:
               right(1)
           elif 25 < i < 40:
               right(2)
       elif i >= 40:
           pensize(a)
           forward(2.5)
           a -= 0.15
           if 40 < i < 55:
               right(2)
           elif 55 < i < 70:
               right(1.5)
           elif 70 < i < 80:
               right(0.6)
   setheading(0)
   penup()
   pencolor("brown")
   goto(-49, -90)
   pendown()
   right(89)
   a = 1
   for i in range(120):
       if i < 60:
           pensize(a)
           forward(3.5)
           a += 0.08
       elif i >= 60:
           pensize(a)
           forward(3.5)
           a -= 0.08
   setheading(0)
   penup()
   goto(-16, -70)
   pendown()
   right(91)
   a = 1
   for i in range(120):
       if i < 60:
           pensize(a)
           forward(3.5)
           a += 0.08
       elif i >= 60:
           pensize(a)
           forward(3.5)
           a -= 0.08
   setheading(0)
   
   speed(1)
   penup()
   goto(-16, -150)
   pendown()
   pensize(3)
   left(35)
   forward(15)
   setheading(0)
   right(115)
   forward(34)
   
   setheading(180)
   penup()
   goto(-49, -250)
   pendown()
   pensize(3)
   right(35)
   forward(15)
   setheading(180)
   left(115)
   forward(34)
   input()
   done
   

3. 使用turtle库绘制一个颜色图谱。

   import turtle
   
   # 定义颜色列表，可以根据需要自定义
   colors = ["#FF0000", "#FF7F00", "#FFFF00", "#00FF00", "#0000FF", "#4B0082", "#8F00FF"]
   
   # 设定turtle画笔和画布的参数
   turtle.speed(0)  # 设置画笔速度，0为最快
   turtle.bgcolor("black")  # 设置画布背景颜色
   turtle.pensize(10)  # 设置画笔大小
   
   # 计算每个颜色框的大小和间距
   box_size = turtle.window_width() // len(colors)
   box_spacing = 5
   
   # 循环绘制颜色框
   for i in range(len(colors)):
       # 设定画笔颜色为当前颜色
       turtle.color(colors[i])
   
       # 填充颜色框
       turtle.begin_fill()
       turtle.forward(box_size)
       turtle.right(90)
       turtle.forward(turtle.window_height() - box_spacing * 2)
       turtle.right(90)
       turtle.forward(box_size)
       turtle.right(90)
       turtle.forward(turtle.window_height() - box_spacing * 2)
       turtle.right(90)
       turtle.end_fill()
   
       # 移动到下一个颜色框的起点
       turtle.penup()
       turtle.forward(box_size + box_spacing * 2)
       turtle.pendown()
   
   # 隐藏画笔
   turtle.hideturtle()
   
   # 等待用户关闭窗口
   turtle.done()
   

4. 利用random库生成一个包含10个0-100之间随机整数的列表。

   import random
   
   random_list = []
   for i in range(10):
       random_list.append(random.randint(0, 100))
   
   print(random_list)
   

5. 利用time库将当前日期转化成类似“Sunday，8.January 2017 11:03PM”的格式。

   import time
   
   # 获取当前时间的struct_time对象
   current_time = time.localtime()
   
   # 定义星期几、月份和AM/PM的字符串列表
   weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
   months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
   ampm = ['AM', 'PM']
   
   # 格式化日期字符串
   formatted_time = weekdays[current_time.tm_wday] + ', ' + str(current_time.tm_mday) + '.' + months[current_time.tm_mon-1] + ' ' + str(current_time.tm_year) + ' ' + str(current_time.tm_hour%12) + ':' + str(current_time.tm_min).zfill(2) + ampm[current_time.tm_hour//12]
   
   # 输出格式化后的日期字符串
   print(formatted_time)