Math Module (math, random)

Beginner14 min read•Updated: 2026-09-30

🧮 Python `math` and `random` Modules

Python already provides basic arithmetic operators:

1+   -   *   /   //   %   **

But sometimes we need more advanced operations such as:

Square roots
Trigonometry
Rounding
Factorials
GCD and LCM
Random numbers
Random selections
Shuffling
Simulations

Python provides useful standard library modules for these tasks.

The two important modules in this lesson are:

1math
2random

And for security-sensitive random values, we will also learn:

1secrets

🧠 What Is a Module?

A module is a Python file that contains useful code such as functions, classes, and constants that we can use in our program.

For example:

1import math

After importing it, we can use:

1math.sqrt(25)

You don't need to install math using pip.

It is included with Python.

🔬 `math` vs `random`

Module	Main Purpose	Example
`math`	Mathematical calculations	`math.sqrt(25)`
`random`	Pseudo-random values	`random.randint(1, 10)`
`secrets`	Security-sensitive random values	Secure OTP/token generation

Simple way to remember

1math
2 ↓
3Calculate
4 
5random
6 ↓
7Simulate chance
8 
9secrets
10 ↓
11Generate security-sensitive random values

1. The `math` Module

Let's start by importing it:

1import math

Now we can access many mathematical functions.

π, e, and τ

The math module provides some important mathematical constants.

1import math
2 
3print(math.pi)
4print(math.e)
5print(math.tau)

Output:

141592653589793
718281828459045
283185307179586

What are they?

1math.pi
2→ π
3→ approximately 3.14159
4 
5math.e
6→ Euler's number
7→ approximately 2.71828
8 
9math.tau
10→ 2π
11→ approximately 6.28318

For example:

1radius = 5
2 
3area = math.pi * radius ** 2
4 
5print(area)

Output:

178.53981633974483

2. Square Root with `math.sqrt()`

The sqrt() function calculates the square root.

1import math
2 
3result = math.sqrt(144)
4 
5print(result)

Output:

112.0

Because:

112 × 12 = 144

Another example:

1print(math.sqrt(25))
2print(math.sqrt(81))

Output:

15.0
29.0

📐 `math.hypot()`

math.hypot() can calculate the length of the hypotenuse of a right triangle.

For example:

1import math
2 
3distance = math.hypot(3, 4)
4 
5print(distance)

Output:

15.0

This is based on:

1√(3² + 4²)
2= √25
3= 5

This function is useful for distance calculations.

3. Rounding with `ceil()`, `floor()`, and `trunc()`

Python provides several ways to handle decimal values.

`math.ceil()`

ceil() rounds up toward positive infinity.

1import math
2 
3print(math.ceil(4.2))
4print(math.ceil(4.9))

Output:

15
25

`math.floor()`

floor() rounds down toward negative infinity.

1print(math.floor(4.2))
2print(math.floor(4.9))

Output:

14
24

Negative numbers are important:

1print(math.floor(-4.2))

Output:

1-5

`math.trunc()`

trunc() removes the decimal part by moving toward zero.

1print(math.trunc(4.9))
2print(math.trunc(-4.9))

Output:

14
2-4

📊 `ceil()` vs `floor()` vs `trunc()`

Value	`ceil()`	`floor()`	`trunc()`
`4.2`	`5`	`4`	`4`
`4.9`	`5`	`4`	`4`
`-4.2`	`-4`	`-5`	`-4`
`-4.9`	`-4`	`-5`	`-4`

Easy memory trick

1ceil
2↑
3go up
4 
5floor
6↓
7go down
8 
9trunc
10✂
11remove decimal part toward zero

4. Factorial with `math.factorial()`

A factorial multiplies a positive integer by all positive integers below it.

For example:

15! = 5 × 4 × 3 × 2 × 1
2   = 120

Python:

1import math
2 
3print(math.factorial(5))

Output:

1120

Another example:

1print(math.factorial(6))

Output:

1720

5. GCD and LCM

GCD

GCD means Greatest Common Divisor.

For example:

1import math
2 
3print(math.gcd(48, 18))

Output:

16

The largest number that divides both 48 and 18 is 6.

LCM

LCM means Least Common Multiple.

1print(math.lcm(12, 15))

Output:

160

So:

1GCD → Greatest Common Divisor
2LCM → Least Common Multiple

These functions are useful in mathematical and scheduling problems.

📐 6. Trigonometry

The math module provides:

1math.sin()
2math.cos()
3math.tan()

These functions expect the angle in radians, not degrees.

This is important.

Degrees vs Radians

Humans commonly use degrees:

145°
290°
3180°

Python's trigonometric functions use radians.

For example:

1import math
2 
3angle_degrees = 45
4 
5angle_radians = math.radians(angle_degrees)
6 
7print(angle_radians)

Output:

10.7853981633974483

Calculating Sine and Cosine

1import math
2 
3angle = math.radians(45)
4 
5sine = math.sin(angle)
6cosine = math.cos(angle)
7 
8print(sine)
9print(cosine)

Output:

10.7071067811865475
20.7071067811865476

For easier reading:

1print(f"sin(45°) = {sine:.4f}")
2print(f"cos(45°) = {cosine:.4f}")

Output:

1sin(45°) = 0.7071
2cos(45°) = 0.7071

🔄 Convert Radians Back to Degrees

Use:

1math.degrees()

Example:

1import math
2 
3radians = math.pi
4 
5degrees = math.degrees(radians)
6 
7print(degrees)

Output:

1180.0

Remember

1Degrees → Radians
2math.radians()
3 
4Radians → Degrees
5math.degrees()

🎲 7. The `random` Module

Now let's learn about randomness.

Import the module:

1import random

The random module can be used for:

Games
Simulations
Random selections
Testing
Sampling
Shuffling

For example:

1import random
2 
3number = random.random()
4 
5print(number)

You will get a different value such as:

10.6394267984578837

The value is:

10.0 <= number < 1.0

🎯 `random.randint()`

randint(a, b) generates a random integer between a and b.

Both endpoints are included.

1import random
2 
3dice = random.randint(1, 6)
4 
5print(dice)

Possible results:

This is useful for simulating a dice roll.

🔢 `random.randrange()`

randrange() works similarly to Python's range().

For example:

1import random
2 
3number = random.randrange(10, 30, 2)
4 
5print(number)

Possible values include:

Notice that 30 is not included.

🍎 `random.choice()`

choice() randomly selects one item from a sequence.

1import random
2 
3fruits = [
4    "Mango",
5    "Apple",
6    "Banana",
7    "Guava"
8]
9 
10fruit = random.choice(fruits)
11 
12print(fruit)

Possible output:

1Mango

or:

1Apple

or another fruit from the list.

🎟️ `random.sample()`

sample() selects multiple unique items without replacement.

1import random
2 
3students = [
4    "Aman",
5    "Riya",
6    "Rahul",
7    "Neha",
8    "Priya"
9]
10 
11winners = random.sample(students, k=2)
12 
13print(winners)

Possible output:

1['Rahul', 'Priya']

The same student will not appear twice in that sample.

This can be useful for:

Raffles
Random teams
Prize selection
Data sampling

🔀 `random.shuffle()`

shuffle() randomly rearranges the items in a list.

1import random
2 
3cards = [
4    "Card A",
5    "Card B",
6    "Card C",
7    "Card D"
8]
9 
10random.shuffle(cards)
11 
12print(cards)

Possible output:

1['Card C', 'Card A', 'Card D', 'Card B']

The original list is changed.

Important

random.shuffle() returns None.

So don't write:

1cards = random.shuffle(cards)

Instead:

1random.shuffle(cards)

Then use:

1print(cards)

🔁 8. `random.seed()`

The numbers generated by random are pseudo-random.

That means they look random, but the sequence is generated by an algorithm.

Sometimes we want the same sequence again.

This is useful for:

Testing
Debugging
Classroom demonstrations
Reproducible experiments

We can use random.seed().

1import random
2 
3random.seed(42)
4 
5print(random.randint(1, 100))
6print(random.randint(1, 100))
7print(random.randint(1, 100))

If you run the same program again with the same seed, the sequence will repeat.

🧪 Example: Reproducible Random Numbers

1import random
2 
3random.seed(42)
4 
5first_run = [
6    random.randint(1, 100)
7    for _ in range(4)
8]
9 
10random.seed(42)
11 
12second_run = [
13    random.randint(1, 100)
14    for _ in range(4)
15]
16 
17print("First Run :", first_run)
18print("Second Run:", second_run)
19 
20print("Same sequence:", first_run == second_run)

Output:

1First Run : [82, 15, 4, 95]
2Second Run: [82, 15, 4, 95]
3Same sequence: True

Remember

seed() is useful when you want repeatable random results.

🔐 9. `random` vs `secrets`

This is a very important concept.

The random module is useful for:

Games
Simulations
Testing
Random selections

But it should not be used for security-sensitive values such as:

Password reset tokens
Authentication tokens
Security codes
Session tokens
Sensitive OTP generation

For these tasks, Python provides:

1secrets

The secrets module is designed for generating random values for security-sensitive applications.

🔑 Secure Random Values with `secrets`

Example:

1import secrets
2 
3number = secrets.randbelow(10)
4 
5print(number)

This generates a secure random number from:

10 to 9

📱 Secure 6-Digit Code

For demonstration purposes, you can generate a secure six-digit code like this:

1import secrets
2 
3otp = "".join(
4    str(secrets.randbelow(10))
5    for _ in range(6)
6)
7 
8print(otp)

Possible output:

1849201

The result will normally be different each time.

Important

In a real banking or authentication system, OTP delivery, expiration, rate limiting, verification, and storage must also be handled securely. Generating the number is only one part of a secure OTP system.

🔐 Secure Password Example

The secrets module can also choose characters securely.

1import secrets
2import string
3 
4characters = string.ascii_letters + string.digits + "!@#$%^&*"
5 
6password = "".join(
7    secrets.choice(characters)
8    for _ in range(12)
9)
10 
11print(password)

Possible output:

19k#V7$qX@2mP

📊 `random` vs `secrets`

Requirement	Use
Dice game	`random`
Game simulation	`random`
Random test data	`random`
Shuffle cards	`random`
Scientific simulation	`random`
Security token	`secrets`
Password reset token	`secrets`
Authentication token	`secrets`
Security-sensitive random value	`secrets`

Easy Rule

1Need normal randomness?
2        ↓
3     random
4 
5Need security randomness?
6        ↓
7     secrets

⚠️ Common Beginner Mistakes

Mistake 1: Using degrees directly with `sin()`

Don't:

1math.sin(90)

if you mean 90 degrees.

Use:

1math.sin(math.radians(90))

Mistake 2: Expecting `shuffle()` to return a list

Don't:

1shuffled = random.shuffle(my_list)

Use:

1random.shuffle(my_list)

shuffle() changes the list directly and returns None.

Mistake 3: Using `random` for security

Don't use:

1random.randint(100000, 999999)

for security-sensitive authentication codes.

Use a security-focused approach such as:

1secrets.randbelow()

✅ Do's and Don'ts

Situation	Don't	Do
Square root	Write your own unnecessarily	`math.sqrt()`
Trigonometry	Pass degrees directly	Convert with `math.radians()`
Random game number	`secrets` unnecessarily	`random.randint()`
Security token	`random`	`secrets`
Shuffle list	`result = random.shuffle(list)`	`random.shuffle(list)`
Repeatable testing	Expect random sequence to repeat automatically	Use `random.seed()`

📌 Quick Revision Cheat Sheet

1PYTHON MATH MODULE
2────────────────────────────────
3 
4import math
5 
6math.pi
7→ π
8 
9math.sqrt(x)
10→ Square root
11 
12math.hypot(x, y)
13→ Hypotenuse / distance
14 
15math.ceil(x)
16→ Round up
17 
18math.floor(x)
19→ Round down
20 
21math.trunc(x)
22→ Remove decimal toward zero
23 
24math.factorial(x)
25→ Factorial
26 
27math.gcd(a, b)
28→ Greatest Common Divisor
29 
30math.lcm(a, b)
31→ Least Common Multiple
32 
33math.radians(x)
34→ Degrees → Radians
35 
36math.degrees(x)
37→ Radians → Degrees
38 
39math.sin()
40math.cos()
41math.tan()
42→ Trigonometry

Interactive Quiz• Knowledge Check

Practice Quiz

Question 1

Which module provides sqrt()?

Question 2

What is the result of math.floor(-4.2)?

Question 3

What does random.randint(1, 10) generate?

Question 4

Which module should be used for security-sensitive random tokens?

Question 5

What does random.shuffle() do?

Question 6

Why do we use math.radians() before math.sin() when working with degrees?

💻 Hands-On Practice Challenge

Challenge 16: Cricket Super Over Simulator

Now let's combine math and random in a fun simulation.

We will create a simple 6-ball cricket simulation.

The program will:

Generate random ball outcomes
Track runs
Track wickets
Use random.choices()
Use math.hypot() for a simple distance calculation

Starter Code

1import random
2import math
3 
4print("=" * 55)
5print("       CRICKET SUPER OVER SIMULATOR")
6print("=" * 55)
7 
8BALL_OUTCOMES = [
9    0,
10    1,
11    2,
12    3,
13    4,
14    6,
15    "WICKET"
16]
17 
18OUTCOME_WEIGHTS = [
19    0.20,
20    0.30,
21    0.15,
22    0.05,
23    0.15,
24    0.10,
25    0.05
26]
27 
28 
29def play_super_over(team_name):
30 
31    runs = 0
32    wickets = 0
33 
34    print(f"\n{team_name} Batting")
35    print("-" * 55)
36 
37    for ball in range(1, 7):
38 
39        outcome = random.choices(
40            BALL_OUTCOMES,
41            weights=OUTCOME_WEIGHTS,
42            k=1
43        )[0]
44 
45        if outcome == "WICKET":
46            wickets += 1
47            print(
48                f"Ball {ball}: WICKET | "
49                f"Score: {runs}/{wickets}"
50            )
51        else:
52            runs += outcome
53 
54            print(
55                f"Ball {ball}: "
56                f"{outcome} run(s) | "
57                f"Score: {runs}/{wickets}"
58            )
59 
60    print(
61        f"Final Score: "
62        f"{runs}/{wickets}"
63    )
64 
65    return runs
66 
67 
68# Simulate two teams
69 
70team_a_score = play_super_over("Team A")
71 
72team_b_score = play_super_over("Team B")
73 
74 
75# Display result
76 
77print("\n" + "=" * 55)
78print("             MATCH RESULT")
79print("=" * 55)
80 
81if team_a_score > team_b_score:
82    print("Team A scored more runs.")
83 
84elif team_b_score > team_a_score:
85    print("Team B scored more runs.")
86 
87else:
88    print("Match tied!")
89 
90 
91# Simple distance calculation
92 
93x = 55
94y = 48
95 
96distance = math.hypot(x, y)
97 
98print(
99    f"\nCalculated distance: "
100    f"{distance:.2f} meters"
101)
102 
103print("=" * 55)

🧪 Challenge Tasks

After running the program, try these changes.

Task 1 — Change the number of balls

Currently:

1for ball in range(1, 7):

Try:

1for ball in range(1, 13):

Observe what happens.

Task 2 — Add a new outcome

Add another possible outcome:

15

Then update the weights.

Task 3 — Make the simulation repeatable

Add:

1random.seed(42)

near the beginning of the program.

Run the program multiple times.

Observe whether the same sequence is produced.

Task 4 — Change the distance

Try:

1x = 60
2y = 40

Then observe the new result from:

1math.hypot(x, y)

🎯 Lesson Summary

In this lesson, you learned:

What Python modules are
How to import a module
How to use the math module
math.pi, math.e, and math.tau
math.sqrt()
math.hypot()
math.ceil()
math.floor()
math.trunc()
math.factorial()
math.gcd()
math.lcm()
Trigonometric functions
Degrees and radians
random.random()
random.randint()
random.randrange()
random.choice()
random.sample()
random.shuffle()
random.seed()
Why random should not be used for security-sensitive randomness
How secrets is used for security-sensitive random values

🚀 What's Next?

In the next lesson, we will continue your Python learning journey with String Introduction (5: Strings).

👉 Continue to Next Lesson: String Introduction →

Next Lesson

String Introduction

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Mathematical Operations	String Introduction

Practice Quiz

Test your understanding of this lesson with 6 questions. Each question has one correct answer.

Previous Next

Loading Page Content...

🧮 Python math and random Modules

🧠 What Is a Module?

🔬 math vs random

Simple way to remember

1. The math Module

π, e, and τ

What are they?

2. Square Root with math.sqrt()

📐 math.hypot()

3. Rounding with ceil(), floor(), and trunc()

math.ceil()

math.floor()

math.trunc()

📊 ceil() vs floor() vs trunc()

Easy memory trick

4. Factorial with math.factorial()

5. GCD and LCM

GCD

LCM

📐 6. Trigonometry

Degrees vs Radians

Calculating Sine and Cosine

🔄 Convert Radians Back to Degrees

Remember

🎲 7. The random Module

🎯 random.randint()

🔢 random.randrange()

🍎 random.choice()

🎟️ random.sample()

🔀 random.shuffle()

Important

🔁 8. random.seed()

🧪 Example: Reproducible Random Numbers

Remember

🔐 9. random vs secrets

🔑 Secure Random Values with secrets

📱 Secure 6-Digit Code

Important

🔐 Secure Password Example

📊 random vs secrets

Easy Rule

⚠️ Common Beginner Mistakes

Mistake 1: Using degrees directly with sin()

Mistake 2: Expecting shuffle() to return a list

Mistake 3: Using random for security

✅ Do's and Don'ts

📌 Quick Revision Cheat Sheet

Practice Quiz

💻 Hands-On Practice Challenge

Challenge 16: Cricket Super Over Simulator

Starter Code

🧪 Challenge Tasks

Task 1 — Change the number of balls

Task 2 — Add a new outcome

Task 3 — Make the simulation repeatable

Task 4 — Change the distance

🎯 Lesson Summary

🚀 What's Next?

String Introduction

Related Lessons

Practice Quiz

🧮 Python `math` and `random` Modules

🔬 `math` vs `random`

1. The `math` Module

2. Square Root with `math.sqrt()`

📐 `math.hypot()`

3. Rounding with `ceil()`, `floor()`, and `trunc()`

`math.ceil()`

`math.floor()`

`math.trunc()`

📊 `ceil()` vs `floor()` vs `trunc()`

4. Factorial with `math.factorial()`

🎲 7. The `random` Module

🎯 `random.randint()`

🔢 `random.randrange()`

🍎 `random.choice()`

🎟️ `random.sample()`

🔀 `random.shuffle()`

🔁 8. `random.seed()`

🔐 9. `random` vs `secrets`

🔑 Secure Random Values with `secrets`

📊 `random` vs `secrets`

Mistake 1: Using degrees directly with `sin()`

Mistake 2: Expecting `shuffle()` to return a list

Mistake 3: Using `random` for security