深入解析：Python 中的可变对象与不可变对象

2026-02-08 05:53:55 0条评论 2次阅读 0人点赞

作为 Python 开发者，你是否曾经好奇过，为什么有时候修改函数内部的参数会影响到外部的变量，而有时候又毫无影响？或者，为什么在循环中修改字典或列表时需要格外小心？这一切的根源，都在于 Python 中最核心的概念之一：可变性。

理解可变对象与不可变对象的区别，不仅仅是通过面试的基础，更是编写健壮、无副作用代码的关键。在 2026 年的今天，随着 AI 辅助编程和云原生架构的普及，深入理解内存模型对于构建高性能、高并发的应用显得尤为重要。在这篇文章中，我们将深入探讨 Python 内存模型的工作原理，剖析这两类对象的本质区别，并通过丰富的实战代码示例，帮助你彻底掌握这一知识点。

对象与变量：名与实的纠葛

在深入具体类型之前，我们需要先厘清“变量”在 Python 中的真实含义。与 C 或 C++ 等语言不同，Python 中的变量更像是“标签”或“便利贴”，而不是存储数据的盒子。

变量指向对象，而非包含对象。

每当我们创建一个对象（无论是数字、字符串还是列表），Python 都会在内存中为其分配一个空间，并赋予它一个唯一的身份标识。我们可以通过 INLINECODE70ee5772 函数查看这个标识，通过 INLINECODE38e7896e 查看对象的类型。而变量，仅仅是贴在这个内存对象上的一个名字。在我们最近的代码审查中，我们发现许多关于状态管理的 Bug 都源于对这个基本概念的误解。

内置函数 id() 与 is

让我们来看看 INLINECODE84b1868d 是如何工作的。INLINECODEaf58d554 返回对象的内存地址。

# 探索变量的身份
a = 10
print(f"对象 a 的值: {a}, ID: {id(a)}")

# 将 b 指向 a
b = a 
print(f"对象 b 的值: {b}, ID: {id(b)}")

print(f"a 和 b 是同一个对象吗? {a is b}")

# 修改变量 b 的指向
b = 20
print(f"修改后 b 的值: {b}, ID: {id(b)}")
print(f"a 的值是否受影响? a = {a}, ID: {id(a)}")

在这个例子中，当我们执行 INLINECODE4f44ebf8 时，Python 并没有复制 INLINECODEfba0264c 的数据，而是让 INLINECODEba2bd6a4 指向了 INLINECODE8123a058 所指向的同一个对象。当我们随后执行 INLINECODEce02e290 时，实际上是创建了一个新的整数对象 INLINECODEdbb1a97e，并把 INLINECODE230a9a1b 这个标签贴到了新对象上，而 INLINECODE82a7e013 依然指着原来的 10。这展示了“引用”与“对象修改”的区别。

什么是不可变对象？

不可变对象，简单来说，就是一旦在内存中创建，其状态就不能被改变的对象。

如果你尝试修改一个不可变对象的内容，Python 实际上会在内存中创建一个新的对象，并返回这个新对象的引用。这意味着，修改操作往往会伴随着内存分配的开销。在现代高并发系统中，不可变性是构建无锁架构的基石。

主要的不可变类型

Python 中主要的内置不可变数据类型包括：

  • 数值类型: INLINECODE58f4ffba (整数), INLINECODE191f00d1 (浮点数), complex (复数)
  • 布尔类型: bool (True/False)
  • 字符串序列: str (字符串)
  • 元组: tuple
  • 冻结集合: frozenset

#### 示例 1：尝试修改字符串（报错演示）

字符串是典型的不可变对象。我们不仅不能改变它的长度，也不能改变其中某个索引处的字符。

# 示例：演示字符串的不可变性
greeting = "Hello World"
print(f"原始字符串: {greeting}")

try:
    # 尝试通过索引修改第一个字符
    # 这在 Python 中会引发 TypeError
    greeting[0] = "h"
except TypeError as e:
    print(f"错误捕获: 无法修改字符串。详情: {e}")

# 如果我们想要“修改”字符串，必须创建一个新的
modified_greeting = "h" + greeting[1:]
print(f"新创建的字符串: {modified_greeting}")
print(f"原始字符串引用: {id(greeting)}")
print(f"新字符串引用:   {id(modified_greeting)}")

关键点： 注意看最后两个 ID 的输出。它们是不同的。这证明了我们并没有改变原来的对象，而是生成了一个全新的对象。这种机制保证了字符串在多线程环境中的安全性，因为你不必担心其他线程会偷偷修改你正在读取的字符串。这也是为什么在处理敏感数据（如 API 密钥）时，我们倾向于使用不可变对象，以减少数据泄露的风险面。

什么是可变对象？

可变对象是指在创建后，其内容（状态）可以被修改的对象。

这对于需要频繁更新数据的场景非常有用。修改可变对象时，对象在内存中的地址（ID）保持不变，但其内部的数据发生了变化。这意味着，所有指向该对象的引用都会立刻看到这种变化。在处理大规模数据集或流式数据时，可变对象提供了零拷贝修改的高效性，但同时也带来了并发竞争的风险。

主要的可变类型

Python 中主要的内置可变数据类型包括：

  • 列表: list
  • 字典: dict
  • 集合: set
  • 自定义类实例: 默认情况下，我们自己定义的类都是可变的。
  • 字节数组: bytearray

#### 示例 2：共享引用带来的副作用

这是可变对象最容易让新手踩坑的地方。当我们将一个可变对象赋值给另一个变量，或者将其作为参数传递给函数时，我们传递的是引用的副本，而不是对象的副本。这意味着两个变量名实际上控制着同一个对象。

# 示例：可变对象的引用共享
data = ["Alice", "Bob", "Charlie"]
print(f"原始数据: {data}")

# 我们想要创建一个备份来进行操作
backup = data 

# 修改“备份”
backup.append("David")
backup[0] = "Alice (Modified)"

print(f"修改后的备份: {backup}")
print(f"原本的数据:   {data}")

# 惊讶吗？原本的 data 也被改变了！
print(f"ID 是否相同? {id(data) == id(backup)}")

解决方案： 如果你想要创建一个真正的副本，必须显式地告诉 Python。对于列表，可以使用切片 INLINECODE86e5599d 或者 INLINECODE0122f2e4 方法。对于字典，使用 INLINECODE49b6c183。对于更复杂的嵌套结构，需要使用 INLINECODE20d0fe49。在我们团队处理配置对象时，强制使用 deepcopy 已经成为防止配置污染的标准规范。

2026 技术视角：并发安全与数据竞争

随着 Agentic AI（自主智能体）和边缘计算的兴起，Python 代码不再仅仅是运行在单机上的脚本，而是经常需要处理来自多个 Agent 的并发请求，或者在异步框架（如 FastAPI, asyncio）中运行。在这种背景下，可变性带来的挑战变得更加尖锐。

线程安全与原子操作

我们来看一个在并发环境下常见的陷阱。当多个线程或异步任务同时修改一个共享的可变对象时，就会发生“数据竞争”。

import threading

# 演示非线程安全的计数器
class UnsafeCounter:
    def __init__(self):
        self.value = 0

    def increment(self):
        # 读取 -> 修改 -> 写回 (非原子操作)
        # 在多线程环境中，这里极易发生冲突
        local_copy = self.value 
        local_copy += 1
        # 模拟 I/O 延迟，增加冲突概率
        import time; time.sleep(0.00001) 
        self.value = local_copy

# 测试场景
counter = UnsafeCounter()
threads = []

# 启动 100 个线程，每个增加 100 次
for _ in range(100):
    t = threading.Thread(target=lambda: [counter.increment() for _ in range(100)])
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(f"预期结果: 10000")
print(f"实际结果: {counter.value}")
# 结果通常会小于 10000，说明有数据丢失

在这个例子中，INLINECODE939cf4a5 是一个可变整数（虽然 int 本身不可变，但 Counter 实例持有的引用可以改变）。由于 INLINECODE02051afb 操作在 Python 中不是原子性的（除非使用特定类型如 multiprocessing.Value），多线程切换时会导致更新丢失。

最佳实践： 在 2026 年的现代开发中，我们尽量避免使用共享的可变状态。取而代之的是：

  • 使用不可变数据结构：如 INLINECODE13c456e6 配合 INLINECODEd9453b28，或者第三方库如 Pydantic 的严格模型。
  • 利用消息传递：像 Go 语言那样，不要通过共享内存来通信，而要通过通信来共享内存。在 Python 中，可以使用 queue.Queue 或消息代理（RabbitMQ, Kafka）。
  • 使用线程原语：如果必须共享状态，请使用 threading.Lock 来保护临界区。

性能优化与内存管理：从 I/O 密集型到计算密集型

在处理海量数据（如训练数据集预处理或日志流分析）时，可变对象的选择直接决定了程序的吞吐量。让我们思考一下字符串拼接的场景。

字符串拼接的演变

import time

# 场景 A: 低效的不可变对象拼接 (模拟新手代码)
def slow_concat():
    s = ""
    for i in range(100000):
        s += "str" # 每次循环都创建一个新的 str 对象，复制旧数据
    return s

# 场景 B: 高效的可变列表拼接 (生产级代码)
def fast_concat():
    parts = []
    for i in range(100000):
        parts.append("str") # 列表 append 是 O(1) 的内存操作
    return "".join(parts) # 最后一次性分配内存

# 性能对比
start = time.time()
slow_concat()
print(f"不可变拼接耗时: {time.time() - start:.4f}s")

start = time.time()
fast_concat()
print(f"可变列表拼接耗时: {time.time() - start:.4f}s")

深度解析： 在“慢速”版本中，每一次 INLINECODE35bf45c1 操作都会导致 Python 重新分配一块更大的内存，将旧字符串复制进去，再加上新部分。这是 O(N^2) 的时间复杂度。而在“快速”版本中，利用列表的可变性，我们预先分配了缓冲区（或动态扩容），append 操作通常是 O(1) 的，最后 INLINECODE23fdcc52 只需计算总长度一次分配内存。这是理解可变性带来的最直接的性能收益。

AI 辅助编程时代的陷阱与对策

现在我们大量使用 Cursor、Windsurf 或 GitHub Copilot 进行编码。虽然 AI 生成的代码通常语法正确，但它们有时会忽略上下文中的可变性陷阱，特别是在处理函数默认参数时。

经典的默认参数陷阱

这是一个连经验丰富的开发者偶尔也会犯的错误，而 AI 往往会复刻这种模式。

# ❌ 错误示范：常见的 AI 生成模式 (如果不加提示)
def add_item(item, my_list=[]): 
    """这里的问题是：[] 在函数定义时就被创建并绑定到了函数对象上。"""
    my_list.append(item)
    return my_list

print(add_item(1)) # 输出 [1]
print(add_item(2)) # 输出 [1, 2] -> 惊讶吗？状态被保留了！

# ✅ 正确示范：不可变默认值
# 我们将这个模式应用在我们的代码规范中

def add_item_correct(item, my_list=None):
    """
    使用 None (不可变单例) 作为占位符。
    这种模式是 Pythonic 且线程安全的，因为每次调用都会创建新的列表。
    """
    if my_list is None:
        my_list = []
    my_list.append(item)
    return my_list

print(add_item_correct(1)) # 输出 [1]
print(add_item_correct(2)) # 输出 [2]

在我们最近的内部培训中，我们强调：在 AI 辅助编程中，人类开发者的核心价值在于审查这些“状态逻辑”，而不仅仅是编写语法。 理解可变性使我们能够精准地指导 AI 修复这类隐晦的 Bug。

总结与关键要点

在这篇文章中，我们一起探索了 Python 中可变对象与不可变对象的深层机制。让我们回顾一下核心要点：

  • 变量即标签：Python 的变量存储的是对象的内存地址，而不是对象本身。
  • 不可变对象：如 INLINECODEe4acdf3d, INLINECODE81305334, tuple。一旦创建，值不可改。修改操作会生成新对象。适用于键值、常量配置、多线程环境下的安全数据共享。
  • 可变对象：如 INLINECODE3abdb82c, INLINECODE88217b7f, set。创建后内容可改。修改操作在原对象上进行。适用于动态数据收集、高性能缓冲区构建。
  • 函数参数传递：Python 采用“按引用传递”的机制。在编写函数时，务必考虑是否会意外修改外部数据（副作用）。
  • 2026 最佳实践：在并发和 AI 时代，优先选择不可变对象来保证状态一致性；在性能瓶颈处利用可变对象（如数组流）优化 I/O；在 AI 编程中保持对“可变性陷阱”的警惕。

掌握这些概念，将帮助你编写出更安全、性能更优、逻辑更清晰的 Python 代码。下次当你看到 TypeError: ‘tuple‘ object does not support item assignment 或者发现你的列表被意外修改时，你就知道背后的原因了。继续探索 Python 的奥秘，你会发现这门语言的设计之美。

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。如需转载，请注明文章出处豆丁博客和来源网址。https://shluqu.cn/34767.html
点赞
0.00 平均评分 (0% 分数) - 0 票

相关文章美国1G带宽/1T流量高速vps $17.99/年