Python顺序结构入门：从逐行执行到实战案例，给初学者的核心基础课

很多初学Python的人，装好环境、打出第一行“Hello World”之后，就开始四处找教程，今天看变量、明天看循环、后天又跑去学函数，结果越学越乱，最后连一个最简单的程序都写不利索。我带的学员里，十个有八个卡在这个阶段。问题不在智商，也不是不够努力，而是缺了一个最基础的东西——理解程序到底是怎么“一条一条”跑起来的。顺序结构讲的就是这件事。它是Python乃至几乎所有编程语言最底层的执行逻辑：代码从上到下、逐行执行，一行跑完才轮到下一行。听起来太简单了？但正是这个“太简单”的规则，决定了你后面写分支、写循环、写函数时能不能顺理成章地理解程序的控制流。这篇文章会从顺序结构的本质讲起，把变量、赋值、注释、缩进、输入输出这些基础串起来，再带着你完整地跑几个实操案例，最后把初学者最容易踩的坑一次性说清楚。不管你是零基础想入门，还是学过一阵子但总觉得基础不牢，这篇都值得你认真过一遍。

1. 顺序结构到底是什么——先别急着写代码，想清楚这件事

1.1 从生活流程到程序执行

顺序结构不是编程独有的概念。你做一道番茄炒蛋，先洗番茄、再切番茄、然后打鸡蛋、开火热油、下锅翻炒，最后装盘——这就是一个顺序流程。如果中间哪一步颠倒了，比如先开火热油再去洗番茄，锅可能就烧坏了。写程序也一样，本质上是在把“做事的步骤”翻译成计算机能理解的语言，翻译完之后，计算机就严格按照这些步骤从头到尾依次执行。

我经常跟学员打一个比方：程序就像一张菜谱，计算机就像一个从来没有下过厨房的助手。它不会自己发挥，不会跳过步骤，更不会在你写错步骤的时候帮你补救。你写“先放油”，它就放油；你写“再放盐”，它就放盐。顺序结构的核心就是这种“按部就班、严格执行”的机制。

放到Python里，顺序结构表现为：解释器从代码的第一行开始，逐行向下执行，直到最后一行结束。中间没有跳转，没有条件判断，没有循环。这个执行模型是所有程序的地基——哪怕你以后写出几百上千行代码，最终分解到最底层，依然是一个又一个顺序执行的步骤组合起来的。

1.2 Python为什么天然就是顺序执行的

Python是一门“解释型”语言，代码不需要预先编译成机器码，而是由解释器一行一行地读取、一行一行地执行。你可以打开Python交互式环境（REPL），输入一行代码回车，它会立刻给你结果；再输入一行，又立刻执行。这种逐行交互的特性，让“顺序执行”变得特别直观。

但在写.py文件的时候，很多人反而会忽略这一点。我在实际教学里见过太多次这样的情况：有人写了一段代码，运行后发现结果不对，随手就把某一行的位置调换了一下，结果居然对了。他不知道为什么，只觉得“瞎调调就好了”。其实背后就是顺序结构在起作用——两个操作之间如果有数据依赖关系，谁先谁后直接决定了结果的正确性。

比如说：

a = 10 b = a + 5 print(b)

这没有问题，输出15。但如果把第一行和第二行调换：

b = a + 5 a = 10 print(b)

运行会直接报错：NameError: name 'a' is not defined。因为解释器执行第二行的时候，a还没有被赋值，它根本不知道a是什么。这个例子极其简单，却精准地说明了顺序执行的核心规则：上面没定义的东西，下面不能用。

很多人一开始不适应这种“线性思维”，总觉得自己写的代码应该可以“随意组合”。但计算机就是这样一个死心眼的执行者，它不会替你排序。理解这一点，是写对程序的第一个前提。

1.3 顺序结构在编程体系中的位置

计算机科学家早就总结过，无论多复杂的程序，控制结构只有三种：顺序结构、选择结构（if/else）、循环结构（for/while）。顺序结构是其中最基础、最不起眼的一个，但恰恰是最重要的那一个。

为什么？因为选择结构和循环结构本质上也是顺序执行的。if语句里，先执行条件判断，再根据结果决定执行哪个分支——条件判断和分支执行之间是顺序关系。循环也一样，先判断条件、再执行循环体、再回去判断条件，每一步都是顺序发生的。换句话说，有了顺序结构这个底盘，选择结构和循环结构才能“长”在上面。

所以我一直建议初学者：不要急着背各种高级语法，先把顺序结构吃透。如果你能闭着眼睛说清楚“我写的每一行代码在什么时机被执行、它是基于哪个之前的结果”，那你学后面章节的速度会快很多。反之，如果顺序结构这种最基本的执行模型都没建立起来，学分支和循环就像在一个没有地基的房子里加楼层，迟早要塌。

2. 写代码前的必备基础：变量、赋值、注释与缩进

2.1 变量就是给数据贴标签

进入顺序结构实操之前，有几个基础概念必须先摆清楚。第一个是变量。

先做一个人体实验：请你心里记住一个数字。好了，你记住它了吗？那个数字此刻就“存”在你的脑子里。如果我想让你把那个数字告诉我，你会怎么说？要么直接报出数字，要么说“我心里想的那个数”——后者就是一种“命名引用”。变量在Python里做的事情，本质上就是这个：给数据起一个名字，之后用这个名字来引用这份数据。

price = 99 count = 3 total = price * count print(total)

这里price、count、total就是变量。等号右边的99和3是数据，等号的作用是把数据“绑定”到变量名上。执行print(total)时，Python会顺着total这个名字找到它绑定的数据，然后打印出来。

很多入门教材会强调“变量就像盒子，赋值就像往盒子里放东西”。这个类比基本可用，但有一个细节需要注意：Python的变量不是“盒子”，更像是“标签贴纸”。当你执行total = price * count时，并没有把计算结果“复制”一份新的存进盒子，而是把total这个标签贴到了计算结果这个对象上。这个区别在后续学列表、字典、对象时会变得非常重要，但在顺序结构阶段，你只需要记得：变量名指向数据，赋值就是建立这种指向关系。

变量命名也有讲究。Python推荐用“小写字母加下划线”的风格，比如student_name、order_total，而不是studentName。名字要尽量“见名知意”。我批改作业时经常看到有人写a=1、b=2、c=3这类命名，程序一长就完全看不懂谁是谁了。变量名不是给计算机看的，是给你自己和其他读者看的——命名清晰，本身就是代码质量的一部分。

2.2 赋值运算的本质和常见误区

说一个我几乎每次上课都要强调的点：在Python里，等号=不是数学里的“等于”，而是“赋值”。这是初学者最容易绕不过去的弯。

数学里，“x = x + 1”是永远不成立的等式；但在程序里，这行代码极其常见，它的含义是：先取出当前x的值，给它加上1，再把新的结果赋给x。换句话说，等号右边的表达式先被计算，算完之后，结果才被“绑定”到等号左边的变量名上。

count = 0 print(count) # 0 count = count + 1 print(count) # 1

这个例子展示了一个标准的数据流方向：从右往左流动。右边先执行，左边接收结果。这一点理解透了，你在顺序结构中写多行赋值时就不会犯迷糊。

另外还有一种“链式赋值”和“多元赋值”也常被初学者碰到：

# 链式赋值：多个变量指向同一个数据 a = b = c = 0 # 多元赋值：一行里给多个变量分别赋值 x, y, z = 1, 2, 3

第二种写法非常实用，尤其是后面要讲到的“交换两个变量”的经典场景，Python可以用x, y = y, x一行搞定，没有任何中间变量。这是Python相对其他语言的语法便利，但也会让刚接触的人觉得不好理解。我的建议是：刚开始不要急着用花哨写法，老老实实写三行赋值，等你对赋值语义有了肌肉记忆，再慢慢用这些简化写法。

2.3 注释：写给未来的自己

顺序结构程序一般不长，很多新手觉得注释可有可无，反正代码就那几行，谁都看得懂。这个想法劝你尽早改掉。

注释是写给阅读代码的人看的，而“那个人”最可能是一个月后的你自己。我见过不少学员，写完一个小程序放几天，再回头根本想不起当时某段逻辑是干什么的。这时候如果有注释，恢复上下文的速度会快得多。

Python的注释分两类。单行注释用#，从#开始到这一行结束的部分都会被忽略；多行注释用三个引号（单引号和双引号都可以）包起来，常用于模块开头的说明文档。

# 这是单行注释 """ 这是多行注释， 可以写很长的说明文字。 """

实际写代码时，注释要写“为什么”，不要写“是什么”。举个例子：

# 用中间变量交换，避免数据丢失 temp = a a = b b = temp

这里的注释说明了意图——“为什么”要用中间变量。而如果你写“把a的值赋给temp”，那就是废话，因为代码本身已经表达了这个意思。

还有一个实用习惯：在调试的时候，临时把某一行代码“注释掉”而不是删除。改到一半发现还是原来的写法更好，取消注释就恢复了。这也是注释的一个高频用途。

2.4 缩进：Python的格式即语法

顺序结构的代码，每一行顶格写就行。那为什么还要专门讲缩进？因为缩进是Python最重要的视觉特征，而且它直接参与语法规则。

其他很多语言用花括号{}来划分代码块，但Python用缩进表示代码的嵌套层次。虽然你目前在顺序结构里可能感受不到，因为顺序结构的代码都在同一层，但如果你习惯了不缩进或者缩进随意，后面学if和for时会立刻翻车。

# 这是顺序结构的正常写法，所有代码顶格 print("第一行") print("第二行")

一旦你写了缩进，却没有任何需要缩进的语法结构，Python会报错：

print("第一行") print("第二行") # 这里多打了四个空格

报错信息是IndentationError: unexpected indent，意思就是“意外的缩进”。新手看到这个错误容易懵，心想“我多打了几个空格怎么了”，但在Python眼里，缩进就是语法的一部分，多退少进都不行。

建议你在编辑器里统一用4个空格表示一级缩进，并且不要混用Tab和空格。很多代码编辑器（比如常见的VS Code、PyCharm）默认都会帮你处理这些事情，但如果你用的编辑器不那么智能，就要特别注意。这个问题我现在打预防针，等你学到分支循环那一章，就知道我为什么反复强调它了。

3. 输入输出：让程序和用户对话

3.1 print输出的三种格式化方式

顺序结构的程序如果没有输出，就像一个人自言自语完了却没人听到。print函数是Python最基础、最常用的输出工具，但越基础的东西越值得仔细打磨。

print最简单的用法就是输出一个值：

print("你好，世界")

进阶一点，print可以同时输出多个值，中间用逗号分隔，默认会以空格隔开：

name = "张三" age = 25 print(name, age) # 张三 25

还可以指定分隔符和结尾符：

print("苹果", "香蕉", "橙子", sep="、") print("第一行", end="") print("第二行")

第一个例子会输出“苹果、香蕉、橙子”，第二个例子把默认的换行结尾改成了空字符串，第二句会和第一句接在同一行。这两个参数在实际写小工具时非常有用，先记住有这回事就行。

更常用的是把变量值拼接到一段话里输出。Python里主要有三种方式，我按出现顺序讲：

name = "李四" score = 92 # 方式1：百分号格式化（老风格） print("同学%s的分数是%d" % (name, score)) # 方式2：format方法 print("同学{}的分数是{}".format(name, score)) # 方式3：f-string（推荐） print(f"同学{name}的分数是{score}")

我建议你直接学第三种，f-string。理由很实在：最简洁、可读性最好、也是目前社区的主流写法。前缀f表示这个字符串里可以用花括号嵌入变量或表达式，Python会自动把它们的值转为字符串再插入。它还支持格式说明符，比如控制小数位数：

pi = 3.1415926 print(f"圆周率约等于{pi:.2f}") # 圆周率约等于3.14

这里.2f的意思是“保留两位小数”。这个写法在后面的量化计算、数据展示章节里用得非常频繁，建议现在就开始习惯。

3.2 input隐藏的大坑：字符串陷阱

有输出就有输入。input函数用来从键盘读取用户输入，但这里的坑比print大得多，几乎所有初学者都在这里栽过跟头。

age = input("请输入你的年龄：") print(f"你输入的年龄是：{age}")

运行没问题，输出也没问题。但如果你接着做运算：

age = input("请输入你的年龄：") next_year_age = age + 1 print(f"明年你{next_year_age}岁")

会直接报错：TypeError: can only concatenate str (not "int") to str。原因很简单：input返回的一定是字符串，哪怕你输入的是数字“18”，它拿到的也是字符串“18”，不是数字18。字符串和整数相加是没有定义的操作，所以Python直接报警。

解决办法就是做类型转换。int()可以把纯数字字符串转成整数，float()可以转成浮点数：

age = int(input("请输入你的年龄：")) next_year_age = age + 1 print(f"明年你{next_year_age}岁")

我给初学者的建议是：**只要用input输入的数字需要参与数学运算，就立刻在接收时完成类型转换。**不要拖到后面再转，那样容易漏掉。从编码习惯上，一行代码写成age = int(input(...))，读起来也非常清晰：先把读到的内容转成整数，再绑定到变量age上。

另外提醒一句，int()只能处理看起来像整数的字符串，比如“18”。如果你输入“18.5”，int(“18.5”)会报ValueError；如果输入“abc”，同样报ValueError。这个问题在后面章节会讲怎么优雅处理，但顺序结构阶段，你只需要确保用户输入的是正常数字就行。

3.3 一个完整的输入输出小案例

把这节内容串起来，写一个稍微完整的小程序：问用户姓名和年龄，然后输出一条个人信息。

name = input("请输入你的姓名：") age = int(input("请输入你的年龄：")) print("========== 个人信息 ==========") print(f"姓名：{name}") print(f"年龄：{age}") print(f"十年后你将{age + 10}岁") print("==============================")

运行示例：

请输入你的姓名：王小明 请输入你的年龄：20 ========== 个人信息 ========== 姓名：王小明 年龄：20 十年后你将30岁 ==============================

不要小看这个程序。它完整地展示了顺序结构程序的编写流程：接收输入、处理数据、输出结果。这个模式是你以后写任何交互式程序的原型。

我特别说一下流程设计的思路：第1-2行先获取输入；第4行输出一行分隔线；第5-6行输出记录本身；第7行根据年龄做一个简单的计算再输出；第8行再输出一条分隔线。可以看到，程序执行的过程就是一步步把用户输入转成输出内容的过程，没有任何跳转。这就是顺序结构的典型节奏——先准备数据，再处理数据，最后呈现结果。如果某一步的数据还没准备好就用了它，程序就会崩，这也呼应了第一节强调的“数据依赖”问题。

4. 顺序结构的实操主战场：从算术到逻辑流程

4.1 基本运算与优先级

顺序结构很多时候是在做“管道式”的数据加工：原始数据进来，经过一系列运算，得到最终结果。这一节我们集中看Python的算术运算和它们之间的优先级规则。

Python支持加减乘除和几个特殊的运算：

这里最需要留意的是/和//的区别。在很多编程语言里，整数除以整数得到的是整数，但Python的/是真正的除法，永远返回浮点数。这个设计让Python在数据处理上很省心，但新手往往会疑惑“为什么7/3不是2”。如果你想要整数结果，就明确用//。

运算优先级跟数学里的规则一致：先乘方、再乘除、后加减，括号可以改变优先级。建议复杂的算数表达式适当加括号，不是为了改变优先级，而是为了让人一眼看懂。比如：

# 原本的含义可能是每秒x个，跑了y分钟，算总个数 total = count * 60 * minutes # 如果你非要写成一行复杂形式 total = count * times * 60 / speed

类似这种表达式，加不加括号在计算机看来没区别，但在人看来区别很大。我见过太多“一行长公式”的作业代码，出了bug需要逐个数运算符才能找到问题。代码最终是给人读的，别吝啬几个括号。

另外要提一个很基础的规则：字符串也可以用+和*操作。+用于拼接字符串，*用于重复字符串。这个特性在生成简单文本时很好用：

print("=" * 20) # 输出20个等号

这行代码不算复杂，但很实用，很多小程序用它来画分隔线。

4.2 经典实战：交换两个变量的值

顺序结构有一个历史悠久的经典题目：有两个变量a和b，请交换它们的值。这个题目看似小儿科，但它能很好地检验你是否有“数据流”意识。

最直观的思路是用一个临时变量：

a = 10 b = 20 temp = a # 先把a的值存到temp a = b # 再把b的值赋给a b = temp # 最后把temp里存的a原值赋给b print(a, b) # 20 10

这个方案的关键在于temp变量。为什么需要temp？因为执行a = b之后，a原来的值10已经被覆盖了，如果不事先存在别处，后面b需要这个10就找不回来了。这正是顺序结构里“变量的值随时可能被覆盖”的一个重要提醒。

利用之前提到的多元赋值，Python还有一个更优雅的版本：

a = 10 b = 20 a, b = b, a print(a, b) # 20 10

这行a, b = b, a表面上看很魔法，实际理解起来也不难：先同时把右边b和a的值读出来，再按顺序赋值给左边的a和b。“同时”这两个字是关键，它绕过了临时变量的覆盖问题。

作为入门阶段的建议，我推荐你先学会第一种临时变量的写法，因为它的每一步都非常明确，容易跟执行流程对应上。等你不假思索地理解temp在这里的作用后，第二种写法自然就能接受了。

4.3 经典实战：摄氏度和华氏度互转

学编程最爽的时刻，就是发现自己写的代码能解决真实世界的小问题。温度转换就是这类问题。

公式是：华氏度 = 摄氏度 * 9 / 5 + 32。

celsius = float(input("请输入摄氏温度：")) fahrenheit = celsius * 9 / 5 + 32 print(f"{celsius} 摄氏度 = {fahrenheit} 华氏度")

运行示例：

请输入摄氏温度：100 100.0 摄氏度 = 212.0 华氏度

注意这里我用了float而不是int，因为温度很可能带小数。什么时候用int、什么时候用float？规则是：如果你处理的数据有可能出现小数，就用float；如果确定是整数（比如人数、年龄取整），就用int。养成这个习惯之后，可以少踩很多类型转换的坑。

这个程序还能继续延伸：做反向转换，从华氏度转回摄氏度。公式是：摄氏度 = (华氏度 - 32) * 5 / 9。让用户选择转换方向就需要用到后面章节的分支结构了，在顺序结构阶段，你可以写两个独立的小程序，一个负责单向转换。或者说，你可以在同一个程序里写两次转换：

celsius = float(input("请输入摄氏温度：")) fahrenheit = celsius * 9 / 5 + 32 print(f"{celsius:.2f} 摄氏度 = {fahrenheit:.2f} 华氏度") fahrenheit2 = float(input("请输入华氏温度：")) celsius2 = (fahrenheit2 - 32) * 5 / 9 print(f"{fahrenheit2:.2f} 华氏度 = {celsius2:.2f} 摄氏度")

两段转换逻辑一前一后，各自是独立的顺序流程。这就是顺序结构最朴素的组织方式——一件事情做完，再做下一件事情。等学了循环和函数，你可以把重复的部分抽象出来，但那都是后话，当前阶段把线性流程写清楚更重要。

4.4 经典实战：用海伦公式求三角形面积

最后一个实战案例，稍微有点数学含量：已知三角形三条边a、b、c的长度，求它的面积。

海伦公式是：面积 = sqrt(p * (p - a) * (p - b) * (p - c))，其中p是半周长，即p = (a + b + c) / 2。

a = float(input("请输入边长 a：")) b = float(input("请输入边长 b：")) c = float(input("请输入边长 c：")) p = (a + b + c) / 2 area = (p * (p - a) * (p - b) * (p - c)) ** 0.5 print(f"三边长分别为 {a}、{b}、{c}") print(f"三角形面积为：{area:.2f}")

这里用了**0.5来表示开平方，因为0.5次方就是平方根。也可以导入数学模块用math.sqrt，但那是下一个章节的内容。用幂运算是顺序结构阶段就能搞定的做法。

运行示例：

请输入边长 a：3 请输入边长 b：4 请输入边长 c：5 三边长分别为 3.0、4.0、5.0 三角形面积为：6.00

3、4、5是典型的直角三角形，面积正好是6，结果没错。

这个程序完美展示了一个顺序结构的完整链路：定义输入、计算半周长、代入公式、输出结果。每一步都依赖前一步的产出，一环扣一环。可能有人会问，如果输入的三条边根本构不成三角形怎么办？程序会算出面积是个负数，然后开方出错。这确实是个bug，但修复它需要条件判断，也就是下一个章节的事了。我特意留这个坑在这里，就是想让读者体会到：顺序结构擅长处理“直来直去”的计算任务，一旦涉及“根据不同情况做不同处理”，就得正式引入选择结构了。这个过渡是非常自然的学习路径。

5. 初学者最容易踩的坑与排查方法

5.1 三大高频报错速查表

顺序结构阶段的代码量不大，但报错类型非常集中。我把教学中出现频率最高的几个错误整理成表格，遇到问题可以先对照。

第三类和第五类错误中，有一个隐藏得很深的坑，我一定要单独拎出来说：中英文标点混用。中文输入法下的括号（）、引号“”、逗号，跟英文输入法下的()、""、,长得非常像，但Python只认英文标点。我见过一个学员排错排了半小时，最后发现是input("请输入你的年龄：")这行里的冒号是中文冒号“：”。这种错误尤其容易发生在中文和英文混打的场景里，解决办法只有一个：写代码时把输入法切到英文模式。这个习惯比任何技巧都重要。

5.2 程序逻辑错误的排查思路

语法报错其实不可怕，因为Python会精确告诉你错误在第几行。真正让人头疼的是“程序不报错，但结果就是不对”。这种逻辑错误在顺序结构阶段同样很常见，而且因为代码不长，很多人反而不知道从哪里开始查。

我总结了一套在顺序结构阶段非常实用的排查思路。第一步，逐行阅读代码，模拟计算机的执行过程，用纸笔或者直接在脑子里跟踪每个变量的值。第二步，在关键节点用print把中间结果打印出来，看是否跟预期一致。第三步，如果某个中间结果不对，就锁定问题出在它之前的那几条语句上，缩小范围。

举个例子。有个学员写了个根据单价和数量求总价的小程序，但结果总是多了一倍：

price = 10 count = 5 discount = 0.8 total = price * count * 2 # 这里多乘了一个2 print(total)

代码不报错，但80输出成了160。如果用print把price、count、discount都分别打出来看，会发现每个变量都对，那问题一定出在计算公式上。这时候只要检查total这一行的表达式，很快就能发现多乘了一个2。

顺序结构程序的逻辑链很短，如果结果不对，问题几乎总出在这几个地方：变量赋值顺序颠倒、类型转换错误、计算公式抄错、变量名写错导致取到了旧值。排查逻辑错误时，把这四个方向全部过一遍，绝大多数问题都能解决。

5.3 两个值得长期坚持的调试习惯

这一节我想分享两个不依赖任何调试工具、但能让你受用很久的习惯。

第一个习惯是“小步快跑”。不要一次性写完十几行代码再运行。每次写三五行，就运行一次，确认结果符合预期，再继续往下写。这样做的好处是，一旦出错，错误大概率就藏在你最近写的那几行里，排查范围极小。很多初学者喜欢一口气把整个程序写完再运行，结果一堆错误叠在一起，报错信息互相干扰，越改越乱。

第二个习惯是“临时print大法”。虽然现代IDE都带有断点调试功能，但对初学者来说，最常见的调试方式依然是在可疑的位置加print，把变量的当前值打出来，看完再删掉。这个办法土，但非常有效。关键是记得调试完要把临时print删掉，不然程序输出里会混入调试信息，显得很不专业。我在批改作业时经常看到有人在最终代码里留着调试用的print，这些残渣会让你的代码观感大打折扣。

有些新手会觉得“会调试”很高级，其实调试很大程度上就是“把执行过程摊开来看”。顺序结构执行的本质就是一行一行往下走，你在中间插入print，就相当于把运行过程慢放，所有细节暴露无遗。等后面学了复杂的库，还可以用日志库、调试器做更精细的事情，但最底层的思维方式和临时print是一样的。

6. 写给初学者的下一步建议

顺序结构这一章的内容，到这里就完整过了一遍。但在收尾之前，我想跟你聊聊“接下来怎么练”这件事。入门阶段最容易犯的错误是“看懂了就觉得自己会了”。看懂别人写的代码和亲手写出能跑的代码，完全是两回事。顺序结构的内容虽然简单，但它是你写出的第一个“完整程序”的起点，值得你亲手搭建。

我的建议是，把下面这几个练习自己做一遍，做完再对照上面的案例检查。不要边看答案边写，尽量凭记忆和理解先独立完成：第一个，输入一个两位数，把它的个位和十位交换后输出，比如输入35，输出53。第二个，输入圆的半径，输出周长和面积，圆周率取3.14159。第三个，输入三个人的语文、数学、英语成绩，分别求出每个人的总分和平均分。第四个，把摄氏温度转华氏温度的例子改成带格式化输出，确保小数部分只显示一位。

这四个练习覆盖了本章的大部分知识点：输入、类型转换、算术运算、格式化输出、顺序组织。做完之后，你就能比较明确地判断自己是不是真的掌握了顺序结构。

如果练习中某个环节卡住了，回头翻一翻这一章对应的部分。尤其要提醒的是，不要跳过“类型转换”这个看起来很小的知识点。后面学列表、字典、函数时，你还会反复跟它打交道。顺序结构阶段把input返回字符串、int和float的转换规则吃透，会给你省下很多麻烦。

我个人在实际教学里有个体会：顺序结构学得好的人，写出来的代码有一种难得的“干净感”——变量从定义到使用井井有条，计算过程一目了然，输入输出前后呼应。这种干净感不是天生的，就是靠一遍遍练习、一次次排查练出来的。这一章只是一个开始，但当你能把最简单的顺序结构写稳写顺，后面学习分支和循环时，你会明显感觉自己站得更稳。