How do you find the square root of a number in Python? Can you find the square root without needing to import the math library?

The most common approach in calculating the square root of a number in Python is to import the math library and use the method math.sqrt(n) where n is the number you want to square root.

But there is an even easier way of being able to calculate the square root of a number in Python **without** having to import the math library. How is this done?

The technique that doesn’t involve importing the math library uses the power operator `**`

.

The power operator is a simple operator that raises a number to an exponent. An example of this is as follows:

```
>>> 5 ** 2
25
>>> 5 ** 3
125
```

In mathematics if you raise a number to the power of 2 you are *squaring *that number. **If you wanted to square root a number you can simply raise a number to the power of one half.**

Here is an example demonstrating this code:

```
>>> 25 ** (1/2)
5.0
>>> 64 ** (1/2)
8.0
```

As you can see from the above code by raising a number to the power of one half you get the **square root** of that number.

You could similarly apply the same technique to cube rooting in Python using the power operator raised to the exponent one-third as demonstrated in the following code below:

```
>>> 125 ** (1/3)
4.9999999999
>>> 27 ** (1/3)
3.0
>>> 64 ** (1/3)
3.9999999996
```

The only issue with using cube roots is some answers are not precise, which highlights an issue seen in other mathematical arithmetic operations when using Python. One workaround is to round the result to a defined number of decimals, as seen here:

```
>>> round(125 ** (1/3), 4)
5.0
>>> round(64 ** (1/3), 4)
4.0
```

## Using Math Library

While there’s nothing wrong with importing the math library and using its methods if you did want to use this approach the `math.`

`sqrt`

`(n)`

method takes a positive number as its sole parameter and calculates its square root.

Here are some examples demonstrating its use:

```
>>> import math
>>> math.sqrt(16)
4.0
>>> math.sqrt(81)
9.0
```

As you can see from the above examples the math square root method works in the same manner as the exponent operator.

Besides using the `math.sqrt(n)`

method you could also use the other math method `math.pow(n, p)`

which works in the same fashion as the power operator allowing for a number to be raised to an exponent.

Therefore, in the same way, the power operator helped in providing the square root by raising a number to the power of one half the same approach could be used by using this method:

```
>>> import math
>>> math.pow(16, 1/2)
4.0
>>> math.pow(81, 1/2)
9.0
```

As can be seen from the above results when compared to the previous results, using the `math.sqrt()`

method, the results are the same.

Equally, the `math.pow(n, p)`

approach can also be used to find the cube root of a number just like the approach above with the power operator.

Here’s how you would use the `math.pow(n, p)`

function to obtain the cube root of a number:

```
>>> import math
>>> math.pow(125, 1/3)
4.999999999999999
>>> math.pow(27, 1/3)
3.0
>>> math.pow(64, 1/3)
3.9999999999999996
```

## What Does `ValueError: math domain error`

Mean?

If you are using the math library and perform an operation that doesn’t make mathematical sense, such as square rooting a negative number then you’re likely to get a `ValueError`

, as demonstrated with the following example:

```
>>> import math
>>> math.sqrt(-25)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: math domain error
>>> math.pow(-25, 1/2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: math domain error
```

As you cannot square root a negative number you will get an error, but what happens when you square root a negative number using the exponent operator, interestingly you get a different response as demonstrated below:

```
>>> -25 ** (1/2)
-5.0
```

The reason for the different result is that Python has arranged the mathematical order of this calculation to be: 1. find the square root of 25; 2. then multiply by negative 1 which equals `-5`

.

To force Python to associate the negative sign to the number being raised to the power of one half using the power operator wrap the number in parentheses, like so:

```
>>> (-25) ** (1/2)
(3.061616997868383e-16+5j)
```

As can be seen from the above code this gives an even weirder answer than before, what is `(3.061616997868383e-16+5j)`

? We can some idea of what this means by writing the result to a string using f-strings:

```
>>> f'{(-25) ** (1/2):.20f}
'0.00000000000000030616+5.00000000000000000000j'
```

And what is revealed from this is that this result is made up of two answers: `0.00000000000000030616`

and `5.00000000000000000000j`

which means the result is a complex number comprising of a real and imaginary component. Here’s further demonstration:

```
>>> n = (-25) ** (1/2)
>>> round(n.real, 4)
0.0
>>> round(n.imag, 4)
5.0
>>> round(n.real, 4) + round(n.imag, 4)
5.0
```

Therefore to achieve a simplified answer from this power operation on a negative number the result needs to be captured and then the `real`

and `imag`

components from the complex number need to be rounded and then added together as was shown above.

## Summary

**To square root a number in Python use either the power operator ** raised to the exponent of one half (1/2) or import the math library and use the math.sqrt(n) function.**

Depending upon the type of answer sought and whether a negative number is permitted with your square root operation either the `math.sqrt(n)`

method is to be preferred (if negative numbers are to throw an error), or if you want to handle complex number results you can use the power operator.