Programming tips for everyone

# Python Exponent – Raise a Number to a Power To raise a number to a power in Python, use the Python exponent `**` operator.

For example, `23` is calculated by:

`2 ** 3`

And generally `n` to the power of `m` by:

`n ** m`

Python exponent also relates to another topic. The Python exponent notation is a way to express numbers with lots of zeros. You can use the exponent notation `e` or `E` to replace the powers of ten.

For example, a billion (`1 000 000 000`) is 109. This means it can be written with an exponential notation using the letter `e` or `E` followed by the number of zeros:

```1000000000  # Hard to read the zeros

## What Is an Exponent in Maths

An exponent is the number of times the number is multiplied by itself. In maths, the exponent is denoted with a number as a superscript, such as 23.

The operation involving exponents is called raising a number to a power.

This means number 2 is multiplied by itself 3 times. This gives:

`23 = 2 * 2 * 2 = 8 `

That’s it for the maths part. Let’s see how to calculate exponents in Python.

Let’s also get to know the exponent notation, which can help you represent large and small numbers.

## How to Raise a Number to a Power in Python

There are three ways you can raise a number to a power in Python:

1. The `**` operator
2. The built-in `pow()` function
3. The `math` module’s `math.pow()` function

Let’s go through each of these with examples. We are also going to discuss the subtle differences between these methods.

### 1. The Double Asterisk (**) Operator

You can use the double-asterisk operator to raise a number to a power in Python.

For example:

`2 ** 3 # -> 8`

This is a clear and efficient way to compute powers in Python. Most of the time, this approach is the fastest to compute a power in Python. More on efficiency later.

### 2. Pow() Function

You can also use the built-in `pow()` function to raise a number to a power.

For instance:

`pow(2, 3) # -> 8`

### 3. Math.pow() Function

Finally, you may also use the `math.pow()` function to raise a number to a power. Just remember to import the `math` module in your project.

For instance:

```import math

math.pow(2, 3) # -> 8.0```

This function does the same thing as the two earlier power calculating approaches. But it is most efficient with floats.

## Pow() vs math.pow() vs ** Operator

There are three main ways to raise a number to a power in Python. Let’s discuss the differences between them.

All three approaches work almost identically with one another. But there are some slight differences you may be interested to learn.

1. `**` is generally faster.
2. `Math.pow()` uses floats only.
3. `Math.pow()` does not allow imaginary numbers.
4. The built-in `pow()` function accepts a third argument.

Let’s go through each of these main differences in a bit more detail.

### 1. ** Is Usually Faster

The double-asterisk approach is slightly faster than `pow()` or `math.pow()`. This is because it does not involve a separate function call.

For example:

```from timeit import timeit

asterisk_time = timeit('70. ** i', setup='i = 10')
pow_time = timeit('pow(70., i)', setup='i = 10')
math_pow_time = timeit('math.pow(70, i)', setup='import math; i = 10')

print(f" **: {asterisk_time} \n pow: {pow_time} \n math.pow: {math_pow_time}")```

Output:

``` **: 0.066251788
pow: 0.080007215
math.pow: 0.10603947999999999```

### 2. Math.pow() Only Uses Floats

`Math.pow()` handles its arguments differently comparing to the built-in `pow()` function or ** operator. M`ath.pow()` converts the arguments to floats and returns the result as a float. In comparison, the built-in `pow()` and the `**` return the result as an integer with integer inputs.

```math.pow(4, 2) # 8.0
pow(4, 2)      # 8
4 ** 2         # 8```

If you want to raise a number to a power and have the result as a float, you can use `math.pow()`. This way you don’t have to separately convert the result to float yourself. This is very subtle, but the difference is there.

### 3. Math.pow() Does Not Accept Imaginary Numbers

The built-in `pow()` function and the ** operator allows imaginary numbers. But `math.pow()` does not.

For instance:

```pow(2, 1 + 0.5j)       # 1.8810842093664877+0.679354250205337j
2 ** 1 + 0.5j          # 1.8810842093664877+0.679354250205337j
math.pow(2, 1 + 0.5j)  # TypeError: can't convert complex to float```

The math.pow() throws an error with imaginary units. So if you want to deal with imaginary numbers with powers, use `pow()` or `**`.

### 4. Pow() Takes a Third Argument

The built-in `pow()` function has a special use case for computing `ab mod c`. To do this, pass a third argument to `pow()` call.

For example, let’s compute `32 mod 4`:

`pow(3, 2, 4) # returns 1`

It turns out this approach is faster than using the ** operator for doing the same:

`(3 ** 2) % 4`

Let’s make a comparison by using the `timeit` module and let’s use some big numbers:

```import timeit

start = timeit.default_timer()
pow(3000000000, 2000, 4000)
stop = timeit.default_timer()

pow_time = stop - start

print('Time using pow: ', pow_time)

start = timeit.default_timer()
(3000000000 ** 2000) % 4000
stop = timeit.default_timer()

asterisk_time = stop - start

print('Time using **: ', asterisk_time)

print(f"The pow was {asterisk_time / pow_time} times faster")```

Output:

```Time using pow:  4.804000000000613e-06
Time using **:  0.0005024339999999995
The pow was 104.58659450456607 times faster```

All in all, the differences between `pow()`, `math.pow()`, and `**` are subtle but they exist. If you are a beginner, it does not really matter which approach you use as long as it works.

## Python Exponent Notation—Get Rid of Zeros

Now that you know how to raise numbers to powers in Python, it’s time to learn what the exponent notation means in Python.

The exponent notation becomes handy with numbers that have a lot of digits.

For example, a big number like one billion (`1 000 000 000`) can be hard to read in Python. This is where the exponent notation helps. It lets you replace powers of ten with `e` or `E`.

As you may know, a billion is `109`. So you can replace that in Python with a shorthand of `1e09`. (This reads 1 multiplied 10 to the power of 9, which is billion.)

```# Hard to read
1000000000

# Better (possible for Python 3.6 <)
1_000_000_000

# Even better especially for the mathematically oriented
1e09

# or
1E09
```

The same goes for tiny numbers. Small numbers such as `0.7` or `0.03` are easy to read. But when numbers get really small, they become hard to read due to the leading zeros. For example, `0.000000001`.

To overcome the readability issues, you can denote small numbers with the exponent notation `e` or `E` as well.

Let’s take a look at that number`0.000000001`. Based on the number of zeros, it appears to be one billionth.

To denote this number in an exponent form, you can use the `e` notation. This time, however, you need to use a negative exponent (as the number is less than 1). This means billion becomes `1e-09`.

```# Hard to read
0.000000001

# Better
1e-09```

Here are some random examples of representing numbers in the exponential form:

```10
1e01

0.1
1e-01

2000
2e03

0.000342
3.42e-04
# Or just as well
342e-06

# The exponent notation does not always make things more readable, though.
# For example:
12000.15
1.200015e04```

## Conclusion

Python exponent refers to two things:

• Raising numbers to a power.
• Denoting large or small numbers with `e` or `E` to reduce zeros.

To raise a number to a power in Python, you can use the double-asterisk operator `**`:

`2 ** 3`

Or you can use the built-in `pow()` function:

`pow(2, 3)`

Or you can use the `math.pow()` function especially when dealing with floats:

```import math

math.pow(2, 3)```

To denote a number in the exponent form, replace powers of 10 with `e` or `E`:

```# Hard to read
1000000000

# Better (possible for Python 3.6 <)
1_000_000_000

# Even better especially for the mathematically oriented
1e09

# or
1E09
```

Thanks for reading. I hope you enjoy it.

Happy coding!