LIST.append（1）和LIST=LIST+；[1] （Python）

当我执行（我正在使用交互式shell）这些语句时，我得到以下结果：

L=[1,2,3]
K=L

L.append(4)

L
[1,2,3,4]
K
[1,2,3,4]

但是当我做完全相同的事情时，用L=L+[4]替换L.append（4） 我得到：

这是某种参考资料吗？为什么会发生这种情况

我注意到的另一件有趣的事情是，L+=[4]的行为类似于.append，这很奇怪，因为我认为它的行为类似于L=L+[4]

请澄清所有这些，我们将不胜感激

---

感谢使用

append

直接修改列表。使用

L=L+[4]

，您将复制原始

L

并添加一个新元素，然后将该结果赋回

L

，并打破其与

K

的等价关系

我不确定

+=

的行为

L.append(4)

这将在现有列表的末尾添加一个元素

L += [4]

+=

操作符调用magic

\uuu iadd\uuu（）

方法。结果是

list

覆盖了

\uuu iadd\uuu（）

方法，并使其等效于

extend（）

，后者与

append（）

一样，直接将元素添加到现有列表中

L = L + [4]

L+[4]

生成一个新列表，该列表等于

L

，末尾添加了4。然后，此新列表被分配回

L

。因为您已经创建了一个新的列表对象，

K

不会因此赋值而改变

我们可以使用

id（）

>>> L = [1, 2, 3]
>>> id(L)
152678284
>>> L.append(4)
>>> id(L)
152678284

>>> L = [1, 2, 3]
>>> id(L)
152680524
>>> L = L + [4]
>>> id(L)
152678316

在第一个示例中，
K
和
L
变量名引用同一个对象，因此当您调用一个方法来改变该对象时，显然可以通过两个引用看到更改。在第二个示例中，
+
操作符调用
列表。\uuuu add\uuuu
返回新对象（两个列表的串联）并且
L
名称现在指的是这个新对象，而
K
是完整的。
如果您对字节码好奇：

>>> def L_app( ):
...     L.append( 4 )
...
>>> def L_add( ):
...     L = L + [ 4 ]
...
>>> def L_add_inplace( ):
...     L += [ 4 ]
...
>>> dis.dis( L_app )
  2           0 LOAD_GLOBAL              0 (L)
              3 LOAD_ATTR                1 (append)
              6 LOAD_CONST               1 (4)
              9 CALL_FUNCTION            1
             12 POP_TOP
             13 LOAD_CONST               0 (None)
             16 RETURN_VALUE
>>> dis.dis( L_add )
  2           0 LOAD_FAST                0 (L)
              3 LOAD_CONST               1 (4)
              6 BUILD_LIST               1
              9 BINARY_ADD
             10 STORE_FAST               0 (L)
             13 LOAD_CONST               0 (None)
             16 RETURN_VALUE
>>> dis.dis( L_add_inplace )
  2           0 LOAD_FAST                0 (L)
              3 LOAD_CONST               1 (4)
              6 BUILD_LIST               1
              9 INPLACE_ADD
             10 STORE_FAST               0 (L)
             13 LOAD_CONST               0 (None)
             16 RETURN_VALUE

+=
的行为似乎类似于
附加
（我刚刚测试过它）@Andre，没有。它的行为类似于
extend
，
+=
在python中很奇怪。例如
a=（1,2）；a+=（2，）
产生
（1，2，3）
！这与ite修改列表的情况正好相反。无法就地修改元组。这就是为什么很多人喜欢总是使用a=a+b的形式；a+=（2，）a是（1，2，2）这有什么奇怪的？我想他的意思是
a+=（3，）
。奇怪的是，它允许您在这样的位置修改（不可变）元组。@Kugel，正确。这是我的错别字。奇怪的是，它适用于列表，但不适用于元组。
+=
运算符没有统一的行为。在某些情况下，它相当于
a=a+b
，而在其他情况下（列表），它是完全不同的操作。在大多数语言中，它总是等价于
a=a+b
这很有意义，+=不能在每种对象类型上都是统一的。这里的一致性和重要的是不可变对象不会被修改，而可变对象会被修改。最有趣的情况是
+=
表单。虽然对编程并不陌生，但我对python还是相当陌生的。这个（字节码）对我来说没什么意义。字节码通常不是比语言级别低的代码吗？它更接近机器码，运行速度更快？也许我的定义错了。@aaronasterling:真有趣！补充说@艾蒂：是的
dis
打印Python函数编译到的字节码的“漂亮”表示形式。这通常有助于了解“幕后”发生了什么。因此，当我将变量分配给列表时，它会得到对对象的引用？这是否因为列表实际上不是列表，而是一个参考？我想我现在明白了。这可能发生在列表和字典上，对吗？因为它们实际上都是对对象本身的引用。非常感谢您的澄清。我在其他地方读到的东西只是夸夸其谈，并没有说使用+运算符调用了列表。谢谢（^ ^ ^ ^）你对+=？不仅仅是
列表
和
dict
，Python中的所有东西都是对象。所有对象都存储在堆中，所有变量都只是引用。但是有些对象是不可变的（比如
int
s和
string
s），有些不可变的对象是内部的，所以您不会得到这种令人费解的行为。必须区分修改数据和修改变量名与数据之间的映射。后一种情况是，当您为变量赋值时发生的情况。但是，请注意，如果变量映射本身表示对象的成员，则它本身可以是数据的一部分。Re
+=
运算符：这只是调用修改对象的
\uuuuu\uu\uuu
方法的语法糖分。谢谢，所有这些都非常有用。
>>> def L_app( ):
...     L.append( 4 )
...
>>> def L_add( ):
...     L = L + [ 4 ]
...
>>> def L_add_inplace( ):
...     L += [ 4 ]
...
>>> dis.dis( L_app )
  2           0 LOAD_GLOBAL              0 (L)
              3 LOAD_ATTR                1 (append)
              6 LOAD_CONST               1 (4)
              9 CALL_FUNCTION            1
             12 POP_TOP
             13 LOAD_CONST               0 (None)
             16 RETURN_VALUE
>>> dis.dis( L_add )
  2           0 LOAD_FAST                0 (L)
              3 LOAD_CONST               1 (4)
              6 BUILD_LIST               1
              9 BINARY_ADD
             10 STORE_FAST               0 (L)
             13 LOAD_CONST               0 (None)
             16 RETURN_VALUE
>>> dis.dis( L_add_inplace )
  2           0 LOAD_FAST                0 (L)
              3 LOAD_CONST               1 (4)
              6 BUILD_LIST               1
              9 INPLACE_ADD
             10 STORE_FAST               0 (L)
             13 LOAD_CONST               0 (None)
             16 RETURN_VALUE