Python 代码速读指南
Python 代码速读指南
这是笔者在教舍友期末速通python时想到的极速学习法，顺序和思路与市面上常见的有些差异。本文试图从解释器解释代码的角度教会你python的基础语法和应用。AI参与。
欢迎！这份指南将尝试在最短的时间内教会你读懂 Python 代码，甚至撰写简单的代码。
Python 代码速读指南 (零基础版)欢迎来到编程世界！别怕，读代码就像学一门新的语言，只不过你的交流对象是电脑。这份指南将教你这门语言最核心的语法规则。
我们的秘诀是：揭开"语法糖"的神秘面纱。
什么是"语法糖" (Syntactic Sugar)？
想象一下，你对朋友说"给我来杯咖啡"，他立刻就明白了。你不需要说："请你站起来，走到咖啡机前，拿起杯子，按下'意式浓缩'按钮，等待咖啡流出..."。
"给我来杯咖啡"就是语法糖，它是一种简洁、方便的说法。编程语言里的很多语法也是如此，它们是方便程序员书写的"简写"，但电脑在执行时，会把它们翻译成最原始、最基础的一步步指令。
电脑执行代码时，就像一个严格遵循"指令清单"的电脑，一步一步往下走，绝不跳步，除非接到"跳转"指令。
所以，代码的核心本质是给电脑的"指令清单" 。
学习目标：理解这些"简写"背后，电脑究竟在做什么。这样，你就能读懂任何基础的 Python 代码了。
第一章：电脑如何存储信息？—— 变量与数据类型
电脑的大脑里有很多带标签的空盒子，这就是变量 (Variable) 。它用这些盒子来存放和处理信息。
当你看到这行代码：
age = 18
电脑收到的指令清单：
指令：准备一个叫
age 的标签。指令：处理
= 右边的东西，得到一个数字18。指令：找一个空盒子，把数字
18 放进去，然后贴上age 标签。
从此，指令中提到 age，电脑就会去这个盒子里找东西。= 的意思是"把右边的东西，存入左边标签的盒子"。
盒子的种类：数据类型
电脑很讲究，不同类型的东西要用不同类型的盒子装，这样它才知道该如何处理。
第二章：代码的骨架 —— 关键字（电脑指令集）
关键字是给电脑的特殊指令，它们会改变电脑"一步一步往下走"的默认行为，告诉它何时需要跳转、重复或绕道。
我们把整个代码看作一个从上到下编号的指令清单。电脑有一个"程序指针"，默认情况下，执行完第1行，指针就移到第2行，再移到第3行...
print （输出函数）
为了方便讲解，我们预先介绍一个知识点：print函数。这个函数不是关键字
print("xxx")
电脑读到这行指令后，会在控制台中输出括号中的东西。如果括号中时变量，就输出值。
至于为什么，见下文函数调用。
拓展内容见文末[1]
if, elif, else (条件跳转指令)
这组指令告诉电脑："先做个检查，根据结果决定要不要跳过一些指令。"
# --- 指令清单 ---
temperature = 40
if temperature > 30:
print("太热了！")
print("30多度了！")
else:
print("天气不错。")
print("检查完毕。")
电脑的执行过程：
指针在行 1：执行
temperature = 40。temperature 盒子里现在是40。指针移到行 2。指针在行 2 (
if ) ：这是一个检查指令。检查
temperature 盒里的40 是否大于30。检查结果为 "是" (
True)。
if 指令说："如果结果为'是'，继续往下走到行 3；如果为'否'，直接跳转到 else 或 if 结束之后的地方。"结果是"是"，所以指针正常移到行 3。
指针在行 3：执行
print("太热了！")。屏幕上显示"太热了！"。指针在行 4：执行
print("30多度了！")。屏幕上显示"30多度了！"。重要！
if 代码块执行完毕后，有一个隐藏指令："跳转到整个 if-else 结构结束之后的地方"。所以，指针直接跳过行 4 和行 5，来到行 6。指针在行 7：执行
print("检查完毕。")。
如果 temperature 是 20 会怎样？
指针在行 2 (
if ) ：检查20 > 30。结果为 "否" (False)。
if 指令说："结果为'否'，立即跳转到 else 所在的位置（行 4）。"指针直接跳到行 4。行 3 被完全忽略。
指针在行 4 (
else ) ：这是一个标签，表示if 检查为"否"时的入口。指针移到行 5。指针在行 5：执行
print("天气不错。")。指针在行 6：执行
print("检查完毕。")。
拓展内容，见文末[2]
那电脑怎么知道if代码块有没有执行完毕呢？
答案是缩进。注意到if下的内容都有一个缩进吗，每出现一个if下方就至少有一行缩进，缩进相同的内容就是同一代码块（缩进块）。缩进可以是键盘上的Tab键，也可以是2~4个空格，但需要再同一文件中保持一致。关于空格，同一文件约定必须一致，例如本文就同一用4个空格。
例如：
i = 0
j = 1
if i == 0:
if j == 0:
print("i和j都是0")
print("i是0")
第4~7行都在一个代码块中，他们都是第3行if的代码块。
而第3行的print("i和j都是0")同时在第3行的if和第4行的if的代码块中，也就是说只有两个if都说"是"时才会执行。
所以电脑的执行过程：赋值部分略
指针在行 3：(
if ) ：这是一个检查指令。检查
i 盒里的0 是否等于0。检查结果为 "是" (
True)。
if 指令说："如果结果为'是'，继续往下走到行 4；如果为'否'，直接跳转到 if 结束之后的地方。"结果是"是"，所以指针正常移到行 4。
指针在行 4：(
if ) ：这是一个检查指令。检查
j 盒里的1 是否等于0。结果是"否"，所以指针直接跳转到
if 结束之后的地方，也就是 行6.
指针在行 6：执行
print("i是0")。屏幕上显示"i是0"。
思考，如果把第1行改为i=1会发生什么。
答案：赋值部分略
指针在行 3：(
if ) ：这是一个检查指令。检查
i 盒里的1 是否等于0。结果是"否"，所以指针直接跳转到
if 结束之后的地方，也就是 程序最后
程序执行完毕
for, in (计数循环指令)
这个指令告诉电脑："针对一个'火车车厢'（列表），对它的每一节车厢都重复执行一段指令。"
如果您打算学习高阶python知识，这里作提示，
in后的内容可以是任意可迭代类型(Iterable)，例如列表、元组、集合、字典（默认遍历key）、字符串和任何生成器(Generator)。
# --- 指令清单 ---
fruits = ["苹果", "香蕉"]
for fruit in fruits:
print("我喜欢吃" + fruit)
print("吃完了。")
电脑的执行过程：
指针在行 1：执行
fruits = ["苹果", "香蕉"]。指针在行 2 (
for ) ：这是一个循环设置指令。电脑拿出
fruits 这列火车。准备一个临时的空盒子，叫
fruit。设置一个"车厢指针"，指向第一节车厢"苹果"。
循环规则："只要'车厢指针'没有越过最后一节车厢*，就重复执行行 3。每次重复完，就把'车厢指针'移到下一节。"
第一次循环：
检查"车厢指针"：指向"苹果"，没问题。
执行：把"苹果"放进
fruit 盒子里。指针移到循环内部，即行 3。
指针在行 3：执行
print("我喜欢吃" + fruit)。打印出"我喜欢吃苹果"。循环体结束，指针跳回行 2，准备下一次循环。
第二次循环：
在行 2，电脑更新"车厢指针"，让它指向下一节车厢"香蕉"。
检查"车厢指针"：指向"香蕉"，没问题。
执行：把"香蕉"放进
fruit 盒子里（覆盖掉原来的"苹果"）。指针再次移到行 3。
指针在行 3：执行
print("我喜欢吃" + fruit)。打印出"我喜欢吃香蕉"。循环体结束，指针跳回行 2。
结束循环：
在行 2，电脑更新"车厢指针"，发现已经没有下一节车厢了。
循环规则说："车厢指针越界，循环结束，跳转到整个
for 结构之后的地方。"指针跳过行 3，直接来到行 4。
指针在行 4：执行
print("吃完了。")。
while (条件循环指令)
这个指令告诉电脑："只要某个条件一直满足，就重复执行一段指令，别停！"
# --- 指令清单 ---
count = 0
while count < 3:
print("你好")
count = count + 1
print("结束。")
电脑的执行过程：
指针在行 1：
count 盒子里放入0。指针移到行 2。指针在行 2 (
while ) ：这是一个循环检查指令。检查
count 盒里的0 是否小于3。结果为"是"。
while 指令说："如果结果为'是'，就继续往下执行；如果为'否'，立即跳转到 while 结构结束之后的地方（行 5）。"结果为是"，指针正常移到行 3。
指针在行 3：执行
print("你好")。指针在行 4：执行
count = count + 1。count 盒子里的值变为1。重要！
while 代码块结尾有一个隐藏指令："无条件跳转回 while 的检查行（行 2）"。指针跳回行 2：再次执行检查。
count 盒里的1 是否小于3？是。指针移到行 3。...重复执行行 3 和行 4，
count 变为2。指针再次跳回行 2：再次检查。
count 盒里的2 是否小于3？是。指针移到行 3。...重复执行行 3 和行 4，
count 变为3。指针再次跳回行 2：再次检查。
count 盒里的3 是否小于3？否。
while 指令说："结果为'否'，立即跳转到 while 结构结束之后的地方"。指针跳过行 3 和行 4，直接来到行 5。
指针在行 5：执行
print("结束。")。
break 和 continue
当电脑遇到 break 时，立即跳转到循环结构结束的地方。
当电脑遇到 continue 时，放弃当前循环，立即跳转到循环结构开始的地方（包含验证）.
例如
for i in range(10):
if i % 2 == 0:
continue
if i == 7:
break
print(i)
思考：如何简化这个代码。
i % 2 == 0的意思是 i 中的值是不是偶数，具体为什么见第三章。
指针在行 1 (
for ) ：这是一个循环设置指令。准备一个临时的空盒子，叫
i。电脑看到
range(10)，创建一个形如[0,1,2,3,4,5,6,7,8,9]的序列（具体见第五章，这个并非创建一个列表）循环规则：只要还能从
range(10)拿到东西，就继续拿东西并进入行2.
第一次循环：
检查
i是否为偶数，0是偶数，执行第3行遇到
continue放弃当前循环，第1行继续。
第二次循环：
检查
i是否为偶数，1是奇数，跳过第3行，执行第4行检查
i是否为7，1不等于7，跳过第5行，执行第6行输出
i，屏幕显示2
类似的多次循环
结束循环：
在行 4，检查
i是否为7，7不等于7，执行第5行遇到
break，放弃循环，跳转到第7行。
程序结束
*: 这个说法来自于C++对基于array容器的遍历过程。尚未考证python遍历list是否也是这个逻辑。但是从理解角度完全不影响。
def, return (定义与执行"子程序"指令)
def 就像是你在指令清单上写下了一套"备用方案"（子程序），但先不执行。return 是这个备用方案的出口。
# --- 主指令清单 ---
def say_hello(name):
greeting = "你好, " + name
return greeting
message = say_hello("张三")
print(message)
电脑的执行过程：
指针在行 1 (
def ) ：这是一个定义指令。电脑看到
def，知道这只是一个"备用方案"的定义，现在不执行（这也意味着，如果其中有错误，也不会立即被发现）。它记下："有一个叫
say_hello 的备用方案，它需要一个叫name 的输入。它的具体步骤在行 2 和行 3。"然后，电脑直接跳转到
def 结构结束之后的地方，即行 4。
指针在行 4：
message = say_hello("张三")。电脑看到
say_hello()，意识到需要启动那个叫say_hello 的备用方案。它暂停当前的主清单，并记住自己停在了行 4。
开始执行备用方案：
创建一个临时的
name 盒子，把输入"张三"放进去。执行备用方案的第一步 (行 2) ：
greeting 盒子里被放入 "你好, 张三"。执行备用方案的第二步 (行 3,
return ) ：return 指令说："备用方案结束。把greeting 盒子里的东西（"你好, 张三"）带出去，作为本次任务的结果。"
备用方案执行完毕。电脑销毁所有临时盒子（如
name,greeting）。返回主清单行 4：电脑带着结果 "你好, 张三" 回来了。现在行 4 的指令变成了
message = "你好, 张三"。电脑执行它。
指针在行 5：执行
print(message)。
值得说明的是，Python中给我们定义好了很多函数，像是print等。这些函数被称为内建函数，我们无需定义就能使用。
不止函数可以被这么调用，部分 类(Class) 也可以被这么调用。但本文不涉及类，暂不做过多解释。
第三章：做决定与使用工具
我们已经知道电脑会按照指令清单一步步往下走，并且会根据关键字进行跳转。但 if 和 while 这种跳转指令的依据是什么呢？这就是本章的第一个重点。
做决定的依据 —— 条件表达式 (Condition Expression)
条件表达式是一句电脑能判断"对"或"错"的话。它的结果永远是两种之一：True (真/对) 或 False (假/错)。
你可以把它看作电脑在执行 if 或 while 前，先自问自答的一个问题。
1. 比较问题 (Comparison Operators)
这是最常见的提问方式，用来比较两个盒子里的东西。
⚠️ 重要提醒：
= 是赋值指令 ("把东西放进盒子")。
== 是提问 ("这两个东西相等吗？")。初学者最容易混淆！
2. 组合问题 (Logical Operators)
有时候，一个问题不够，需要把多个问题组合起来。
随手可用的公共工具 —— 常用全局函数
这些是 Python 自带的、无需导入就能直接使用的公共工具。
盒子的"自带工具" —— 常用方法 (Methods)
除了公共工具，每种类型的盒子（数据类型）还附带了一套自己的专用小工具，我们称之为方法 (method) 。
使用方法时，格式是 盒子变量.方法名()，这个 . 的意思是"对这个盒子，使用它自带的XX工具"。
1. 文本盒 (str ) 的自带工具
这些工具专门用来处理文本。
文本 (str ) 的比较规则
当你看到 if "apple" < "banana": 这样的代码时，电脑如何判断大小？
它会逐个比较两个文本中每个字符的"身份证号"（ord()值）。
比较第一个字符：
'a' vs'b'。ord('a') 是97，ord('b') 是98。因为97 < 98，所以电脑立刻得出结论"apple" < "banana" 是True，后面的字符就不再比较了。如果第一个字符相同，就比较第二个，以此类推。
注意：大写字母的"身份证号"比小写字母小（
ord('A')是65，ord('a')是97），所以"Apple" <"apple"。
2. 火车车厢 (list ) 的自带工具
这些工具专门用来管理一连串的数据。
关于
int 和 float：数字类型的盒子（int,float）很少使用.方法，它们主要的"工具"是数学运算符（+,-,*,/）。
第四章：整理与归纳 —— 使用数据容器
我们已经知道，变量是电脑用来存放单个东西的"盒子"。但如果我们要处理一大堆东西，比如一个班所有学生的名字，或者购物清单上的所有商品，一个一个地创建盒子就太麻烦了。
这时，我们就需要容器 (Container) 。容器就像一个大储物柜，里面可以整齐地存放很多小盒子。电脑可以通过 for 循环指令，轻松地遍历储物柜里的每一个物品。这些可以被 for 循环遍历的容器，我们统称为可迭代对象 (Iterable) 。
1. 列表 (list)：万能的储物柜
列表是我们最常用、最灵活的储物柜。它有两大特点：
有序：你放进去的东西会按照你存放的顺序排好。
可变：你可以随时往里面添加、删除或更换物品。
存取物品：使用索引和切片
想象一个列表就是一个从 0 开始编号的储物柜。
# 编号 0 编号 1 编号 2
fruits = ["apple", "banana", "cherry"]
获取单个物品 (Indexing) :
fruits[0] 会得到"apple"。fruits[-1] 会得到"cherry"。修改单个物品:
fruits[1] = "orange"，列表会变成["apple", "orange", "cherry"]。获取一批物品 (Slicing) :
fruits[0:2] 会得到["apple", "orange"] (不包含编号2)。
列表的常用工具 (常用方法)
这些是列表储物柜自带的、用于整理物品的工具。
2. 元组 (tuple)：一次性封装的"真空包"
元组和列表非常像，也是有序的。但它有一个核心区别：不可变。一旦创建，就不能再修改。它就像一个被"真空密封"的包裹，保证内容物不会被更改。
# 创建一个元组，使用小括号 ()
coordinates = (100, 200)
你可以像列表一样用 coordinates[0] 来读取数据，但任何修改操作（如 coordinates[0] = 50）都会导致电脑报错。
3. 字典 (dict)：带标签的档案柜
列表和元组都靠数字编号来存取东西。但字典不靠编号，而是靠我们自定义的键 (key) 和 值 (value) 的配对来组织数据。
student = {"name": "小明", "age": 18}
存取：
student["name"] 会得到"小明"。修改/添加：
student["age"] = 19 会修改年龄；student["city"] = "北京" 会添加一个新的键值对。
关于"无序"的重要说明
你可能会发现，当你打印一个字典时，里面的项目好像是按照你添加的顺序排列的。这是现代 Python 为了效率做的一个内部优化。
但是，你绝对不能依赖这个顺序！
把字典想象成一个图书管理员。他可能为了自己方便，把新来的书都放在架子最右边。但他的工作承诺是：你给他书名（键），他能快速找到书（值）。他没有承诺书在书架上的物理位置是固定的。也许明天他为了整理，会把所有书按大小重新排列。
结论：永远通过键来访问字典，绝不要假设它的第 N 个元素是什么。
字典的常用工具 (常用方法)
4. 集合 (set)：不含重复元素的"魔法袋"
集合是一种非常特殊的容器，它有两大特点：
无序：和字典一样，你不能依赖它的顺序。
唯一：它不允许有重复的元素，会自动帮你去重。
# 集合会自动去除重复的 'banana'
unique_fruits = {"apple", "banana", "cherry", "banana"}
# unique_fruits 的内容是 {"apple", "banana", "cherry"}
集合的常用工具 (常用方法)
集合的主要威力在于进行数学上的关系运算。
拓展阅读：更专业的工具箱
当你成为更熟练的程序员后，会发现 Python 还提供了更专业的容器来解决特定问题。现在你不需要学习如何使用它们，但知道它们的存在很有帮助：
collections.Counter：一个特化的字典，专门用来计数。比如Counter(['a', 'b', 'a']) 会直接得到{'a': 2, 'b': 1}。
collections.deque：一个"双端队列"，它在列表的两头添加和删除元素都非常快。用它来实现队列 (Queue) （先进先出，像排队买票）非常高效。
用它来实现栈 (Stack) （后进先出，像叠盘子）也非常高效。
幕间曲：规范化所有专业用语
为了方便交流，将上文所有比喻都删掉，换成专业名称。这可能需要你背住。
变量：存放数据的“小盒子”。
数据类型：变量所存内容的类型，包括整数
int，浮点数（小数）float，布尔型bool，列表list字符串str，字典dict，集合set，元组tuple（，复数complex不做介绍）条件分支语句
if ... elif ... elsefor循环while循环（很多教程喜欢先for后while，因为for比while常用）in关键字None关键字空，意味着什么都没有。当函数没有return或者return后什么也没有就返回这个。def定义函数
（在python中，没有区分方法method和函数function，但我建议您记住。有返回内容的是function，没有返回的或者更严格来说，只返回None的是方法method）return返回：函数返回或终止。
第五章：扩展你的工具箱 —— 模块与标准库
想象一下，如果一个工匠需要把所有的工具（锤子、锯子、扳手、电钻、焊枪...）都随时带在身上，那他会寸步难行。编程也是如此。
Python 把不那么基础、但非常有用的功能分门别类地装进了不同的"工具箱"里，这些工具箱就叫做 模块 (Module) 。
模块 (Module) : 一个包含了预先写好的函数和变量的 Python 文件。它是一个专门解决某一类问题的工具箱。例如，有一个
math 模块（数学工具箱），里面有计算平方根、三角函数等工具。预定义的函数 (Pre-defined Functions) :
全局函数: 像
print(),len() 这样，是你随身携带、无需任何准备就能使用的基础工具。模块内的函数: 像电钻、焊枪这样的专业工具，你必须先去仓库里把对应的工具箱 (
import) 拿出来，才能使用。例如math.sqrt()。
标准库 (Standard Library) : 这是 Python 自带的"官方五金店"。当你安装 Python 时，一大批高质量、经过官方认证的模块（工具箱）就已经一起安装好了。你不需要额外下载，只需
import 就能使用。我们接下来要讲的random 和turtle 就是标准库里非常有用的两个模块。
第六章：有趣的工具箱 —— random 和 turtle 模块
使用前，你必须先告诉电脑你要用这个工具箱：import random 或 import turtle。
1. random (随机数工具箱)
random.seed(a) 作用：设置随机数种子。如果种子
a 一样，后续生成的"随机数"序列也完全一样。这在需要"可复现的随机"时很有用。不设置则每次都不同。
random.randint(a, b) 作用：生成一个随机整数，范围是
a 到b (包括a 和b)。示例：
dice_roll = random.randint(1, 6)
2. turtle (小海龟绘图工具箱)
这是一个绘图工具，你通过指令控制一只"小海龟"在屏幕上移动，留下轨迹。
常见指令
turtle.forward(distance): 前进。
turtle.backward(distance): 后退。
turtle.left(angle): 左转angle 度。
turtle.right(angle): 右转angle 度。
turtle.penup(): 抬笔，移动不画图。
turtle.pendown(): 落笔，移动画图。
turtle.pencolor(color_name): 设置画笔颜色，如"red"。
turtle.done(): 程序执行完后，保持窗口不关闭。
第七章：实战演练 —— 让我们一起读代码
下面是一段完整的猜数字游戏代码。让我们用"电脑的思考方式"来逐行阅读它。
# 1. 导入工具箱
import random
# 2. 设置游戏
secret_number = random.randint(1, 20)
print("我心里想了一个1到20之间的数字。")
# 3. 开始游戏循环
for i in range(5):
print("你还有 " + str(5 - i) + " 次机会。")
guess_str = input("猜猜看: ")
guess = int(guess_str)
if guess < secret_number:
print("太小了！")
elif guess > secret_number:
print("太大了！")
else:
break # 猜对了，跳出循环
# 4. 游戏结束
if guess == secret_number:
print("恭喜你，猜对了！")
else:
print("很遗憾，你没猜对。我心里想的数字是 " + str(secret_number))
电脑的思考过程：
import random：好的，random 工具箱准备就绪。
secret_number = random.randint(1, 20)：使用random 的randint 工具，在1到20之间选一个数，存入secret_number 盒子。
print(...)：在屏幕上显示提示文字。
for i in range(5)：要开始一个5次的循环。range(5) 会提供0, 1, 2, 3, 4。第一次循环 (i=0) ：
print(...): 显示"你还有 5 次机会。"
input(...): 等待用户输入。假设用户输入了10。
guess_str 盒子里存入文本"10"。
guess = int(guess_str)：把文本"10" 转换成数字10，存入guess 盒子。
if ... elif ... else: 电脑进行比较，根据结果打印"太小了！"或"太大了！"。
后续循环：重复上述过程。如果用户猜对，
else 里的break 指令会让电脑立即终止for 循环，直接跳到循环外面的代码。
if guess == secret_number：循环结束后，最后再做一次判断，guess 盒里的值和secret_number 盒里的值是否相等。根据判断结果，打印最终的祝贺或遗憾信息。
程序结束。
总结
恭喜你！现在你已经掌握了阅读 Python 基础代码的核心技巧。记住，万变不离其宗：
= 是赋值，从右到左。关键字决定了代码的结构和流程 (判断、循环、定义)。
函数
() 是在请求执行一个特定的任务。从上到下，逐行理解，把自己想象成一台只会一步一步执行指令的笨电脑。
多看、多读、多用这种"电脑视角"去分析代码，你很快就能对 Python 代码了如指掌！
拓展内容
[1]
为什么一会输出括号中的东西一会输出变量内容呢？
在忽略所有优化的条件下，在代码中任何的可以作为变量的东西（例如上例中xxx）一旦出现，电脑就会默默创建一个临时变量，将其存在其中。我们已知python中创建变量的写法为
a=1那么上述内容实质上为
temp = "xxx"
print(temp)至此上述说法统一为：电脑读取print 后，将括号中变量的值输出到控制台中。
这个说法在大多数程序语言中都成立，但不绝对。在有 常量(constant) 概念的语言和编译性语言中，上述说法错误。在python的具体实现中，上述说法不总是成立。
[2]
很多教程不会这么解释这个过程，这里这种解释方式实质上在向您解释计算机底层的运行逻辑。也许您听过汇编，这是及其接近计算机最底层的一种编程语言，所有程序都必然可以转换为一段汇编代码。
除非您有意学习计算机原理或者网络安全方向，没有学习汇编的必要。如果您有这个意向，请立即停止阅读本文，这不是为您设计的，这篇文章的目的是为了让您快速读懂简单的python代码，本拓展只是拓宽视野罢了。
上述内容在汇编中的表达为：
section .data
msg_hot db "太热了！", 0 ; 定义字符串常量
msg_hot2 db "30多度了！", 0 ; 定义字符串常量
msg_cool db "天气不错。", 0 ; 定义字符串常量
msg_done db "检查完毕。", 0 ; 定义字符串常量
temperature db 40
section .text
global _start
_start: ; 主程序入口
; Load temperature
mov eax, [temperature] ; 将 temperature 变量加载到 eax 寄存器
cmp eax, 30 ; 比较 temperature 和 30，并将结果存储在标志寄存器中
jle .else_block ; 如果标志寄存器值为小于等于，跳转到 else 块
mov rdi, msg_hot ; 将msg_hot的地址加载到rdi寄存器，用于调用print_string函数
call print_string ; 调用打印函数
mov rdi, msg_hot2 ; 将msg_hot2的地址加载到rdi寄存器，用于调用print_string函数
call print_string ; 调用打印函数
jmp .end_if ; 跳转到 if 结束处
.else_block: ; 否则块
mov rdi, msg_cool ; 将msg_cool的地址加载到rdi寄存器，用于调用print_string函数
call print_string ; 调用打印函数
.end_if: ; if 结束处
mov rdi, msg_done ; 将msg_done的地址加载到rdi寄存器，用于调用print_string函数
call print_string ; 调用打印函数
mov rax, 60 ; 准备退出系统调用
xor rdi, rdi ; 准备退出代码0
syscall ; 调用内核退出程序可以感受到，很繁琐不是吗。但计算机本质上就是在做如此繁琐的工作。但写代码的人可受不了，所以创造了类似python的高级语言。感谢那些程序语言的创造者和维护者吧，正式他们的无偿无私贡献造就了当今的计算机和网络体系。
