带有列表参数的递归调用（python）

Question

所以 a 有两个函数进行递归调用，第一个调用修改列表 l1，然后将其传递给第二个调用。在 f1 第二次递归调用中收到修改后的列表 [1,1]：

b 2 []
b 1 []
a 1 [1, 1]
b 1 [1, 1]
a 1 [1, 1, 1, 1]
a 2 [1, 1, 1, 1, 1, 1]

但在 f2 第二次调用中收到未修改的空列表：

b 2 []
b 1 []
a 1 [1, 1]
b 1 []
a 1 [1, 1]
a 2 [1, 1, 1, 1]

为什么？ f2(f1) 不是在这两种情况下都被连续调用了吗？

def f1(l1=[],num = 2):
    if num == 0: return[1]
    print('b',num,l1)
    l1 = [*l1, *f1(l1, num-1)]
    l1 = [*l1, *f1(l1, num -1)]
    print('a',num,l1)
    return l1

def f2(l1=[],num = 2):
    if num == 0: return[1]
    print('b',num,l1)
    l1 = [*l1, *f2(l1, num-1),*f2(l1, num -1)]
    print('a',num,l1)
    return l1


       

如果列表理解是一个问题（你不能在其中修改列表），为什么在这里修改它：

def f3(l1):
    print(l1)
    l1 +=[1]
    return l1
l1 = []
l1 = [*l1, *f3(l1), *f3(l1)]

print(l1)

[]
[1]
[1, 1, 1]

Answer 1

函数f1 创建一个全新的列表，然后在第二次调用f1 时使用该新列表。函数f2 只会将原始列表传递给它对f2 的调用。

展开，f1，逻辑如下：

def f1(l1=[],num = 2):
    if num == 0: return[1]
    print('b',num,l1)
    
    # Here, *f1(l1, num-1) uses the original value of
    # l1, then expands it.
    # *l1 expands the original value of l1.
    # The [...] creates a completely new list,
    # and finally, l1 = ... assigns that completely new
    # list to the value of l1.
    l1 = [*l1, *f1(l1, num-1)]
    
    # Here, the l1 in *f1(l1, num -1) refers to the
    # result of the assignment above, l1 = ...
    #
    # *l1 also refers to the result of the assignment
    # above.
    #
    # Again, [...] creates a completely new list,
    # then l1 = ... assigns that new list to the name l1.
    l1 = [*l1, *f1(l1, num -1)]
    print('a',num,l1)
    return l1
    
# This function is identical
def f1(first_list = [], num = 2):
    if num == 0: return [1]
    print('b', num, first_list)
    
    second_list = [*first_list, *f1(first_list, num - 1)]
    
    third_list = [*second_list, *f1(second_list, num - 1)]
    print('a', num, third_list)
    return third_list

f2 中的逻辑如下：

def f2(l1=[],num = 2):
    if num == 0: return[1]
    print('b',num,l1)
    
    # Here, both *f2(l1, num-1) calls refer to the original l1
    # passed in the argument list.
    #
    # *l1 refers to the original l1 passed in the argument list,
    # too.
    #
    # The [...] creates a whole new list,
    # then l1 = ... assigns that new list to the name l1.
    l1 = [*l1, *f2(l1, num-1),*f2(l1, num -1)]
    print('a',num,l1)
    return l1

# This function is identical
def f2(first_list = [], num = 2):
    if num == 0: return [1]
    print('b', num, first_list)
    
    second_list = [*first_list, *f2(first_list, n - 1), *f2(first_list, n - 1)]
    print('a', num, second_list)
    return second_list

f2 和 f3 之间的区别在于，在 f2 中，您没有调用任何修改列表的代码：您正在创建一个全新的列表，然后重新分配名称 l1 以引用到新列表。在f3 中，您并没有创建一个全新的列表，您只是在原地修改列表。

让我们举一个简化的例子来说明这一点：

>>> def set_value(first_list):
...     first_list = [ 2 ]
... 
>>> mylist = [3, 4]
>>> set_value(mylist)
>>> mylist
[3, 4]
>>> 
>>> def set_value(first_list):
...     first_list.clear()
...     first_list.append(2)
... 
>>> mylist
[3, 4]
>>> set_value(mylist)
>>> mylist
[2]
>>> 

+= 操作符修改左边的列表，而= 根本不修改列表。 l1 += ... 将 ... 添加到 l1 所指列表的末尾。 l1 = ... 只是更改了名称 l1 所指的内容：您可以使其引用整数、字典、对象或其他任何内容。

Answer 2

在f1 中，第二个调用接收l1 的修改内容，但在f2 它接收原始（未修改）内容，因为在执行推导时列表未修改，但仅在最后一次结果列表已完成构建。