Python列表陷阱：修改与赋值区别解析

IT行业相对于一般传统行业，发展更新速度更快，一旦停止了学习，很快就会被行业所淘汰。所以我们需要踏踏实实的不断学习，精进自己的技术，尤其是初学者。今天golang学习网给大家整理了《Python列表陷阱：原地修改与变量赋值区别》，聊聊，我们一起来看看吧！

1. 问题现象：为何列表修改未生效？

在Python编程中，当我们将一个列表作为参数传递给函数时，有时会发现尽管在函数内部对列表进行了操作，但函数外部的原始列表却没有任何改变。这通常是由于对Python变量引用机制的误解，尤其是在涉及到变量重赋值时。

考虑以下代码片段，它尝试合并两个列表 nums1 和 nums2，并将其结果“原地”修改到 nums1 中：

from typing import List

def merge_problematic(nums1: List[int], m: int, nums2: List[int], n: int) -> None:
    """
    尝试原地修改 nums1，但存在问题。
    """
    if m + n == m:
        # 这个分支的逻辑与核心问题无关，但它也涉及重赋值
        nums1 = nums2 if m == 0 else nums1
    else:
        # 核心问题所在：这行代码创建了一个新列表并重赋值给局部变量 nums1
        nums1 = nums1[:m] # nums1 现在指向一个新列表 [nums1[0], ..., nums1[m-1]]
        nums1.extend(nums2) # 修改的是这个新列表

    print('函数内部重赋值后的 nums1:', nums1) # 此时打印的是新列表
    nums1.sort() # 对新列表进行排序
    print('函数内部排序后的 nums1:', nums1) # 此时打印的是排序后的新列表

# 示例调用
original_nums1 = [1, 2, 3, 0, 0, 0]
m_val = 3
nums2_val = [2, 5, 6]
n_val = 3

print('调用前 original_nums1:', original_nums1)
merge_problematic(original_nums1, m_val, nums2_val, n_val)
print('调用后 original_nums1:', original_nums1)

运行上述代码，你会发现 调用后 original_nums1 的输出仍然是 [1, 2, 3, 0, 0, 0]，而并非期望的合并排序后的结果。 尽管在函数内部 print('函数内部排序后的 nums1:', nums1) 显示了正确合并排序后的列表，但这些修改并没有反映到函数外部的 original_nums1 上。

2. Python变量与对象：理解引用传递

要理解上述现象，我们需要回顾Python中变量和对象的基本概念：

• 变量是对象的引用： 在Python中，变量不是存储值本身，而是存储对内存中某个对象的引用（内存地址）。
• 可变与不可变类型：
  • 不可变类型（如整数、浮点数、字符串、元组）一旦创建，其值就不能改变。对不可变类型的操作通常会创建新的对象。
  • 可变类型（如列表、字典、集合）在创建后可以修改其内容。
• 函数参数传递： Python采用的是“传对象引用”（pass-by-object-reference）机制。这意味着当一个对象作为参数传递给函数时，函数内部的形参会引用与实参相同的对象。

问题的症结在于 nums1 = nums1[:m] 这行代码。当执行这行代码时：

1. nums1[:m] 创建了一个新的列表对象，包含了 nums1 前 m 个元素的副本。
2. nums1 = ... 这条赋值语句将函数内部的局部变量 nums1 重新绑定到这个新创建的列表对象。
3. 此时，函数内部的 nums1 变量不再引用外部传入的 original_nums1 对象，而是引用了一个全新的列表。
4. 后续的 nums1.extend(nums2) 和 nums1.sort() 操作都作用于这个新的局部列表，与外部的 original_nums1 没有任何关系。
5. 当函数执行完毕，局部变量 nums1 及其引用的新列表会被销毁，而外部的 original_nums1 始终未被修改。

3. 实现列表原地修改的正确方法

要实现对列表的“原地修改”，我们必须确保操作是作用于函数外部传入的那个原始列表对象本身，而不是创建一个新的列表并重赋值给局部变量。以下是几种常用的原地修改方法：

3.1 方法一：使用列表方法 clear() 和 extend()

这种方法首先清空原始列表的所有内容，然后将新的元素添加到原始列表中。

def merge_in_place_clear_extend(nums1: List[int], m: int, nums2: List[int], n: int) -> None:
    """
    通过 clear() 和 extend() 方法实现列表的原地修改。
    """
    # 1. 获取需要合并的元素
    # 假设我们只需要 nums1 的前 m 个元素和 nums2 的前 n 个元素
    merged_elements = nums1[:m] + nums2[:n]
    merged_elements.sort() # 对合并后的元素进行排序

    # 2. 清空原始 nums1 列表
    nums1.clear() # 这会清空 original_nums1 的内容，但 original_nums1 仍然指向同一个列表对象

    # 3. 将排序后的元素添加到原始 nums1 列表
    nums1.extend(merged_elements) # 这会将元素添加到 original_nums1 中

# 示例调用
original_nums1 = [1, 2, 3, 0, 0, 0]
m_val = 3
nums2_val = [2, 5, 6]
n_val = 3

print('调用前 original_nums1:', original_nums1)
merge_in_place_clear_extend(original_nums1, m_val, nums2_val, n_val)
print('调用后 original_nums1:', original_nums1)
# 输出: 调用后 original_nums1: [1, 2, 2, 3, 5, 6]

说明： nums1.clear() 和 nums1.extend() 都是列表对象的原地修改方法。它们直接操作 nums1 引用的那个列表对象的内容，而不会改变 nums1 变量本身的引用。

3.2 方法二：使用切片赋值 [:]

切片赋值 list[:] = new_content 是一种强大的原地修改机制。它会用 new_content 中的元素替换掉 list 中所有（或指定切片范围）的元素，但保持 list 变量引用的是同一个列表对象。

def merge_in_place_slice_assignment(nums1: List[int], m: int, nums2: List[int], n: int) -> None:
    """
    通过切片赋值 nums1[:] = ... 实现列表的原地修改。
    """
    # 1. 获取需要合并的元素
    merged_elements = nums1[:m] + nums2[:n]
    merged_elements.sort() # 对合并后的元素进行排序

    # 2. 使用切片赋值将排序后的元素替换掉原始 nums1 的内容
    nums1[:] = merged_elements # 这会替换 original_nums1 的所有元素

# 示例调用
original_nums1 = [1, 2, 3, 0, 0, 0]
m_val = 3
nums2_val = [2, 5, 6]
n_val = 3

print('调用前 original_nums1:', original_nums1)
merge_in_place_slice_assignment(original_nums1, m_val, nums2_val, n_val)
print('调用后 original_nums1:', original_nums1)
# 输出: 调用后 original_nums1: [1, 2, 2, 3, 5, 6]

说明： nums1[:] = merged_elements 同样直接操作了 nums1 引用的原始列表对象，替换了其所有元素，因此外部的 original_nums1 也会看到这些变化。

3.3 方法三：针对特定合并排序问题的优化（双指针法）

对于像LeetCode上“合并两个有序数组”这类特定问题，如果 nums1 已经预留了足够的空间（通常在末尾填充0），则可以使用双指针从后向前合并的策略，这是一种更高效且完全原地修改的算法。

def merge_leetcode_style_in_place(nums1: List[int], m: int, nums2: List[int], n: int) -> None:
    """
    针对 nums1 预留足够空间（m+n 长度）的合并有序数组问题，使用双指针原地合并。
    """
    # 初始化三个指针：
    # p1 指向 nums1 中有效元素的最后一个位置
    # p2 指向 nums2 中最后一个元素的位置
    # write_idx 指向 nums1 中合并后元素的写入位置 (从末尾开始)
    p1 = m - 1
    p2 = n - 1
    write_idx = m + n - 1

    # 从后向前遍历，比较 nums1 和 nums2 的元素，将较大的放入 nums1 的末尾
    while p1 >= 0 and p2 >= 0:
        if nums1[p1] > nums2[p2]:
            nums1[write_idx] = nums1[p1]
            p1 -= 1
        else:
            nums1[write_idx] = nums2[p2]
            p2 -= 1
        write_idx -= 1

    # 如果 nums2 中还有剩余元素（说明 nums2 中有比 nums1 中所有元素都小的），
    # 将它们复制到 nums1 的前部
    while p2 >= 0:
        nums1[write_idx] = nums2[p2]
        p2 -= 1
        write_idx -= 1

    # 如果 nums1 中还有剩余元素（p1 >= 0），它们已经位于正确的位置，无需额外处理。

# 示例调用
original_nums1 = [1, 2, 3, 0, 0, 0] # nums1 长度为 6 (m+n)
m_val = 3
nums2_val = [2, 5, 6]
n_val = 3

print('调用前 original_nums1:', original_nums1)
merge_leetcode_style_in_place(original_nums1, m_val, nums2_val, n_val)
print('调用后 original_nums1:', original_nums1)
# 输出: 调用后 original_nums1: [1, 2, 2, 3, 5, 6]

说明： 这种方法不涉及创建任何中间列表，直接在 nums1 上进行操作，是效率最高的原地修改方式之一，但它要求 nums1 必须有足够的预留空间。

4. 返回新列表的替代方案

虽然问题要求原地修改，但在很多情况下，我们可能更倾向于创建一个新的列表并返回，而不是修改原始列表。这种方式的好处是不会影响到调用者可能依赖的原始数据，保持了函数的纯洁性。

def merge_and_return_new_list(nums1: List[int], m: int, nums2: List[int], n: int) -> List[int]:
    """
    合并列表并返回一个新的排序后的列表，不修改原始列表。
    """
    # 1. 获取需要合并的元素
    merged_elements = nums1[:m] + nums2[:n]
    # 2. 使用 sorted() 函数返回一个新的排序列表
    sorted_merged_list = sorted(merged_elements)
    return sorted_merged_list

# 示例调用
original_nums1 = [1, 2, 3, 0, 0, 0]
m_val = 3
nums2_val = [2, 5, 6]
n_val = 3

print('调用前 original_nums1:', original_nums1)
new_result_list = merge_and_return_new_list(original_nums1, m_val, nums2_val, n_val)
print('调用后 original_nums1 (未改变):', original_nums1)
print('新生成的合并列表:', new_result_list)
# 输出:
# 调用后 original_nums1 (未改变): [1, 2, 3, 0, 0, 0]
# 新生成的合并列表: [1, 2, 2, 3, 5, 6]

说明： sorted() 函数总是返回一个新的已排序列表，而不会修改原始列表。这种方式清晰明了，但如果调用者期望的是原地修改，则不符合要求。

5. 总结与注意事项

• 理解变量重赋值与原地修改： 这是Python中处理可变类型（尤其是列表）时最核心的概念之一。函数内部对形参变量的重赋值（如 nums1 = new_list）会使该形参指向一个新对象，从而断开与外部实参的关联。而原地修改（如 nums1.append(), nums1.extend(), nums1.sort(), nums1.clear(), nums1[:] = ...）则是直接操作实参引用的原始对象，其改变在函数外部可见。
• 明确函数意图： 在设计函数时，应明确是需要“原地修改”传入的可变对象，还是“返回一个新的对象”。这通常通过函数签名（例如 -> None 表示原地修改，-> List[int] 表示返回新列表）和文档字符串来体现。
• 避免混淆： 避免在需要原地修改的函数中对参数变量进行重赋值，除非你明确知道这样做不会影响外部对象（例如，如果外部对象是不可变类型，或者你打算返回这个新对象）。
• 常用原地修改操作：
  • list.append(item)
  • list.extend(iterable)
  • list.insert(index, item)
  • list.remove(item)
  • list.pop(index)
  • list.sort()
  • list.reverse()
  • list.clear()
  • list[start:end] = new_sublist (切片赋值)

掌握这些概念对于编写健壮、可预测的Python代码至关重要。

本篇关于《Python列表陷阱：修改与赋值区别解析》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！