# Simple Python Math Module Guide (22 Examples and 18 Functions)

# Using The `math`

Module in Python

`math`

is a built-in module in the Python 3 standard library that provides standard mathematical constants and functions. You can use the `math`

module to perform various mathematical calculations, such as numeric, trigonometric, logarithmic, and exponential calculations.

This tutorial will explore the common constants and functions implemented in the `math`

module — and how to use them.

## The `math`

Module Constants

There are several built-in constants in the `math`

module. We’ll cover some of the most important constants in this section.

`math.pi`

The number 𝜋 is a mathematical constant, approximately equal to 3.14159. After importing the `math`

module, you just need to write `math.pi`

to access the 𝜋 number:

```
import math
print(math.pi)
```

`3.141592653589793`

Let’s use the 𝜋 number to calculate the area of a circle. The formula for calculating a circle area is as follows:

$Area = \pi r^2$

```
import math
def circle_area(r):
return math.pi*r**2
radius = 3
print("Area =", circle_area(radius))
```

`Area = 28.274333882308138`

`math.tau`

The τ constant returns an almost precise value of $2\pi$. Let’s print its value:

`print(math.tau)`

`6.283185307179586`

`math.e`

We can access the number *e* (or the Euler’s number) simply by using the `math.e`

constant:

`print(math.e)`

`2.718281828459045`

`math.nan`

The `math.nan`

constant stands for *Not a Number*, and it can initialize those variables that aren’t numbers. Technically, the data type of the `math.nan`

constant is *float*; however, it’s not considered a valid number.

```
print(math.nan)
print(type(math.nan))
```

```
nan
<class 'float'>
```

`math.inf`

The `math.inf`

constant represents a floating-point positive infinity. It can represent both positive infinity and negative infinity constants, as follows:

```
print(math.inf)
print(-math.inf)
```

```
inf
-inf
```

## The `math`

Module Functions

The `math`

module provides a wide range of mathematical functions for many different scientific and engineering applications, including the following:

- Number functions
- Power and logarithmic functions
- Trigonometric functions
- Angular conversion functions
- Hyperbolic functions
- and some special functions

However, we will only discuss the most important ones in this section. Let’s explore them.

### Number Functions

`math.ceil()`

The `math.ceil()`

method maps a floating-point number to the smallest succeeding integer:

```
p = 10.1
print(math.ceil(p))
```

`11`

`math.floor()`

The `math.floor()`

method maps a floating-point number to the greatest preceeding integer:

```
q = 9.99
print(math.floor(q))
```

`9`

`math.factorial()`

The `math.factorial(n)`

method returns the product of all natural numbers less than or equal to `n`

, if `n`

a positive integer. However, if `n = 0`

, it returns `1`

. The code below uses the `math.factorial()`

to calculate $5!$:

```
n = 5
print("{}! = {}".format(n, math.factorial(n)))
```

`5! = 120`

`math.gcd()`

The `math.gcd()`

method returns the greatest common denominator for two numbers; we can use it to reduce fractions.

For example, the GCD for 25 and 120 is 5, so we can divide the numerator and denominator by 5 to get a reduced fraction (e.g., $\frac{25}{120} = \frac{5}{24}$). Let’s see how it works:

```
gcd = math.gcd(25, 120)
print(gcd)
```

`5`

`math.fabs()`

The `math.fabs()`

method removes the negative sign of a given number, if any, and returns its absolute value as a float:

`print(math.fabs(-25))`

`25.0`

### Power and Logarithmic Functions

`math.pow()`

The `math.pow()`

method returns a floating-point value representing the value of x to the power of y $(x^y)$. Let’s try the `math.pow()`

method by forecasting an investment. To do that, we need to know the initial deposit, the annual interest rate, and the number of years that you invest your money in an investment account. Finally, by using the following formula, we can calculate the final amount of the investment:

${amount} = deposit(1+interest)^{years}$

For example, consider the following values:

- Initial deposit: $10,000
- Annual interest rate: 4%
- Number of years: 5

The code calculates the final amount deposited in the investment account after five years:

```
deposit = 10000
interest_rate = 0.04
number_years = 5
final_amount = deposit * math.pow(1 + interest_rate, number_years)
print("The final amount after five years is", final_amount)
```

`The final amount after five years is 12166.529024000001`

The `math.pow(x, y)`

method always returns a floating-point value, Let’s check the data type of the function’s return value:

`print(type(math.pow(2, 4)))`

`<class 'float'>`

`math.exp()`

The `math.exp(x)`

method is equal to $e^x$, where $e$ is the Euler’s number. We can say the `math.exp(x)`

method is equivalent to the statement below:

`math.pow(math.e, x)`

```
print(math.exp(3))
print(math.pow(math.e, 3))
```

```
20.085536923187668
20.085536923187664
```

`math.sqrt()`

The `math.sqrt()`

method returns the square root of a number. Let’s try it:

`print(math.sqrt(16))`

`4.0`

`math.log()`

The `math.log()`

method accepts two arguments, `x`

and `base`

, where the default value of base is $e$. So the method returns the natural logarithm of *x* $(\log_e x)$ if we only pass one argument. On the other hand, if we provide two arguments, it calculates the logarithm of x to the given base ($\log_b x$). Let’s calculate different logarithms:

```
print(math.log(10))
print(math.log(10, 3))
```

```
2.302585092994046
2.095903274289385
```

The first line returns the natural logarithm of 10, and the second line returns the logarithm of 10 to the base 3.

Although we’re able to calculate the logarithm of any number to the base 10 using `math.log(x, 10)`

, the `math`

module provides a more accurate method to perform the same calculation. Let’s check it out:

`print(math.log10(1000))`

`3.0`

### Trigonometric Functions

The `math`

module also provides some useful methods for doing trigonometry. In this section, we’ll learn how to calculate the sine, cosine, and tangent of a given value using the following methods provided in the `math`

module.

`math.sin()`

The `math.sin()`

method returns the sine of a given value, where the value must be in radians. The returned value is a floating-point number between -1 and 1:

`print(math.sin(math.pi/4))`

`0.7071067811865476`

`math.cos()`

The `math.cos()`

method returns the cosine of a given value, and like the `math.sin()`

method, the value must be in radians. The returned value is a floating-point number between -1 and 1:

`print(math.cos(math.pi/2))`

`6.123233995736766e-17`

`math.tan()`

The `math.tan()`

method returns a floating-point value representing the tangent of a given value. The value must be in radians. Let’s find the tangent of different angles:

```
print(math.tan(math.pi/4))
print(math.tan(math.pi/6))
print(math.tan(0))
```

```
0.9999999999999999
0.5773502691896257
0.0
```

**NOTE**

The `math`

module provides two useful methods for angular conversion. To convert a given angle from radians to degrees, use the `math.degrees()`

, and to convert a given angle from degrees to radians, use `math.radians(x)`

.

### Hyperbolic Functions

The hyperbolic functions are quite similar to the trigonometric functions; however, there are differences. The `math`

module provides all the hyperbolic functions that appear in scientific and engineering applications, as follows:

Function | Description |
---|---|

`math.cosh(x)` |
computes the hyperbolic cosine of x. |

`math.sinh(x)` |
computes the hyperbolic sine of x. |

`math.tanh(x)` |
computes the hyperbolic tangent of x. |

`math.acosh(x)` |
computes the inverse hyperbolic cosine of x. |

`math.asinh(x)` |
computes the inverse hyperbolic sine of x. |

`math.atanh(x)` |
computes the inverse hyperbolic tangent of x. |

Let’s do some calculations using the hyperbolic functions:

```
x = 0.5
print(math.cosh(x))
print(math.sinh(x))
print(math.tanh(x))
```

```
1.1276259652063807
0.5210953054937474
0.46211715726000974
```

## Conclusion

The `math`

built-in module includes a number of constants and methods that support mathematical operations from basic to advanced. We explored some of the most important and widely used constants and methods, including the number, power and logarithmic, trigonometric functions, and more.