1. Python函数参数传递机制
在python中，函数参数的传递遵循“按对象引用传递”（call by object reference）的原则。这意味着当我们将一个变量（例如一个列表）作为参数传递给函数时，函数接收到的是该变量所引用对象的内存地址。
- 可变对象（Mutable Objects）：列表（list）、字典（dict）、集合（set）等是可变对象。函数内部可以通过这个引用直接修改对象的内部状态，这些修改会反映到函数外部。
- 不可变对象（Immutable Objects）：整数（int）、浮点数（float）、字符串（str）、元组（tuple）等是不可变对象。函数内部无法修改这些对象。任何看似“修改”的操作实际上都会创建一个新的对象，并让局部变量指向这个新对象。
2. 原地修改与变量重赋值的区别
理解原地修改和变量重赋值是掌握Python中可变对象操作的关键。
2.1 原地修改（In-place Modification）
原地修改是指直接操作现有对象的内容，而不改变变量所指向的对象本身。对于列表，常见的原地修改操作包括：
- 列表方法：list.append(), list.extend(), list.sort(), list.pop(), list.remove(), list.reverse() 等。这些方法会直接改变列表的内容。
- 切片赋值：list_var[:] = new_content。这种方式会将 new_content 中的元素替换掉 list_var 当前包含的所有元素，同时保持 list_var 变量指向同一个列表对象。这是一种强大的原地修改手段，可以改变列表的长度。
当函数内部对列表进行原地修改时，函数外部的原始列表也会受到影响。
2.2 变量重赋值（Reassignment）
变量重赋值是指将一个变量指向一个新的对象。例如，list_var = some_new_list_object。
立即学习“Python免费学习笔记（深入）”；
当在函数内部对一个作为参数传入的列表变量进行重赋值时，会发生以下情况：
- 函数内部的局部变量（例如 nums1）会创建一个新的引用。
- 这个新的引用指向 some_new_list_object。
- 此时，函数内部的局部变量 nums1 与函数外部传入的原始 nums1 变量不再指向同一个对象。它们之间的关联被切断。
- 后续对函数内部 nums1 的任何操作（无论是原地修改还是再次重赋值）都只会影响这个新的局部列表对象，而不会影响函数外部的原始列表。
3. 案例分析：原始代码的问题
让我们分析原始代码片段，理解为何其对 nums1 的修改未能如预期般生效：
from typing import List
def merge(self, 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[:m]
# 对新的局部列表进行原地修改
nums1.extend(nums2)
print('nums1', nums1) # 此时打印的是局部变量 nums1 所指向的新列表
print('nums2', nums2)
nums1.sort() # 对局部变量 nums1 所指向的新列表进行排序
# 函数结束，局部变量 nums1 及其指向的新列表被销毁，
# 外部传入的原始 nums1 未被触及。在这段代码中，最关键的问题出在 nums1 = nums1[:m] 这一行。
- nums1[:m] 操作会创建一个新的列表对象，其中包含原始 nums1 的前 m 个元素。
- nums1 = ... 这是一个重赋值操作。它将函数内部的局部变量 nums1 重新指向了这个刚刚创建的新列表对象。
- 从这一刻起，函数内部的 nums1 变量与函数外部传入的原始 nums1 列表对象就失去了关联。
- 随后的 nums1.extend(nums2) 和 nums1.sort() 操作都是针对这个新的局部列表进行的。
- 由于函数被声明为 -> None（不返回任何值），这意味着它期望通过副作用（即原地修改参数）来完成任务。但因为重赋值，这种原地修改只发生在局部变量上，并未影响到函数外部的原始 nums1。因此，当函数执行完毕后，调用者看到的 nums1 仍然是函数调用前的值。
4. 正确的原地修改策略
为了实现“不返回任何值，而是原地修改 nums1”的目标，我们需要避免在函数内部对 nums1 进行重赋值，而是直接操作其内容。
4.1 策略一：利用切片赋值替换内容
这是最直接且推荐的方式，可以在不改变 nums1 变量指向的前提下，完全替换其内容，甚至改变其长度。
from typing import List
def merge_in_place_by_slice(nums1: List[int], m: int, nums2: List[int], n: int) -> None:
"""
将 nums2 的前 n 个元素合并到 nums1 的前 m 个有效元素中，
然后对 nums1 进行原地排序，通过切片赋值实现。
"""
# 1. 创建一个临时合并列表，包含 nums1 的前 m 个和 nums2 的前 n 个
temp_combined = nums1[:m] + nums2[:n]
# 2. 对临时列表进行排序
temp_combined.sort()
# 3. 将排序后的结果复制回原始的 nums1
# 使用切片赋值 nums1[:] = ... 确保原地修改
nums1[:] = temp_combined
# 示例调用
nums1_example = [1,2,3,0,0,0]
nums2_example = [2,5,6]
m_example, n_example = 3, 3
print(f"调用前 nums1: {nums1_example}")
merge_in_place_by_slice(nums1_example, m_example, nums2_example, n_example)
print(f"调用后 nums1: {nums1_example}") # 输出: [1, 2, 2, 3, 5, 6]在这个示例中，nums1[:] = temp_combined 确保了 nums1 这个变量本身仍然指向原来的列表对象，但其内部的所有元素都被 temp_combined 的内容所替换。
4.2 策略二：利用列表方法进行原地操作
如果操作逻辑允许，也可以直接使用列表的原地方法。例如，先清空或截断 nums1，然后 extend 并 sort。
from typing import List
def merge_in_place_by_methods(nums1: List[int], m: int, nums2: List[int], n: int) -> None:
"""
将 nums2 的前 n 个元素合并到 nums1 的前 m 个有效元素中，
然后对 nums1 进行原地排序，通过列表方法实现。
"""
# 1. 保留 nums1 的前 m 个元素，并清空后续内容
# 确保 nums1 仍指向原始对象，且长度变为 m
nums1[m:] = [] # 或者 nums1 = nums1[:m] (但这是重赋值，此处不适用)
# 更安全的方式是 nums1[:] = nums1[:m]
nums1[:] = nums1[:m] # 确保只保留前m个元素，且是原地修改
# 2. 将 nums2 的前 n 个元素扩展到 nums1
nums1.extend(nums2[:n])
# 3. 对 nums1 进行原地排序
nums1.sort()
# 示例调用
nums1_example = [1,2,3,0,0,0]
nums2_example = [2,5,6]
m_example, n_example = 3, 3
print(f"调用前 nums1: {nums1_example}")
merge_in_place_by_methods(nums1_example, m_example, nums2_example, n_example)
print(f"调用后 nums1: {nums1_example}") # 输出: [1, 2, 2, 3, 5, 6]4.3 策略三：返回新列表（非原地修改，但常见且有效）
虽然与“原地修改”的初衷不符，但如果函数可以返回一个新列表，那么这通常是更简洁、更不容易出错的方式。这正是原始问题答案中采取的策略。
from typing import List
def merge_and_return_new_list(nums1: List[int], m: int, nums2: List[int], n: int) -> List[int]:
"""
将 nums2 的前 n 个元素合并到 nums1 的前 m 个有效元素中，
然后对结果进行排序，并返回一个新的列表。
"""
# 1. 创建一个新的列表，合并 nums1 的前 m 个和 nums2 的前 n 个
new_list = nums1[:m] + nums2[:n]
# 2. 对新列表进行排序
new_list.sort() # 或者使用 sorted() 函数直接返回一个新排序列表: sorted(new_list)
# 3. 返回排序后的新列表
return new_list
# 示例调用
nums1_example = [1,2,3,0,0,0]
nums2_example = [2,5,6]
m_example, n_example = 3, 3
print(f"调用前 nums1: {nums1_example}")
result_list = merge_and_return_new_list(nums1_example, m_example, nums2_example, n_example)
print(f"调用后原始 nums1: {nums1_example}") # 输出: [1, 2, 3, 0, 0, 0] (未被修改 
