Python(八) 基础语法：变量赋值与多重赋值

一、为什么要学习变量赋值与多重赋值

写程序时，我们经常需要把数据保存起来，后面继续使用。

例如：

name = "小明"
age = 18
score = 95

print(name)
print(age)
print(score)

这里的 name、age、score 就是变量。

变量可以帮助我们给数据起名字，让程序更容易理解。

如果没有变量，很多代码会变得很难读：

print("小明")
print(18)
print(95)

这段代码虽然能运行，但别人不一定知道 18 和 95 分别表示什么。

使用变量后：

name = "小明"
age = 18
score = 95

意思就清楚多了：

name 表示姓名。
age 表示年龄。
score 表示成绩。

变量赋值是 Python 中最基础、最常用的语法之一。多重赋值则可以让我们一次给多个变量赋值，让代码更加简洁。

二、变量的定义

变量是用来保存数据的名字。

通俗地说：

变量就像一个标签，贴在某个数据上，方便我们以后通过这个名字找到这个数据。

例如：

age = 18

可以理解为：

把 age 这个名字和整数 18 关联起来。

以后使用 age，就相当于使用它保存的值：

age = 18

print(age)

输出：

三、赋值的定义

赋值是把一个数据保存到变量中的操作。

Python 中使用等号 = 进行赋值。

基本格式：

变量名 = 值

例子：

name = "小明"
age = 18
height = 1.75

可以读作：

把 "小明" 赋值给变量 name。
把 18 赋值给变量 age。
把 1.75 赋值给变量 height。

注意：

在 Python 中，= 不是数学里的“相等”，而是“赋值”。

四、= 和 == 的区别

初学者很容易把 = 和 == 混淆。

符号	名称	作用	示例
`=`	赋值运算符	把右边的值赋给左边变量	`age = 18`
`==`	比较运算符	判断左右两边是否相等	`age == 18`

例子：

age = 18

print(age == 18)

输出：

True

解释：

age = 18

表示把 18 保存到变量 age 中。

age == 18

表示判断 age 的值是否等于 18。

错误示例：

age = 18

if age = 18:
    print("年龄是 18")

这会报错，因为 if 条件中应该写判断表达式，不能写赋值语句。

正确写法：

age = 18

if age == 18:
    print("年龄是 18")

教学口诀：

一个等号是赋值，两个等号才是比较。

五、变量赋值的基本使用方法

1. 给变量赋一个固定值

name = "小明"
age = 18
score = 95

print(name)
print(age)
print(score)

输出：

小明
18
95

2. 把表达式结果赋值给变量

赋值号右边不一定是一个固定值，也可以是一个表达式。

price = 20
count = 3

total = price * count

print(total)

输出：

这里：

price * count

先被计算出结果 60，然后赋值给变量 total。

3. 把函数返回值赋值给变量

函数调用的结果也可以赋值给变量。

name = input("请输入姓名：")

print(f"你好，{name}")

这里：

input("请输入姓名：")

会得到用户输入的内容，然后赋值给变量 name。

再如：

length = len("Python")

print(length)

输出：

4. 先赋值，再使用

变量必须先赋值，才能使用。

正确：

message = "欢迎学习 Python"
print(message)

错误：

print(message)
message = "欢迎学习 Python"

这会报错，因为在 print(message) 时，变量 message 还没有被创建。

常见错误是：

NameError: name 'message' is not defined

意思是：变量名 message 没有定义。

六、变量命名规则

变量名不是随便写的，要遵守 Python 的命名规则。

1. 变量名可以由字母、数字和下划线组成

正确：

name = "小明"
age2 = 18
student_score = 95

2. 变量名不能以数字开头

错误：

2age = 18

正确：

age2 = 18

3. 变量名不能使用 Python 关键字

Python 关键字是语言已经占用的词，例如：

if
else
for
while
def
class
True
False
None

错误：

if = 10
class = "一班"

这些名字有特殊含义，不能用作变量名。

可以使用下面代码查看关键字：

import keyword

print(keyword.kwlist)

4. 变量名区分大小写

name = "小明"
Name = "小红"

print(name)
print(Name)

输出：

小明
小红

name 和 Name 是两个不同的变量。

教学时建议：

不要故意用大小写区分意思相近的变量，否则代码容易混乱。

七、变量命名建议

规则决定“能不能运行”，建议决定“好不好读”。

1. 变量名要有意义

不推荐：

a = "小明"
b = 18
c = 95

2. 多个单词推荐使用下划线连接

Python 中常用蛇形命名法，也就是用小写字母加下划线。

3. 布尔变量名可以带 is、has、can

布尔变量表示真或假，命名时可以体现判断含义。

is_student = True
has_ticket = False
can_enter = True

这样写在条件判断中更自然：

if has_ticket:
    print("可以入场")

4. 不要使用容易混淆的变量名

不推荐：

l = 10
O = 0

小写字母 l 和数字 1、大写字母 O 和数字 0 容易看混。

5. 不建议覆盖内置函数名

Python 有很多内置函数，例如：

print
list
str
int
sum
max
min

不推荐：

list = [1, 2, 3]
str = "Python"
sum = 100

虽然有时能运行，但会覆盖原来的内置函数，后面再调用可能出问题。

例如：

list = [1, 2, 3]

numbers = list("abc")

这会报错，因为 list 已经不再表示内置的 list() 构造函数，而是一个列表变量。

八、变量的重新赋值

变量可以被重新赋值。

score = 80
print(score)

score = 95
print(score)

输出：

80
95

第二次赋值会让变量 score 指向新的值。

可以这样理解：

变量名没有变，但它保存的数据变了。

1. 重新赋值可以改变类型

Python 是动态类型语言，变量本身不固定类型。

x = 10
print(type(x))

x = "Python"
print(type(x))

输出：

<class 'int'>
<class 'str'>

变量 x 先保存整数，后来保存字符串。

虽然 Python 允许这样做，但实际教学和开发中不建议随便改变同一个变量的含义。

不推荐：

score = 95
score = "优秀"

更推荐：

score = 95
level = "优秀"

这样变量含义更清楚。

2. 使用变量自身进行更新

变量可以在原有值的基础上更新。

count = 0

count = count + 1

print(count)

输出：

执行过程：

右边先计算 count + 1。
原来的 count 是 0。
0 + 1 得到 1。
把 1 重新赋值给 count。

注意：

这一行不是数学等式：

count = count + 1

在数学中不成立，但在程序里表示“更新变量”。

九、复合赋值

复合赋值是把运算和赋值合在一起写。

常见复合赋值运算符：

写法	等价写法	含义
`x += 1`	`x = x + 1`	加后赋值
`x -= 1`	`x = x - 1`	减后赋值
`x *= 2`	`x = x * 2`	乘后赋值
`x /= 2`	`x = x / 2`	除后赋值
`x //= 2`	`x = x // 2`	整除后赋值
`x %= 2`	`x = x % 2`	取余后赋值
`x **= 2`	`x = x ** 2`	幂运算后赋值

例子：

count = 0

count += 1
count += 1

print(count)

输出：

累加总分：

total = 0

total += 90
total += 85
total += 100

print(total)

输出：

十、多重赋值的定义

多重赋值指的是在一行代码中同时给多个变量赋值。

基本格式：

变量1, 变量2, 变量3 = 值1, 值2, 值3

例子：

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

print(name)
print(age)
print(score)

输出：

小明
18
95

可以理解为：

name 得到 "小明"
age 得到 18
score 得到 95

多重赋值可以让代码更简洁，但要注意可读性。

十一、多重赋值的使用方法

1. 同时给多个变量赋不同的值

x, y = 10, 20

print(x)
print(y)

输出：

10
20

2. 同时接收多个输入结果

配合 split() 使用：

name, age = input("请输入姓名和年龄，用空格分隔：").split()

print(name)
print(age)

用户输入：

小明 18

输出：

小明
18

注意：

此时 age 还是字符串。

如果年龄要参与计算，需要转换：

name, age = input("请输入姓名和年龄，用空格分隔：").split()
age = int(age)

print(f"{name}今年{age}岁")

3. 同时输入多个整数

分步写法：

a, b = input("请输入两个整数，用空格分隔：").split()
a = int(a)
b = int(b)

print(a + b)

简写：

a, b = map(int, input("请输入两个整数，用空格分隔：").split())

print(a + b)

对于初学者，建议先掌握分步写法。

4. 交换两个变量的值

很多语言交换两个变量需要借助第三个变量。

传统写法：

a = 10
b = 20

temp = a
a = b
b = temp

print(a)
print(b)

输出：

20
10

Python 可以用多重赋值更简洁地交换：

a = 10
b = 20

a, b = b, a

print(a)
print(b)

输出：

20
10

这也是 Python 多重赋值非常经典的用法。

十二、多重赋值的原理简单理解

看下面代码：

a, b = b, a

它不是先把 b 赋值给 a，再把新的 a 赋值给 b。

可以简单理解为：

Python 先计算右边的 b, a。
得到一组临时结果。
再把结果分别赋值给左边的 a, b。

所以交换变量时不会丢失原来的值。

课堂中不需要一开始讲太深，只要让学生知道：

多重赋值会先准备好右边的值，再分配给左边的变量。

十三、链式赋值

链式赋值指的是同时给多个变量赋同一个值。

格式：

变量1 = 变量2 = 变量3 = 值

例子：

a = b = c = 0

print(a)
print(b)
print(c)

输出：

0
0
0

这种写法常用于初始化多个变量。

total = count = 0

表示：

total 初始值是 0。
count 初始值也是 0。

十四、链式赋值的注意事项

链式赋值给不可变类型通常没问题。

a = b = 0

a += 1

print(a)
print(b)

输出：

1
0

因为整数是不可变类型，a += 1 会让 a 指向新的整数对象，不会影响 b。

但是链式赋值给可变类型时要小心。

a = b = []

a.append(1)

print(a)
print(b)

输出：

[1]
[1]

很多学生会以为 b 应该还是空列表，但实际上 a 和 b 指向同一个列表对象。

如果想创建两个独立列表，不要这样写：

a = b = []

应该写：

a = []
b = []

教学时可以强调：

链式赋值给列表、字典、集合这类可变对象时，要特别小心。

十五、序列拆包赋值

序列拆包赋值是多重赋值的一种常见形式。

它可以把列表、元组、字符串等序列中的元素，分别赋值给多个变量。

1. 拆包列表

data = ["小明", 18, 95]

name, age, score = data

print(name)
print(age)
print(score)

输出：

小明
18
95

2. 拆包元组

point = (3, 5)

x, y = point

print(x)
print(y)

输出：

3
5

3. 拆包字符串

a, b, c = "ABC"

print(a)
print(b)
print(c)

输出：

A
B
C

字符串也可以拆包，因为字符串可以看成由一个个字符组成的序列。

4. 拆包时数量必须匹配

错误示例：

a, b = [1, 2, 3]

这会报错，因为左边有 2 个变量，右边有 3 个值。

错误示例：

a, b, c = [1, 2]

这也会报错，因为左边有 3 个变量，右边只有 2 个值。

正确写法：

a, b, c = [1, 2, 3]

十六、星号拆包

当右边的数据个数不固定，或者我们只关心其中一部分时，可以使用星号 *。

1. 获取中间多个值

numbers = [1, 2, 3, 4, 5]

first, *middle, last = numbers

print(first)
print(middle)
print(last)

输出：

1
[2, 3, 4]
5

这里：

first 得到第一个元素。
last 得到最后一个元素。
middle 得到中间剩下的元素，并组成列表。

2. 只取前几个值

data = ["小明", 18, 95, "北京"]

name, age, *others = data

print(name)
print(age)
print(others)

输出：

小明
18
[95, '北京']

3. 只取第一个值，忽略后面

numbers = [10, 20, 30, 40]

first, *rest = numbers

print(first)
print(rest)

输出：

10
[20, 30, 40]

4. 使用下划线表示不关心的变量

有时候我们拆包时不关心某些值，可以用 _ 作为变量名。

name, _, score = ["小明", 18, 95]

print(name)
print(score)

输出：

小明
95

这里 _ 接收了年龄，但表示我们不打算使用它。

注意：

_ 本质上也是一个变量名，只是 Python 社区习惯用它表示“不重要、不会使用的值”。

十七、变量赋值与对象引用

在 Python 中，变量保存的并不是“盒子里的值”这么简单。

更准确地说：

变量名引用对象。

可以用简单比喻理解：

对象像一件物品，变量名像贴在物品上的标签。

例如：

a = [1, 2, 3]
b = a

这表示：

创建一个列表对象 [1, 2, 3]。
a 这个标签贴到这个列表上。
b = a 让 b 也贴到同一个列表上。

所以：

a = [1, 2, 3]
b = a

b.append(4)

print(a)
print(b)

输出：

[1, 2, 3, 4]
[1, 2, 3, 4]

因为 a 和 b 指向同一个列表。

如果想复制列表：

a = [1, 2, 3]
b = a.copy()

b.append(4)

print(a)
print(b)

输出：

[1, 2, 3]
[1, 2, 3, 4]

十八、赋值与可变类型、不可变类型

理解赋值时，要注意可变类型和不可变类型。

1. 不可变类型

常见不可变类型：

整数 int
浮点数 float
布尔值 bool
字符串 str
元组 tuple

例子：

a = 10
b = a

a = 20

print(a)
print(b)

输出：

20
10

解释：

a = 20 只是让 a 指向新的整数对象 20，不会影响 b。

2. 可变类型

常见可变类型：

列表 list
字典 dict
集合 set

例子：

a = [1, 2]
b = a

a.append(3)

print(a)
print(b)

输出：

[1, 2, 3]
[1, 2, 3]

解释：

append() 修改的是列表对象本身，而 a 和 b 指向同一个列表，所以都会看到变化。

十九、常量的约定写法

Python 中没有真正意义上禁止修改的常量语法。

但是我们通常用全大写变量名表示“这个值不应该被修改”。

例如：

PI = 3.14159
MAX_SCORE = 100
DEFAULT_CITY = "北京"

这只是约定，不是强制限制。

PI = 3.14159
PI = 3

这样写仍然能运行，但不推荐。

教学时可以这样讲：

全大写变量名表示常量，提醒大家不要随便改。

二十、变量赋值和 None

有时候我们暂时还没有具体值，可以先赋值为 None。

None 表示“没有值”或“暂时为空”。

result = None

print(result)

输出：

None

常见场景：

student = None

if student is None:
    print("还没有学生信息")

判断是否为 None，推荐使用：

is None

或：

is not None

二十一、变量赋值和类型标注

Python 支持类型标注。

类型标注可以告诉读代码的人：这个变量期望保存什么类型的数据。

age: int = 18
name: str = "小明"
score: float = 95.5
is_passed: bool = True

注意：

类型标注主要是提示和辅助检查，不会强制限制变量类型。

例如：

age: int = 18
age = "十八"

print(age)

这段代码仍然可以运行。

基础教学中，类型标注可以作为扩展内容，不必一开始要求学生全部使用。

二十二、变量作用域简单了解

变量的作用域指的是变量可以在哪里使用。

基础阶段可以先简单了解两类：

全局变量：定义在函数外部。
局部变量：定义在函数内部。

例子：

name = "小明"


def show_name():
    age = 18
    print(name)
    print(age)


show_name()

这里：

name 是全局变量，在函数外定义。
age 是局部变量，在函数内部定义。

如果在函数外使用 age：

print(age)

会报错，因为 age 只在函数内部有效。

这部分可以在讲函数时再详细展开。

二十三、变量赋值常见错误

1. 使用未定义变量

错误：

print(score)
score = 95

正确：

score = 95
print(score)

2. 变量名写错

student_name = "小明"

print(studet_name)

这里 student_name 和 studet_name 拼写不同，会报错。

建议：

变量名不要太随意。
使用编辑器自动补全。
报错时检查拼写。

3. 使用非法变量名

错误：

2name = "小明"
student-name = "小明"
class = "一班"

正确：

name2 = "小明"
student_name = "小明"
class_name = "一班"

4. 把 = 和 == 混淆

错误：

age = 18

if age = 18:
    print("年龄是 18")

正确：

age = 18

if age == 18:
    print("年龄是 18")

5. 多重赋值数量不匹配

错误：

a, b = 1, 2, 3

错误：

a, b, c = 1, 2

正确：

a, b, c = 1, 2, 3

6. 链式赋值创建共享列表

容易出错：

a = b = []

a.append("Python")

print(b)

输出：

['Python']

如果希望 a 和 b 是两个独立列表：

a = []
b = []

7. 覆盖内置函数名

不推荐：

str = "Python"
int = 10
list = [1, 2, 3]

这样可能影响后面调用 str()、int()、list()。

推荐使用更具体的变量名：

text = "Python"
age = 10
numbers = [1, 2, 3]

二十四、课堂综合示例

示例：学生成绩信息处理

name = input("请输入学生姓名：").strip()
age = int(input("请输入学生年龄："))
chinese, math, english = map(int, input("请输入语文、数学、英语成绩，用空格分隔：").split())

total = chinese + math + english
average = total / 3
is_passed = average >= 60

print("学生成绩信息：")
print(f"姓名：{name}")
print(f"年龄：{age}")
print(f"总分：{total}")
print(f"平均分：{average:.2f}")

if is_passed:
    print("结果：通过")
else:
    print("结果：未通过")

这段代码中包含：

普通赋值：name = ...
类型转换赋值：age = int(...)
多重赋值：chinese, math, english = ...
表达式赋值：total = chinese + math + english
布尔变量赋值：is_passed = average >= 60

可以引导学生分析每一个变量保存了什么数据。

二十五、教学中可以这样讲

可以用“标签”来解释变量：

变量不是盒子，更像标签。
数据是对象，变量名是贴在对象上的名字。

例如：

a = [1, 2, 3]
b = a

可以讲成：

a 和 b 两个标签贴在同一个列表上。

所以修改列表：

b.append(4)

a 看到的内容也会变化。

对于初学者，可以先掌握三句话：

变量用来保存数据。
= 表示赋值，不是判断相等。
多重赋值可以一次给多个变量赋值。

再逐步补充：

链式赋值可以给多个变量同一个值。
拆包赋值可以把一组数据拆给多个变量。
可变对象赋值时要注意共享引用。

二十六、课堂练习

练习 1：定义变量并输出

请定义姓名、年龄、城市三个变量，并输出。

参考答案：

name = "小明"
age = 18
city = "北京"

print(name)
print(age)
print(city)

练习 2：计算商品总价

请定义商品单价和数量，计算总价。

参考答案：

price = 19.9
count = 3

total = price * count

print(f"总价是{total:.2f}元")

练习 3：交换两个变量

请交换变量 a 和 b 的值。

a = 10
b = 20

参考答案：

a = 10
b = 20

a, b = b, a

print(a)
print(b)

输出：

20
10

练习 4：多重赋值

请用一行代码给 name、age、score 赋值。

参考答案：

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

print(name)
print(age)
print(score)

练习 5：链式赋值

请把 a、b、c 都初始化为 0。

参考答案：

a = b = c = 0

print(a)
print(b)
print(c)

练习 6：拆包列表

给定列表：

data = ["小明", 18, 95]

请分别赋值给 name、age、score。

参考答案：

data = ["小明", 18, 95]

name, age, score = data

print(name)
print(age)
print(score)

练习 7：星号拆包

给定列表：

numbers = [1, 2, 3, 4, 5]

请取出第一个数、最后一个数，以及中间的数。

参考答案：

numbers = [1, 2, 3, 4, 5]

first, *middle, last = numbers

print(first)
print(middle)
print(last)

输出：

1
[2, 3, 4]
5

练习 8：修正错误代码

下面代码有什么问题？请改正。

student-name = "小明"

参考答案：

变量名不能使用减号 -。

正确写法：

student_name = "小明"

练习 9：判断输出结果

阅读下面代码，判断输出结果。

a = b = []
a.append(1)

print(a)
print(b)

参考答案：

[1]
[1]

原因：

a 和 b 指向同一个列表对象。

练习 10：输入三个成绩并计算平均分

请让用户一行输入三个整数成绩，计算平均分。

参考答案：

score1, score2, score3 = map(int, input("请输入三个成绩，用空格分隔：").split())

average = (score1 + score2 + score3) / 3

print(f"平均分是{average:.2f}")

二十七、常见错误对照表

错误现象	常见原因	修改方法
`NameError`	变量未赋值就使用，或变量名拼错	先赋值再使用，检查拼写
`if age = 18:` 报错	把赋值 `=` 当成比较 `==`	条件判断使用 `==`
`2name = "小明"` 报错	变量名不能数字开头	改成 `name2`
`student-name = "小明"` 报错	变量名不能包含减号	使用下划线 `student_name`
`a, b = 1, 2, 3` 报错	多重赋值数量不匹配	左右数量保持一致，或使用星号拆包
`a = b = []` 后修改 a，b 也变	两个变量指向同一个列表	分别写 `a = []` 和 `b = []`
`list = [1, 2]` 后 `list("abc")` 报错	覆盖了内置函数名	不要用内置函数名做变量名
输入年龄后比较报错	`input()` 得到字符串	使用 `int()` 转换

二十八、总结

变量是用来保存数据的名字，赋值是把数据关联到变量名上的操作。

Python 中使用 = 进行赋值。

基础阶段需要重点掌握：

变量名 = 值 是最基本的赋值写法。
= 表示赋值，== 表示判断相等。
变量必须先赋值，后使用。
变量名要遵守命名规则，建议使用有意义的英文单词和下划线。
变量可以重新赋值，也可以保存不同类型的数据。
x += 1 是 x = x + 1 的简写。
多重赋值可以一次给多个变量赋值。
a, b = b, a 可以交换两个变量的值。
链式赋值可以让多个变量得到同一个值。
给可变对象做链式赋值时要小心共享引用。
拆包赋值可以把列表、元组、字符串中的元素分配给多个变量。
星号拆包可以接收多个剩余值。

教学时可以让学生记住一句话：

赋值是给数据起名字，多重赋值是一次起多个名字。

掌握变量赋值与多重赋值以后，学生就能更自然地学习输入输出、表达式、条件判断、循环、函数和数据结构。