Tuples and immutability

Ian Kelly ian.g.kelly at gmail.com
Sun Mar 9 03:39:50 CET 2014

On Sat, Mar 8, 2014 at 5:40 PM, Gregory Ewing
<greg.ewing at canterbury.ac.nz> wrote:
> Ian Kelly wrote:
>> class LessThanFilter:
>>     def __init__(self, the_list):
>>         self._the_list = the_list
>>     def __getitem__(self, bound):
>>         return [x for x in self._the_list if x < bound]
>> filter = LessThanFilter([10, 20, 30, 40, 50])
>> filter[25] += [15, 17, 23]
>> Should that last line not raise an exception?
> In this case it will fail to catch what is probably an error,
> but you can't expect the language to find all your bugs for
> you. If you wrote the same bug this way:
>    filter[25].extend([15, 17, 23])
> it wouldn't be caught either.
> What's happening is that we're trying to use the syntax
> a += b to mean two different things:
> 1) Shorthand for a = a + b
> 2) A way of expressing an in-place modification, such
>    as a.extend(b)
> Case (2) is not really an assignment at all, so arguably
> it shouldn't require the LHS to support assignment.

In my view the second one is wrong.  a += b should be understood as
being equivalent to a = a + b, but with the *possible* and by no means
guaranteed optimization that the operation may be performed in-place.

In fact, if you read the documentation for lists, you may notice that
while they clearly cover the + operator and the extend method, they do
not explicitly document the list class's += operator.  So although I'm
not entirely sure whether it is intentional or not, and I would be
quite surprised if some implementation were actually to differ on this
point, the language does *not* from what I can see guarantee that the
+= operator on lists is equivalent to calling .extend.

That having been said, code that uses += and relies on the operation
to be performed in-place should be considered buggy.  If you need the
operation to be performed in-place, then use in-place methods like
list.extend.  If you need the operation not to be performed in-place,
then use a = a + b.  If you're ambivalent on the in-place issue and
just want to write polymorphic code, that's when you should consider
using +=.

More information about the Python-list mailing list