Python内存与性能——可变与不可变对象

一、什么是可变与不可变？

在Python中，对象的**可变性（mutability）**决定了对象创建后其内容是否可以被改变。

• • 不可变对象（Immutable）：创建后内容不可改变
• • 可变对象（Mutable）：创建后内容可以被修改

# 不可变对象：整数
a = 10
print(id(a))  # 查看内存地址
a += 1# 实际上创建了新对象
print(id(a))  # 地址改变

# 可变对象：列表
b = [1, 2, 3]
print(id(b))
b.append(4)   # 修改原对象
print(id(b))  # 地址不变

二、Python中常见类型的可变性

三、不可变对象的性能特性

3.1 小整数缓存

Python 会缓存 -5 到 256 之间的小整数，这些整数在内存中只有一份。

# 小整数缓存
a = 100
b = 100
print(a is b)   # True（同一对象）

c = 257
d = 257
print(c is d)   # False（不同对象，但值相等）

性能影响：

• • ✅ 优点：小整数频繁使用时不重复创建，节省内存。
• • ⚠️ 注意：不要依赖 is 比较整数，使用 == 比较值。

3.2 字符串驻留（Intern）

Python 会自动驻留某些字符串（短字符串、标识符等）。

s1 = "hello"
s2 = "hello"
print(s1 is s2)     # True（驻留）

s3 = "hello world"
s4 = "hello world"
print(s3 is s4)     # 可能 False（取决于实现）

# 手动驻留
import sys
s5 = sys.intern("hello world")
s6 = sys.intern("hello world")
print(s5 is s6)     # True

性能建议：

• • 大量重复字符串比较时，使用 sys.intern 可提升性能。
• • 一般情况使用 == 比较，不要依赖 is。

3.3 字符串拼接的性能陷阱

import timeit

# ❌ 低效：每次拼接创建新字符串
defbad_concat():
    s = ""
for i inrange(10000):
        s += str(i)    # 每次都创建新字符串
return s

# ✅ 高效：使用列表收集后 join
defgood_concat():
    parts = []
for i inrange(10000):
        parts.append(str(i))
return"".join(parts)

print(timeit.timeit(bad_concat, number=10))
print(timeit.timeit(good_concat, number=10))
# good_concat 快 10-100 倍

四、可变对象的性能特性

4.1 列表的动态扩容

列表在添加元素时，如果空间不足会自动扩容（通常增加到当前容量的 1.125 倍）。

import sys

lst = []
for i inrange(10):
print(f"长度: {len(lst):3}, 容量: {sys.getsizeof(lst)}")
    lst.append(i)

性能建议：

• • 预分配列表大小：[0] * n 可避免多次扩容。
• • 使用 collections.deque 在两端频繁添加/删除。

4.2 列表 vs 元组性能

import timeit

# 列表创建稍慢
lst_time = timeit.timeit('[1, 2, 3, 4, 5]', number=1000000)
tup_time = timeit.timeit('(1, 2, 3, 4, 5)', number=1000000)
print(f"列表: {lst_time:.4f}s, 元组: {tup_time:.4f}s")

# 访问速度相近
# 元组内存更小
import sys
print(sys.getsizeof([1, 2, 3]))   # 72 字节（大概）
print(sys.getsizeof((1, 2, 3)))   # 48 字节（大概）

选择建议：

• • 需要修改的数据 → 列表
• • 不需要修改的数据 → 元组（更小、更快）

4.3 字典的性能

字典基于哈希表，查找、插入、删除的平均时间复杂度为 O(1)。

# 哈希冲突的影响
classBadHash:
def__hash__(self):
return1# 所有实例哈希值相同

def__eq__(self, other):
returnTrue

d = {}
for i inrange(1000):
    d[BadHash()] = i  # 所有键哈希冲突，性能退化到 O(n)

性能建议：

• • 使用内置类型作为键（字符串、整数、元组）。
• • 避免自定义类的哈希冲突。
• • 使用 __slots__ 减少实例内存。

五、函数参数传递机制

5.1 不可变对象传值

defmodify(x):
    x += 1
print(f"函数内: {x} (id: {id(x)})")

a = 10
print(f"调用前: {a} (id: {id(a)})")
modify(a)
print(f"调用后: {a} (id: {id(a)})")
# 调用前: 10 (id: ...)
# 函数内: 11 (id: ...) 新地址
# 调用后: 10 (id: ...) 原地址不变

5.2 可变对象传引用

defmodify(lst):
    lst.append(4)
print(f"函数内: {lst} (id: {id(lst)})")

a = [1, 2, 3]
print(f"调用前: {a} (id: {id(a)})")
modify(a)
print(f"调用后: {a} (id: {id(a)})")
# 调用前: [1, 2, 3] (id: ...)
# 函数内: [1, 2, 3, 4] (id: 相同地址)
# 调用后: [1, 2, 3, 4] (id: 相同地址)

5.3 避免意外修改

# ❌ 函数修改了传入的列表
defprocess_data(data):
    data.sort()        # 修改原列表
return data[-1]

original = [3, 1, 4, 1, 5]
result = process_data(original)
print(original)        # [1, 1, 3, 4, 5] 被修改了！

# ✅ 使用副本
defprocess_data_safe(data):
    data = data[:]      # 创建副本
    data.sort()
return data[-1]

original = [3, 1, 4, 1, 5]
result = process_data_safe(original)
print(original)        # [3, 1, 4, 1, 5] 不变

六、深拷贝 vs 浅拷贝

6.1 浅拷贝

import copy

# 浅拷贝：只复制外层，内层对象共享
original = [[1, 2], [3, 4]]
shallow = copy.copy(original)
shallow[0][0] = 99
print(original)   # [[99, 2], [3, 4]] 受到影响！

6.2 深拷贝

# 深拷贝：递归复制所有嵌套对象
original = [[1, 2], [3, 4]]
deep = copy.deepcopy(original)
deep[0][0] = 99
print(original)   # [[1, 2], [3, 4]] 不受影响

6.3 性能对比

import copy
import timeit

original = [list(range(100)) for _ inrange(10)]

shallow_time = timeit.timeit(lambda: copy.copy(original), number=10000)
deep_time = timeit.timeit(lambda: copy.deepcopy(original), number=10000)
print(f"浅拷贝: {shallow_time:.4f}s, 深拷贝: {deep_time:.4f}s")

选择建议：

• • 只复制一层 → 浅拷贝
• • 完全独立副本 → 深拷贝（较慢）

• 请在微信客户端打开

七、内存优化技巧

7.1 使用 __slots__

# 普通类（使用 __dict__）
classPoint:
def__init__(self, x, y):
self.x = x
self.y = y

# 使用 __slots__
classPointSlots:
    __slots__ = ('x', 'y')
def__init__(self, x, y):
self.x = x
self.y = y

import sys
p1 = Point(1, 2)
p2 = PointSlots(1, 2)
print(f"普通类: {sys.getsizeof(p1) + sys.getsizeof(p1.__dict__)} 字节")
print(f"__slots__: {sys.getsizeof(p2)} 字节")
# __slots__ 可节省 50-70% 内存

7.2 使用生成器代替列表

# ❌ 列表：占用大量内存
squares_list = [x**2for x inrange(1000000)]

# ✅ 生成器：惰性求值，节省内存
squares_gen = (x**2for x inrange(1000000))

import sys
print(f"列表: {sys.getsizeof(squares_list)} 字节")
print(f"生成器: {sys.getsizeof(squares_gen)} 字节")

7.3 使用 array 模块

import array

# 列表存储整数（每项 28 字节）
lst = [1, 2, 3, 4, 5]

# 数组存储整数（每项 4 字节）
arr = array.array('i', [1, 2, 3, 4, 5])

print(f"列表: {sys.getsizeof(lst)} 字节")
print(f"数组: {sys.getsizeof(arr)} 字节")

7.4 使用 weakref 避免内存泄漏

import weakref

classCache:
def__init__(self):
self._data = weakref.WeakValueDictionary()

defset(self, key, value):
self._data[key] = value   # 弱引用

defget(self, key):
returnself._data.get(key)

八、实战案例

8.1 缓存不可变对象

from functools import lru_cache

# ❌ 不使用缓存
deffibonacci_slow(n):
if n < 2:
return n
return fibonacci_slow(n-1) + fibonacci_slow(n-2)

# ✅ 使用缓存（要求参数不可变）
@lru_cache(maxsize=128)
deffibonacci_fast(n):
if n < 2:
return n
return fibonacci_fast(n-1) + fibonacci_fast(n-2)

import time
start = time.time()
fibonacci_fast(35)
print(f"缓存版: {time.time() - start:.4f}s")

8.2 字符串拼接优化

defbuild_query(conditions):
# ❌ 低效
    query = ""
for key, value in conditions.items():
        query += f"{key}={value}&"
return query.rstrip('&')

defbuild_query_efficient(conditions):
# ✅ 高效
    parts = [f"{key}={value}"for key, value in conditions.items()]
return"&".join(parts)

conditions = {"name": "张三", "age": 25, "city": "北京"}
print(build_query_efficient(conditions))

8.3 函数参数防御性拷贝

classTeam:
def__init__(self, members):
# 防御性拷贝：防止外部修改
self._members = members[:] ifisinstance(members, list) elselist(members)

defadd_member(self, name):
self._members.append(name)

defget_members(self):
# 返回副本，防止内部状态被修改
returnself._members[:]

members = ["张三", "李四"]
team = Team(members)
members.append("王五")  # 外部修改不影响 team
print(team.get_members())  # ['张三', '李四']

九、总结

核心要点：

• • Python 中整数、字符串、元组是不可变的；列表、字典、集合是可变的。
• • 不可变对象在修改时创建新对象，要注意字符串拼接的性能问题。
• • 可变对象作为函数参数时，要注意避免意外修改外部数据。
• • 防御性拷贝（创建副本）可以保护外部数据不被修改。
• • __slots__、生成器、array 可以优化内存使用。
• • 理解可变性有助于写出更高效、更安全的代码。

记忆口诀：

整数字符串元组，不可改变要记住
列表字典和集合，原地修改更快速
函数参数要注意，可变对象会传染
防御拷贝保安全，性能优化要实践