01 Python基础：变量类型、字符串格式化、输入输出与运算符

学习方式：对照黑马 Python+AI 讲义第 2 章第 1 节（数据存储与运算）边看边敲，代码验证文件 01.py。已有 C++/Java 基础，重点记录 Python 与它们的写法差异。

一、变量与动态类型

1.1 变量与字面量

• 字面量：程序中直接书写的固定值，如 10、8.5、"Python"、True、None。
• 变量：存储单个数据的容器，定义格式 变量名 = 值，如 num = 1114.1。
• 动态类型：Python 是动态类型语言，变量不需要声明类型，类型由当前存的值决定，可以反复赋不同类型的值。这是与 C++/Java 静态类型最大的差异。

a = 10          # 此时 a 是 int
a = 12.5        # 重新赋值为 float，无需任何声明
a = 'hello'     # 再赋值为 str

1.2 五大基础数据类型

类型	说明	示例
int	整数	10、-5
float	浮点数	8.5、3.14
str	字符串	"Python"
bool	布尔	True、False
NoneType	空值	None

实际验证（01.py）：

a = 10
print(a, type(a))        # 10 <class 'int'>
a = 12.5
print(a, type(a))        # 12.5 <class 'float'>
a = 'hello'
print(a, type(a))        # hello <class 'str'>
a = True
print(a, type(a))        # True <class 'bool'>
a = None
print(a, type(a))        # None <class 'NoneType'>

注意两点：

• 布尔本质是数字，参与运算时 True 当 1、False 当 0。
• 变量本身没有类型，type(变量) 输出的是变量中存储的数据的类型。

1.3 类型判断：type() 与 isinstance()

• type(数据)：返回数据的确切类型（用于调试查看）。
• isinstance(数据, 类型)：判断数据是否属于某类型，返回布尔，子类也算（面向对象中猫属于动物）。

num = 5.0
print(isinstance(num, int))    # False
print(isinstance(num, float))  # True
print(type(num))               # <class 'float'>

写判断逻辑优先用 isinstance，它支持一次判断多个类型（传元组）：

x = 3.14
print(isinstance(x, (int, float)))   # True，x 是数字

两个容易踩的点：

• bool 是 int 的子类：isinstance(True, int) 结果为 True。想严格区分布尔，要先 isinstance(x, bool) 或直接用 type(x) == bool。
• 判断 None 不要用 isinstance(x, None)（None 不是类型，会报错），标准写法是 x is None；如果非要用 isinstance，写 isinstance(x, type(None))。判断”非 None 且有内容”用 if x is not None。

二、字符串：定义、拼接与格式化

2.1 三种定义方式

a = 'hello'                  # 单引号
a = "world"                  # 双引号（单双引号等效，项目中保持一种）
a = """hellowor
ld"""                        # 三引号，支持多行

2.2 拼接与格式化三种方式

拼接用 +，但只能拼字符串，非字符串必须先 str() 转换；拼接繁琐，实际更常用格式化。

name = '小明'
age = 21
print(str(name) + "今年" + str(age) + "岁")   # 拼接，需手动转 str
print('%s 今年 %s 岁' % (name, age))          # % 占位符，%s 表示字符串
print(f'{name}今年{age}岁了')                  # f-string，推荐

三种方式中 f-string 最推荐：直接写 f"{变量}"，不用类型转换，可读性最好。

2.3 f-string 进阶格式（组合顺序）

格式说明符完整顺序：对齐 + 宽度 + 千分位 + 精度 + 类型。

x = 1234.5678
print(f"{x:.2f}")           # 1234.57    保留两位小数（类型 f = 浮点）
print(f"{x:,.0f}")          # 1,235      千分位
print(f"{x:>10.1f}")        # 右对齐占 10 位，做表格对齐
print(f"{x:<10.1f}")        # 左对齐
print(f"{x:>10,.2f}")       #   1,234.57 对齐+千分位+精度，组合顺序：对齐宽度在前，逗号中间，精度最后

位置	写法	示例
对齐	>右、<左、^居中（必须和宽度成对）	>10
宽度	数字	10
千分位	逗号	,
精度	.数字	.2
类型	f 浮点 / d 十进制整数 / % 百分比 / x 十六进制等	f

类型说明符区分：

• f 是浮点，可以用精度（:.2f 控制小数位）。
• d 是十进制整数，不能用精度（f"{255:.2d}" 会报错），补位用零填充 f"{255:05d}" → 00255，千分位 f"{1234567:,d}" → 1,234,567。
• % 也是类型位，排在最后，会自动把值乘 100 再加百分号：f"{0.2567:.1%}" → 25.7%，不要自己再乘一次。

print(f"{1234.5678:>10,.2%}")   # 123,456.78% 全组合：右对齐+千分位+2位小数+百分比

三、输入输出与类型转换

3.1 input() 永远返回字符串

name = input('请输入姓名:')
age = input('请输入年龄:')
print(f'{name}今年{age}岁了')

input() 无论键盘输入什么，得到的永远是字符串。要参与数学运算必须先转换类型。

3.2 类型转换

int(数据)、float(数据)、str(数据)、bool(数据)。

实际验证（01.py，输入 50）：

a = input()
print(a, type(a))      # 50 <class 'str'>
a = int(a)
print(a, type(a))      # 50 <class 'int'>

3.3 print() 的 sep 与 end

sep 控制多个值之间的分隔符（默认空格），end 控制结尾字符（默认换行）：

print(1, 2, 3, sep='~', end='!')   # 1~2~3!

3.4 一行输入多个值：split()

a, b = input().split()    # 输入 "5 9"，a='5'，b='9'（仍是字符串）
print(a, b)               # 5 9

# split() 默认按空白切分，也能拆字符串：
a = '1 2 3 4\n5'
print(a.split())          # ['1', '2', '3', '4', '5']

四、运算符与表达式

4.1 算术运算符及结果类型

运算符	含义	示例	结果
/	除法，结果永远是浮点	5/2	2.5（float）
//	整除（向下取整）	5//2	2（int）
%	取余	5%2	1
**	幂	2**3	8

实际验证（01.py 的运行结果，注意类型跟随结果变化）：

print("1+2=", 1+2, type(1+2))        # 3 <class 'int'>
print("1+2.3=", 1+2.3, type(1+2.3))  # 3.3 <class 'float'>
print("5/2=", 5/2, type(5/2))        # 2.5 <class 'float'>  ← 除法永远是浮点
print("5//2=", 5//2, type(5//2))     # 2 <class 'int'>
print("5%2", 5%2, type(5%2))         # 1 <class 'int'>
print("2**3", 2**3, type(2**3))      # 8 <class 'int'>

Python 没有 ++/-- 自增自减，递增写 x += 1。

4.2 浮点精度问题

print(0.1+0.2, type(0.1+0.2))
# 0.30000000000000004 <class 'float'>

二进制无法精确表示所有小数，浮点运算可能损失精度。涉及金额等精确计算不要用 float（见 5.2 Decimal）。

4.3 链式比较

Python 特有（C++/Java 不能这样写），连续比较等价于用 and 连接：

print(1 < 2 < 3)         # True
print(1 < 2 and 2 < 3)   # True（等价写法）

4.4 divmod() 一次拿商和余数

q, r = divmod(10, 3)
print(q, r)              # 3 1

4.5 赋值、比较与逻辑运算符

• 赋值：= += -= *= /= %= //= **=。
• 比较：== != > >= < <=，返回布尔。
• 逻辑：and（与）、or（或）、not（非），对应 C++/Java 的 &&、||、!，是单词不是符号。

判断”在 10-20 之间”：10 <= num <= 20 或 num >= 10 and num <= 20。

五、易踩坑与补充知识点

5.1 round() 是银行家舍入，不是四舍五入

round(x) 取整、round(x, n) 保留 n 位小数，但规则是四舍六入五成双：小数部分正好 .5 时看前一位，偶数舍、奇数进（向偶数靠拢）。

print(round(2.5))   # 2  ← 5 前是 2（偶数），舍掉，不是数学上的 3
print(round(3.5))   # 4  ← 5 前是 3（奇数），进位
print(round(4.5))   # 4  ← 4 是偶数，舍掉
print(round(2.675, 2))  # 2.67  ← 2.675 在二进制里实际是 2.67499...，浮点误差导致

f"{2.5:.0f}" 输出也是 2，和 round() 同一套五成双规则，不是真四舍五入。需要四舍五入时：正数用 int(x + 0.5)，精确场景用 Decimal 的 ROUND_HALF_UP。

5.2 Decimal：精确十进制，金额计算用它

decimal 模块提供的精确十进制数，解决 float 二进制误差。构造时传字符串，不要传 float（会把误差一起带进来）。

from decimal import Decimal

print(Decimal("0.1") + Decimal("0.2"))   # 0.3 精确

from decimal import Decimal, ROUND_HALF_UP
print(Decimal("2.5").quantize(Decimal("1"), rounding=ROUND_HALF_UP))        # 3，真四舍五入
print(Decimal("2.675").quantize(Decimal("0.01"), rounding=ROUND_HALF_UP))  # 2.68

5.3 海象运算符 :=（Python 3.8+）

赋值并立即在表达式中使用，省一行：

if (n := len("hello")) > 3:
    print(f"长度是 {n}")    # 长度是 5

5.4 多变量赋值与解包

一条语句给多个变量赋值，交换变量一行搞定，也能把列表元素解包给多个变量：

a, b, c = 100, 200, 300
a, b, c = c, a, b          # 右侧整体打包后依次赋值，实现轮换
print(a, b, c)             # 300 100 200

a = [5, 8, 7]
z, x, c = a                # 解包：z=5, x=8, c=7
print(z, x, c)             # 5 8 7

今日总结

模块	核心要点
变量与类型	动态类型不声明；五大类型 int/float/str/bool/NoneType；判断类型用 isinstance（认子类、可多类型），None 用 is None
字符串	三引号可多行；格式化首选 f-string；格式顺序=对齐+宽度+千分位+精度+类型；f可设精度、d不能、%自动×100
输入输出	input() 永远是字符串，要转换；print 用 sep/end 控制分隔和结尾；split() 一行取多值
运算符	/ 永远浮点、// 整除、% 取余、** 幂；浮点有精度误差；支持链式比较 1<2<3；divmod() 一次拿商余
易踩坑	round() 五成双不是四舍五入；精确金额用 Decimal（构造传字符串）；无 ++/-- 用 +=