# Exponentiation in Python - should I prefer ** operator instead of math.pow and math.sqrt?

PythonMathExponentiation## Python Problem Overview

In my field it's very common to square some numbers, operate them together, and take the square root of the result. This is done in pythagorean theorem, and the RMS calculation, for example.

In numpy, I have done the following:

```
result = numpy.sqrt(numpy.sum(numpy.pow(some_vector, 2)))
```

And in pure python something like this would be expected:

```
result = math.sqrt(math.pow(A, 2) + math.pow(B,2)) # example with two dimensions.
```

However, I have been using this pure python form, since I find it much more compact, import-independent, and seemingly equivalent:

```
result = (A**2 + B**2)**0.5 # two dimensions
result = (A**2 + B**2 + C**2 + D**2)**0.5
```

I have heard some people argue that the `**`

operator is sort of a hack, and that squaring a number by exponentiating it by `0.5`

is not so readable. But what I'd like to ask is if:

"Is there any COMPUTATIONAL reason to prefer the former two alternatives over the third one(s)?"

Thanks for reading!

## Python Solutions

## Solution 1 - Python

`math.sqrt`

is the C implementation of square root and is therefore different from using the `**`

operator which implements Python's built-in `pow`

function. Thus, using `math.sqrt`

actually gives a different answer than using the `**`

operator and there is indeed a computational reason to prefer `numpy`

or `math`

module implementation over the built-in. Specifically the sqrt functions are probably implemented in the most efficient way possible whereas `**`

operates over a large number of bases and exponents and is probably unoptimized for the specific case of square root. On the other hand, the built-in `pow`

function handles a few extra cases like "complex numbers, unbounded integer powers, and modular exponentiation".

See this Stack Overflow question for more information on the difference between `**`

and `math.sqrt`

.

In terms of which is more "Pythonic", I think we need to discuss the very definition of that word. From the official Python glossary, it states that a piece of code or idea is Pythonic if it "closely follows the most common idioms of the Python language, rather than implementing code using concepts common to other languages." In every single other language I can think of, there is some math module with basic square root functions. However there are languages that lack a power operator like `**`

e.g. C++. So `**`

is probably more Pythonic, but whether or not it's objectively better depends on the use case.

## Solution 2 - Python

Even in base Python you can do the computation in generic form

```
result = sum(x**2 for x in some_vector) ** 0.5
```

`x ** 2`

is surely not an hack and the computation performed is the same (I checked with cpython source code). I actually find it more readable (and readability counts).

Using instead `x ** 0.5`

to take the square root doesn't do the exact same computations as `math.sqrt`

as the former (probably) is computed using logarithms and the latter (probably) using the specific numeric instruction of the math processor.

I often use `x ** 0.5`

simply because I don't want to add `math`

just for that. I'd expect however a specific instruction for the square root to work better (more accurately) than a multi-step operation with logarithms.