What does it mean to say that x is evaluated only once in an accumulated substitution sentence such as x+=1?

Wouldn't it be easier to interpret x as representing anything that can come to the left of the cumulative assignment rather than literally understanding x as a single identifier?

i=0
definc():
    global i
    i+=1
    returni
list = [1,2,3]
list [inc()] + = 1
print(list)//-> [1,3,3]

In such an example, you can clearly see the difference between list[inc()]+=1 and list[inc()]=list[inc()]+1.

I think it's a comparison with a substitute.
"If x=x+1, evaluate x on the right and x on the left, but x+=1 only once, so it is not strictly equivalent (internal processing)."
I think it means the degree.

What does it mean to say that x is evaluated only once in an accumulated substitution sentence such as x+=1?

"I interpreted ""subsidiary"" as being counted in the evaluation."

• If x=x+1

  Calculating x+1 -- > x (first assessment)
  Assessment of -->x (second assessment) replacing results with x

• If x+=1

  Add 1 to x -->x Assessment

If x=x+1

Calculating x+1 -- > x (first assessment)
Assessment of -->x (second assessment) replacing results with x

If x + = 1

Add 1 to x -->x Assessment

However,

A cumulative assignment expression, such as x+=1, can be rewritten as x=x+1, but is not strictly equivalent.For the cumulative assignment, x is evaluated only once.

"I think ""x is evaluated only once for the accumulated substitution"" in is an unnecessary explanation (*)."
"Strictly unequivalent" does not occur in the ""difference in the number of evaluations"", but rather the difference in whether x is being rewritten (subscribed) or not (subscribed) in the new object you generated.

そう I thought so because I couldn't think of an example where behavior changes depending on the number of evaluations.

Add

"For those who add up, x is evaluated only once" is suspicious.

I looked into Python Documentation and found out

x+=1 is equivalent to x=operator.iadd(x,1)
x=x+1 is equivalent to x=operator.add(x,1)

said he.
This allows you to read x's ratings in the same way, whether it's in-place or not.

Also, when I put a print statement into the properties of the class, both of them had the same number of evaluations.

Below is the source and verification results.

operator--- Standard operator in functional form
describes the following:

The operator module provides an efficient set of functions corresponding to Python's built-in operators. For example, operator.add(x,y) is equivalent to the expression x+y

According to this, x=x+1 is equivalent to x=operator.add(x,y).

In-place operator
describes the following:

Many operations have "in-place" versions. The following functions provide a simpler way to call such operators than the usual grammar.For example, the statement x+=y is equivalent to x=operator.iadd(x,y).In other words, z=operator.iadd(x,y) is equivalent to the compound statement z=x;z+=y.

According to this, x+=1 is equivalent to x=operator.iad(x,1).

[Code used for verification]

class Sample():
    def__init__(self, x):
        self.xx = x
    @property
    defx(self):
        print('get x==>',self.xx)
        return self.xx
    @x.setter
    def x (self, x):
        print('set x<==',x)
        self.xx = x

sample=Sample(12)
sample.x + = 1
print(sample.x)
sample.x = sample.x+1
print(sample.x)

[Results]

get x==>12
set x<==13
get x == > 13
13
get x == > 13
set x<==14
get x == > 14
14

Additional 2

"For those who add up, x is evaluated only once" is suspicious.

is withdrawn.

From answers and comments from dosec, OOPer, peppaa, oriri5,

A cumulative assignment expression, such as x+=1, can be rewritten as x=x+1, but is not strictly equivalent.For the cumulative assignment, x is evaluated only once.

If interpreted as having a different number of evaluations of 」x を before ++= や or ++ 」 operations, の it is understandable that xx is evaluated only once しか.

Different values for each f() called
The reason why x[f()]=x[f()]+1 and x[f()]+=1 results are different is because x[f()] evaluates differently.

If the left side x has side effects, you will be in trouble if you don't specify a one-time evaluation

Example of c if other languages are acceptable

int*p=&array[i];
*p+++=1; // *p++=*p+++1; replaces "undefined behavior"
// I don't know if p[i] will change or p[i+1] will change if there is only one evaluation.

c++ Example

inta, debugcount;
int&func() {++ debug count;return a;}
func()+=1;// Same as above, debugcount is confirmed to increase by 1 for one evaluation

What does it mean to say that x is evaluated only once in an accumulated substitution sentence such as x+=1?

It literally means that x is evaluated only once, but I think it is intended to be the expression +=1.
Here's an example of OOper essentially the same as what he says, but different from the substitution statement.

7.2.1. Aggregated assignment statement

augmented_assignment_stmt::=ugtarget augop(expression_list|yield_expression)
target:: = identifier | attributeref | subscription | slicing
augop::="+="|"-="|"*="|"@="|"/="|"//="|"%="|"**="
| ">>="|"<="|"&="|"^="|"|="

There is a subscription in the target, and the subscript notation is also covered, so lst is used as the
lst[n]+=1
is also applicable.
6.3.2.Subscription

subscription::=primary"["expression_list"]"
If the primary is a sequence, the evaluation result of the expression list must be an integer or a slice (discussed in the following section).

In the description, you can specify an expression that returns an integer to n for the list.
That's why

lst=[1,3,5]
it=iter(range(5))
lst[next(it)]+=1#lst[0]+=1
print(lst)# [2,3,5]

If so, lst[next(it)] is evaluated only once, so lst[0]+=1 but

lst=[1,3,5]
it=iter(range(5))
lst [next(it)] = lst [next(it)] +1 #lst[1] = lst[0] +1
print(lst)#[1,2,5]

In this case, 6.16. According to the evaluation order, the right-hand lst [next(it)] is evaluated first to lst[0], and the left-hand lst[next(it) is evaluated later, so it is different from lst[1].