Python provides the in-place exponentiation operator x **= y
that raises x
to the power of y
using x ** y
and assigns the result to the first operands variable name x
. You can set up the in-place exponentiation behavior for your own class by overriding the magic “dunder” method __ipow__(self, other)
in your class definition.
>>> x = 2 >>> x **= 3 >>> x 8
The expression x **= y
is syntactical sugar for the longer-form x = x ** y
:
>>> x = 2 >>> x = x ** 3 >>> x 8
Let’s explore some examples on different data types of the operands.
Integer Example
The **=
operator on integer operands raises the first to the power of the second operand and stores it in the left-hand operands’ variable.
>>> x = 8 >>> x **= 2 >>> x 64
Float Example
If at least one of the operands is a float value, the result is also a float—float is infectious!
>>> x = 8 >>> x **= 2.0 >>> x 64.0
Incompatible Data Type
What if two operands have an incompatible data type—unlike floats and integers? For example, if you try to potentiate an integer and a list variable?
>>> x = 4 >>> x **= [1, 2] Traceback (most recent call last): File "<pyshell#5>", line 1, in <module> x **= [1, 2] TypeError: unsupported operand type(s) for ** or pow(): 'int' and 'list'
The result of incompatible addition is a TypeError
. You can fix it by using only compatible data types for the in-place exponentiation operation.
Can you use the exponent operator on custom objects? Yes!
Python In-Place Exponentiation Magic Method
To use the in-place exponentiation operator **=
on custom objects, define the __ipow__()
method (“dunder method”, “magic method”) that takes two arguments self
and other
, updates the first argument self
with the result of the addition, and returns the updated object.
In the following code, you calculate the power of two Data
objects by combining their contents:
class Data: def __init__(self, data): self.data = data def __ipow__(self, other): self.data **= other.data return self x = Data(2) y = Data(3) x **= y print(x.data) # 8
You can see that the content of the first operand is updated as a result of the in-place exponentiation operation.
Python In-Place Operators
In-place assignment operators (also called compound assignment operators) perform an operation in-place on a variable provided as first operand. They overwrite the value of the first operand variable with the result of the operation when performing the operator without assignment. For example, x += 3
is the same as x = x + 3
of first calculating the result of x +3
and then assigning it to the variable x.
Operator | Name | Short Example | Equivalent Long Example |
---|---|---|---|
= | In-place Assignment | x = 3 | |
+= | In-place Addition | x += 3 | x = x + 3 |
-= | In-place Subtraction | x -= 3 | x = x - 3 |
*= | In-place Multiplication | x *= 3 | x = x * 3 |
/= | In-place Division | x /= 3 | x = x / 3 |
%= | In-place Modulo | x %= 3 | x = x % 3 |
//= | In-place Integer Division | x //= 3 | x = x // 3 |
**= | In-place Power | x **= 3 | x = x ** 3 |
&= | In-place Bitwise And | x &= 3 | x = x & 3 |
|= | In-place Bitwise Or | x |= 3 | x = x | 3 |
^= | In-place Bitwise XOR | x ^= 3 | x = x ^ 3 |
>>= | In-place Bitwise Shift Right | x >>= 3 | x = x >> 3 |
<<= | In-place Bitwise Shift Left | x <<= 5 | x = x << 5 |