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

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

本文旨在探讨Python函数中对列表参数进行操作时，原地修改（in-place modification）与变量重赋值（reassignment）之间的关键区别。通过分析一个常见的代码问题，我们将深入理解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学习网公众号！