On the other hand, list._iadd_ is defined, so x += when x is a list is the same as x = x._iadd_(). (Indeed, the purpose of INPLACE_ADD is to provide a way to mutate an object rather than always create a new object.)įor example, int._iadd_ is not defined, so x += 7 when x is an int is the same as x = x._add_(y), setting x to a new instance of int. x._iadd_ typically returns x, so that the resulting STORE_NAME does not change the referent of x, though that object may have been mutated. If that does not exist, then x._add_ is used in its place. INPLACE_ADD is implemented using x._iadd_. Both _add_ and _radd_ typically return new instances, without modifying either argument. The only difference between the two is the bytecode used for the operator: INPLACE_ADD for +=, and BINARY_ADD for +.īINARY_ADD is implemented using x._add_ (or y._radd_ if necessary), so x = x + y is roughly the same as x = x._add_(y). (Yes, this is implementation-depenent, but it gives you an idea of the language-defined semantics being implemented.) > import dis
PYTHON NOT EQUAL TO OPERATOR CODE
Let's look at the byte code that CPython generates for x += y and x = x = y. In this case will successfully be added to the list referred to by a but then afterwards an exception will be raised when the code tries and fails to reassign a. This doesn't matter much if the left hand side is simply a variable but it can cause confusing behaviour when you have an immutable collection referring to mutable collections for example: a = (,) In python 3, similar behaviour is observed with the "bytes" and "bytearray" types.įinally note that reassignment happens even if the object is not replaced. However when we invoke it with a list the list is modified in place, so both a and b are affected. When we invoke dostuff with a tuple then the tuple is copied as part of the += operation and so b is unaffected. Technically this is implemented by looking for _IADD_ first, if that is not implemented then _ADD_ is tried and finally _RADD_.Ĭare is required when using += in python on variables where we are not certain of the exact type and in particular where we are not certain if the type is mutable or not. In this case the variable "a" will be updated to point to a new object containing the result of an addition operation. Some mutable objects may also not have an implementation of an in-place "add" operation. If the object is immutable then it obviously can't perform the modification in-place.
So a points to the same object it did before but that object now has different content. If the object is mutable then it is encouraged (but not required) to perform the modification in-place. So what does "storing the value in a" mean?
Note that for lists += is more flexible than +, the + operator on a list requires another list, but the += operator will accept any iterable. For lists, tuples, strings etc it means concatenation.In python the answers to both of these questions depend on the data type of a. What exactly do we mean by "storing the result in a"? python variables don't store values directly they store references to objects.However the simplistic description raises a couple of questions. This simplistic description would describe the += operator in many languages.
Notionally a += b "adds" b to a storing the result in a.
0 kommentar(er)
