Arash Arfaee wrote:
Python does not have 'in-place operators'. It has 'augmented assignment
statements' that combines a binary operation with an assignment. *If*
the target being rebound is mutable, *then* (and only then) the
operation can be and is recommended to be done 'in-place'. User-defined
mutable classes (as most are) can implement in-place behavior with
__ixxx__ methods. But for the reason given below, __ixxx__ methods
should supplement and not replace direct mutation methods.
Correct terminology is important for understanding what augmented
assigments do and what they are basically about.
First, most augmented assignments target immutables, in particular,
numbers and strings, which do not have __ixxx__ methods. So the
operation is *not* done in-place. The only difference from separately
indicating the assignment and operation is that the programmer writes
the target expression just once and the interpreter evaluates the target
expression just once instead of each repeating themselves. (And
consequently, any side-effects of that evaluation happen just once
instead of twice.) The same __xxx__ or __rxxx__ method is used in
either case. This non-repetition is the reason for augmented
assigments. The optional in-place optimization for mutables is
secondary. It was debated and could have been left out.
Second, all augmented assignments perform an assignment, even if the
operation is done in place. However, if a mutable such as a list is
accessed as a member of an immutable collection such as a tuple,
mutation is possible, but rebinding is not. So the mutation is done and
then an exception is raised. To avoid the exception, directly call a
mutation method such as list.extend.
Terry Jan Reedy
Hi All,
>
Is there anyway to add new in-place operator to Python? Or is there any
way to redefine internal in-place operators?
>
Is there anyway to add new in-place operator to Python? Or is there any
way to redefine internal in-place operators?
statements' that combines a binary operation with an assignment. *If*
the target being rebound is mutable, *then* (and only then) the
operation can be and is recommended to be done 'in-place'. User-defined
mutable classes (as most are) can implement in-place behavior with
__ixxx__ methods. But for the reason given below, __ixxx__ methods
should supplement and not replace direct mutation methods.
Correct terminology is important for understanding what augmented
assigments do and what they are basically about.
First, most augmented assignments target immutables, in particular,
numbers and strings, which do not have __ixxx__ methods. So the
operation is *not* done in-place. The only difference from separately
indicating the assignment and operation is that the programmer writes
the target expression just once and the interpreter evaluates the target
expression just once instead of each repeating themselves. (And
consequently, any side-effects of that evaluation happen just once
instead of twice.) The same __xxx__ or __rxxx__ method is used in
either case. This non-repetition is the reason for augmented
assigments. The optional in-place optimization for mutables is
secondary. It was debated and could have been left out.
Second, all augmented assignments perform an assignment, even if the
operation is done in place. However, if a mutable such as a list is
accessed as a member of an immutable collection such as a tuple,
mutation is possible, but rebinding is not. So the mutation is done and
then an exception is raised. To avoid the exception, directly call a
mutation method such as list.extend.
Terry Jan Reedy