变异、重新绑定、复制值和赋值运算符之间的区别

Question

#!/usr/bin/env python3.2

def f1(a, l=[]):
    l.append(a)
    return(l)

print(f1(1))
print(f1(1))
print(f1(1))

def f2(a, b=1):
    b = b + 1
    return(a+b)

print(f2(1))
print(f2(1))
print(f2(1))

在 f1 中，参数 l 具有默认值分配，并且仅计算一次，因此三个 print 输出 1、2 和 3为什么f2不做类似的事情？

结论：

为了使我学到的知识更容易为该线程的未来读者导航，我总结如下：

• 我发现这个关于这个主题的很好的教程。

• 我制作了一些简单的示例程序来比较变异、重新绑定、复制值和赋值运算符之间的区别。

Answer 1

相对流行的 SO 问题对此进行了详细介绍，但我会尝试在您的特定情况下解释这个问题。

---

当您声明函数时，默认参数将在此时被评估。每次调用该函数时它不会刷新。

您的函数表现不同的原因是您以不同的方式对待它们。在 f1 中，您正在改变对象，而在 f2 中，您正在创建一个新的整数对象并将其分配给 b。您不是在这里修改 b，而是重新分配它。现在它是一个不同的对象。在 f1 中，您保留相同的对象。

考虑一个替代函数：

def f3(a, l= []):
   l = l + [a]
   return l

其行为类似于 f2 并且不会继续附加到默认列表。这是因为它正在创建一个新的 l ，而没有修改默认参数中的对象。

---

python 中常见的风格是分配默认参数 None，然后分配一个新列表。这解决了整个歧义。

def f1(a, l = None):
   if l is None:
       l = []

   l.append(a)

   return l

Answer 2

因为在 f2 中，名称 b 被重新绑定，而在 f1 中，对象 l 被突变。

Answer 3

这是一个有点棘手的案例。当您很好地理解 Python 如何处理名称和对象时，这是有意义的。如果您正在学习 Python，您应该努力尽快加深对 Python 的理解，因为它绝对是您在 Python 中所做的一切的核心。

Python 中的名称类似于 a、f1、b。它们仅存在于特定范围内（即您不能在使用 b 的函数之外使用它）。在运行时，名称​​引用一个值，但可以随时使用赋值语句重新绑定到新值，例如：

a = 5
b = a
a = 7

值在程序中的某个时刻创建，并且可以通过名称引用，也可以通过列表或其他数据结构中的槽。在上面的名称 a 绑定到值 5，然后反弹到值 7。这对 值 5 没有影响，它始终是值 5无论当前有多少个名字与其绑定。

另一方面，对 b 的赋值会将名称 b 绑定到 a 引用的值那个时间点。之后重新绑定名称 a 对 值 5 没有影响，因此对也绑定到该值的名称 b 没有影响5.

在 Python 中赋值总是以这种方式进行。它永远对价值观没有任何影响。 （除了某些对象包含“名称”；重新绑定这些名称显然会影响包含该名称的对象，但不会影响更改之前或之后名称引用的值）

每当您在赋值语句，您正在（重新）绑定名称。每当您在任何其他上下文中看到某个名称时，您都会检索该名称引用的（当前）值。

---

有了这个，我们就可以看到您的示例中发生了什么。

当Python执行函数定义时，它会评估用于默认参数的表达式，并将它们偷偷地记住在旁边的某个地方。之后：

def f1(a, l=[]):
    l.append(a)
    return(l)

l 就什么都不是了，因为 l 只是函数 f1 范围内的一个名称，而我们并不在其中。功能。然而，值[]被存储在某个地方。

当 Python 执行转移到对 f1 的调用时，它将所有参数名称（a 和 l）绑定到适当的值 - 调用者传入的值，或者定义函数时创建的默认值。因此，当 Python 执行调用 f3(5) 时，名称 a 将绑定到值 5，名称 l 将绑定到我们的默认列表。

当 Python 执行 l.append(a) 时，看不到任何赋值，因此我们指的是 l 和 a 的当前值。因此，如果这对 l 有任何影响，它只能通过修改 l 引用的值来实现，而且确实如此。列表的 append 方法通过在末尾添加一个项目来修改列表。因此，在此之后，我们的列表值，仍然是存储为 f1 的默认参数的相同值，现在已经有了 5（a< 的当前值） /code>) 附加到它后面，看起来像 [5]。

然后我们返回l。但我们修改了默认列表，因此它将影响以后的任何调用。而且，我们还返回了默认列表，因此对我们返回的值的任何其他修改都将影响以后的任何调用！

现在，考虑 f2：

def f2(a, b=1):
    b = b + 1
    return(a+b)

这里，和以前一样，值 1 被保存在某个地方作为 b 的默认值，当我们开始执行 f2( 5) 调用名称 a 将绑定到参数 5，名称 b 将绑定到默认值 1 >。

但随后我们执行赋值语句。 b 出现在赋值语句的左侧，因此我们重新绑定名称 b。首先，Python 计算出 b + 1，即 6，然后将 b 绑定到该值。现在，b 绑定到值 6。但函数的默认值并未受到影响：1 仍然是 1！

---

希望事情已经澄清了。为了理解 Python，你确实需要能够根据引用值的名称进行思考，并且可以反弹以指向不同的值。

也许还值得指出一个棘手的案例。我上面给出的规则（关于赋值总是绑定名称而不影响值，因此如果有任何其他影响名称的事情，它必须通过更改值来实现）对于标准赋值来说是正确的，但并不总是对于“增强”赋值运算符例如 +=、-= 和 *=。

不幸的是，它们的作用取决于您使用它们的目的。在：

x += y

这通常表现得像：

x = x + y

即它计算一个新值并将x重新绑定到该值，对旧值没有影响。但如果 x 是一个列表，那么它实际上会修改 x 引用的值！所以要小心这种情况。

Answer 4

在 f1 中，您将值存储在数组中，或者更好的是在 Python 中存储在列表中，而在 f2 中，您对传递的值进行操作。这就是我对此的解释。我可能错了

Answer 5

其他答案解释了为什么会发生这种情况，但我认为如果您想获得新对象，应该对要做什么进行一些讨论。许多类都有方法.copy()，允许您创建副本。例如，如果我们重写f1，那么

def f1(a, l=[]):
    new_l = l.copy()
    new_l.append(a)
    return(new_l)

无论我们调用它多少次，它都会继续返回[1]。还有库 https://docs.python.org/3/library/copy .html 用于管理副本。

另外，如果您要循环访问容器的元素并逐一改变它们，那么使用推导式不仅更具 Python 风格，而且可以避免改变原始对象的问题。例如，假设我们有以下代码：

data = [1,2,3]
scaled_data = data
for i, value in enumerate(scaled_data):
     scaled_data[i] = value/sum(data)

这会将 scaled_data 设置为 [0.166666666666666666, 0.38709677419354843, 0.8441754916792739]；每次将 scaled_data 的值设置为缩放版本时，您也会更改 data 中的值。如果您这样做

data = [1,2,3]
scaled_data = [x/sum(data) for x in data]

，则将 scaled_data 设置为 [0.16666666666666666, 0.3333333333333333, 0.5] 因为您不是在改变原始对象，而是在创建一个新对象。