This sent me searching everywhere, because the documentation of '+=' and
other "augmented assignment statements" says
"The target is only evaluated once.",
like in C++, which implies a kind of reference to mutable object.
Not exactly. For an augmented assignment, the target (left side) may be an
identifier, an atttribute reference, or a subscription/slicing. In the
first case, the comment simply does not apply (there is a single one
opportunity to evaluate the target).
a += some(expression) means: evaluate "a", evaluate some(expression),
perform the operation +=, bind the resulting object to the name "a".
a.attr += some(expression) means: evaluate "a", ask it for its attribute
"attr", evaluate some(expression), perform the operation +=, ask the
(already known) object "a" to store the resulting object as its attribute
"attr".
a[index] += some(expression) performs a similar sequence of steps; "a" is
evaluated only once, then it is asked to retrieve its element at [index],
the computation is performed, and finally the (already known) object "a"
is asked to store the result at [index].
"The target is only evaluated once." means that it is NOT reevaluated
before the final result is stored. Same applies to "index" above, although
this is not explicited. Perhaps it is more clear with a longer expression:
a[b+c].c[d(e[f])].h += 1 computes the a[b+c].c[d(e[f])] part only once.
I couldn't immediately see how subscription could apparently return a
reference to mutable int object in Python in a way so that it worked
transparently (the idiom in C++).
It does not. It perform first a "getitem" operation followed by a
"setitem" to store the result. A normal dictionary would fail when asked
for an inexistent item; a defaultdict creates and returns a default value
in such case.
py> import collections
py> d = collections.defaultdict(int)
py> d['a'] += 1
py> d['a'] += 1
py> d['a']
2
py> d['b']
0
note: int() returns 0; defaultdict(lambda: 0) could have been used.
However, it worked to replace collections.defaultdict with a class
overriding __getitem__ and __setitem__, so I guess that's how it works,
that in this case '+=' is simply translated like 'x += n' -> 'temp = x;
x = temp + n'.
Is this a correct understanding, and if so, what exactly does the
documentation mean for the general case?
If x is a simple name, the only difference between x += n and x = x+n is
the method invoked to perform the operation (__iadd__ vs __add__ in
arbitrary objects). Both x and n are evaluated only once - and this is not
an optimization, nor a shortcut, simply there is no need to do otherwise
(please make sure you understand this).
From the docs for the operator module: "Many operations have an “in-placeâ€
version. The following functions provide a more primitive access to
in-place operators than the usual syntax does; for example, the statement
x += y is equivalent to x = operator.iadd(x, y). Another way to put it is
to say that z = operator.iadd(x, y) is equivalent to the compound
statement z = x; z += y."
http://docs.python.org/library/operator.html
foo()[bar()] += 1
so here it's not translated like 'foo()[bar()] = foo()[bar()] + 1' but
evidently more like 'a = foo(); i = bar(); a.__setitem__(i,
a.__getitem__(i) + 1)'?
Yes, something like that.
If so, is this behavior defined anywhere?
Isn't the description at
http://docs.python.org/reference/simple_stmts.html#assignment-statements
enough? It goes to some detail describing, e.g., what a.x = 1 means. The
next section explains what a.x += 1 means in terms of the former case.
I did find discussion (end of §6.2 of the language reference) of the
case where the target is an attibute reference, with this example:
class A:
x = 3 # class variable
a = A()
a.x += 1 # writes a.x as 4 leaving A.x as 3
Do you want to discuss this example?
