Skip to content

第 1 章:变量与数据类型 ​

本章能学到什么 ​

  • 变量是什么,为什么要用变量
  • 变量的赋值与命名规则
  • Python 的四种基本数据类型:int、float、str、bool
  • 用 type() 查看一个变量的类型
  • 动态类型与静态类型的区别(与 C++ 对照)

本章承接第 0 章"启程"——程序已经能跑起来,现在开始往程序里放"数据"。本章讲的数据类型,是第 2 章"运算符与表达式"的基础:不同类型的数据,能做的运算不一样。

1.1 从改分数说起 ​

班主任要登记小明的期中成绩。成绩单上写着:语文 92 分。后来复核发现加错了,应该是 95 分。如果成绩被抄进了十张表格,就得改十个地方;漏改一处,两处数据就对不上。

游戏里也有同样的事。角色血量显示在屏幕左上角,战斗时扣血,吃道具时加血。血量这个数字会被很多处用到,它不能写死在屏幕上,必须存在一个统一的地方,哪里要看血量,就去那里取。

程序里这个"统一存放数据的地方"就是变量。变量是一个带名字的格子,格子里放数据;程序通过名字找到格子,看里面的数,或者换一个新的数。

再细化一下游戏的例子。角色被怪物打一下,程序做的事是:找到名叫"血量"的格子,把里面的数减去 10,放回去,屏幕左上角的显示跟着刷新。如果血量不是一个变量,而是直接画在屏幕上的数字 100,被打一下就得把整张图重画一遍——每改一次数字重画一次,游戏根本做不出来。变量把"数据"和"显示"分开了:数据在格子里变,显示随时去读格子。

数学里其实早就在用字母代表数。交换律 a+b=b+a 里的 a 和 b 可以代入任何数;长方形面积 S=a×b 里的 a、b、S 各有各的角色。程序里的变量和它们是同一种思维,只是格子里的值可以随时换。

这个思路在数学里早就见过。方程 x+5=12 里的 x 就是一个"带名字的格子":它代表一个数,这个数可以待定、可以求解、可以代入。程序里的变量比方程里的未知数更灵活一点——x 在方程里通常只有一个答案,而变量的值在程序运行过程中可以多次改变,像记分牌上的分数一样可以翻动。

1.2 赋值 ​

在 Python 里,给变量赋一个值,变量就诞生了,不需要提前声明。

python
score = 92    # 赋值:把 92 放进名为 score 的格子
score = 95    # 再赋值:复核后改成 95,旧值被覆盖

print("复核后的成绩:", score)

预期输出:

text
复核后的成绩:95

三个要点:

操作写法含义
赋值score = 92造出格子 score,把 92 放进去
再赋值score = 95旧值被新值覆盖,格子里只剩 95
读取print(score)通过名字取出格子里的值

这里的 = 不是数学里的"等于"。数学里 x=5 是陈述"x 等于 5"这个事实;程序里 score = 92 是一个动作:"把 92 放进 score"。方向从右往左,右边的值进左边的格子。判断"等不等于"用的是另一个符号 ==,第 2 章会讲。

变量的命名规则 ​

规则合法的例子不合法的例子
只能用字母、数字、下划线score、hp2、player_1my score(含空格)
不能用数字开头score22score
不能用 Python 的关键字my_printprint、for、if
区分大小写score 和 Score 是两个变量—

名字要有意义。score 一看就懂,a1b2 过几天自己也看不懂。这是个好习惯,不强制,但强烈建议。多个单词组成的名字,习惯用下划线连起来,如 my_score、player_name,这种写法叫"蛇形命名",本书的变量名都按这个风格写。名字取得好,代码自己会说话;名字取得差,每行都要靠注释解释。

1.3 数据类型 ​

第 0 章的 "Hello, World!" 是文字,这里的 95 是整数。它们是不同类型的数据。为什么需要类型?因为不同数据的处理办法不一样:整数可以做除法求余数,文字不能;小数要保留小数点,整数不需要。

Python 最常用的四种基本类型:

类型放什么例子说明
int整数95、-3、0多大都能放,不用担心溢出
float小数(浮点数)1.42、95.5带小数点的数
str一串文字(字符串)"小明"、"Hello"用引号包住,单双引号都行
bool真假True、False只有两个值,首字母大写,第 4 章大显身手

Python 不用在代码里写类型名,但每个变量确实都有类型。用 type() 可以查看:

python
score = 95        # int:整数
height = 1.42     # float:小数
name = "小明"     # str:字符串
passed = True     # bool:真假

print(type(score))
print(type(height))
print(type(name))
print(type(passed))

预期输出:

text
<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>

类型决定数据能做什么。95 + 3 算出 98,是算术;"你" + "好" 拼出 "你好",是拼接。如果把文字当数字算,比如 "95" + 3,Python 会报 TypeError。类型是数据的"品种",品种不同,能做的操作不同。

字符串还有一种乘法的玩法:"ab" * 3 得到 "ababab"——把字符串重复三遍。数字的乘法是算术,字符串的乘法是复制,同一个 * 因类型而行为不同。这正是"类型决定操作"的又一个例子。

1.4 【跨语言对照】动态类型 vs 静态类型 ​

这件事本质上解决什么问题 ​

两种语言都要回答同一个问题:一个变量能放哪种数据、什么时候检查放对了没有。答案都是"要检查",分歧只在什么时候检查。

各自怎么做 ​

对比项Python(动态类型)C++(静态类型)
类型何时确定赋值时自动确定,运行时才知道声明时写明,编译时检查
声明写法score = 95int score = 95;
换个类型再赋值允许,直接赋新值不允许,编译报错
错误暴露时机运行到那一行时才报错编译期,程序还没运行就报错

下面是两段等价代码,做同样的事,输出完全一致。

Python:

python
name = "小明"   # 不用写类型,赋值时自动确定
score = 95
height = 1.42

print(name + " 考了 " + str(score) + " 分")
print("身高是 " + str(height) + " 米")

C++(详见《C++ 从入门到精通》第 1 章):

cpp
#include <iostream>
#include <string>

int main() {
    std::string name = "小明";  // 类型写死在声明里
    int score = 95;
    double height = 1.42;

    std::cout << name << " 考了 " << score << " 分" << std::endl;
    std::cout << "身高是 " << height << " 米" << std::endl;
    return 0;
}

两段代码的预期输出都是:

text
小明 考了 95 分
身高是 1.42 米

Python 版里一个类型名都没有,解释器看赋的值自己判断;C++ 版里每个变量都标了类型,编译器逐行核对。注意 Python 版的 str(score):数字要先转成字符串才能和文字拼接,这个"转换"的话题在第 3 章还会遇到。

动态类型还有一个直观的现象:同一个变量可以先放整数、再放文字。

python
x = 95        # 此刻 x 是 int
print(type(x))
x = "九十五"  # 现在 x 变成了 str
print(type(x))

预期输出:

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

同样的代码在 C++ 里编译都过不了——格子造好之后形状就定死了。

为什么设计得不一样 ​

Python 选择灵活。变量不用声明类型,少写很多字;想临时换个用途,直接赋新值就行。写代码快、改代码快,适合快速试验和短脚本。代价是类型错误要等运行到那一行才暴露。

C++ 在编译期查错。程序还没运行,类型错误就被编译器拦下来。同时,编译器提前知道了每个变量的类型,就能生成恰到好处的机器指令,运行时不必再花时间检查类型——这叫"零开销",是 C++ 快的原因之一。

两种设计各解决一类问题:要开发效率和灵活,动态类型顺手;要极限速度和尽早发现错误,静态类型顺手。本书不评判优劣,后面的章节里两种写法会一直对照出现。

1.5 x = x + 1:数学里不成立的等式 ​

数学课上,方程 x=x+1 是无解的——一个数不可能等于自己加一。程序里这一行不仅成立,而且极其常用:

python
x = 5
x = x + 1   # 数学上无解,程序里是动作
x = x + 1   # 再来一次

print("x 现在是 " + str(x))

预期输出:

text
x 现在是 7

原因在于 1.2 节说过的:= 是动作,不是陈述。x = x + 1 读作"先算出右边 x + 1 得 6,再把 6 放进 x"。等号两边地位不同:右边是"算",左边是"装"。计数器、得分、血量,全都靠这个写法一点点变化。第 2 章还会给它一个更短的写法 x += 1。

1.6 变量的本质:名字贴在值上 ​

Python 的变量更像便利贴,而不是格子。x = 95 是写一张写着 x 的便利贴,贴在数字 95 上;x = "九十五" 是把这张便利贴撕下来,贴到文字"九十五"上。便利贴本身没有类型,类型属于被贴的那个值。

这个模型能解释 1.4 节的现象:同一个名字先贴整数、再贴文字,没人阻拦,因为便利贴本来就没有形状限制。它也解释了一个容易迷惑的现象:

python
a = 100
b = a      # 把写着 b 的便利贴也贴到 100 上
a = 200    # a 撕下来贴到 200 上
print(b)   # b 还贴在 100 上

预期输出:

text
100

a 改贴别处,不影响 b 还贴在原来的值上。便利贴各管各的。

1.7 常量:全大写的约定 ​

圆的面积公式是 S=πr2。π 的值是固定的,程序里不希望任何一行不小心改掉它。Python 没有"锁住变量"的语法,用的是一条约定:名字全大写的变量,请大家别改。

python
PI = 3.14159   # 全大写表示"这是常量",是约定,不是强制
r = 2.0

print("半径 " + str(r) + " 的圆,面积是 " + str(PI * r * r))

预期输出:

text
半径 2.0 的圆,面积是 12.56636

写 PI = 3.14 不会报错,但所有读代码的人都知道这违反了约定。C++ 里有真正的锁——const 关键字,改了就编译不过,姊妹册第 1 章有对照写法(见《C++ 从入门到精通》第 1 章)。两种办法一松一严,背后的意图相同:把"不许动"写在明处。

1.8 类型选择小指南 ​

遇到一个新数据,它会是什么类型?按这张表对号入座:

数据长什么样是什么类型例子
整的数,没有小数点int年龄、分数、血量
带小数点的数float身高、体重、价格
一个词、一句话str姓名、地址
只有两个状态bool是否及格、是否在线

两个 Python 特有的便利,了解一下:

一是一次给多个变量赋值:a, b = 1, 2,一行搞定两个。变量个数和值的个数要一样多,对不上会报错。

二是交换两个变量只要一行:a, b = b, a。其他语言通常要借第三个变量中转,姊妹册第 2 章会专门演示 C++ 的交换写法(见《C++ 从入门到精通》第 2 章)。Python 这一行的背后,也是先把两个值都准备好,再同时贴回名字——用 1.6 节的便利贴模型一想就通。

还有一个习惯值得养成:变量出生时就给它一个明确的值。Python 里不赋值就没有这个名字,硬要用会报 NameError,错误信息里会指出是哪个名字不认识。看到 NameError,先去检查名字有没有拼错、赋值语句有没有执行到。

动手实验 ​

实验 1:给游戏角色建档。 创建四个变量:角色名(str)、等级(int)、血量(int)、是否在线(bool),赋上你设计的值,逐行显示出来,并用 type() 显示血量的类型。

💡 查看答案
python
hero = "小勇士"
level = 12
hp = 350
online = True

print("角色:" + hero)
print("等级:" + str(level))
print("血量:" + str(hp))
print("在线:" + str(online))
print(type(hp))

预期输出:

text
角色:小勇士
等级:12
血量:350
在线:True
<class 'int'>

True 显示为 True,首字母大写,与 C++ 显示 1 不同。

实验 2:见证覆盖。 写 hp = 100,然后连续写 hp = 80、hp = 120,最后 print(hp)。先预测屏幕上出现的是哪个数,再运行。

💡 查看答案
python
hp = 100
hp = 80    # 覆盖 100
hp = 120   # 覆盖 80
print("当前血量:" + str(hp))

预期输出:

text
当前血量:120

格子里永远只留最后一次放进去的值。

实验 3:制造类型错误。 写 print("分数是" + 95),运行。观察报错信息,再用 str() 改成合法写法。

💡 查看答案

运行时报 TypeError: can only concatenate str ... to str,意思是文字只能和文字拼接,不能直接拼数字。这正是动态类型的特点:错误在运行到这一行时才暴露。改成 print("分数是" + str(95)) 即可,先预测再验证输出:

text
分数是95