Python 基础

是什么，为什么存在

Python 基础不是一张语法清单，而是一组解释程序行为的规则。最重要的一条是： 名称引用对象，代码对对象求值或执行操作。理解这条规则后，赋值、参数传递、可变容器、 条件判断与函数调用就不再是互不相关的特例。

Python 是动态类型语言。每个对象都有类型，名称本身没有固定类型；同一个名称可以在不同时间 绑定到不同类型的对象。动态类型不等于没有类型，像字符串加整数这样的不兼容操作仍会在 运行时抛出 TypeError。

程序由代码块组成，模块、函数体和类定义都是代码块。代码块在执行帧中运行，执行帧保存本次 执行所需的状态，并决定名称在哪里查找。Python 实现会先解析源码；以 CPython 为例，源码通常 还会编译成代码对象中的字节码，因此“解释型语言就是逐行执行文本”并不准确。

这些规则适用于脚本、命令行工具、Web 服务和数据处理程序。框架会增加约定，却不会改变 名称绑定、对象可变性、函数调用和异常传播的语言语义。掌握这层基础，才能判断库代码与生成代码 究竟在做什么。

工作原理

从源码到代码块

Python 先检查源码能否按语法解析，再执行得到的代码块。缩进是语法的一部分：if、for、 while、def、class 和 try 后面的缩进语句组属于相应代码块。混乱的缩进不是排版瑕疵， 而是可能改变控制范围或直接触发 IndentationError 的程序错误。

下面的图只描述语言层面需要理解的路径。缓存的字节码格式、具体指令和优化策略属于实现细节， 不应成为应用代码的依赖。

表达式（expression）会被求值并产生一个值，例如 price * quantity、函数调用或列表字面量。 语句（statement）执行动作，例如赋值、导入、return 或 raise。一行可以包含嵌套表达式， 但把“每一行”当作一个独立执行单位，会掩盖函数体、异常处理和多行表达式的真实边界。

名称绑定对象

赋值语句先计算右侧表达式，再把左侧名称绑定到所得对象。quantity = 3 没有创建一个能容纳整数的 固定类型盒子；它让名称 quantity 引用一个整数对象。后续写 quantity = "3" 是重新绑定， 原来的整数对象不会因此变成字符串。

函数定义、类定义、导入、循环目标和 except ... as ... 也会绑定名称。读取名称时，Python 按当前 作用域规则寻找最近的绑定；完全找不到就抛出 NameError。函数中的局部名称在函数体开始执行前 就由编译器根据绑定语句确定，这也是某些“先读取、后赋值”代码会抛出 UnboundLocalError 的原因。

每个对象都有值、类型和 对象标识（object identity） 。 type(value) 查看类型，== 比较值是否相等，is 比较两个引用是否指向同一个对象。 对象创建后，标识与类型不变；对象的值能否变化则取决于它的类型。

可变对象与不可变对象

列表、字典和集合是常见的可变对象。append()、键赋值和 add() 会修改原对象，所以所有指向 该对象的名称都能观察到变化。给其中一个名称重新赋值只会改变该名称的绑定，不会修改其他名称， 也不会自动复制旧对象。

整数、浮点数、布尔值、字符串、字节串和元组是常见的不可变对象。所谓不可变，是说对象创建后 不能原地改成另一个值；表达式 count + 1 会得到另一个整数对象。元组本身不可变，但元组可以 引用可变对象，因此元组中的列表仍然能被修改。

容器的选择取决于数据需要什么操作，而不是哪种写法更短。

列表和元组支持索引、切片与迭代。字典遍历默认产生键，遍历键值对要调用 items()。集合适合表达 唯一性，却不该用来承诺显示顺序；如果输出必须稳定，就显式排序，或选择本来就保存所需顺序的结构。

条件与循环

if 和 while 接受任意对象，并对它执行 真值测试（truth value testing） 。 None、False、数值零和空容器为假，其他对象通常为真。这个便利规则不能替你决定业务含义： 在库存系统里，数量 0 可能是有效值，而 None 表示尚未提供，两者不应混在一起。

and 与 or 会短路，并返回某个操作数，不保证返回 bool。configured_port or 8000 会把有效的 零值替换掉；只有业务规则确实把所有假值都视为缺失时，这种写法才正确。需要布尔结果时，可以 显式比较或调用 bool()。

for 从 可迭代对象（iterable） 逐项取值，不要求被迭代对象支持索引。 列表、字典、字符串、文件对象和生成器都可迭代。range(stop) 产生从 0 到 stop - 1 的整数， 不会把终点包含在内。

当工作是消费一组项目时，优先使用 for。只有重复取决于变化状态时才使用 while，并确保每条 回到条件的路径都推进状态。break 结束当前最内层循环，continue 只跳到下一轮，return 则离开整个函数。

函数、参数与返回值

执行 def 语句会创建函数对象，并把函数名绑定到它。函数调用先求值实参，再把得到的对象引用 绑定到本次调用的 形参（parameter） 。调用位置提供的值或表达式叫作 实参（argument） 。

形参是新的局部绑定，不是实参对象的副本。函数重新绑定形参，不会改变调用方的名称；函数修改 双方共享的列表或字典，调用方则能看到变化。公开函数应从名称和文档明确说明是否会修改传入对象。

return 把一个对象交回调用方。return minimum, maximum 看似返回两个值，实际返回一个二元组； 调用方可以再将它解包到两个名称。没有执行到带值的 return 时，函数返回单例对象 None。

位置实参按形参顺序绑定，关键字实参按名称绑定。默认表达式在执行 def 时求值一次，而不是每次 调用时求值。容易混淆的布尔开关、单位和超时适合设计成仅限关键字形参；完整的签名设计由 python/functions 专题继续讲解。

异常与导入

异常（exception） 会把控制从失败点转移到匹配的处理器。Python 会为 除零、无效转换和缺少键等运行时错误抛出异常，程序也可以用 raise 明确拒绝不满足契约的输入。 未处理的异常会沿调用栈传播，最终通常打印回溯并结束脚本。

try 块只应包住你准备处理的操作。except 捕获预期的具体异常，else 适合放只有成功后才执行的 代码，finally 负责无论成功或失败都必须执行的清理。捕获 Exception 后什么也不做，会把编程错误 伪装成正常结果。

import module 会绑定模块名称，from module import name 会直接绑定所选名称。模块第一次成功导入时 会执行其顶层代码，之后通常从 sys.modules 缓存复用模块对象。模块顶层应以定义、常量和轻量初始化 为主；网络请求或不可逆写入等昂贵副作用不应悄悄发生在导入阶段。

示例

名称、别名与重新绑定

先观察最容易误判的部分：两个名称可以共享一个列表，而浅复制得到另一个列表。修改共享对象与 重新绑定名称是两件不同的事。

第一次 append() 修改了共享列表，因此 cart 与 alias 都能看到 cable。snapshot 是独立的 外层列表，所以保持原值。列表展开式创建新列表并重新绑定 cart 后，alias 仍指向原来的列表。

用函数组织控制流

下一步把购物车汇总规则放进函数。输入只读，计数结果由函数自己创建；未知商品被单独返回， 而不是在循环中静默伪装成零价格商品。

def summarize_cart(items, prices, *, minimum_line_total=0):
    counts = {}
    unknown = []

    for item in items:
        if item not in prices:
            unknown.append(item)
            continue
        counts[item] = counts.get(item, 0) + 1

    lines = []
    total = 0
    for item, quantity in counts.items():
        line_total = prices[item] * quantity
        if line_total < minimum_line_total:
            continue
        lines.append(f"{item} x{quantity}: {line_total}")
        total += line_total

    return lines, total, unknown


prices = {"keyboard": 80, "mouse": 25, "cable": 10}
cart = ["keyboard", "mouse", "mouse", "sticker"]
lines, total, unknown = summarize_cart(
    cart, prices, minimum_line_total=20
)

print(*lines, sep="\n")
print(f"total={total}")
print(f"unknown={unknown}")

keyboard x1: 80
mouse x2: 50
total=130
unknown=['sticker']

minimum_line_total 是仅限关键字形参，调用处能看出 20 的含义。函数返回一个三元组，随后被解包。 空购物车也能正常返回三个空结果或零值，不需要另设分支。

在输入边界抛出具体异常

文本输入必须先解析并验证，才能进入前面的汇总逻辑。这个例子保留原始异常作为原因，同时把 错误补充为调用方能定位的行号。

def parse_cart(raw):
    items = []

    for line_number, line in enumerate(raw.splitlines(), start=1):
        if not line.strip():
            continue

        name, separator, quantity_text = line.partition("=")
        if not separator or not name.strip():
            raise ValueError(f"line {line_number}: expected name=quantity")

        try:
            quantity = int(quantity_text.strip())
        except ValueError as error:
            raise ValueError(
                f"line {line_number}: quantity must be an integer"
            ) from error

        if quantity < 1:
            raise ValueError(f"line {line_number}: quantity must be positive")
        items.extend([name.strip()] * quantity)

    return items


samples = ["keyboard=1\nmouse=2", "keyboard=one"]
for sample in samples:
    try:
        print(parse_cart(sample))
    except ValueError as error:
        print(f"invalid: {error}")

['keyboard', 'mouse', 'mouse']
invalid: line 1: quantity must be an integer

处理器只捕获这层契约预期的 ValueError。如果函数内部出现无关的 NameError 或 TypeError， 它们不会被误报成输入格式问题。raise ... from error 还保留了转换失败的异常链，便于诊断。

验证反序列化数据

类型注解不会验证运行时数据。JSON 能成功解析，只说明文本符合 JSON 语法，并不保证字段存在或 具有程序需要的类型。下面的函数在边界逐项检查，再计算总额。

import json


def active_total(raw):
    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


payload = '[{"active": true, "cents": 1250}, {"active": false, "cents": 900}]'
print(active_total(payload))

1250

bool 是 int 的子类，因此只写 isinstance(cents, int) 会接受 True。这里额外排除布尔值， 是因为订单金额的领域契约需要整数分值，而不是所有具备整数行为的对象。

陷阱

延伸阅读

• Python 语言参考：执行模型
• Python 语言参考：数据模型
• Python 标准库：内置类型
• Python 教程：更多控制流工具
• Python 教程：错误与异常