Path: csiph.com!fu-berlin.de!uni-berlin.de!not-for-mail
From: MRAB <python@mrabarnett.plus.com>
Newsgroups: comp.lang.python
Subject: Re: Could you explain this rebinding (or some other action) on "nums = nums"?
Date: Tue, 1 Dec 2015 03:32:31 +0000
Lines: 118
Message-ID: <mailman.51.1448940760.14615.python-list@python.org>
References: <94c2e42e-1e5f-40cf-9259-26035e277bf3@googlegroups.com> <mailman.37.1435191416.3674.python-list@python.org> <b48d4b38-a28a-4408-8271-f79e850f453f@googlegroups.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 7bit
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:38.0) Gecko/20100101 Thunderbird/38.3.0
In-Reply-To: <b48d4b38-a28a-4408-8271-f79e850f453f@googlegroups.com>
Precedence: list
Xref: csiph.com comp.lang.python:99765

On 2015-12-01 02:14, fl wrote:
> On Wednesday, June 24, 2015 at 8:17:08 PM UTC-4, Chris Angelico wrote:
>> On Thu, Jun 25, 2015 at 9:52 AM, fl <rxjgmail.com> wrote:
>> > The reason is that list implements __iadd__ like this (except in C, not Python):
>> >
>> > class List:
>> >     def __iadd__(self, other):
>> >         self.extend(other)
>> >         return self
>> > When you execute "nums += more", you're getting the same effect as:
>> >
>> > nums = nums.__iadd__(more)
>> > which, because of the implementation of __iadd__, acts like this:
>> >
>> > nums.extend(more)
>> > nums = nums
>> > So there is a rebinding operation here, but first, there's a mutating operation, and the rebinding operation is a no-op.
>>
>> It's not a complete no-op, as can be demonstrated if you use something
>> other than a simple name:
>>
>> >>> tup = ("spam", [1, 2, 3], "ham")
>> >>> tup[1]
>> [1, 2, 3]
>> >>> tup[1].extend([4,5])
>> >>> tup[1] = tup[1]
>> Traceback (most recent call last):
>>   File "<stdin>", line 1, in <module>
>> TypeError: 'tuple' object does not support item assignment
>> >>> tup
>> ('spam', [1, 2, 3, 4, 5], 'ham')
>> >>> tup[1] += [6,7]
>> Traceback (most recent call last):
>>   File "<stdin>", line 1, in <module>
>> TypeError: 'tuple' object does not support item assignment
>> >>> tup
>> ('spam', [1, 2, 3, 4, 5, 6, 7], 'ham')
>>
>> The reason for the rebinding is that += can do two completely
>> different things: with mutable objects, like lists, it changes them in
>> place, but with immutables, it returns a new one:
>>
>> >>> msg = "Hello"
>> >>> msg += ", world!"
>> >>> msg
>> 'Hello, world!'
>>
>> This didn't change the string "Hello", because you can't do that.
>> Instead, it rebound msg to "Hello, world!". For consistency, the +=
>> operator will *always* rebind, but in situations where that's not
>> necessary, it rebinds to the exact same object.
>>
>> Does that answer the question?
>>
>> ChrisA
>
> I have revisit the past post. In the example code snippet:
>
> type(tup[1])
> Out[162]: list
>
> 'list' is mutable. Why does the following line have errors?
> In practical Python code, error is not acceptable. Then, what purpose is
> for the following code here to show?
>
> Thanks,
>
>
>>>> tup[1] += [6,7]
> Traceback (most recent call last):
>    File "<stdin>", line 1, in <module>
> TypeError: 'tuple' object does not support item assignment
>
When you write:

     x += y

Python tries to do:

     x = x.__iadd__(y)

If x doesn't have the "__iadd__" method, Python then tries to do:

     x = x.__add__(y)

The "__iadd__" method should mutate the object in-place and then return
itself.

Here's an example where it returns something else instead:

# Example

class Test:
     def __init__(self):
         self.string = ''

     def __iadd__(self, other):
         self.string += other
         return "Surprise!"

t = Test()
t += 'foo'
print(t)

# End of example

In the case of:

     tup[1] += [6, 7]

what it's trying to do is:

     tup[1] = tup[1].__iadd__([6, 7])

tup[1] refers to a list, and the __iadd__ method _does_ mutate it, but
then Python tries to put the result that the method returns into
tup[1]. That fails because tup itself is a tuple, which is immutable.