一、变量：给数据起个名字

变量的作用只有一句话：把数据存起来，起个名字，以后用名字叫它。

>>> age = 18
>>> age
18
>>> age + 2
20

读法：age = 18 不是数学上的"等于"，而是 "把 18 装进名叫 age 的盒子"。

1.1 与 C++ / Java 的第一个大差别：不用声明类型

age = 18
price = 9.9
name = "树莓派"
ok = True

就这么四行，一个类型都没写，Python 自己看值决定：

对照 C++（回顾 变量）：

int age = 18;
double price = 9.9;
std::string name = "树莓派";   // 还得 #include <string>
bool ok = true;                // 注意 C++ 是小写 true

x = 5          # 现在是整数
x = "五"       # 变成字符串了，没人拦你

1.2 命名规则：三条硬规矩 ＋ 一条软约定

硬规矩（违反就是语法错误）：

软约定（不遵守也能跑，但会被嫌弃）：

• 全小写 ＋ 下划线分隔，叫蛇形命名：user_name、max_speed、led_pin （C++ / Java 习惯是驼峰 userName——Python 社区一律用下划线，跟着来）
• 名字要有意义：a、b、x1 这种，过两天你自己都看不懂
• 全大写表示"常量"（Python 没有真正的常量，这是君子协定）：MAX_SPEED = 100

二、数据类型：五大金刚

Python 内置类型很多，入门只需认这五个：

2.1 提前打预防针：小数的精度问题

>>> 0.1 + 0.2
0.30000000000000004

不是 Python 的 bug，是所有编程语言的通病（C++ / Java 也一样）。原因是计算机用二进制存小数，0.1 这种十进制小数存不精确。

>>> 0.1 + 0.2 == 0.3
False          # 你以为是 True

三、运算符：算数、比较、逻辑

3.1 算术运算符（七个，注意其中两个和 C++ 不同）

>>> 10 / 3      # 真除法
3.3333333333333335
>>> 10 // 3     # 整除（只要整数部分，不四舍五入）
3
>>> 10 % 3      # 取余（剩下多少）
1

// 和 % 是天生一对——分东西的时候必用：

>>> total = 3661                 # 一共多少秒
>>> hours = total // 3600        # 里面有 1 个整小时
>>> rest = total % 3600          # 去掉整小时后，还剩 61 秒
>>> minutes = rest // 60         # 61 秒里有 1 个整分钟
>>> seconds = rest % 60          # 最后剩 1 秒
>>> print(hours, minutes, seconds)
1 1 1

验证：1 小时 = 3600 秒，加 1 分钟 60 秒，加 1 秒 = 3661 ✅ 对得上。

3.2 字符串运算符（只有两个能用）

>>> "3" + 4
TypeError: can only concatenate str (not "int") to str

字符串另一个特别常用的是 f-string（下一小节专门讲）。

3.3 比较运算符（结果是 True / False）

x = 5      # 把 5 装进 x
x == 5     # 问：x 是不是 5？ → True

3.4 逻辑运算符：and / or / not

Python 用英文单词，不用符号（C++ / Java 用的是 && / || / !）：

>>> temp = 25
>>> temp > 20 and temp < 30
True
>>> not (temp > 30)
True

3.5 增强赋值：+= 这类简写

x = x + 1 写多了很啰嗦，所以有简写：

>>> stock = 10
>>> stock += 5
>>> stock
15

>>> x = 5
>>> x++
  File "<stdin>", line 1
    x++
       ^
SyntaxError: invalid syntax

四、type()、input() 与类型转换（本节最关键的一段）

4.1 type()：问一个值"你是什么"

因为动态类型不会报错，所以你需要主动去问：

>>> type(18)
<class 'int'>
>>> type(9.9)
<class 'float'>
>>> type("18")
<class 'str'>
>>> type(True)
<class 'bool'>

注意 type("18") 的结果是 str——加了引号就是文字，哪怕内容全是数字。这是本课后面最容易出错的地方。

4.2 input()：从键盘要一个值——它永远给你字符串！

>>> name = input("请输入你的名字：")
请输入你的名字：波仔
>>> print("你好，" + name + "！")
你好，波仔！

看起来很顺。但换成数字就翻车了：

>>> age = input("你多大了？")
你多大了？18
>>> age + 1
TypeError: can only concatenate str (not "int") to str

为什么？ 因为 input() 拿到的永远是字符串——你敲的是 18，它给你的是 "18"（带引号的文字）。文字不能加数字。

>>> age = int(input("你多大了？"))
你多大了？18
>>> age + 1
19

ValueError: invalid literal for int() with base 10: '十八'

4.3 类型转换四兄弟

4.4 f-string：把变量塞进句子里（现代 Python 最常用的写法）

最老的拼接方式：

name = "波仔"
print("你好，" + name + "，今天天气不错。")

f-string（Python 3.6 起，现在一律用它）：

name = "波仔"
temp = 25.6
print(f"你好，{name}，现在室温 {temp} 度。")

输出：你好，波仔，现在室温 25.6 度。

三个要点：

1. 字符串前面加一个 f（format 的意思）——不加就变成普通文字，{} 里原样输出。
2. {} 里可以直接写变量名，也可以写表达式：f"两数之和是 {3 + 4}"。
3. 它还能顺手做格式化（这个很实用）： ```python

   pi = 3.14159265 f"{pi:.2f}" # 保留两位小数 '3.14' count = 7 f"{count:03d}" # 补零到三位 '007' ```

五、动手 Demo：写一个"秒数换算器"

把本节学到的东西串起来。在命令行里写（无头模式的做法见 6-2）：

mkdir -p ~/projects
cd ~/projects
nano sec2hms.py

内容：

# 秒数换算器：把一大堆秒，换算成几小时几分几秒
total = int(input("请输入秒数："))

hours = total // 3600        # 一个小时 3600 秒，整除得到小时数
rest = total % 3600          # 去掉整小时后，还剩多少秒
minutes = rest // 60         # 剩下的秒里有多少个整分钟
seconds = rest % 60          # 最后剩几秒

print(f"{total} 秒 = {hours} 小时 {minutes} 分 {seconds} 秒")

# 顺便算点别的
print(f"这相当于 {total / 60:.1f} 分钟")
print(f"一天有 86400 秒，这些秒占一天的 {total / 86400 * 100:.2f}%")

跑：

python3 sec2hms.py

输入 3661，看到什么算成功：

请输入秒数：3661
3661 秒 = 1 小时 1 分 1 秒
这相当于 61.0 分钟
一天有 86400 秒，这些秒占一天的 4.24%

读结果（每一步都验算给你看）：

再试一个：输入 86399，应该得到 23 小时 59 分 59 秒、1439.98 分钟、100.00%（真实值是 99.9988…%——这正好演示了"格式化会四舍五入"，它把 99.9988 显示成了 100.00）。

六、30 秒实验

实验一：亲眼看见 / 和 // 的区别

>>> 7 / 2
3.5
>>> 7 // 2
3
>>> 7 % 2
1
>>> type(7 / 2)
<class 'float'>
>>> type(7 // 2)
<class 'int'>

7 / 2 连类型都变了（float）—— 这是 Python 和 C++ 最硬的一个差别。

实验二：亲眼看见"文字不是数字"

>>> type("18")
<class 'str'>
>>> "18" * 3
'181818'
>>> 18 * 3
54

看见了吗："18" * 3 不是乘法，是字符串重复三次（得到 '181818'）。引号一加，它就从"数"变成了"一串字符"——这是个非常容易看走眼的坑。

实验三：小数精度

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1 + 0.2 == 0.3
False
>>> round(0.1 + 0.2, 2)
0.3

round(值, 位数) 是"四舍五入到几位小数"——显示数字时可以用它，但比较大小还是别用 ==。

实验四：bool() 的规律

>>> bool(0), bool(1)
(False, True)
>>> bool(""), bool("0")
(False, True)

注意 bool("0") 是 True（因为 "0" 是非空字符串，是"有东西"，不是"零"）——这一条骗过无数人。

七、常见误区

1. "10 / 2 应该等于 5" —— 在 Python 里它等于 5.0（浮点数）。/ 永远返回小数，要整数用 //。这是 C++ / Java 转过来最常见的错。
2. "x++ 是加一" —— Python 没有 ++ / --，会直接 SyntaxError。写 x += 1。
3. "input() 拿到的是数字" —— 永远是字符串。做算术前必须 int() 或 float() 转一遍（int(input(...)) 是最常见的写法）。
4. ""3" + 4 会自动拼成 "34"" —— 那是 Java / C++ 的行为。Python 直接报 TypeError，逼你说清楚到底是要"拼字"还是"算数"。要拼就 str(4)，要算就 int("3")。
5. "true / false / none 小写也行" —— 不行。这三个特殊值必须首字母大写：True / False / None。小写会报 NameError（true 在 C++ / Java 里是小写，习惯得改）。
6. "小数比较用 == 没问题" —— 有问题。0.1 + 0.2 == 0.3 的结果是 False。小数比较要用"差值够小"的方式。
7. "变量名随便起，反正能跑" —— 能跑，但过两天你自己看不懂。用有意义的名字，并且跟着 Python 社区用下划线（led_pin 而不是 ledPin）。

• ☐ 下一节（6-4 Python 流程控制）

相关笔记

• 在树莓派开发 Python 程序 —— 上一节：这些例子都在那里学的交互模式里练
• 变量 —— 「必须声明类型」的对照；变量到底是什么，那里讲得更细
• 数据类型 —— 类型系统对照（C++ 有 int 上限，Python 整数不限大小）
• 运算符 —— 运算符分类的对照；/ 与 // 的差别在那里是本课没提过的
• ☕ Java 基础 · 索引 —— Java 的字符串拼接行为，正好和 Python 相反
• 🍓 树莓派 · 索引 —— 全课路线图