Does Python optimize low-power functions?

Question

The following two functions return the same result:

 x**2
 x*x

But they may be computed in different ways. The first choice can accommodate non-integer powers and so it would logically proceed by taking a logarithm, multiplying by the power (in this case, 2), and then taking the anti-logarithm. But for a trivial value for the power like 2, this is clearly a wasteful choice. Just multiply x by itself, and skip the expensive log and anti-log steps.

My question is, what do Python interpreters do with power operators where the power is a small constant, like 2? Do they know to take the shortcut?

Comments

It is probably specific to the interpreter implementation(cython, jython, iron python etc...). You'd better optimize it yourself should you really care about this.

An alternative is to use numpy functions, like numpy.power, they are optimized version of most mathematical functions.

Answer 1

It's worth noting that the *interpreter* per se is not doing this. The implementation of the long object does this in its implementation of the __pow__ method, which the interpreter invokes. Other objects may implement this differently and use whatever optimizations they like. They may even (ab)use the syntax for things other than numerical exponentiation where x**2 is not equivalent to x*x. Since objects are free to do so, the interpreter itself cannot choose to optimize that exponentiation down to multiplication.