Python核心语法速查：变量、控制流与函数详解

假设要写一个简单程序：读取一名学生的姓名和成绩，根据成绩判断是否合格，再通过函数输出结果。这个小任务看似简单，却已经用到了 Python 最核心的三部分语法：变量负责保存数据，控制流负责决定代码执行顺序，函数负责把一段逻辑封装起来重复使用。掌握这三部分，就能读懂和编写相当一部分基础 Python 程序。

本文围绕变量、条件判断与循环、函数三个主题展开，并把常见写法、容易混淆的地方以及完整示例放在一起，既适合初学者顺序学习，也可以作为之后写代码时的语法速查。

一、变量：让程序保存和使用数据

Python 中的变量可以理解为一个名称，这个名称指向某个值。创建变量时不需要提前声明类型，直接使用赋值运算符 = 即可。

name = "小明"
age = 18
score = 92.5
is_passed = True

上面的四个变量分别保存字符串、整数、浮点数和布尔值。Python 会根据赋进去的值确定当前对象的类型，因此不需要像部分静态类型语言那样提前写出 int、float 或 string。

1. 变量命名规则

Python 变量名需要遵守几个基本规则：

• 可以使用字母、数字和下划线。
• 不能以数字开头。
• 变量名区分大小写，score 和 Score 是两个不同名称。
• 不能使用 if、for、def 等 Python 关键字作为变量名。

常见写法是使用小写字母和下划线：

user_name = "Alice"
total_score = 280
max_retry_count = 3

与 totalScore 相比，total_score 更符合 Python 中常见的变量命名习惯。变量名也应该能够说明数据含义，除临时循环变量外，不建议大量使用 a、b、x1 之类难以理解的名字。

2. 常见基础类型

类型	示例	常见用途
int	18、-5	年龄、数量、计数器
float	3.14、92.5	带小数的数值
str	"Python"	姓名、文本、路径等字符串
bool	True、False	表示真或假、开或关等状态
NoneType	None	表示当前没有有效值

需要查看一个值的类型，可以使用 type()：

score = 92.5

print(type(score))

3. 变量可以重新赋值

Python 允许同一个变量名先后指向不同的值：

status = "waiting"
print(status)

status = "finished"
print(status)

还可以把变量原来的值取出来计算，再把新结果赋回去：

count = 10
count = count + 1

print(count)

这种写法也可以简化成：

count = 10
count += 1

4. 多变量赋值与交换

Python 支持一次给多个变量赋值：

name, age, score = "小明", 18, 92

交换两个变量时，也不需要额外创建临时变量：

a = 10
b = 20

a, b = b, a

print(a, b)

5. 类型转换

从键盘通过 input() 得到的数据是字符串。如果要参与数字计算，通常需要先进行类型转换。

age_text = input("请输入年龄：")
age = int(age_text)

print(age + 1)

也可以直接写成：

age = int(input("请输入年龄："))

常见转换函数包括：

• int()：转换为整数。
• float()：转换为浮点数。
• str()：转换为字符串。
• bool()：转换为布尔值。

二、运算符：控制流判断之前必须掌握的基础

控制流通常依赖一个“条件”。例如“成绩大于等于 60 分”就是一个条件，而条件本身往往由比较运算符和逻辑运算符组成。

1. 比较运算符

运算符	含义	示例
==	等于	score == 100
!=	不等于	status != "closed"
>	大于	age > 18
>=	大于等于	score >= 60
<	小于	count < 10
<=	小于等于	temperature <= 0

2. 逻辑运算符

当一个判断需要同时考虑多个条件，可以使用 and、or 和 not。

age = 20
has_ticket = True

can_enter = age >= 18 and has_ticket
print(can_enter)

三个逻辑运算符的含义可以直接记成：

• and：两边都为真，结果才为真。
• or：只要一边为真，结果就为真。
• not：把真假结果反转。

三、条件判断：让程序根据情况选择执行路径

如果代码永远从第一行执行到最后一行，很多实际需求都无法完成。条件判断解决的是“满足某个条件时执行什么，否则执行什么”的问题。

1. 最基本的 if

score = 75

if score >= 60:
    print("成绩合格")

if 后面是条件表达式，末尾必须有冒号。属于 if 的代码通过缩进表示。Python 通常使用 4 个空格作为一级缩进。

2. if...else 二选一

score = 55

if score >= 60:
    print("成绩合格")
else:
    print("成绩不合格")

如果条件为 True，执行 if 中的代码；条件为 False，执行 else。

3. elif 处理多个分支

如果成绩需要划分多个等级，可以使用 elif：

score = 86

if score >= 90:
    level = "优秀"
elif score >= 80:
    level = "良好"
elif score >= 60:
    level = "合格"
else:
    level = "不合格"

print(level)

Python 会从上到下判断，一旦某个条件成立并执行对应分支，就不会再继续检查后面的 elif。

因此条件顺序很重要。如果把 score >= 60 放在 score >= 90 前面，那么 95 分同样满足“至少 60 分”，程序会提前进入该分支，后面的“优秀”条件就没有机会执行。

四、循环：重复执行一段代码

当同样的逻辑需要重复执行时，不应该复制很多遍代码。Python 主要提供 for 和 while 两种循环。

1. for：适合遍历一组数据

例如依次输出列表中的学生姓名：

names = ["小明", "小红", "小李"]

for name in names:
    print(name)

每次循环时，列表中的一个元素会被赋给变量 name，然后执行缩进区域内的代码。

2. range() 生成数字序列

需要按次数循环时，经常与 range() 配合：

for number in range(5):
    print(number)

range(5) 从 0 开始，到 5 之前结束，因此不包含 5。

指定起点和终点可以写成：

for number in range(1, 6):
    print(number)

这次会得到 1、2、3、4、5。

还可以指定步长：

for number in range(0, 10, 2):
    print(number)

3. while：条件满足时持续循环

如果事先不知道准确循环次数，而是希望“只要条件成立就继续”，通常使用 while。

count = 1

while count <= 3:
    print("第", count, "次执行")
    count += 1

count += 1 很关键。如果循环中的条件一直为真，就可能形成无限循环。

4. break 与 continue

break 用于立即结束当前循环，continue 则跳过本次循环剩余代码，直接开始下一轮。

例如找到第一个大于 10 的数字后停止：

numbers = [3, 7, 12, 18, 5]

for number in numbers:
    if number > 10:
        print("找到：", number)
        break

跳过偶数，只输出奇数：

for number in range(1, 7):
    if number % 2 == 0:
        continue

    print(number)

五、函数：把一段逻辑封装成可重复调用的代码

当同样的处理逻辑会在多个位置使用时，可以把它写成函数。函数可以接收输入参数，执行内部逻辑，再通过返回值把结果交给调用者。

1. 使用 def 定义函数

下面定义一个计算两个数字之和的函数：

def add(a, b):
    result = a + b
    return result

调用函数：

total = add(10, 20)
print(total)

这段代码中：

• def 表示开始定义函数。
• add 是函数名。
• a 和 b 是形参，用来接收调用时传入的数据。
• return result 把计算结果返回给调用位置。

2. 参数与返回值分别解决什么问题

可以把函数理解为一个加工过程：参数是输入数据，函数体负责处理，return 是输出结果。

3. 没有 return 会发生什么

函数不一定必须写 return：

def say_hello(name):
    print("你好，" + name)

result = say_hello("小明")

print(result)

函数内部虽然输出了一行文字，但没有显式返回结果，因此调用得到的返回值是 None。

4. 默认参数

如果某个参数大部分时候都有相同值，可以给它设置默认值。

def greet(name, message="你好"):
    return message + "，" + name

print(greet("小明"))
print(greet("小红", "早上好"))

调用时不传 message，就使用默认的 "你好"；如果显式传入，就使用新的值。

5. 关键字参数

函数调用时还可以直接指出参数名称：

def create_user(name, age, city):
    print(name, age, city)

create_user(
    name="小明",
    age=18,
    city="上海"
)

关键字参数在参数较多时可提高可读性，也可以避免单纯依靠位置造成误解。

6. 返回多个值

Python 函数可以一次返回多个结果：

def calculate(a, b):
    total = a + b
    difference = a - b
    return total, difference

sum_result, diff_result = calculate(10, 3)

print(sum_result)
print(diff_result)

从使用方式上看，可以直接通过多个变量接收这些返回结果。

六、变量作用域：函数内部和外部的变量并不完全相同

函数内部创建的普通变量通常属于局部变量，只能在该函数内部使用。

def calculate():
    result = 100
    print(result)

calculate()

这里的 result 在 calculate() 内可以正常使用。如果在函数外直接访问：

def calculate():
    result = 100

calculate()
print(result)

会因为函数外不存在这个局部变量而产生 NameError。

而在函数外定义的变量属于更外层作用域，例如：

site_name = "Python学习站"

def show_site():
    print(site_name)

show_site()

函数可以读取外层变量，但实际开发中，如果一个函数依赖的数据能够通过参数传入，通常会比大量直接依赖全局变量更容易理解和维护。

七、把变量、控制流和函数组合起来

单独掌握语法之后，更重要的是理解它们如何组合。下面实现一个简单的学生成绩评级程序。

要求如下：

1. 使用变量保存学生姓名和成绩。
2. 使用函数封装成绩评级逻辑。
3. 在函数中使用条件判断确定等级。
4. 使用循环批量处理多个学生。

def get_level(score):
    if score >= 90:
        return "优秀"
    elif score >= 80:
        return "良好"
    elif score >= 60:
        return "合格"
    else:
        return "不合格"


students = [
    {"name": "小明", "score": 92},
    {"name": "小红", "score": 85},
    {"name": "小李", "score": 58}
]

for student in students:
    name = student["name"]
    score = student["score"]
    level = get_level(score)

    print(name, score, level)

这段程序已经把三个核心语法组合起来了。students、name、score 和 level 用于保存数据；for 负责依次处理每名学生；if / elif / else 决定成绩属于哪个等级；get_level() 则把评级规则独立封装。

这种结构比把所有判断直接堆在循环中更容易维护。如果以后评级标准变化，只需要修改 get_level()，调用它的代码可以保持不变。

八、一个完整练习：从输入到函数调用

再看一个更接近实际交互的例子。程序要求用户输入姓名和成绩，然后检查成绩范围并输出等级。

def get_level(score):
    if score >= 90:
        return "优秀"
    elif score >= 80:
        return "良好"
    elif score >= 60:
        return "合格"
    else:
        return "不合格"


name = input("请输入姓名：")
score = float(input("请输入成绩："))

if score < 0 or score > 100:
    print("成绩必须在 0 到 100 之间")
else:
    level = get_level(score)
    print(f"{name}的成绩是 {score}，等级为：{level}")

假设输入：

请输入姓名：小明
请输入成绩：86

这里还使用了 f-string：

f"{name}的成绩是 {score}"

花括号中的变量会被替换成实际值。这是在 Python 中组合字符串和变量时非常常见的写法。

九、初学时最容易遇到的几个问题

1. 为什么缩进不正确会直接报错？

Python 使用缩进确定代码块，因此缩进不仅影响美观，还直接参与语法结构。

正确写法：

score = 80

if score >= 60:
    print("合格")
    print("继续执行该分支")

两个 print() 具有相同缩进，因此都属于 if。

下面这种结构则不同：

score = 80

if score >= 60:
    print("合格")

print("判断结束")

最后一行没有缩进，所以无论条件是否成立，程序执行完条件判断后都会继续执行它。

2. 为什么条件成立了，却进入了错误的 elif 分支？

常见原因是条件顺序不合理。例如：

score = 95

if score >= 60:
    print("合格")
elif score >= 90:
    print("优秀")

95 已经满足第一个条件，所以程序输出“合格”，不会再判断后面的 score >= 90。解决方法是把更严格的条件放在前面。

3. for 和 while 应该怎么选？

如果需要遍历列表、字符串、字典或一个确定的数字范围，优先考虑 for。如果循环是否继续主要取决于一个状态条件，例如“只要用户还没有输入正确密码就继续”，通常更适合使用 while。

例如：

password = ""

while password != "python123":
    password = input("请输入密码：")

print("验证通过")

这个场景事先不知道用户要输入多少次，因此使用 while 比固定循环次数更自然。

4. 什么情况下应该写函数？

可以从三个角度判断：

• 一段逻辑会在多个地方重复使用。
• 一段代码本身承担一个明确任务，例如“计算价格”“验证成绩”“格式化用户名”。
• 主程序已经变得很长，把具体处理拆成函数后更容易读懂。

函数并不是越多越好。只有一两行、只使用一次并且语义已经非常清晰的代码，不一定必须单独拆成函数。

十、Python核心语法速查表

需求	常用语法	示例
创建变量	=	name = "小明"
判断是否相等	==	status == "ok"
多个条件同时成立	and	age >= 18 and enabled
多个条件满足其一	or	role == "admin" or role == "editor"
二选一判断	if / else	根据条件执行不同代码
多个分支判断	if / elif / else	成绩等级判断
遍历数据	for	for item in items:
按条件持续循环	while	while count < 10:
立即结束循环	break	找到目标后停止搜索
跳过当前一轮	continue	忽略不需要处理的数据
定义函数	def	def add(a, b):
返回函数结果	return	return a + b

十一、如何真正掌握这三部分语法

变量、控制流和函数不适合只靠背语法。更有效的方法是用一个很小的任务，把几种结构连续组合起来。

可以从“学生成绩”这个例子继续扩展：先用变量保存姓名和成绩，再通过 if 判断成绩等级，然后把判断过程封装成函数，最后把多个学生放进列表，通过 for 循环批量处理。

练习时可以按下面的顺序增加功能：

1. 创建 name 和 score 两个变量，并输出它们。
2. 使用 if / else 判断成绩是否合格。
3. 改成 if / elif / else，增加多个成绩等级。
4. 把评级代码放进 get_level() 函数。
5. 建立包含多个学生的列表，通过 for 批量评级。
6. 增加成绩范围检查，避免小于 0 或大于 100 的数值进入评级函数。

完成这个过程后，再去学习列表、字典、异常处理、文件操作和类，会更容易理解，因为后面的功能仍然会大量使用本文介绍的变量、控制流和函数。