第6章 函数及其应用
6.5 两个标准库模块

本节学习目标
·理解时间在程序设计中的重要性,掌握time库的常用函数
·掌握turtle库的基本绘图功能,能够绘制各种几何图形
·理解__name__变量的作用,掌握模块化编程的核心技巧
·能够综合运用函数、循环、分支等知识完成复杂程序设计

6.5.1 time库
一、时间的重要性
在计算机程序设计中,时间是一个极其重要的概念。无论是我们日常使用的手机闹钟、电脑上的文件修改时间,还是复杂的金融交易系统、网络游戏中的倒计时,都离不开对时间的处理。对于数字经济专业的同学来说,理解时间的程序化处理尤为重要,因为在数据分析、金融建模、系统监控等领域,时间数据的处理是核心技能之一。
时间在程序设计中的常见应用场景:
应用领域 | 具体场景 | 时间的作用 |
金融领域 | 股票交易系统 | 记录交易时间、计算持有期、生成K线图 |
数据分析 | 用户行为分析 | 时间序列分析、趋势预测、周期性检测 |
系统监控 | 服务器性能监控 | 记录日志时间、计算响应时间、定时任务 |
游戏开发 | 游戏计时器 | 倒计时、冷却时间、游戏时长统计 |
日常应用 | 日程管理软件 | 提醒功能、时间计算、日程安排 |
知识回顾:在第3章分支程序设计中,我们学习了程序的基本控制结构;在第4章循环程序设计中,我们学习了如何让程序重复执行某些操作。time库的学习将帮助我们实现更精确的时间控制,比如让程序每隔固定时间执行一次操作。
二、time模块概述
Python的time模块是Python标准库中的一个重要模块,它提供了各种操作时间的函数。所谓标准库,就是Python安装时自带的库,不需要额外安装,直接导入即可使用。
在第1章我们学习了模块的导入方法,这里回顾一下:
# 方法一:导入整个模块import time# 方法二:导入模块中的特定函数from time import time, sleep, ctime# 方法三:导入模块中的所有函数(不推荐)from time import *
知识回顾:模块导入的知识在第1章1.3.2节”Python程序的模块及引用”中已经学习过。使用import关键字可以导入Python的标准库模块或第三方库模块。
三、time模块三个常用函数
time模块提供了很多函数,本节我们重点学习三个最常用的函数:time()、ctime()和sleep()。
3.1 time()函数 —— 获取时间戳
知识点讲解:
time()函数返回当前时间的时间戳。时间戳是指从1970年1月1日00:00:00(称为Unix纪元或Epoch)到当前时间的秒数。这是一个浮点数,精确到微秒级别。
时间戳的概念非常重要,它是计算机存储和处理时间的基础方式。因为时间戳是一个数值,所以可以方便地进行时间计算,比如计算两个时间点之间相差多少秒。
函数语法:
返回值: 返回一个浮点数,表示当前时间的时间戳(秒数)。
代码案例:
import time# 获取当前时间戳current_timestamp = time.time()print(f"当前时间戳:{current_timestamp}")print(f"当前时间戳(保留2位小数):{current_timestamp:.2f}")# 时间戳是一个浮点数,可以进行数学运算print(f"时间戳的类型:{type(current_timestamp)}")# 计算从Unix纪元到现在经过了多少天days = current_timestamp / (24 * 60 * 60) # 一天有24小时,一小时60分钟,一分钟60秒print(f"从1970年1月1日到现在已经过了约 {days:.0f} 天")
运行结果示例:
当前时间戳:1703145600.123456当前时间戳(保留2位小数):1703145600.12时间戳的类型:从1970年1月1日到现在已经过了约 19711 天
知识回顾:这里用到了第2章学习的浮点数类型和格式化输出。{current_timestamp:.2f}表示保留2位小数输出浮点数,这是f-string格式化字符串的用法。
3.2 ctime()函数 —— 获取可读时间字符串
知识点讲解:
ctime()函数将时间戳转换为人类可读的时间字符串。如果不传入参数,默认返回当前时间的可读字符串格式。
函数语法:
参数说明: - timestamp:可选参数,时间戳(浮点数)。如果不提供,默认使用当前时间。
返回值: 返回一个字符串,格式为'Wed Jan 01 12:00:00 2025'这样的形式。
代码案例:
import time# 获取当前时间的可读字符串current_time = time.ctime()print(f"当前时间:{current_time}")print(f"返回值类型:{type(current_time)}")# 将特定时间戳转换为可读字符串timestamp = 1703145600.0 # 这是一个示例时间戳readable_time = time.ctime(timestamp)print(f"时间戳 {timestamp} 对应的时间:{readable_time}")# 获取当前时间戳并转换now_timestamp = time.time()now_readable = time.ctime(now_timestamp)print(f"当前时间戳:{now_timestamp:.2f}")print(f"对应时间:{now_readable}")
运行结果示例:
当前时间:Thu Dec 21 12:00:00 2023返回值类型:时间戳 1703145600.0 对应的时间:Thu Dec 21 12:00:00 2023当前时间戳:1703145600.12对应时间:Thu Dec 21 12:00:00 2023
知识回顾:这里用到了第2章学习的字符串类型。ctime()函数返回的是一个字符串,我们可以对它进行字符串的各种操作,比如切片、查找等。
3.3 sleep()函数 —— 程序暂停
知识点讲解:
sleep()函数让程序暂停执行指定的秒数。这在需要控制程序执行节奏、实现动画效果、模拟延时等场景中非常有用。
函数语法:
参数说明: - seconds:暂停的秒数,可以是整数或浮点数。浮点数可以表示更精确的时间,如0.5表示暂停半秒。
返回值: 无返回值(None)。
代码案例:
import timeprint("程序开始执行...")start = time.time()# 暂停2秒print("暂停2秒...")time.sleep(2)# 暂停0.5秒print("暂停0.5秒...")time.sleep(0.5)end = time.time()print(f"程序继续执行...")print(f"实际暂停时间:{end - start:.2f} 秒")
运行结果:
程序开始执行...暂停2秒...暂停0.5秒...程序继续执行...实际暂停时间:2.50 秒
知识回顾:这里综合运用了time()函数获取时间戳,然后通过减法计算时间差。这种”记录开始时间 → 执行操作 → 记录结束时间 → 计算差值”的模式是测量程序执行时间的常用方法。
四、time库综合应用:动态计时程序
程序设计要求:
编程实现一个按秒进行动态计时的程序,动态显示经过的秒数,当按下Ctrl+C键时结束程序并输出: - 程序运行开始时间(时、分、秒格式) - 程序运行结束时间(时、分、秒格式) - 总用时(秒数,保留整数) - 总用时(分钟,保留小数点后1位精度)
提示: 当按下Ctrl+C键时会引发名字为KeyboardInterrupt的异常。
设计思路分析:
1.记录开始时间:用变量start记录程序运行开始时的时间戳
2.无限循环控制:使用while True创建无限循环
3.计算经过时间:每次循环用当前时间戳减去开始时间戳,得到经过的秒数
4.输出并暂停:输出经过的秒数,使用sleep(1)暂停1秒
5.清屏效果:输出特殊字符实现清屏效果
6.异常处理:捕获KeyboardInterrupt异常,在异常处理中输出统计信息
知识回顾: - 第3章学习了try-except异常处理结构 - 第4章学习了while True无限循环 - 第4章学习了break语句退出循环
完整代码实现:
import timeimport os # 用于清屏操作def dynamic_timer(): """ 动态计时器函数 功能:按秒动态显示经过的时间,按Ctrl+C结束并显示统计信息 """ print("=" * 50) print("动态计时器") print("按 Ctrl+C 键结束计时") print("=" * 50) # 记录开始时间戳 start_timestamp = time.time() # 记录开始时间的可读格式 start_time_str = time.ctime(start_timestamp) try: # 无限循环,动态显示经过的秒数 while True: # 计算经过的时间(秒) current_timestamp = time.time() pass_time = current_timestamp - start_timestamp # 清屏(在Jupyter Notebook中可以用换行代替) # os.system('cls') # Windows系统清屏 # os.system('clear') # Linux/Mac系统清屏 # 动态显示经过的秒数 print(f"\r已经过:{int(pass_time)} 秒", end="", flush=True) # 暂停1秒 time.sleep(1) except KeyboardInterrupt: # 用户按下Ctrl+C时执行 print("\n\n" + "=" * 50) print("计时结束!") print("=" * 50) # 记录结束时间 end_timestamp = time.time() end_time_str = time.ctime(end_timestamp) # 计算总用时 total_seconds = end_timestamp - start_timestamp total_minutes = total_seconds / 60 # 输出统计信息 print(f"开始时间:{start_time_str}") print(f"结束时间:{end_time_str}") print(f"总用时:{int(total_seconds)} 秒") print(f"总用时:{total_minutes:.1f} 分钟") print("=" * 50)# 调用函数dynamic_timer()
运行效果演示:
==================================================动态计时器按 Ctrl+C 键结束计时==================================================已经过:1 秒已经过:2 秒已经过:3 秒...(持续更新)(用户按下 Ctrl+C 后)==================================================计时结束!==================================================开始时间:Thu Dec 21 10:30:00 2023结束时间:Thu Dec 21 10:30:15 2023总用时:15 秒总用时:0.3 分钟==================================================
代码详解:
代码行 | 知识点 | 说明 |
start_timestamp = time.time() | time库函数 | 获取开始时间的时间戳 |
while True: | 第4章循环结构 | 创建无限循环 |
pass_time = current_timestamp - start_timestamp | 浮点数运算 | 计算时间差 |
print(f"\r已经过:{int(pass_time)} 秒", end="", flush=True) | 格式化输出 | \r实现同行更新,end=""不换行,flush=True立即刷新输出 |
time.sleep(1) | time库函数 | 暂停1秒 |
except KeyboardInterrupt: | 第3章异常处理 | 捕获Ctrl+C引发的异常 |
{int(total_seconds)} | 类型转换 | 将浮点数转换为整数 |
{total_minutes:.1f} | 格式化输出 | 保留1位小数 |
知识回顾: - \r是回车符,让光标回到行首,实现同行内容更新 - end=""参数让print不自动换行 - flush=True强制立即输出,不等待缓冲区满
拓展:将时间戳转换为时、分、秒格式
ctime()返回的是完整的日期时间字符串,如果我们只需要时、分、秒,可以使用localtime()函数配合格式化:
import time# 获取当前时间的结构化时间local_time = time.localtime()print(f"当前时间结构:{local_time}")print(f"类型:{type(local_time)}")# 提取时、分、秒hour = local_time.tm_hourminute = local_time.tm_minsecond = local_time.tm_secprint(f"当前时间:{hour:02d}:{minute:02d}:{second:02d}")# 使用strftime格式化时间formatted_time = time.strftime("%H:%M:%S", local_time)print(f"格式化时间:{formatted_time}")# 完整的日期时间格式化formatted_datetime = time.strftime("%Y年%m月%d日 %H:%M:%S", local_time)print(f"完整时间:{formatted_datetime}")
运行结果:
当前时间结构:time.struct_time(tm_year=2023, tm_mon=12, tm_mday=21, tm_hour=10, tm_min=30, tm_sec=0, tm_wday=3, tm_yday=355, tm_isdst=0)类型:当前时间:10:30:00格式化时间:10:30:00完整时间:2023年12月21日 10:30:00
strftime格式化符号说明:
格式符 | 含义 | 示例 |
%Y | 四位年份 | 2023 |
%m | 两位月份 | 12 |
%d | 两位日期 | 21 |
%H | 24小时制小时 | 14 |
%M | 分钟 | 30 |
%S | 秒 | 00 |
%A | 星期名称 | Thursday |
%B | 月份名称 | December |
五、time库常用函数速查表
函数 | 功能 | 示例 |
time() | 返回当前时间戳(秒数) | time.time() → 1703145600.123 |
ctime() | 返回可读时间字符串 | time.ctime() → ‘Thu Dec 21 10:30:00 2023’ |
sleep(secs) | 暂停指定秒数 | time.sleep(1) |
localtime() | 返回本地时间的结构化对象 | time.localtime() |
strftime() | 格式化时间 | time.strftime("%H:%M:%S") |
mktime() | 将结构化时间转为时间戳 | time.mktime(t) |
perf_counter() | 返回性能计数器值(高精度) | time.perf_counter() |

🤖 AI辅助学习环节 —— time库
学习目标:通过与AI对话,深入理解time库的应用,提升编程实践能力。
练习一:制作一个考试倒计时器
场景描述:CK学校的期末考试即将开始,请设计一个倒计时程序,显示距离考试还有多少天、多少小时、多少分钟、多少秒。
AI提示词:
请帮我用Python的time库编写一个倒计时程序:1. 设定一个未来的考试时间(比如2025年1月10日9:00)2. 实时显示距离考试还有多少天、时、分、秒3. 每秒更新一次显示4. 使用time库的localtime()和mktime()函数5. 代码要有详细注释
练习二:程序运行时间测量工具
场景描述:在数据分析中,我们经常需要测量代码的执行时间来优化程序性能。请设计一个可以测量任意代码执行时间的装饰器函数。
AI提示词:
请帮我用Python编写一个测量函数执行时间的工具:1. 使用time.perf_counter()获取高精度时间2. 可以测量任意函数的执行时间3. 输出函数名和执行时间(毫秒)4. 给出一个计算1到1000000累加和的示例5. 代码要有详细注释
练习三:制作一个简单的数字时钟
场景描述:在控制台显示一个实时更新的数字时钟,格式为”HH:MM:SS”。
AI提示词:
请帮我用Python的time库制作一个控制台数字时钟:1. 实时显示当前时间,格式为 HH:MM:SS2. 每秒自动更新3. 使用\r实现同行刷新效果4. 按Ctrl+C可以退出5. 代码要有详细注释

6.5.2 turtle库
一、turtle库概述
Python的turtle库是一个非常有趣的绘图库,它源于一种叫做”Logo语言”的教育编程语言。turtle库的设计理念是:想象一只小海龟在沙滩上爬行,它爬过的地方会留下痕迹,通过控制海龟的移动方向和距离,就可以绘制出各种图形。
turtle库特别适合初学者学习编程,因为: 1. 可视化强:代码的执行结果直观可见 2. 即时反馈:每一条绘图命令都能立即看到效果 3. 趣味性高:可以绘制各种有趣的图案 4. 概念清晰:帮助理解坐标系、角度、循环等概念
知识回顾:在第1章我们学习了Python的标准库,turtle库就是Python标准库的一部分,不需要额外安装,直接导入即可使用。
二、turtle绘图窗体的两个坐标系
在使用turtle绘图之前,我们需要理解两个重要的坐标系概念。
2.1 窗体坐标系(屏幕坐标系)
窗体坐标系用于描述绘图窗口在屏幕上的位置。
·原点:屏幕左上角
·x轴:向右为正
·y轴:向下为正
·单位:像素
当我们使用setup()函数设置窗口位置时,使用的就是窗体坐标系。
2.2 海龟坐标系(绘图坐标系)
海龟坐标系用于描述海龟(画笔)在绘图窗口中的位置。
·原点:绘图窗口中心
·x轴:向右为正
·y轴:向上为正
·单位:像素
知识回顾:坐标系的概念在第2章”数据类型与变量”中有所涉及。理解坐标系对于后续学习数据可视化(如matplotlib库)非常重要。
三、turtle绘图颜色设置
turtle库提供了两种设置颜色的方法。
方法一:颜色字符串
使用颜色的英文名称来设置颜色,这是最简单直观的方法。
常用颜色字符串:
颜色名 | 英文 | 中文含义 |
‘red’ | 红色 | 基本颜色 |
‘green’ | 绿色 | 基本颜色 |
‘blue’ | 蓝色 | 基本颜色 |
‘yellow’ | 黄色 | 基本颜色 |
‘purple’ | 紫色 | 基本颜色 |
‘orange’ | 橙色 | 基本颜色 |
‘pink’ | 粉色 | 基本颜色 |
‘black’ | 黑色 | 默认画笔颜色 |
‘white’ | 白色 | 默认填充颜色 |
‘gray’ / ‘grey’ | 灰色 | 中性色 |
‘cyan’ | 青色 | 蓝绿色 |
‘magenta’ | 品红 | 紫红色 |
代码示例:
import turtle# 创建画笔t = turtle.Turtle()# 设置画笔颜色为红色t.pencolor('red')# 设置填充颜色为黄色t.fillcolor('yellow')# 同时设置画笔颜色和填充颜色t.color('blue', 'green') # 画笔蓝色,填充绿色# 绘制一个填充的正方形t.begin_fill()for i inrange(4): t.forward(100) t.left(90)t.end_fill()turtle.done()
方法二:RGB颜色值
RGB代表红(Red)、绿(Green)、蓝(Blue)三种颜色通道。通过组合这三个通道的值,可以表示几乎所有的颜色。
每个通道的取值范围: - 整数模式:0-255 - 小数模式:0.0-1.0
RGB颜色示例:
RGB值 | 颜色 | 说明 |
(255, 0, 0) | 红色 | 红通道最大,其他为0 |
(0, 255, 0) | 绿色 | 绿通道最大,其他为0 |
(0, 0, 255) | 蓝色 | 蓝通道最大,其他为0 |
(255, 255, 0) | 黄色 | 红绿混合 |
(255, 0, 255) | 品红 | 红蓝混合 |
(0, 255, 255) | 青色 | 绿蓝混合 |
(255, 255, 255) | 白色 | 三通道全开 |
(0, 0, 0) | 黑色 | 三通道全关 |
(128, 128, 128) | 灰色 | 三通道中等 |
代码示例:
import turtle# 创建画笔t = turtle.Turtle()# 设置RGB模式(默认是1.0模式)turtle.colormode(255) # 使用0-255的整数模式# turtle.colormode(1.0) # 使用0.0-1.0的小数模式# 使用RGB值设置画笔颜色t.pencolor(255, 0, 0) # 红色画笔# 使用RGB值设置填充颜色t.fillcolor(0, 255, 0) # 绿色填充# 使用RGB元组设置颜色t.color((0, 0, 255), (255, 255, 0)) # 蓝色画笔,黄色填充# 绘制一个填充的三角形t.begin_fill()for i in range(3): t.forward(100) t.left(120)t.end_fill()turtle.done()
知识回顾:这里用到了第2章学习的元组类型。RGB颜色值(255, 0, 0)就是一个元组,元组是不可变的序列类型。
四、turtle常用函数
turtle库的函数可以分为三大类:窗体函数、画笔状态函数和画笔运动函数。
4.1 窗体函数
窗体函数用于控制绘图窗口的属性。
函数 | 功能 | 参数说明 |
setup(width, height, startx, starty) | 设置窗口大小和位置 | width/height:宽高(像素或比例);startx/starty:窗口位置 |
title(title) | 设置窗口标题 | title:标题字符串 |
bgcolor(color) | 设置背景颜色 | color:颜色字符串或RGB值 |
screensize(canvwidth, canvheight, bg) | 设置画布大小 | canvwidth/canvheight:画布宽高;bg:背景色 |
clear() | 清空画布 | 无参数 |
bye() | 关闭窗口 | 无参数 |
setup()函数详解:
import turtle# 设置窗口大小为800x600像素,位于屏幕中央turtle.setup(800, 600)# 设置窗口大小为屏幕的50%,位于屏幕左上角# turtle.setup(0.5, 0.5, 0, 0)# 设置窗口标题turtle.title("CK学校Python绘图演示")# 设置背景颜色turtle.bgcolor('lightblue')# 创建画笔并绘图t = turtle.Turtle()t.forward(100)turtle.done()
4.2 画笔状态函数(14个)
画笔状态函数用于控制画笔的属性,如颜色、粗细、状态等。
函数 | 功能 | 参数说明 |
pensize(width) 或 width(width) | 设置画笔粗细 | width:线条宽度(像素) |
pencolor(color) | 设置画笔颜色 | color:颜色字符串或RGB值 |
fillcolor(color) | 设置填充颜色 | color:颜色字符串或RGB值 |
color(pen, fill) | 同时设置画笔和填充颜色 | pen:画笔颜色;fill:填充颜色 |
penup() 或 pu() 或 up() | 抬起画笔(移动不画线) | 无参数 |
pendown() 或 pd() 或 down() | 放下画笔(移动画线) | 无参数 |
isdown() | 判断画笔是否落下 | 返回True或False |
speed(speed) | 设置画笔移动速度 | speed:0-10,0最快,1最慢,10快 |
hideturtle() 或 ht() | 隐藏画笔形状 | 无参数 |
showturtle() 或 st() | 显示画笔形状 | 无参数 |
isvisible() | 判断画笔是否可见 | 返回True或False |
begin_fill() | 开始填充区域 | 无参数 |
end_fill() | 结束填充区域 | 无参数 |
reset() | 重置画笔状态 | 无参数 |
代码示例:
import turtle# 设置窗口turtle.setup(600, 400)turtle.title("画笔状态函数演示")# 创建画笔t = turtle.Turtle()# 设置画笔属性t.speed(5) # 设置速度为5(中等速度)t.pensize(3) # 设置线条粗细为3像素t.pencolor('blue') # 设置画笔颜色为蓝色t.fillcolor('yellow') # 设置填充颜色为黄色# 绘制一个填充的正方形t.begin_fill() # 开始填充for i in range(4): t.forward(100) t.left(90)t.end_fill() # 结束填充# 抬起画笔,移动到新位置t.penup()t.forward(150)t.pendown()# 隐藏画笔形状t.hideturtle()# 绘制一个三角形t.color('red', 'green') # 同时设置画笔和填充颜色t.begin_fill()for i in range(3): t.forward(80) t.left(120)t.end_fill()turtle.done()
知识回顾:这里用到了第4章学习的for循环。for i in range(4):是遍历循环的标准写法,range(4)生成0,1,2,3四个数。
4.3 画笔运动函数(9个)
画笔运动函数用于控制画笔的移动,从而绘制图形。
函数 | 功能 | 参数说明 |
forward(distance) 或 fd(distance) | 向前移动 | distance:移动距离(像素) |
backward(distance) 或 bk(distance) 或 back(distance) | 向后移动 | distance:移动距离(像素) |
right(angle) 或 rt(angle) | 右转 | angle:旋转角度(度) |
left(angle) 或 lt(angle) | 左转 | angle:旋转角度(度) |
goto(x, y) 或 setpos(x, y) | 移动到指定坐标 | x, y:目标坐标 |
setx(x) | 设置x坐标 | x:新的x坐标 |
sety(y) | 设置y坐标 | y:新的y坐标 |
setheading(angle) 或 seth(angle) | 设置朝向角度 | angle:角度(0东,90北,180西,270南) |
home() | 回到原点 | 无参数,画笔回到(0,0),朝向东 |
circle(radius, extent, steps) | 绘制圆或圆弧 | radius:半径;extent:弧度;steps:多边形边数 |
dot(size, color) | 绘制圆点 | size:点大小;color:颜色 |
代码示例:
import turtle# 设置窗口turtle.setup(800, 600)turtle.title("画笔运动函数演示")# 创建画笔t = turtle.Turtle()t.speed(3)# 示例1:forward和backwardt.forward(100) # 向前100像素t.backward(50) # 向后50像素# 示例2:left和rightt.left(90) # 左转90度t.forward(100)t.right(45) # 右转45度t.forward(100)# 示例3:goto移动到指定位置t.penup()t.goto(0, -100) # 移动到(0, -100)t.pendown()# 示例4:setheading设置朝向t.setheading(0) # 朝向东(右)t.forward(50)# 示例5:circle绘制圆t.penup()t.goto(-200, 0)t.pendown()t.circle(50) # 绘制半径为50的圆# 示例6:circle绘制半圆t.penup()t.goto(-200, -100)t.pendown()t.circle(50, 180) # 绘制半径为50的半圆(180度)# 示例7:circle绘制正多边形t.penup()t.goto(100, 0)t.pendown()t.circle(50, steps=6) # 绘制正六边形# 示例8:dot绘制点t.penup()t.goto(200, 100)t.pendown()t.dot(20, 'red') # 绘制红色圆点turtle.done()
知识回顾: - circle(radius, steps=n)可以绘制正n边形,这是第5章组合数据类型中多边形绘制的常用方法 - 角度计算在第2章数值型数据处理中有所涉及
五、程序设计实例:多模块绘图程序
程序设计要求:
利用多模块编程实现一个菜单驱动的绘图程序: - 选择1:随机绘制一个10条边以内的正多边形 - 选择2:绘制一个使用随机颜色填充的10个圆组成的球 - 选择3:绘制一个带坐标轴的[-3π, +3π]之间的正弦函数曲线 - 选择4:退出程序
设计思路:
1.模块划分:将不同功能封装成不同的函数
2.菜单设计:使用while循环和分支结构实现菜单选择
3.随机功能:使用random库生成随机数
4.数学计算:使用math库进行数学运算
知识回顾: - 第4章学习了random库的使用 - 第3章学习了多路分支语句if-elif-else - 第6章学习了函数的定义和调用
完整代码实现:
import turtleimport randomimport mathimport time# ==================== 模块1:绘制正多边形 ====================def draw_polygon(): """ 随机绘制一个10条边以内的正多边形 """ # 清空画布 turtle.clear() turtle.reset() # 随机生成边数(3-10) sides = random.randint(3, 10) # 计算每条边的长度和角度 radius = 100 # 外接圆半径 angle = 360 / sides # 每个外角 # 随机选择颜色 colors = ['red', 'blue', 'green', 'purple', 'orange', 'cyan', 'magenta'] pen_color = random.choice(colors) fill_color = random.choice(colors) # 创建画笔 t = turtle.Turtle() t.speed(5) t.pensize(2) t.color(pen_color, fill_color) # 移动到起始位置 t.penup() t.goto(0, -radius) t.setheading(0) t.pendown() # 开始绘制 t.begin_fill() for i in range(sides): t.forward(2 * radius * math.sin(math.pi / sides)) t.left(angle) t.end_fill() # 显示信息 t.penup() t.goto(0, -200) t.write(f"正{sides}边形", align="center", font=("Arial", 16, "bold")) print(f"已绘制正{sides}边形,画笔颜色:{pen_color},填充颜色:{fill_color}") return t# ==================== 模块2:绘制圆球 ====================def draw_ball(): """ 绘制一个使用随机颜色填充的10个圆组成的球 """ # 清空画布 turtle.clear() turtle.reset() # 创建画笔 t = turtle.Turtle() t.speed(8) t.pensize(1) t.hideturtle() # 绘制10个同心圆,每个使用随机颜色 colors = ['red', 'blue', 'green', 'purple', 'orange', 'cyan', 'magenta', 'yellow', 'pink', 'brown'] random.shuffle(colors) # 打乱颜色顺序 for i in range(10): radius = 20 + i * 10 # 半径从20到110 t.penup() t.goto(0, -radius) t.pendown() # 随机选择填充颜色 fill_color = colors[i % len(colors)] t.fillcolor(fill_color) t.begin_fill() t.circle(radius) t.end_fill() # 显示信息 t.penup() t.goto(0, -200) t.write("彩色圆球", align="center", font=("Arial", 16, "bold")) print("已绘制彩色圆球,由10个同心圆组成") return t# ==================== 模块3:绘制正弦曲线 ====================def draw_sine(): """ 绘制一个带坐标轴的[-3π, +3π]之间的正弦函数曲线 """ # 清空画布 turtle.clear() turtle.reset() # 设置窗口 turtle.setup(800, 600) # 创建画笔 t = turtle.Turtle() t.speed(0) # 最快速度 t.pensize(2) t.hideturtle() # 定义比例尺 scale_x = 30 # x轴比例:1个单位 = 30像素 scale_y = 80 # y轴比例:1个单位 = 80像素 # 绘制x轴 t.penup() t.goto(-250, 0) t.pendown() t.goto(250, 0) # x轴箭头 t.goto(245, 5) t.goto(250, 0) t.goto(245, -5) # 绘制y轴 t.penup() t.goto(0, -150) t.pendown() t.goto(0, 150) # y轴箭头 t.goto(-5, 145) t.goto(0, 150) t.goto(5, 145) # 标注坐标轴 t.penup() t.goto(255, -15) t.write("x", font=("Arial", 12, "normal")) t.goto(-15, 155) t.write("y", font=("Arial", 12, "normal")) t.goto(-15, -15) t.write("O", font=("Arial", 12, "normal")) # 标注x轴刻度(-3π到+3π) pi_pixels = math.pi * scale_x # π对应的像素数 for i in range(-3, 4): x_pos = i * pi_pixels t.penup() t.goto(x_pos, -10) t.pendown() t.goto(x_pos, 10) t.penup() t.goto(x_pos - 10, -25) if i == 0: t.write("0", font=("Arial", 10, "normal")) elif i == 1: t.write("π", font=("Arial", 10, "normal")) elif i == -1: t.write("-π", font=("Arial", 10, "normal")) else: t.write(f"{i}π", font=("Arial", 10, "normal")) # 标注y轴刻度 for i in range(-1, 2): if i != 0: y_pos = i * scale_y t.penup() t.goto(-10, y_pos) t.pendown() t.goto(10, y_pos) t.penup() t.goto(-25, y_pos - 8) t.write(str(i), font=("Arial", 10, "normal")) # 绘制正弦曲线 t.penup() t.pencolor('blue') t.pensize(2) # 从-3π到+3π绘制正弦曲线 x_start = -3 * math.pi x_end = 3 * math.pi step = 0.1 # 步长 first_point = True x = x_start while x <= x_end: y = math.sin(x) screen_x = x * scale_x screen_y = y * scale_y if first_point: t.penup() t.goto(screen_x, screen_y) t.pendown() first_point = False else: t.goto(screen_x, screen_y) x += step # 显示信息 t.penup() t.goto(0, -200) t.write("y = sin(x), x ∈ [-3π, 3π]", align="center", font=("Arial", 14, "bold")) print("已绘制正弦曲线,范围[-3π, +3π]") return t# ==================== 模块4:主菜单 ====================def show_menu(): """ 显示菜单并获取用户选择 """ print("\n" + "=" * 40) print(" CK学校 Python绘图程序") print("=" * 40) print(" 1. 随机绘制正多边形") print(" 2. 绘制彩色圆球") print(" 3. 绘制正弦曲线") print(" 4. 退出程序") print("=" * 40) choice = input("请输入您的选择(1-4): ") return choice# ==================== 主程序 ====================def main(): """ 主程序:菜单驱动的绘图程序 """ # 设置窗口 turtle.setup(800, 600) turtle.title("CK学校 Python绘图程序") turtle.bgcolor('white') print("\n欢迎使用CK学校Python绘图程序!") print("本程序由数字经济专业开发") while True: choice = show_menu() if choice == '1': print("\n正在绘制正多边形...") draw_polygon() elif choice == '2': print("\n正在绘制彩色圆球...") draw_ball() elif choice == '3': print("\n正在绘制正弦曲线...") draw_sine() elif choice == '4': print("\n感谢使用,再见!") turtle.bye() break else: print("\n输入无效,请重新输入1-4之间的数字!")# 程序入口if __name__ == '__main__': main()
程序运行效果:
欢迎使用CK学校Python绘图程序!本程序由数字经济专业开发========================================CK学校 Python绘图程序========================================1. 随机绘制正多边形2. 绘制彩色圆球3. 绘制正弦曲线4. 退出程序========================================请输入您的选择(1-4): 1正在绘制正多边形...已绘制正6边形,画笔颜色:blue,填充颜色:green========================================CK学校 Python绘图程序========================================1. 随机绘制正多边形2. 绘制彩色圆球3. 绘制正弦曲线4. 退出程序========================================请输入您的选择(1-4): 4感谢使用,再见!
代码详解:
函数 | 功能 | 涉及知识点 |
draw_polygon() | 绘制正多边形 | random库、math库、for循环、turtle绘图 |
draw_ball() | 绘制彩色圆球 | for循环、列表、随机颜色、circle函数 |
draw_sine() | 绘制正弦曲线 | math库、while循环、坐标系转换 |
show_menu() | 显示菜单 | 字符串输出、input函数 |
main() | 主程序 | while循环、if-elif-else分支、函数调用 |
知识回顾: - random.randint(a, b)生成[a, b]范围内的随机整数(第4章) - random.choice(list)从列表中随机选择一个元素(第4章) - math.sin(x)计算正弦值,math.pi表示π(第2章数学运算) - if __name__ == '__main__':是Python程序的入口判断(本节后续讲解)

🤖 AI辅助学习环节 —— turtle库
学习目标:通过与AI对话,掌握turtle库的绘图技巧,创作有趣的图形作品。
练习一:绘制一个爱心图案
场景描述:在CK学校的编程社团活动中,同学们想用Python绘制一个爱心图案送给朋友。
AI提示词:
请帮我用Python的turtle库绘制一个红色的爱心图案:1. 爱心要足够大,居中显示2. 使用红色填充3. 可以使用数学公式或简单的几何图形组合4. 绘制完成后在爱心下方显示"Love Python"文字5. 代码要有详细注释
练习二:绘制一个彩色螺旋图案
场景描述:使用turtle库绘制一个炫酷的彩色螺旋图案,展示循环和颜色的组合效果。
AI提示词:
请帮我用Python的turtle库绘制一个彩色螺旋图案:1. 使用for循环绘制螺旋线2. 每次循环改变画笔颜色(使用RGB或颜色列表)3. 螺旋线逐渐变长4. 设置合适的速度让动画效果更好5. 代码要有详细注释
练习三:绘制一个简单的时钟
场景描述:使用turtle库绘制一个模拟时钟,显示当前时间。
AI提示词:
请帮我用Python的turtle库和time库绘制一个模拟时钟:1. 绘制圆形表盘2. 绘制12个小时刻度3. 绘制时针、分针、秒针(不同颜色和长度)4. 使用time库获取当前时间5. 让时钟实时更新(可选)6. 代码要有详细注释
练习四:绘制CK学校校徽(创意设计)
场景描述:为CK学校设计一个简单的校徽图案。
AI提示词:
请帮我用Python的turtle库设计一个CK学校的校徽:1. 包含圆形或盾形外框2. 中间包含"CK"字母3. 使用蓝色和白色为主色调4. 可以添加一些装饰性图案5. 代码要有详细注释

6.5.3 __main__模块
一、问题的引入
在第1章我们学习了模块的导入,在第6章我们学习了函数的定义和调用。现在我们来思考一个问题:当我们把一个Python文件作为模块导入到另一个文件时,会发生什么?
让我们通过一个具体的例子来理解这个问题。
场景设定:假设CK学校数字经济专业的一位同学写了一个有趣的程序。
二、案例演示:模块导入的问题
第一步:创建一个函数库文件
注意!:
以下案例建议在python自带的IDLE、Pycharm、vscode等中尝试:1. 使用python自带的IDLE,可以点击File New File 创建.py文件2. 使用Pycharm、vscode直接在项目创建.py文件3. 若要在jupyter notebook中调用.py文件,可直接使用魔法命令 %run spam.py 运行文件
假设有一位同学写了一个”洗脑营销”的程序,保存为spam.py:
# 文件名:spam.py# 作者:CK学校数字经济专业学生def spam1(): print('还我血汗钱!')def spam2(guy): print(guy + '你不是人!')def spam3(guy): print(guy + '你还我血汗钱!')def spam4(guy): print(guy + '连夜扛着火车跑路了!') # 改编自网络热梗# 直接调用这些函数spam1()spam1()spam2('黄老板')spam3('黄老板')spam4('黄老板')
运行效果:
E:\>python spam.py还我血汗钱!还我血汗钱!黄老板你不是人!黄老板你还我血汗钱!黄老板连夜扛着火车跑路了!
知识回顾:这里定义了4个函数spam1()到spam4(),并且依次调用了这些函数。函数的定义和调用在第6章6.1节已经详细学习过。
第二步:另一个同学想复用这些函数
隔壁班的小李看到这么好的程序效果,想借这个代码用一下,尤其是想复用那几个spam()函数。他把spam.py拿去以后,另外写了一个liSpam.py,在其中用import导入了spam.py,并且传了他自己想用的对象’陈老板’作为参数:
# 文件名:liSpam.py# 作者:小李import spamspam.spam1()spam.spam1()spam.spam2('陈老板')spam.spam3('陈老板')spam.spam4('陈老板')
运行效果:
E:\>python liSpam.py还我血汗钱!还我血汗钱!黄老板你不是人!黄老板你还我血汗钱!黄老板连夜扛着火车跑路了!还我血汗钱!还我血汗钱!陈老板你不是人!陈老板你还我血汗钱!陈老板连夜扛着火车跑路了!
问题出现了! 小李只是想用那些函数来输出关于”陈老板”的内容,但是程序却先输出了关于”黄老板”的内容。这是因为在liSpam.py里通过import spam导入spam.py时,会执行一遍spam.py里的所有代码。
三、__name__变量的作用
有没有什么办法在spam.py里作区分呢?我们希望实现这样的效果:
·如果spam.py被拿来直接运行,就执行那几个spam()函数的调用
·如果spam.py被用来当作函数库导入到其他文件里面去,就不执行那些调用
这就需要用到Python的一个特殊变量:__name__。
探索__name__的值
让我们在spam.py里显示__name__的值:
# 文件名:spam.py# 探索__name__变量def spam1(): print('还我血汗钱!')def spam2(guy): print(guy + '你不是人!')def spam3(guy): print(guy + '你还我血汗钱!')def spam4(guy): print(guy + '连夜扛着火车跑路了!')print(__name__) # 打印__name__的值
直接运行spam.py:
E:\>python spam.py__main__
可以看到,直接运行spam.py时,__name__的值是'__main__'。
运行liSpam.py(它导入了spam):
E:\>python liSpam.pyspam还我血汗钱!还我血汗钱!陈老板你不是人!陈老板你还我血汗钱!陈老板连夜扛着火车跑路了!
当spam.py被导入时,__name__变成了'spam',这是导入的模块的名字。
知识回顾:字符串类型在第2章已经学习过。'__main__'和'spam'都是字符串类型的值。
四、__name__的原理
Python解释器在执行代码时,会根据文件的执行方式给__name__变量赋予不同的值:
执行方式 | __name__的值 | 说明 |
直接运行文件 | '__main__' | 文件作为主程序运行 |
被import导入 | 模块名(字符串) | 文件作为模块被导入 |
原理图解:
直接运行 spam.py:┌─────────────────────────────────┐│python spam.py││││__name__ = '__main__'││││执行所有代码│└─────────────────────────────────┘导入 spam.py:┌─────────────────────────────────┐│import spam││││__name__ = 'spam'││││执行所有代码(但可以区分)│└─────────────────────────────────┘
五、解决方案:使用if __name__ == '__main__':
由此我们得到了区分的方法: - 定义函数的部分原封不动 - 把”直接运行此文件时执行,但把此文件当作函数库导入的时候不运行”的代码放进if分支里 - 判断条件是__name__是否等于'__main__'
修改后的spam.py:
# 文件名:spam.py# 使用__name__区分直接运行和被导入def spam1(): print('还我血汗钱!')def spam2(guy): print(guy + '你不是人!')def spam3(guy): print(guy + '你还我血汗钱!')def spam4(guy): print(guy + '连夜扛着火车跑路了!')# 只有直接运行此文件时才执行以下代码if __name__ == '__main__': spam1() spam1() spam2('黄老板') spam3('黄老板') spam4('黄老板')
直接运行spam.py:
E:\>python spam.py还我血汗钱!还我血汗钱!黄老板你不是人!黄老板你还我血汗钱!黄老板连夜扛着火车跑路了!
自己运行,完全没问题!
运行liSpam.py:
E:\>python liSpam.py还我血汗钱!还我血汗钱!陈老板你不是人!陈老板你还我血汗钱!陈老板连夜扛着火车跑路了!
小李拿去当作函数库,也不会输出错误的内容了!
知识回顾: - if __name__ == '__main__':是第3章学习的if分支语句 - ==是关系运算符,用于判断两个值是否相等(第3章) - 字符串比较区分大小写,'__main__'必须完全匹配
六、进阶:检测被导入的情况
如果你想在被导入时执行一些特殊操作,也可以利用__name__的值:
# 文件名:spam.py# 进阶用法:检测被导入的情况def spam1(): print('还我血汗钱!')def spam2(guy): print(guy + '你不是人!')def spam3(guy): print(guy + '你还我血汗钱!')def spam4(guy): print(guy + '连夜扛着火车跑路了!')# 直接运行时执行if __name__ == '__main__': spam1() spam1() spam2('黄老板') spam3('黄老板') spam4('黄老板')# 被导入时执行if __name__ == 'spam': print('提示:我是一个大骗子!满嘴跑火车!不信你看:')
直接运行spam.py:
E:\>python spam.py还我血汗钱!还我血汗钱!黄老板你不是人!黄老板你还我血汗钱!黄老板连夜扛着火车跑路了!
运行liSpam.py:
E:\>python liSpam.py提示:我是一个大骗子!满嘴跑火车!不信你看:还我血汗钱!还我血汗钱!陈老板你不是人!陈老板你还我血汗钱!陈老板连夜扛着火车跑路了!
七、if __name__ == '__main__':的标准用法
在实际开发中,if __name__ == '__main__':是Python程序的标准入口写法。它的典型结构如下:
# 文件名:my_module.py# 标准的Python模块结构# 1. 导入语句import module1import module2# 2. 全局变量定义GLOBAL_VAR = 100# 3. 函数定义def func1(): """函数1的说明""" passdef func2(): """函数2的说明""" passdef main(): """主函数:程序的入口""" print("程序开始执行") func1() func2() print("程序执行结束")# 4. 程序入口if __name__ == '__main__': main()
这种写法的优点:
1.模块可复用:其他文件可以导入这个模块,使用其中的函数,而不会自动执行主程序逻辑
2.代码清晰:主程序逻辑集中在main()函数中,结构清晰
3.便于测试:可以单独测试模块中的各个函数
4.符合规范:这是Python社区广泛认可的标准写法
知识回顾: - 函数定义使用def关键字(第6章6.1节) - main()函数只是一个普通的函数名,习惯上用来表示程序的主入口 - 函数调用必须放在函数定义之后
八、综合案例:多模块程序设计
让我们回到前面的turtle绘图程序,看看if __name__ == '__main__':是如何在实际项目中使用的。
项目结构:
project/├── main.py# 主程序入口├── draw_polygon.py# 绘制正多边形模块├── draw_ball.py# 绘制圆球模块└── draw_sine.py# 绘制正弦曲线模块
模块文件示例(draw_polygon.py):
# 文件名:draw_polygon.py# 功能:绘制正多边形import turtleimport randomimport mathdef draw_polygon(sides=None, pen_color=None, fill_color=None): """ 绘制正多边形 参数: sides: 边数,如果为None则随机生成 pen_color: 画笔颜色,如果为None则随机选择 fill_color: 填充颜色,如果为None则随机选择 """ # 清空画布 turtle.clear() # 随机生成边数(3-10) if sides is None: sides = random.randint(3, 10) # 计算每条边的长度和角度 radius = 100 angle = 360 / sides # 随机选择颜色 colors = ['red', 'blue', 'green', 'purple', 'orange', 'cyan', 'magenta'] if pen_color is None: pen_color = random.choice(colors) if fill_color is None: fill_color = random.choice(colors) # 创建画笔 t = turtle.Turtle() t.speed(5) t.pensize(2) t.color(pen_color, fill_color) # 移动到起始位置 t.penup() t.goto(0, -radius) t.setheading(0) t.pendown() # 开始绘制 t.begin_fill() for i in range(sides): t.forward(2 * radius * math.sin(math.pi / sides)) t.left(angle) t.end_fill() # 显示信息 t.penup() t.goto(0, -200) t.write(f"正{sides}边形", align="center", font=("Arial", 16, "bold")) return sides, pen_color, fill_color# 测试代码:只有直接运行此文件时才执行if __name__ == '__main__': turtle.setup(800, 600) turtle.title("正多边形绘制测试") sides, pen, fill = draw_polygon() print(f"测试结果:绘制了正{sides}边形") print(f"画笔颜色:{pen},填充颜色:{fill}") turtle.done()
主程序文件(main.py):
# 文件名:main.py# 功能:主程序入口import turtlefrom draw_polygon import draw_polygon# from draw_ball import draw_ball# from draw_sine import draw_sinedef show_menu(): """显示菜单""" print("\n" + "=" * 40) print(" CK学校 Python绘图程序") print("=" * 40) print(" 1. 随机绘制正多边形") print(" 2. 绘制彩色圆球") print(" 3. 绘制正弦曲线") print(" 4. 退出程序") print("=" * 40) return input("请输入您的选择(1-4): ")def main(): """主函数""" turtle.setup(800, 600) turtle.title("CK学校 Python绘图程序") print("\n欢迎使用CK学校Python绘图程序!") while True: choice = show_menu() if choice == '1': sides, pen, fill = draw_polygon() print(f"已绘制正{sides}边形") elif choice == '4': print("\n感谢使用,再见!") turtle.bye() break else: print("\n功能开发中...")if __name__ == '__main__': main()
知识回顾: - from module import function语法在第1章学习过 - while True:无限循环在第4章学习过 - 函数参数的默认值在第6章6.2节学习过

🤖 AI辅助学习环节 —— __main__模块
学习目标:通过与AI对话,深入理解模块化编程的核心概念,掌握__name__变量的应用。
练习一:创建一个数学工具模块
场景描述:CK学校数字经济专业的学生需要一个数学工具模块,包含常用的数学函数。
AI提示词:
请帮我创建一个Python数学工具模块math_tools.py:1. 包含以下函数:- add(a, b): 加法- subtract(a, b): 减法- multiply(a, b): 乘法- divide(a, b): 除法(处理除零异常)- power(base, exp): 幂运算- factorial(n): 阶乘2. 使用if __name__ == '__main__':进行模块测试3. 测试代码输出每个函数的测试结果4. 代码要有详细注释
练习二:创建一个字符串处理模块
场景描述:创建一个字符串处理工具模块,可以被其他程序导入使用。
AI提示词:
请帮我创建一个Python字符串处理模块str_tools.py:1. 包含以下函数:- reverse_string(s): 反转字符串- count_words(s): 统计单词数- is_palindrome(s): 判断是否为回文- remove_spaces(s): 删除所有空格2. 使用if __name__ == '__main__':进行模块测试3. 创建另一个文件main.py导入并使用这些函数4. 代码要有详细注释
练习三:理解模块导入的执行顺序
场景描述:通过实验理解模块导入时的执行顺序。
AI提示词:
请帮我创建一个演示模块导入执行顺序的示例:1. 创建module_a.py,包含:- 一个全局变量- 一个函数- 在模块级别打印一条消息- 在if __name__ == '__main__':中打印另一条消息2. 创建module_b.py,导入module_a3. 分别运行两个模块,观察输出差异4. 解释为什么会有这样的差异5. 代码要有详细注释

本节小结
知识点总结
知识点 | 核心内容 | 应用场景 |
time库 | 时间戳获取、时间格式化、程序暂停 | 计时器、延时操作、时间记录 |
turtle库 | 绘图窗口、画笔控制、图形绘制 | 数据可视化、图形设计、教学演示 |
__name__变量 | 区分直接运行和被导入 | 模块化编程、代码复用 |
核心函数速查
time库常用函数: - time.time() - 获取当前时间戳 - time.ctime() - 获取可读时间字符串 - time.sleep(secs) - 暂停指定秒数 - time.strftime() - 格式化时间
turtle库常用函数: - setup(width, height) - 设置窗口大小 - forward(distance) - 向前移动 - left(angle) / right(angle) - 左转/右转 - penup() / pendown() - 抬笔/落笔 - color(pen, fill) - 设置颜色 - begin_fill() / end_fill() - 开始/结束填充
模块入口判断:
if __name__ == '__main__': main()
学习建议
1.多动手实践:time库和turtle库都需要通过实际编程来加深理解
2.理解原理:不仅要记住函数用法,更要理解背后的原理
3.模块化思维:养成使用if __name__ == '__main__':的习惯
4.创意绘图:尝试用turtle库绘制各种有趣的图形
