A brief introduction to sequence incremental assignment in Python (with examples)

This article brings you a brief introduction to sequence incremental assignment in Python (with examples). It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

The incremental assignment operators include = and *=. = The special method behind is __iadd__. If a class does not implement the __iadd__ method, Python will take a step back and call it __add__ method. The difference between these two methods is that __iadd__ is an in-place change and will not change the memory address of the original value, while the __add__ method will get a new object.

Consider the following expression:

a = b

If a implements the __iadd__ method, a will be changed in place (the memory address remains unchanged). If a does not implement the __iadd__ method, then the effect of the expression a = b becomes the same as a = a b, generating a new object and assigning it to a.

Generally speaking, variable sequences generally implement the __iadd__ method, so = is an in-place addition, while immutable sequences do not support this operation at all.

*= is the same as =, except that the special method behind it is __imul__.

a = [1, 2, 3]
b = [4, 5, 6]print("id(a) = %d" % id(a))
a += bprint("id(a) = %d" % id(a))

c = [1, 2, 3]print("id(c) = %d" % id(c))
c = c + bprint("id(c) = %d" % id(c))

d = (1, 2, 3)print("id(d) = %d" % id(d))
d *= 2print("id(d) = %d" % id(d))

The running results are as follows:

id(a) = 1298277978824
id(a) = 1298277978824
id(c) = 1298277978696
id(c) = 1298277978632
id(d) = 1298277972872
id(d) = 1298277136616

Understand the incremental assignment of the sequence, Let’s look at the puzzle mentioned by Leonardo Rochael at the Python Brazil conference in 2013:

t = (1, 2, [30, 40])
t[2] += [50, 60]

A. t becomes (1, 2, [30 , 40, 50, 60])

B. Because tuple does not support assignment to its elements, a TypeError exception will be thrown

C. Neither of the above is

D. A and B are both correct

I guess many people will choose B like me, but in fact the answer is D. Run the code on the console and the result is as follows:

Summary:

1. If you perform repeated splicing operations on immutable sequences , the efficiency will be very low, because each time you have to create a new sequence, then copy the elements in the original sequence to the new sequence, and then append new elements.

2. Don’t put mutable objects in tuples.

3. Incremental assignment is not an atomic operation. We just saw that although it threw an exception, the value of t still changed.

The above is the detailed content of A brief introduction to sequence incremental assignment in Python (with examples). For more information, please follow other related articles on the PHP Chinese website!