Python基础标量类型用法：整数、浮点数与布尔值

一、整数类型（int）：任意精度大数与进制计算

Python 3 的整数类型 int 拥有一个极其关键的语言特性：无溢出任意精度（Arbitrary Precision）。在 C/C++、Java 等多数静态编译语言中，整型通常被严格限制在 32 位（-2,147,483,648 到 2,147,483,647）或 64 位内，一旦数值计算超出上限就会触发静默溢出或异常；而在 Python 3 中，整数由底层的 PyLongObject 结构体支持，其内部通过连续的动态数组（以 30 位或 15 位为一个数字化单元）记录数值，只要物理内存充裕，整数可以无限增长。

1. 字面量与多进制表示语法

在编写代码时，除了最常用的十进制整数外，Python 还内置支持二进制、八进制和十六进制字面量表示。同时，为了提高长数字的可读性，Python 允许在整数字面量中使用下划线 _ 作为视觉分隔符，解释器在语法解析阶段会自动忽略下划线。

# 常见十进制与下划线增强可读性
decimal_val = 1_000_000_000  # 等价于 1000000000
negative_val = -42

# 多进制字面量声明
bin_num = 0b101010   # 二进制前缀 0b 或 0B（十进制对应 42）
oct_num = 0o52       # 八进制前缀 0o 或 0O（十进制对应 42）
hex_num = 0x2A       # 十六进制前缀 0x 或 0X（十进制对应 42）

# 示例输出验证
print(bin_num == oct_num == hex_num == 42)
# [输出] True

# 内置转换函数
print(bin(42))   # [输出] '0b101010'
print(hex(42))   # [输出] '0x2a'
print(int("0x2a", 16)) # [输出] 42

2. 核心算术运算与除法分流规则

在整数算术中，最需要警惕的是除法运算的符号分流。Python 提供了两种除法操作符：

• 真除法（/）：无论被除数和除数是否为整数、是否能够整除，计算结果一律强制提升为浮点数 float。例如 4 / 2 得到 2.0 而不是 2。
• 整除向下取整（//）：执行整除运算，结果朝负无穷方向取整（Floor Division）。对于正数，7 // 2 得到 3；但对于负数，-7 // 2 得到 -4 而非 -3。
• 求模运算（%）：计算余数，Python 严格保证数学恒等式 a == (a // b) * b + (a % b) 始终成立。因此负数取模结果的符号始终与除数 b 一致，例如 -7 % 2 为 1（因为 (-4)*2 + 1 == -7）。
• 内置函数 divmod(a, b)：同时返回商和余数的二元组 (a // b, a % b)，在处理时分秒换算或分页逻辑时既高效又清晰。

# 整数除法与取整行为对比
print(8 / 4)      # [输出] 2.0 (类型为 float)
print(7 // 2)     # [输出] 3 (整除截断)
print(-7 // 2)    # [输出] -4 (向下朝负无穷取整，初学者高频踩坑)

# 恒等式验证与 divmod
q, r = divmod(17, 5)
print(f"商: {q}, 余数: {r}") # [输出] 商: 3, 余数: 2
print(17 == q * 5 + r)        # [输出] True

# 幂运算（支持大数快速幂）
large_pow = 2 ** 100
print(large_pow)  # [输出] 1267650600228229401496703205376 (自动支持超大数)

二、浮点数类型（float）：IEEE 754 标准与精度控制

Python 中的 float 类型对应底层的 C 语言 double（双精度浮点数），遵循 IEEE 754 标准。它在内存中占用固定的 64 位（8 字节）：1 位符号位、11 位指数位（阶码）以及 52 位有效尾数位（由于隐含首位为 1，实际有效精度约为 53 位二进制，等价于十进制 15 到 17 位有效数字）。

1. 浮点数字面量与科学计数法

浮点数字面量可以通过小数点直接声明，也可以通过科学计数法（使用 e 或 E）表示极大或极小的值：

standard_float = 3.1415926
scientific_large = 2.99792458e8  # 光速，等价于 299792458.0
scientific_small = 1.6e-19       # 元电荷

2. 为什么 0.1 + 0.2 != 0.3？精度误差的底层推导

几乎所有初学者都会对 0.1 + 0.2 == 0.3 返回 False 感到困惑。这并不是 Python 的 bug，而是二进制浮点体系的内在局限：

正如十进制无法用有限小数表达三分之一（1/3 = 0.33333... 无限循环）一样，以 2 为基数的二进制系统也无法精确表示十进制小数 0.1 和 0.2（因为其分母因子包含 5）。在转换为二进制后，尾数呈 0011 无限循环，而 64 位浮点数仅能保留 53 位有效位，多余部分被迫发生舍入截断。

当执行 0.1 + 0.2 时，两个本就带微小偏差的数值求和对阶，最终在内存中得出的值约为 0.30000000000000004441...，而字面量 0.3 的内存表示约为 0.29999999999999998890...。两者在二进制级别并不相等，直接使用 == 判断必然失败。

3. 浮点数安全比对与 math.isclose

在编写包含浮点数逻辑的条件分支时，绝对禁止使用 == 或 != 直接判等。标准做法是调用 Python 标准库提供的 math.isclose()：

import math

a = 0.1 + 0.2
b = 0.3

# 错误写法
print(a == b)  # [输出] False (危险！业务逻辑将误入错误分支)

# 正确写法：使用相对与绝对容差进行比对
print(math.isclose(a, b))  # [输出] True (默认 rel_tol=1e-09)

# 针对接近 0 的极小值比对，需手动提供绝对容差 abs_tol
x = 1e-11
y = 0.0
print(math.isclose(x, y, abs_tol=1e-10))  # [输出] True

4. 银行家舍入法与财务级精度方案（decimal.Decimal）

Python 的内置四舍五入函数 round(number, ndigits) 采用的是银行家舍入法（Round half to even，奇进偶舍）：当待舍弃部分恰好为 0.5 时，向最近的偶数舍入。这有助于在大量数据统计中抵消系统性向上偏差，但常出乎日常直觉：

print(round(2.5))  # [输出] 2 (向偶数 2 舍入)
print(round(3.5))  # [输出] 4 (向偶数 4 舍入)
print(round(4.5))  # [输出] 4 (向偶数 4 舍入)

对于电商支付、记账系统、金融清算等对精度有绝对零容差要求的场景，严禁使用 float，必须使用内置的 decimal 模块。注意：初始化 Decimal 时必须传入字符串，若传入浮点数则在初始化前就已经丢失了精度：

from decimal import Decimal

# 错误示例：传入 float 无法消除已有的截断误差
bad_dec = Decimal(0.1)
print(bad_dec)  # [输出] 0.1000000000000000055511151231257827021181583404541015625

# 正确示例：传入字符串进行精确初始化
d1 = Decimal("0.1")
d2 = Decimal("0.2")
d3 = Decimal("0.3")
print(d1 + d2 == d3)  # [输出] True (无损十进制高精度比对)

三、布尔类型（bool）：int 的子类与短路求值

布尔类型 bool 只有两个常量实例：True 和 False。它们在 Python 内部是不可变的全局单例对象。深入理解布尔类型，必须把握两个根本设计：它是 int 的直接子类，以及逻辑运算符具有短路与原值返回特性。

1. bool 继承自 int 的本质

在 Python 的对象体系中，bool 是通过继承 int 实现的：

print(issubclass(bool, int))  # [输出] True
print(isinstance(True, int))   # [输出] True
print(True == 1)               # [输出] True
print(False == 0)              # [输出] True
print(True is 1)               # [输出] False (值相等，但并非同一单例对象)

由于这个继承关系，布尔值可以直接参与所有算术运算。在工程中，常见的优雅用法是配合 sum() 进行条件计数统计：

scores = [85, 92, 58, 76, 61, 99]
# 统计及格（>=60）的人数：每个满足条件的表达式求值为 True (即 1)
passed_count = sum(score >= 60 for score in scores)
print(f"及格人数: {passed_count}")  # [输出] 及格人数: 5

2. 对象的真值测试（Truthy 与 Falsy 规则）

任何 Python 对象都可以在 if 或 while 条件语境中作为条件表达式求值，或者传递给 bool(x) 进行显式判定。根据官方规范，只有以下特定对象会被判定为假（Falsy），其余所有对象一律判定为真（Truthy）：

• 假值（Falsy）核心清单：
  • 常量：None、False
  • 各类数值零：0、0.0、0j、Decimal(0)、Fraction(0, 1)
  • 所有空序列与集合：空字符串 ""、空元组 ()、空列表 []、空字典 {}、空集合 set()、空切片 range(0)
  • 定义了 __bool__() 返回 False 或定义了 __len__() 返回 0 的自定义类实例
• 常见误区：非空字符串 "0"、"False"、包含单个假值的列表 [False]、[0] 均属于真值（Truthy）。初学者常误以为 bool("False") 会返回 False，实际结果为 True。

3. 逻辑运算符（and, or, not）与短路求值（Short-circuit Evaluation）

Python 中的 and 和 or 运算符并不单纯返回布尔值 True/False，而是返回首个决定表达式结果的原始操作数，并且具备“短路求值”特性：

• expr1 and expr2（遇假即停）：首先计算 expr1。如果 expr1 为 Falsy，由于无论后续为何值整个与运算必为假，解释器立即短路中断，直接返回 expr1 原对象（不执行 expr2）；若 expr1 为 Truthy，则继续求值并返回 expr2。
• expr1 or expr2（遇真即停）：首先计算 expr1。如果 expr1 为 Truthy，整式必为真，解释器立即短路，直接返回 expr1 原对象（不执行 expr2）；若 expr1 为 Falsy，则继续求值并返回 expr2。
• not expr：不同于前两者，not 强制执行类型转换，无论操作数为何种类型，始终严格返回布尔值 True 或 False。

# and 返回决定性原对象
print([] and "Python")       # [输出] [] (遇到假值立即短路并返回)
print("Hello" and [1, 2, 3]) # [输出] [1, 2, 3]

# or 用于配置项的安全默认兜底
user_input = ""
port = user_input or 8080
print(f"生效端口: {port}")  # [输出] 生效端口: 8080

# 短路求值避免运行时异常（Guard Expression）
data = None
# 若无短路，data["key"] 将引发 TypeError: 'NoneType' object is not subscriptable
if data is not None and data.get("is_active"):
    print("有效数据")
else:
    print("跳过处理，未触发异常") # [输出] 跳过处理，未触发异常

四、标量类型的混合运算与强制转换

在实际工程开发中，标量类型经常混合出现在同一个数学表达式中。Python 拥有一套清晰的隐式类型提升规则，同时也要求开发者在显式转换时做好边界防护。

1. 隐式类型提升规则

当不同标量类型参与双目算术运算时，Python 会自动将窄类型提升为宽类型，以防精度丢失。其阶梯流向为：

bool  →  int  →  float

• bool + int：布尔值转换为 1 或 0，运算结果为 int。例如 True + 10 结果为 11。
• int + float：整数自动转换为双精度浮点数，运算结果为 float。例如 10 + 2.5 结果为 12.5。
• bool + float：布尔值跨级转换为浮点数，运算结果为 float。例如 False + 3.14 结果为 3.14。

2. 显式类型转换的陷阱与边界防御

当通过 int()、float()、bool() 进行显式类型转换时，需要牢记以下常见边界问题：

# 字符串转整型的健壮防护封装
def parse_positive_int(raw_text: str, default: int = 0) -> int:
    """安全解析整数字符串，带异常防护与业务校验"""
    if not isinstance(raw_text, str):
        return default
    cleaned = raw_text.strip()
    try:
        val = int(cleaned)
        return val if val > 0 else default
    except ValueError:
        # 输入格式非有效整型文本（如 "12.5"、"abc"）
        return default

print(parse_positive_int("  128  ")) # [输出] 128
print(parse_positive_int("12.8"))     # [输出] 0 (平稳降级，无崩溃)
print(parse_positive_int("-5"))       # [输出] 0 (触发业务规则校验)

五、工程最佳实践总结清单

1. 整数计算：放心使用长整型进行无上限数值计算；但凡需要保留整数语义的除法，务必使用整除运算符 //，并时刻记住负数整除是朝负无穷取整。
2. 浮点比对：永远不要使用 == 判断两个浮点数是否相等。常规科学计算统一使用 math.isclose(a, b, rel_tol=1e-9)。
3. 财务资产：涉及钱款、利率、汇率的金额计算，坚决摒弃 float，全部使用 decimal.Decimal 并以字符串字面量初始化。
4. 逻辑控制：利用 and/or 的短路特性构建轻量级守卫表达式，但注意它们返回的是原操作数；在对外暴露纯布尔接口时，应显式使用 bool(expr) 规避返回内部数据类型。
5. 类型转换：字符串转换为数值时，不可假定数据永远规范，必须配合 try...except ValueError 构筑鲁棒的安全防御边界。