为什么在Python中发生这种情况？ 是否与列表可变性有关？

Question

Please don't be harsh if my question is very simple or obvious. Am a Python newbie, so just started out.

Actually this was a piece of code I came across on this Stack Overflow only but could not find an answer for why this is happening, so decided to ask it myself.

I wrote the below two programs :

1)

x=[1,2,3]
y=x
print x
y=y+[3,2,1]
print x

Output:

[1,2,3]
[1,2,3]

2)

x=[1,2,3]
y=x
print x
y+=[3,2,1]
print x

Output:

[1,2,3]
[1,2,3,3,2,1]

I can't understand why the two outputs are different in this case ? is y=y+(something) not the same as y+=(something)

what is it that I am missing here ?

Thanks a lot for helping me out on this

Answer 1

This has nothing to do with mutability. It has to do with list objects and references to it.

When you do:

y=x

You are essentially making y refer to the same list that x is referring to.

Now,

y=y+[3,2,1]
  ^-------^  - Create a **new** List is that is equal to concatenation of `y` and [1,2,3]
^---^        - Bind variable `y` to this **new** list.
             - The original list which `x` refered to -- is still *intact*

---

Again,

y+=[3,2,1]
 ^-------^   - Append [1,2,3] **in-place**. 
             - Since even `x` is pointing to the same list, it gets modified.

Answer 2

y = y+something will replace the contents of y , while y+=something will modify the list in-place.

TL;DR; Code explanation:

>>> x = [1, 2]
>>> y = x
>>> id(y) == id(x)
True
>>> y += [3]
>>> id(y) == id(x)
True
>>> y = y + [3]
>>> id(y) == id(x)
False

---

Here's a little explanation of what's going on in your code.\\

First code

You declared x:

x=[1,2,3]

Then you point y to the value of x :

y=x

After that, here's the tricky part:

y=y+[3,2,1]

This creates a new y variable, replacing the old one. y is no longer related to x . Now, x has it's own place in memory, and y has a separate one

Second code

Declare x :

x=[1,2,3]

Points y to the value of x :

y=x

And lastly:

y+=[3,2,1]

This modifies the list pointed by y in-place. In other words, you're modifying x as well:

If this isn't clear enough, just comment:)

Hope this helps!

Answer 3

After the line

y = x

Both x and y point to the same object. In way that operators are overloadable in Python:

y += [3, 2, 1]

Is calling function

y.__iadd__([3, 2, 1])

Which in turn adds the elements of [3, 2, 1] to a list pointed by y - which happens to be the same list pointed by x . On the other hand:

y = y + [3, 2, 1]

Is the same as:

y = y.__add__([3, 2, 1])

Which, in turn, creates a new list containing combination of both and assign it to y . After it y and x points to different objects and the one pointed by x is not modified.

Answer 4

No, it's not the same. In fact this was one of the reasons why it took a long time for Python to get += , in the beginning people thought it would be too confusing to add.

y = y + [3, 2, 1]

Rebinds y to a new value, the one that is the result of the expression y + [3, 2, 1].

But

y += [3, 2, 1]

changes y, if it currently refers to something that can be changed. And lists can.

Since the list that y refers to is changed, and x refers to the same list, printing x also shows the new value.

If y were immutable (like a tuple), then it doesn't work that way:

x = y = (1, 2, 3)
y += (3, 2, 1)
print(x)  # prints (1, 2, 3)
print(y)  # prints (1, 2, 3, 3, 2, 1)

The reason is that in the case of mutable objects, it's more likely that changing the object is what you actually want, so they made it work that way. Immutable object can't work that way, so they don't.

Answer 5

In python every time you use the operator = you "delete" the old version and create a new one.

Thus y = y + something will create a new variable of y that isn't the same as the old y.

While y+=something will add something to the current value in y.