变量与数据类型

是什么，为什么存在

Python 中的变量更准确地说是名称（name）。执行赋值时，Python 先计算右侧表达式，再把左侧名称绑定到所得对象。名称本身没有固定类型；对象才有类型、值与标识。

这种 名称绑定（name binding） 模型让同一种代码可以处理实现相同操作的不同对象，也让函数、类和模块都能像数据一样被名称引用。代价是你必须分清两个动作：把名称改为指向另一个对象，以及通过名称修改原对象。前者是重新绑定（rebinding），后者是原地修改（mutation）。

数据类型规定对象支持哪些操作，以及对象的值能否改变。int、float、complex、bool、str 与 NoneType 是常见的标量类型；list、tuple、dict 和 set 则组织多个对象。变量声明、函数参数、循环目标与导入名称最终都遵循同一套绑定规则。

你会在读取配置、解析 JSON、计算金额、传递列表以及处理可选值时遇到这些规则。很多看似偶发的错误，例如共享列表被意外修改、有效的零被默认值覆盖，根源都是把名称、对象与类型混成了一个概念。

工作原理

名称绑定到对象

每个 Python 对象都有值、类型与 对象标识（object identity） 。type(value) 返回对象的类型，id(value) 返回表示其标识的整数，is 比较两个引用是否指向同一对象。对象创建后，类型与标识不会改变。

赋值 quantity = 3 让名称 quantity 指向一个整数对象。随后执行 quantity = "3" 是重新绑定：名称开始指向字符串对象，原来的整数没有变成字符串。如果旧对象不再被任何引用使用，它之后可以被回收。

名称并不只由普通赋值引入。函数定义、类定义、导入、函数参数、for 循环目标、with ... as ... 与异常处理器中的 as 都会绑定名称。具体绑定位于哪个作用域，由这些语句所在的代码块决定。

图中 cart 与 alias 起初引用同一个列表，所以通过任一名称修改列表都能从另一名称看到。重新绑定 cart 后，alias 仍指向旧列表。箭头变了，对象没有凭空复制。

内置类型各管一件事

Python 的内置类型不是一组可以任意互换的标签。类型决定有效操作，例如字符串支持拼接，整数支持位运算，字典按键查找值。对不兼容对象执行操作时，Python 通常抛出 TypeError，而不是猜测程序意图。

容器类型保存对其他对象的引用。列表、字典和集合可以原地改变；元组不能替换自身槽位中的引用，但元组指向的列表仍然可以改变。因此，“容器不可变”不等于“从它出发能到达的所有对象都不可变”。

赋值、解包与别名

逗号分隔的目标可以一次绑定多个名称。left, right = right, left 会先计算右侧对象，再把结果解包到两个目标，因此不需要临时变量。目标数量与右侧可迭代对象产出的数量不匹配时，会抛出 ValueError。

链式赋值 primary = backup = [] 只创建一个列表对象，再把两个名称都绑定到它。它不等于两次独立执行 []。如果需要独立容器，应分别创建，或根据所需复制深度显式复制。

增强赋值的结果取决于对象类型。列表的 items += more 通常原地扩展现有列表，其他别名也能看到；整数的 count += 1 创建另一个整数并重新绑定 count。相同语法并不保证相同的共享效果。

动态类型不是没有类型

Python 使用 动态类型（dynamic typing） ：名称不需要永久声明一种类型，操作运行时会检查相关对象。一个名称先后绑定整数与字符串是合法的，但表达式 "3" + 2 仍会抛出 TypeError。动态类型与“所有类型会自动兼容”是两回事。

类型注解可以描述预期契约，例如 quantity: int 或 def total(price: int) -> int。普通 Python 调用不会因为注解而自动转换或拒绝参数。静态类型检查器、编辑器或框架可以读取注解，但运行时输入仍需由程序验证。

需要允许多种类型时，应先问这些类型是否真的共享同一业务语义。接受 int | float 适合一般测量值，却不一定适合货币分值；bool 又是 int 的子类，所以单纯的 isinstance(value, int) 也可能比契约更宽。

真值、缺失与布尔运算

条件语句会对任意对象执行 真值测试（truth value testing） 。None、False、各类数值零和空容器通常为假，其他对象通常为真。自定义类型还可以通过 __bool__() 或 __len__() 决定真值。

真值相同不代表业务含义相同。库存数量 0 可以表示确实无货，None 可以表示尚未盘点；空字符串可能是有效输入，也可能表示字段缺失。条件应保留领域需要区分的状态。

and 与 or 会短路，并返回某个操作数，不保证返回 bool。configured_port or 8000 在端口为 0 时也返回 8000。只有当所有假值都应当使用同一默认值时，这种写法才符合契约。

显式转换与类型检查

int()、float()、str() 和 bool() 构造目标类型的对象，但它们不是通用的数据清洗器。int(3.9) 向零截断为 3，int("3.9") 抛出 ValueError，而 bool("false") 是 True，因为任何非空字符串都为真。

混合内置数值运算会执行规定好的数值提升，例如整数与浮点数相加会得到浮点数。这类行为不代表 Python 会普遍把字符串转换为数字。外部文本应在边界处按明确格式解析，并为失败选择具体的错误路径。

isinstance(value, ExpectedType) 会考虑子类，通常适合检查对象是否支持某个类型家族。type(value) is ExpectedType 只接受确切类型，适用范围更窄。业务契约要求“整数但不能是布尔值”时，可以组合 isinstance(value, int) 与 not isinstance(value, bool)。

示例

查看绑定对象的类型

第一个示例展示赋值、解包与重新绑定。quantity 的类型变化来自名称指向了新对象，不是旧对象改变了类型。

type(value).__name__ 适合演示与诊断，但生产逻辑通常不应根据类型名称字符串分支。真正需要类型检查时，应直接传入类型对象给 isinstance()。

字典保存的是对象引用，所以循环取得的 value 仍是原对象。打印表示形式中的引号来自 !r，它让字符串与数字在输出中容易区分。

区分修改与重新绑定

第二个示例让两个名称共享列表，同时保留一份浅复制。观察两次操作后各名称指向的内容与标识关系。

cart = ["keyboard", "mouse"]

# alias 与 cart 指向同一个列表。
alias = cart
# 浅复制创建新的外层列表。
snapshot = cart.copy()

alias.append("cable")
print(f"cart={cart}")
print(f"snapshot={snapshot}")
print(f"alias_is_cart={alias is cart}")

# 此表达式创建新列表，然后只重新绑定 cart。
cart = [*cart, "adapter"]
print(f"alias={alias}")
print(f"cart={cart}")
print(f"alias_is_cart={alias is cart}")

cart=['keyboard', 'mouse', 'cable']
snapshot=['keyboard', 'mouse']
alias_is_cart=True
alias=['keyboard', 'mouse', 'cable']
cart=['keyboard', 'mouse', 'cable', 'adapter']
alias_is_cart=False

append() 修改共享列表，所以 cart 与 alias 起初都能看到 cable。snapshot 是另一个外层列表，不受这次修改影响。

列表展开表达式创建新列表，再把 cart 绑定过去。alias 继续引用旧列表，说明重新绑定一个名称不会追踪并修改其他别名。

在边界转换文本

来自命令行、环境变量或表单的值通常是文本。转换函数应同时定义允许的格式与数值范围，而不是把任何失败都换成一个看似正常的默认值。

def parse_quantity(raw: str) -> int:
    try:
        quantity = int(raw)
    except ValueError as error:
        raise ValueError("quantity must be a base-10 integer") from error

    if quantity < 0:
        raise ValueError("quantity must not be negative")
    return quantity


samples = ["12", "3.5", "-1", ""]
for sample in samples:
    try:
        print(f"{sample!r} -> {parse_quantity(sample)}")
    except ValueError as error:
        print(f"{sample!r} -> invalid: {error}")

'12' -> 12
'3.5' -> invalid: quantity must be a base-10 integer
'-1' -> invalid: quantity must not be negative
'' -> invalid: quantity must be a base-10 integer

这里的 try 只包住可能产生预期转换失败的 int(raw)。函数没有捕获所有 Exception，因此后续代码中的编程错误不会被伪装成无效输入。

raise ... from error 保留原始 ValueError 作为异常原因，同时向调用方提供稳定的领域消息。调用方根据异常类型处理失败，不应解析 Python 自带的错误消息。

验证反序列化后的类型

JSON 解析成功只证明文本语法有效，不证明字段符合应用契约。这个示例逐层检查容器、布尔字段与整数分值，并特意排除 bool。

import json


def active_total(raw: str) -> int:
    records = json.loads(raw)
    if not isinstance(records, list):
        raise ValueError("orders must be a list")

    total = 0
    for index, record in enumerate(records):
        if not isinstance(record, dict):
            raise ValueError(f"order {index}: expected an object")

        active = record.get("active")
        cents = record.get("cents")
        if not isinstance(active, bool):
            raise ValueError(f"order {index}: active must be boolean")
        if not isinstance(cents, int) or isinstance(cents, bool):
            raise ValueError(f"order {index}: cents must be an integer")
        if cents < 0:
            raise ValueError(f"order {index}: cents must not be negative")

        if active:
            total += cents

    return total


payloads = [
    '[{"active": true, "cents": 1250}, {"active": false, "cents": 900}]',
    '[{"active": true, "cents": true}]',
]
for payload in payloads:
    try:
        print(active_total(payload))
    except ValueError as error:
        print(f"invalid: {error}")

1250
invalid: order 0: cents must be an integer

虽然 isinstance(True, int) 的结果为真，但这里的分值字段不应接受布尔值。检查顺序先确认类型，再比较数值范围，避免在错误类型上执行 <。

函数不保留输入记录，也不修改解析出的列表。每次调用都从局部的 total = 0 开始，因此不同请求之间没有隐藏的共享状态。

陷阱

延伸阅读

• Python 语言参考：名称与绑定
• Python 数据模型：对象、值与类型
• Python 标准库：真值测试与内置类型
• Python 内置函数：int() 与 isinstance()
• Python 标准库：typing 与类型注解