第 02 课
变量、基础数据类型、表达式与输入输出
本课从《星潮生存战》的动态数据出发,学习变量命名、str、int、float、bool、字符串与方法、注释、算术与比较表达式、input、类型转换和 f-string 格式化。你会边阅读完整代码边操作 VS Code,最终说清“输入 → 清理 → 转换 → 计算 → 比较 → 显示”的完整路线。
从《星潮生存战》读懂变量、运算与转换
从游戏画面中的分数、时间、击杀和等级出发,学会给变量清楚命名,读懂字符串、注释与方法,再依次完成四个 Python 程序并根据代码骨架制作结果摘要。
学完你将能够
学习目标
- 把变量理解为指向当前值的名字,使用合法、清楚的 snake_case 变量名。
- 区分 str、int、float、bool,并读懂单引号、双引号、三引号、转义字符与注释。
- 区分函数与字符串方法,使用大小写、清理空白和删除前缀的方法得到新字符串。
- 区分 =、== 和增强赋值,说明赋值、比较与更新分别发生了什么。
- 使用 +、-、*、/、//、%、** 完成算术运算,并用比较运算得到 True 或 False。
- 按照括号、乘方、乘除整除余数、加减、比较的顺序理解表达式。
- 编写说明内容、格式和单位的 input 提示,并使用 strip 清理两端空白。
- 使用 int 和 float 产生可计算的新值,并知道原来的文字变量不会被改变。
- 使用 f-string、:.2f 和 :02d 输出整齐的结果卡与分:秒计时。
- 根据错误类型和出错位置处理 SyntaxError、NameError、ValueError 与 TypeError。
开始操作前
准备工作
- 已经完成上一课,能够在 VS Code 终端运行 python game.py。
- 电脑已经安装 Python 3.10.11,VS Code 已选择这套解释器。
- 准备一个自己拥有写入权限的文件夹,并将它命名为“第02次_星潮结果卡与时间格式化”。
- 代码、命令、括号、引号、冒号、下划线和运算符都使用英文字符。
- 本课会先用代码框逐个建立四个程序;四段代码全部学完后,页面会提供完整练习包和第五个程序的起步骨架,由你补全关键语句。
本课学习路线
按照学习模块逐步完成
每个模块都包含理解、跟随操作和独立实践。先找到程序正在记录什么
从游戏画面认识数据与变量
分数、时间、击杀和等级都会随着一局游戏发生变化。先在熟悉的画面中找到它们,再学习怎样在程序中为这些数据起名字。变量名像标签一样指向当前值
变量是程序给当前值起的名字。score = 18460 可以读成“让名字 score 指向整数 18460”。后面的代码只要使用 score,就能取得它当前指向的值。
初学时也可以把变量想成贴着名称的盒子,这有助于理解“保存数据”;但重新赋值时,更准确的理解是让同一个名字改为指向新值。score = 19000 后,score 指向 19000,而不是在 18460 这个整数内部继续写入。
完整游戏中会看到 self.score。点号表示从某个对象中读取它保存的数据,这叫属性访问。本课先使用更简单的 score;对象和属性会在后续课程中继续学习。
- 姓名和提示语通常使用 str,也就是字符串。
- 得分、击杀数和等级没有小数部分,通常使用 int。
- 存活时间可能带小数,适合使用 float。
- 是否结束、比较是否成立只有真或假,适合使用 bool。

先观察名称与值之间的指向关系:变量名帮助程序再次找到当前值;重新赋值会改变这条指向关系。
点击图片可以查看完整截图
盒子比喻适合帮助初学者理解“保存”,但遇到重新赋值时,请回到更准确的“名字指向当前值”模型。
点击图片可以查看完整截图score = 860
print(score)
score = 980
print(score)文件从上到下执行:第一行让 score 指向 860;第二行输出 860;第三行让同一个名字改为指向 980;第四行输出 980。
在游戏画面中指出四项动态数据
- 01
游戏窗口输入和终端输入的区别
两种方式都能取得键盘内容,但程序读取它们的位置与时机不同。
左右滑动表格,可查看完整内容
| 输入方式 | 在哪里输入 | 程序怎样取得内容 |
|---|---|---|
| Pygame 键盘事件 | 游戏窗口 | 游戏不断读取按键产生的消息 |
| input(...) | VS Code 终端 | 程序执行到 input 时暂停并等待 |
用变量描述一局游戏
在纸上写出 score、kill_count、level 和 survival_seconds,并为每个名字填写一个你在画面中看到的值。
- 每个变量名都能对应一项画面数据。
- 能够指出哪些值没有小数,哪些值可能带小数。
- 能够说明变量保存的是当前值,后续仍可以更新。
让名字既能运行又容易读
给变量起合法、清楚的名字
变量名首先要符合 Python 规则,其次要让读代码的人知道它保存什么。规则决定程序能否识别,命名习惯决定程序是否容易理解和修改。变量名规则与本课约定
“可以运行”和“适合使用”不是同一件事;先通过语言规则,再选择清楚的名称。
左右滑动表格,可查看完整内容
| 要求 | 正确例子 | 需要改正的例子 | 原因 |
|---|---|---|---|
| 首字符是字母或下划线 | player2、_temp | 2player | 数字不能放在开头 |
| 其余字符只用字母、数字、下划线 | player_score | player score、score-2 | 空格和连字符会改变代码结构 |
| 不能使用 Python 关键字 | player_class | class | 关键字已经承担语法作用 |
| 区分大小写 | score | Score 与 score 混用 | 它们会被当作两个名字 |
| 不覆盖常用内置函数 | player_name | print、input、type | 覆盖后会让原来的函数无法正常调用 |
| 使用有意义的 snake_case | survival_seconds | s、abc | 小写单词用下划线连接,含义更清楚 |
Python 能使用中文名字,本课统一使用英文 snake_case
Python 可以识别中文等非拉丁文字作为变量名,但同一项目中的工具、库和团队习惯可能不同。本课程普通变量统一使用有意义的英文小写单词,并用下划线连接,例如 player_name。
尽量避免单独使用小写 l、大写 O 等容易与数字 1、0 混淆的字符。读代码时若分不清字符,变量名就很容易拼错并产生 NameError。
数字下划线、多变量赋值与常量命名
较长数字可以用下划线分组:15_000 与 15000 完全相等,下划线只帮助阅读。等号左侧可以同时写多个变量,右侧的值会按位置一一对应。
不会在程序运行中随意改变的配置值,通常使用全大写名称,例如 PERSONAL_GOAL。它是共同遵守的命名约定,不是 Python 强制的锁定功能;代码仍然能够再次赋值,因此编写者要主动保持它不变。
PERSONAL_GOAL = 15_000
score, level, game_over = 860, 2, False
print(PERSONAL_GOAL == 15000)
print(score, level, game_over)第一行是常量约定,第二行把三个值按位置交给三个变量,最后两行用于确认数值和对应关系。

观察等号两侧都按从左到右的位置对应:第一个值给第一个名字,第二个值给第二个名字。
点击图片可以查看完整截图把不清楚的名字改成可读变量名
依次改写 2score、player name、class、print 和 s,使每个名字既符合规则又能说明保存的数据。
- 所有名称都以字母或下划线开头,只包含字母、数字和下划线。
- 没有使用关键字或 print、input、type。
- 至少写出 player_score、player_name、player_class、message 和 survival_seconds 中合适的名称。
- 能够解释 15_000 为什么与 15000 相等,以及全大写名称为什么仍可能被重新赋值。
把代码与命令放到正确位置
建立练习文件夹并认识 VS Code
先建立专用文件夹并分清资源管理器、编辑区和终端。图中展示的是四个程序全部建立后的工作区;你会在后续模块中通过完整代码框逐个建立它们。打开练习文件夹并准备终端
- 01
- 02
- 03
语法高亮帮助辨认代码角色,不替代实际运行
VS Code 会用不同颜色显示字符串、数字、函数名和注释,这叫语法高亮。颜色能帮助你快速看出一行代码由哪些部分组成,但主题不同,具体颜色也会不同。
引号没有闭合时,后面的文字可能突然都变成字符串颜色;编辑器也可能出现波浪线。这些都是定位线索,真正判断程序是否正确,还要保存文件、运行代码并阅读终端结果。
从代码外观找到需要观察的位置
不要背颜色名称,只判断不同部分是否被编辑器区分。
左右滑动表格,可查看完整内容
| 代码部分 | 示例 | 观察重点 |
|---|---|---|
| 字符串 | "小林" | 引号与其中的文字通常显示为同一类颜色 |
| 数字 | 860、42.5 | 没有引号,通常与字符串颜色不同 |
| 函数调用 | print(...)、type(...) | 函数名后有英文圆括号 |
| 注释 | # 说明得分来源 | 从 # 开始到本行结尾,不作为代码执行 |
| 可疑位置 | print("小林) | 颜色异常延伸或出现波浪线时,先检查成对符号 |
准备第一个空文件
在资源管理器中新建 01_game_result_card.py,先不要运行。下一模块会给出完整代码。
- 文件保存在本课练习文件夹中。
- 扩展名是 .py,不是 .txt。
- 终端已经打开,运行命令不会写进代码文件。
让文字既写得正确又说明得清楚
读懂字符串、转义、注释与文件说明
字符串用于保存和显示文字。引号决定字符串从哪里开始、在哪里结束;转义字符表示不容易直接输入的换行、制表符和引号;注释与文档字符串则帮助人理解文件。三种引号怎样选择
单引号和双引号都能建立单行字符串;三引号可以跨行,也可以放在文件开头说明整个文件。
左右滑动表格,可查看完整内容
| 写法 | 适合的情况 | 示例 |
|---|---|---|
| '...' | 普通单行文字,内部包含双引号时很方便 | '玩家说:"继续挑战!"' |
| "..." | 普通单行文字,内部包含单引号时很方便 | "I'm ready" |
| """...""" | 跨行字符串;位于文件第一条语句时可说明整个模块 | """星潮结果卡练习 从输入到显示。""" |
title = "星潮生存战"
message = '玩家说:"继续挑战!"'
english = "I'm ready"
rules = """第一行:只输入数字
第二行:按 Enter 继续"""
print(title)
print(message)
print(english)
print(rules)四个变量都保存字符串。三引号中的换行属于字符串内容;只有交给 print 后,文字才会显示到终端。
三引号字符串与 # 注释不是同一种东西
文件第一条语句如果是三引号字符串,它可以作为模块文档字符串,说明这个文件解决什么问题、怎样运行或需要什么输入。Python 工具能够读取这段说明。
# 从出现位置开始到本行结尾都是注释,解释器不会把它当作普通代码执行。好注释说明目的、原因或限制,例如“得分只用于本课运算练习”,而不是把 score = 860 重复翻译成“把 860 给 score”。

观察 # 后的说明没有出现在输出中;真正显示的是下一行 print 调用产生的结果。
点击图片可以查看完整截图常用转义字符
反斜杠与后面的字符组合成一个特殊写法;它们仍然位于字符串内部。
左右滑动表格,可查看完整内容
| 写法 | 表示什么 | 观察方法 |
|---|---|---|
| \n | 换到下一行 | 运行 print("第一行\n第二行") |
| \t | 插入一个制表位置 | 运行 print("姓名:\t小林") |
| \\ | 显示一个反斜杠 | 运行 print("C:\\Python") |
| \" | 在双引号字符串内显示双引号 | 运行 print("他说:\"开始\"") |
| \' | 在单引号字符串内显示单引号 | 运行 print('I\'m ready') |

比较三次输出:普通空格只分隔文字,\t 留出更宽间隔,\n 让后面的文字出现在下一行。
点击图片可以查看完整截图字符串可以拼接和重复,但不能直接与整数相加
字符串 + 字符串会按顺序拼成一个新字符串;字符串 * 整数会重复指定次数。这两种运算都产生新值,不会自动修改原变量。
"得分:" + 860 会产生 TypeError,因为左边是 str,右边是 int。暂时可以使用 print("得分:", 860) 分别显示;后面还会学习 f-string。
game_name = "星潮"
mode_name = "生存战"
full_title = game_name + mode_name
divider = "=" * 10
print(divider)
print(full_title)先产生 full_title 和 divider 两个新字符串,再把它们交给 print。
建立字符串观察文件
新建 string_notes.py,先写模块文档字符串,再用代码观察换行、制表、反斜杠、引号、拼接和重复。这个观察文件与后面的四个完整程序相互独立。
- 文件第一条语句是说明练习目的的三引号模块文档字符串。
- 至少使用一次 \n、\t、\\ 和一种引号转义。
- 使用 + 拼接两个字符串,使用 * 重复一个字符串。
- 写一条解释目的或限制的 # 注释,并运行确认它不会出现在输出中。
认识赋值、类型与变量更新
程序一:用变量保存一局数据
第一个程序从上到下建立四个变量,输出值与类型,再更新一次得分。先保存完整代码,之后再按截图逐行阅读和运行。程序通常从文件第一行向下执行
score = 860 先建立变量并保存 860,后面的 print(score) 才能找到它。每次重新运行文件,Python 都会从第一行重新开始。
print、type、input、int 和 float 都是 Python 已经准备好的内置函数。函数名后的一对圆括号表示现在调用这个功能。
三个相似符号承担不同任务
先学会把每一行代码读成一句完整的话。
左右滑动表格,可查看完整内容
| 写法 | 作用 | 可以怎样读 |
|---|---|---|
| score = 860 | 赋值 | 把 860 保存到 score |
| score == 860 | 比较是否相等 | score 是否等于 860 |
| score += 120 | 增加后存回 | score 在旧值上增加 120 |
增强赋值会读取旧值、计算并存回
左侧变量必须已经有值。每一种写法都等价于“变量 = 变量 运算 新值”。
左右滑动表格,可查看完整内容
| 写法 | 完整写法 | 作用 |
|---|---|---|
| score += 120 | score = score + 120 | 增加后存回 |
| score -= 20 | score = score - 20 | 减少后存回 |
| score *= 2 | score = score * 2 | 相乘后存回 |
| score /= 2 | score = score / 2 | 普通除法后存回,通常得到 float |
| score //= 2 | score = score // 2 | 整除后存回 |
| score %= 60 | score = score % 60 | 余数存回 |
| score **= 2 | score = score ** 2 | 乘方后存回 |
value = 10
value += 5
value *= 2
value //= 4
value %= 5
value **= 2
value /= 1
print(value, type(value))每一行都使用上一行刚保存的值。最后的 /= 使用普通除法,因此即使结果是 6,也会保存为 6.0。
"""练习1:用变量保存《星潮生存战》的一局游戏结果。
请从上向下阅读:先创建四个变量,再输出它们,最后更新一次得分。
"""
# 第1步:用四个变量分别保存文字、整数、小数和布尔值。
player_name = "小林"
score = 860
survival_seconds = 42.5
game_over = False
# 第2步:把变量中保存的内容显示在终端里。
print("=== 游戏结果卡 ===")
print("玩家:", player_name)
print("得分:", score)
print("生存时间:", survival_seconds, "秒")
print("本局是否结束:", game_over)
# 第3步:使用type查看每个变量当前保存的数据类型。
print("player_name 的类型:", type(player_name))
print("score 的类型:", type(score))
print("survival_seconds 的类型:", type(survival_seconds))
print("game_over 的类型:", type(game_over))
# 第4步:score += 120与score = score + 120的作用相同。
score += 120
print("再次挑战后更新的得分:", score)
复制全部代码,粘贴到 01_game_result_card.py,保存后再继续。这个文件已经完整,可以独立运行。
阅读、运行并确认程序一
- 01
- 02
- 03
- 04
- 05
- 06
- 07
亲手改动一次变量
把姓名改为“小周”,初始得分改为 900,保存并重新运行;观察完成后再改回原值。
- 玩家姓名变成小周。
- 更新后的得分变成 1020。
- 能够说明重新运行会从第一行重新建立变量。
让字符串完成属于自己的操作
使用点号调用字符串方法
函数可以直接通过名称调用;方法属于某一类值,要先写操作对象,再写点号和方法名。字符串方法会根据原字符串产生新字符串,是否保存结果由下一次赋值决定。函数调用与方法调用
圆括号表示现在执行;点号左侧说明由哪个对象执行它所属的操作。
左右滑动表格,可查看完整内容
| 写法 | 名称 | 功能从哪里来 | 这次处理什么 |
|---|---|---|---|
| print(name) | 函数调用 | Python 内置函数 | 圆括号中的 name |
| input(提示语) | 函数调用 | Python 内置函数 | 提示语与键盘输入 |
| name.strip() | 方法调用 | str 字符串类型 | 点号左侧的 name 当前字符串 |
| "star tide".title() | 方法调用 | str 字符串类型 | 点号左侧的文字 |

图中先查看 print 属于内置函数、title 属于字符串方法;真正执行时,还要在名称后写一对圆括号。
点击图片可以查看完整截图大小写方法返回不同形式的新字符串
title() 把英文单词的开头转为大写,upper() 转为大写,lower() 转为小写。中文字符没有大小写,因此方法会保留中文部分。
这些方法不会自动改变原字符串。original.upper() 产生新值;只有写成 changed = original.upper() 或 original = original.upper(),返回值才会被变量保存。

分别观察 title()、upper()、lower() 产生的结果;第三行重新给 name 赋值后,变量保存的字符串也随之改变。
点击图片可以查看完整截图肉眼相似的字符串可能带有不同空白
用户输入姓名时,可能在文字前后多按空格。终端输出看起来接近,但这些空白仍属于字符串,会影响比较、保存和后续显示。
strip() 删除两端空白,lstrip() 只删除左端,rstrip() 只删除右端;它们不会删除文字中间用于分隔单词的空格。

肉眼只看文字很难发现首尾空白;清理前要知道空白可能在左端、右端或两端。
点击图片可以查看完整截图常用字符串方法
所有方法都会返回新字符串;要在后面继续使用,就把返回值赋给变量。
左右滑动表格,可查看完整内容
| 方法 | 作用 | 示例结果 |
|---|---|---|
| title() | 英文单词开头大写 | "star tide" → "Star Tide" |
| upper() | 英文转为大写 | "Star" → "STAR" |
| lower() | 英文转为小写 | "Star" → "star" |
| strip() | 删除两端空白 | " 小林 " → "小林" |
| lstrip() | 只删除左端空白 | " 小林 " → "小林 " |
| rstrip() | 只删除右端空白 | " 小林 " → " 小林" |
| removeprefix("Lv.") | 开头完全匹配时删除指定前缀 | "Lv.7" → "7" |

清理前先对照引号边界与终端输出:引号能帮助看到空白属于字符串的哪一端。
点击图片可以查看完整截图
清理后观察三个方法删除的位置不同;将这张图与左图对照,可以确认方法返回的是新的字符串结果。
点击图片可以查看完整截图name = " 小林 "
cleaned = name.strip()
print(f"原值:[{name}]")
print(f"新值:[{cleaned}]")
level_text = "Lv.7"
level_number_text = level_text.removeprefix("Lv.")
print(level_number_text)第一行保存带空白的原值;第二行调用方法并把新值交给 cleaned;第三、四行分别用方括号显示两个变量的边界。
清理并统一一组字符串
分别处理带首尾空格的姓名、大小写混合的英文模式名和带 Lv. 前缀的等级文字,并显示原值与新值。
- 使用 strip() 清理姓名,并用方括号显示清理前后的边界。
- 对英文模式名分别调用 title()、upper() 和 lower()。
- 使用 removeprefix("Lv.") 得到等级数字文字。
- 能够说明每个方法先返回新字符串,赋值后变量才保存结果。
学习算术、比较与运算顺序
程序二:用表达式计算结果
表达式会读取变量、完成运算并产生结果。本程序用简化数据练习运算符,不代表游戏的完整动态计分规则。赋值时先计算完整右侧
time_score = total_seconds * 100 会先读取 total_seconds,完成乘法,再把结果保存到 time_score。比较表达式同样先计算两边,最后产生 True 或 False。
一行中出现多种运算时,顺序是:括号 → 乘方 → 乘法、除法、整除、余数 → 加减 → 比较。同一层级通常从左到右。
七种算术运算符
Python 使用 *、/ 和 **,不能照写数学课本中的 ×、÷ 和 ^。
左右滑动表格,可查看完整内容
| 运算符 | 含义 | 例子 | 结果 |
|---|---|---|---|
| + | 加法 | 9 + 3 | 12 |
| - | 减法 | 9 - 3 | 6 |
| * | 乘法 | 9 * 3 | 27 |
| / | 普通除法 | 9 / 3 | 3.0 |
| // | 整除,得到完整份数 | 125 // 60 | 2 |
| % | 取得余数 | 125 % 60 | 5 |
| ** | 乘方 | 2 ** 3 | 8 |
六种比较运算符
比较表达式只会得到 bool,也就是 True 或 False。
左右滑动表格,可查看完整内容
| 运算符 | 询问的问题 | 例子 |
|---|---|---|
| == | 两边是否相等 | 5 == 5 → True |
| != | 两边是否不相等 | 5 != 3 → True |
| > | 左边是否大于右边 | 5 > 3 → True |
| >= | 左边是否大于或等于右边 | 5 >= 5 → True |
| < | 左边是否小于右边 | 3 < 5 → True |
| <= | 左边是否小于或等于右边 | 5 <= 4 → False |
"""练习2:把简化的游戏数据写成算术表达式和比较表达式。
这里的基础表现分只用于练习运算符,不是《星潮生存战》的真实计分规则。
"""
# 第1步:准备计算时要使用的两个基础数据。
total_seconds = 125
kill_count = 9
personal_goal = 15000
# 第2步:使用算术运算符计算各项得分和时间。
time_score = total_seconds * 100
kill_score = kill_count * 300
basic_performance_score = time_score + kill_score
score_difference = basic_performance_score - personal_goal
half_score = basic_performance_score / 2
whole_minutes = total_seconds // 60
remaining_seconds = total_seconds % 60
difficulty_weight = 2 ** 3
# 第3步:比较基础表现分是否达到15000,结果只会是True或False。
reached_personal_goal = basic_performance_score >= personal_goal
# 第4步:把每个表达式的计算结果显示出来。
print("=== 表达式实验室 ===")
print("时间得分:", time_score)
print("击杀得分:", kill_score)
print("基础表现分:", basic_performance_score)
print("与15000分目标的差值:", score_difference)
print("基础表现分的一半:", half_score)
print(total_seconds, "秒可以写成:", whole_minutes, "分", remaining_seconds, "秒")
print("2的3次方:", difficulty_weight)
print("是否达到个人15000分目标:", reached_personal_goal)
在资源管理器中新建 02_expression_lab.py,复制全部代码并保存。这个文件已经完整,可以独立运行。
在程序中找到表达式与目标比较
- 01
- 02
- 03
- 04
运行两组数据并解释 True 与 False
- 01
- 02
- 03
为自己的数据写表达式
任选一个新的秒数和击杀数,先手算,再修改程序运行。
- 能够使用 * 和 + 算出基础表现分。
- 能够使用 // 与 % 拆分分钟和秒。
- 能够在运行前预测目标比较会得到 True 还是 False。
让终端输入进入程序
程序三:用 input 接收并转换数据
程序执行到 input 时会暂停,等待你输入并按 Enter。input 直接得到的始终是 str;需要计算时,再使用 int 或 float 产生数值新值。一次 input 会经历六个动作
input 先显示问题,程序暂停,等待你在终端输入;按 Enter 后,input 得到一段字符串,把它赋给变量,程序再继续下一行。光标停在问题后面不是卡住,而是在等你。
score = int(score_text) 会根据 score_text 产生整数新值并保存到 score。score_text 本身仍是字符串;类型转换不会把原变量原地改成另一种类型。
- int("860") 产生整数 860。
- float("42.5") 产生小数 42.5。
- 能够转换只说明文字格式正确,不代表数值一定符合任务范围。
本程序的输入规则
只输入数据本身,不要附带单位、中文引号或多余符号。
左右滑动表格,可查看完整内容
| 数据 | 本课规则 | 可以输入 | 不要输入 |
|---|---|---|---|
| 得分 | 不小于 0 的整数 | 860、0 | 860分、42.5、-1 |
| 生存时间 | 不小于 0 的数字 | 42.5、30、0 | 42.5秒、-1 |
清楚的提示说明内容、格式和单位
提示语要让输入者不看源代码也知道该做什么。至少说明数据名称;容易输错时再说明允许的格式、单位或用途,例如“生存时间(秒,只输入数字)”。
提示语末尾使用中文冒号能清楚分隔问题和输入。学生只输入数据本身,不输入单位、引号或说明文字;程序之后再负责清理和转换。
raw_name = input("请输入玩家姓名:")
player_name = raw_name.strip()
print(f"原始输入:[{raw_name}]")
print(f"清理结果:[{player_name}]")input 返回的原始字符串先交给 raw_name;strip 返回去掉两端空白的新字符串,再赋给 player_name。两者仍然都是 str。
"""练习3:观察input得到的数据类型,再完成整数和小数转换。
运行时请依次输入姓名、整数得分和不小于0的生存时间。
"""
# 第1步:程序会在每个input处暂停,输入内容并按Enter键后才继续。
player_name = input("请输入玩家姓名:")
score_text = input("请输入本局得分:")
survival_text = input("请输入生存时间(秒):")
# 第2步:先确认键盘输入的得分和时间目前都是字符串。
print("转换前 score_text 的类型:", type(score_text))
print("转换前 survival_text 的类型:", type(survival_text))
# 第3步:把整数得分转换成int,把可能带小数的时间转换成float。
score = int(score_text)
survival_seconds = float(survival_text)
# 第4步:再次查看类型。转换会产生新值,不会改掉原来的字符串。
print("转换后 score_text 的类型仍然是:", type(score_text))
print("转换后 survival_text 的类型仍然是:", type(survival_text))
print("转换后 score 的类型:", type(score))
print("转换后 survival_seconds 的类型:", type(survival_seconds))
print("玩家:", player_name, "得分:", score, "生存:", survival_seconds, "秒")
在资源管理器中新建 03_input_conversion.py,复制全部代码并保存。这个文件已经完整,可以独立运行。
观察三次暂停与转换前后类型
- 01
- 02
- 03
- 04
- 05
- 06
- 07
不改代码再输入一组数据
重新运行程序,依次输入小周、650、30,观察同一程序怎样处理另一组内容。
- score 的类型仍是 int。
- survival_seconds 显示 30.0,类型仍是 float。
- 能够区分“文字可以转换”和“数值符合任务范围”。
连接输入、转换、计算与输出
程序四:生成完整格式化结果卡
第四个程序把前面三次练习连成一条完整路线。每一步都依赖上一步:输入没有完成就无法转换,转换没有完成就无法计算,计算没有完成就没有最终结果。完整程序的数据路线
五个 input 先取得姓名、得分、时间、击杀和等级的字符串;int 与 float 产生数值;int、//、%、>= 完成时间和目标计算;print 与 f-string 最后显示结果卡。
f-string 在字符串前加 f,并用大括号放入变量。:.2f 让小数显示两位,:02d 让整数不足两位时左侧补 0;格式说明符只改变这一次怎样显示。
五项输入的顺序与规则
每个 input 都会暂停一次,只输入数据本身。
左右滑动表格,可查看完整内容
| 顺序 | 数据 | 类型与范围 | 正确输入 |
|---|---|---|---|
| 1 | 玩家姓名 | 简短字符串 | 小林 |
| 2 | 本局得分 | 不小于 0 的整数 | 18460 |
| 3 | 生存时间 | 不小于 0 的数字 | 81.5 |
| 4 | 本局击杀数 | 不小于 0 的整数 | 86 |
| 5 | 当前等级 | 大于 0 的整数 | 7 |
"""练习4:生成《星潮生存战》结果卡,并格式化显示计时。
请按“输入—转换—计算—输出”的顺序阅读代码。得分、击杀数和等级输入
整数,生存时间输入不小于0的数字。
"""
# 第1步:依次读取五项输入。程序会在每个input处暂停,得到的内容都是字符串。
player_name = input("请输入玩家姓名:")
score_text = input("请输入本局得分:")
survival_text = input("请输入生存时间(秒):")
kill_count_text = input("请输入本局击杀数:")
level_text = input("请输入当前等级:")
# 第2步:把需要参与计算的字符串转换成整数或小数。
score = int(score_text)
survival_seconds = float(survival_text)
kill_count = int(kill_count_text)
level = int(level_text)
# 第3步:把总秒数拆成完整分钟和剩余秒数,再比较是否达到个人目标。
total_seconds = int(survival_seconds)
minutes = total_seconds // 60
seconds = total_seconds % 60
reached_personal_goal = score >= 15000
# 第4步:格式说明符只改变显示形式,不改变变量中保存的值和类型。
print()
print("=== 星潮游戏结果卡 ===")
print(f"玩家:{player_name}")
print(f"本局得分:{score} 分")
print(f"原始生存时间:{survival_seconds:.2f} 秒")
print(f"计时显示:{minutes:02d}:{seconds:02d}")
print(f"本局击杀:{kill_count}")
print(f"当前等级:Lv.{level}")
print(f"达到个人15000分目标:{reached_personal_goal}")
在资源管理器中新建 04_game_result_formatter.py,复制全部代码并保存。这个文件已经完整,可以独立运行。
按完整执行路线阅读代码
- 01
- 02
- 03
- 04
类型转换、格式说明符与属性访问
三个写法外观相近,但改变的对象不同。
左右滑动表格,可查看完整内容
| 写法 | 正确名称 | 它改变什么 |
|---|---|---|
| int(...)、float(...) | 类型转换 | 产生另一种类型的新值 |
| :.2f、:02d | 格式说明符 | 只改变这一次怎样显示 |
| self.score | 属性访问 | 读取某个对象中保存的数据 |
运行两组完整游戏数据
- 01
- 02
- 03
- 04
- 05
- 06
下载四个程序的完整练习包
四段完整代码已经学习完毕。下载后解压,会得到“第02次_星潮结果卡与时间格式化”文件夹以及其中四个 Python 程序。
- 压缩包只包含本课四个 .py 文件。
- 解压后可以直接使用 VS Code 打开顶层文件夹。
- 代码内容与页面四个完整代码框一致。
用自己的数据生成一张结果卡
输入自己的姓名和一组符合规则的数据,先预测分:秒与目标结果,再运行确认。
- 五项输入都不带单位或引号。
- 能够解释每一次类型转换和计算。
- 能够指出格式说明符只改变显示形式。
把练习连接回完整游戏
回看游戏计时的数据转换
完整游戏把当前毫秒数转换为秒,再取得完整秒数,最后拆成分钟和剩余秒数。本课只阅读已经学过的顺序代码,不展开对象、def 与 return。elapsed_ms = 102000.0
elapsed_seconds = elapsed_ms / 1000.0
total_seconds = int(elapsed_seconds)
minutes = total_seconds // 60
seconds = total_seconds % 60
print(f"{minutes:02d}:{seconds:02d}")从上到下阅读每一行:除以 1000 得到秒,int 取得完整秒,// 与 % 拆分时间,:02d 控制显示。
从毫秒到分:秒的六步路线
每一步都使用上一行刚产生的值。
左右滑动表格,可查看完整内容
| 步骤 | 当前值 | 发生的变化 |
|---|---|---|
| 1 | 102000.0 毫秒 | 保存当前毫秒数 |
| 2 | 102.0 秒 | 除以 1000.0 |
| 3 | 102 完整秒 | int 产生整数新值 |
| 4 | 1 分钟 | 102 // 60 |
| 5 | 42 秒 | 102 % 60 |
| 6 | 01:42 | :02d 补足两位 |
预测 81500 毫秒的显示结果
把第一行改为 elapsed_ms = 81500.0。先不用运行,沿六步路线写出每一步的值,再复制代码确认。
- 81500.0 / 1000.0 得到 81.5。
- int(81.5) 产生完整秒数 81。
- 最终显示 01:21。
先读最后一行,再回到出错位置
读懂并处理四类常见错误
终端出现错误时先保留信息:看最后一行的错误类型,再向上找到文件名和行号,回到对应代码修改、保存并重新运行。print("hello"下面这行代码没有闭合 print 的圆括号。Python 会提示 SyntaxError,并指出左括号没有闭合。
补齐右括号
- 01
print("玩家:小林)下面的双引号只有开头,没有结尾。Python 无法判断字符串在哪里结束,因此在执行任何输出前就会停止。
先用语法高亮找到未闭合引号
把错误代码放入临时文件,观察引号之后的颜色是否异常,再运行并阅读 SyntaxError。补上结束引号后重新运行。
- 指出字符串从第一个双引号开始。
- 在右括号前补上英文双引号。
- 重新运行后看到“玩家:小林”。
print(scoree)scoree 没有在前面赋值,而且很可能是 score 的拼写错误。
改正变量名拼写
- 01
score = int("abc")abc 不是整数数字,因此 int 无法根据它产生整数。
找到不能转换的原始文字
- 01
result = "得分:" + 860
print("得分:", 860)字符串和整数不能直接使用 + 相加。本课可以把它们分别交给 print。
确认参加运算的两种类型
- 01
四类错误的处理入口
先确定类型,再只修改与它有关的位置。
左右滑动表格,可查看完整内容
| 错误类型 | 本课常见原因 | 下一步 |
|---|---|---|
| SyntaxError | 括号或引号没有成对 | 回到行号附近补齐对应的结束符号 |
| NameError | 变量名拼错或在赋值前使用 | 对照定义处的拼写与顺序 |
| ValueError | 文字不符合目标数字格式 | 只输入能够转换的数字部分 |
| TypeError | 把不适合直接运算的类型放在一起 | 用 type 确认类型后改变写法 |
完成一次错误恢复
从四个临时代码中选择一个,先运行看到错误,再按页面方法修改、保存并重新运行。完成后删除临时错误文件。
- 能够从最后一行说出错误类型。
- 能够根据文件名和行号回到对应代码。
- 修改后重新运行成功,不把错误窗口直接关闭。
把分散知识连成完整路线
串联四个程序并补全游戏摘要
前四个文件彼此独立,每条命令都会让 Python 从所选文件的第一行重新开始。依次运行并理解它们后,再根据半成品代码骨架补全自己的游戏摘要。python 01_game_result_card.py
python 02_expression_lab.py
python 03_input_conversion.py
python 04_game_result_formatter.py前一个程序结束、终端重新出现提示符后,再输入下一条命令。
确认四个程序都能独立运行
- 01
四个程序各自完成什么
每个文件只集中解决一组新问题。
左右滑动表格,可查看完整内容
| 程序 | 关键知识 | 完成标志 |
|---|---|---|
| 01_game_result_card.py | 变量、四种类型、+= | 更新后的得分为 980 |
| 02_expression_lab.py | 算术、比较、运算顺序 | 15200、2 分 5 秒、True |
| 03_input_conversion.py | input、int、float | 原输入仍是 str,新值为 int 与 float |
| 04_game_result_formatter.py | 完整数据流与格式化 | 能够生成两组完整结果卡 |
第五个程序 05_my_game_summary.py 的文件结构
先看清文件结构,再复制后面的起步骨架。骨架会帮你建立输入和分步检查的位置,清理、转换、计算与 f-string 显示仍由你完成。
左右滑动表格,可查看完整内容
| 顺序 | 要完成的内容 | 完成标准 |
|---|---|---|
| 1 | 模块文档字符串 | 说明文件用途和需要输入的数据 |
| 2 | 输入与清理 | 姓名先保存原始输入,再用 strip 得到清理后的字符串 |
| 3 | 类型转换 | 至少把一项数字文字转换为 int 或 float |
| 4 | 计算 | 使用转换后的数值完成至少一次算术或比较 |
| 5 | 显示 | 使用 f-string 输出姓名、输入数据和计算结果 |
| 贯穿文件 | 有意义的变量名与注释 | 变量使用 snake_case,注释解释目的、原因或限制 |
"""请在这里用一句话说明这个程序的用途。"""
# 固定奖励单独保存,调整规则时只需要修改这一处。
BONUS_SCORE = 200
# 保留原始输入,便于比较清理前后的状态。
raw_name = input("请输入玩家姓名:")
# 请补全 1:使用能同时清理两端空白的字符串方法,生成 player_name。
# 完成后临时取消下一行开头的 #,观察方括号是否紧贴姓名。
# print(f"清理后姓名:[{player_name}]")
score_text = input("请输入本局得分(整数,只输入数字):")
# 请补全 2:把 score_text 转换为整数,保存到 score。
# 完成后临时取消下一行开头的 #,确认类型是 int。
# print(type(score))
# 请补全 3:计算 score + BONUS_SCORE,保存到 final_score。
# 完成后临时取消下一行开头的 #,输入 800 时应显示 1000。
# print(final_score)
print("=== 我的游戏摘要 ===")
# 请补全 4:用一条 f-string 显示 player_name、score 和 final_score。把骨架复制到 05_my_game_summary.py。本练习约定:完成额外挑战后固定获得 200 分奖励。以 # 开头的四条“请补全”是学习提示,Python 会把它们当作注释跳过,所以骨架可以先运行,再逐条补全。
每补全一步,就运行一次
- 01
新建 05_my_game_summary.py,复制骨架,先把第一行三引号里的文字改成文件用途。第一次运行时会依次询问姓名和得分,最后只显示摘要标题;这说明骨架已经正确运行,内容还没有补完。
- 02
完成“请补全 1”:回到“常用字符串方法”表,找到能同时清理两端空白的方法,让 player_name 保存清理后的新字符串。取消姓名检查行开头的 #,运行时先按两次空格键、输入小林、再按两次空格键;如果显示“[小林]”,说明清理成功。确认后把检查行重新变回注释。
- 03
完成“请补全 2”:input 得到的是 str,要选择能把整数文字转换为 int 的函数,让 score 保存转换结果。取消类型检查行开头的 #;如果显示 <class 'int'>,说明可以继续。确认后把检查行重新变回注释。
- 04
完成“请补全 3”:让 final_score 保存奖励前得分与 BONUS_SCORE 的和。取消得分检查行开头的 #,输入 800;如果显示 1000,说明计算正确。确认后把检查行重新变回注释。
- 05
完成“请补全 4”:先写 print(f""),在引号中写“玩家”“本局得分”“奖励后得分”等固定文字,再把三个已有变量分别放进一对花括号。在一条 f-string 中可以使用多对花括号。
- 06
最后再写一条自己的 # 注释,说明固定奖励为什么单独保存。运行成功后,从第一行开始说明 BONUS_SCORE、raw_name、player_name、score_text、score 和 final_score 怎样依次建立并参与显示。
补全并检查 05_my_game_summary.py
完成骨架中的四条关键语句后,从终端运行 python 05_my_game_summary.py。用下面两组数据检查清理、转换、计算和显示是否都真正生效。
- 第一组姓名:先按两次空格键,输入小林,再按两次空格键,不输入引号;得分输入 800。姓名检查行应显示“[小林]”,最终摘要中的本局得分是 800,奖励后得分是 1000。
- 第二组姓名输入小周,得分输入 1200:摘要内容随输入改变,奖励后得分是 1400。
- 文件第一条语句是自己改写的模块文档字符串,后面至少有一条自己写的 # 注释,用来解释目的、原因或限制。
- 所有变量名合法、清楚,不覆盖 print、input 或 type。
- 姓名输入先保存原始字符串,再使用 .strip() 得到清理后的新值。
- 至少完成一次类型转换、一次计算和一次 f-string 输出。
- 能够按“输入 → 清理 → 转换 → 计算 → 显示”逐行说明执行顺序和变量状态变化。
- 在终端当前位置确认文件存在,运行成功后保存一份自己能解释的输出。
用一句话复述完整数据流
从键盘输入开始,依次说出清理后的字符串、数值、表达式、布尔值和格式化显示之间的关系。
- 能够指出 input 直接得到 str。
- 能够说明字符串方法返回清理后的新字符串。
- 能够说明 int 与 float 产生数值新值。
- 能够说明算术与比较表达式怎样产生结果。
- 能够说明 f-string 和格式说明符怎样显示最终结果。
把知识变成作品
本课练习
请按顺序完成以下任务,并保存自己的学习成果。- 01
把一组数字开头、带空格、使用关键字或覆盖内置函数的名字改成清楚的 snake_case 变量名。
- 02
在独立观察文件中比较单引号、双引号、三引号、转义字符、字符串拼接与重复,并说明文档字符串和 # 注释的区别。
- 03
使用 title、upper、lower、strip、lstrip、rstrip 和 removeprefix 处理字符串,分别显示原值与新值。
- 04
不看运行结果,先预测程序一的四种类型和更新后的得分,再运行确认。
- 05
为程序二选择一组新的秒数与击杀数,手算表现分、分:秒和目标结果。
- 06
使用自己的姓名运行程序三,解释转换前后四个变量的类型。
- 07
使用两组不同数据运行程序四,保存自己能够解释的完整结果卡。
- 08
选择一种常见错误,完成“读错误类型 → 找到行号 → 修改 → 保存 → 重新运行”的恢复过程。
- 09
根据代码骨架补全 05_my_game_summary.py,并按“输入 → 清理 → 转换 → 计算 → 显示”解释代码。
把本课进度保存下来
登录后可以保存浏览内容、有效学习时间、完成状态和答题参与记录。







































