Python Modules

A module is a file of ready-written Python code that you can pull into your own program. Somebody has already written it, tested it and packed it up; you just borrow it. Python ships with dozens of these. Your syllabus names three: math, random and statistics.

A note about your NCERT book, before you get confused. NCERT prints all of this material inside Chapter 7, which is titled "Functions". Most of that chapter teaches you to write your own functions with def and return, along with parameters and scope. The CBSE 2025-26 syllabus for Class 11 (code 083) places all of that in Class 12, not Class 11. Only the module half of NCERT Chapter 7 is examinable for you this year. So when you open the book and find pages on def, do not panic that we have skipped them - they are not yours yet. Everything on this page is.

Why modules exist at all. Suppose there were no math module and you needed a square root. You would have to write the algorithm yourself. Here is the Babylonian method, which starts from a guess and keeps improving it:

# Square root the hard way (Babylonian method)
n = 2
guess = 1.0
for i in range(20):
    guess = (guess + n / guess) / 2
print("Hand written :", guess)

# Square root the module way - one line
import math
print("math.sqrt(2)  :", math.sqrt(2))

Output:

Hand written : 1.414213562373095
math.sqrt(2)  : 1.4142135623730951

Five lines and a loop against one line - and look closely at the last digit. The module's answer is the more accurate of the two, because it hands the job to the processor's own square-root instruction instead of guessing twenty times. That is the whole argument for modules: code that is correct, fast and already tested, which you did not have to write.

Nothing is available until you import it. Run this on its own:

print(sqrt(144))

The last lines of the traceback read:

NameError: name 'sqrt' is not defined

Now add the import and run it again:

import math
print(sqrt(144))

It still fails, with exactly the same message:

NameError: name 'sqrt' is not defined

This trips up almost everybody once. import math brings one new name into your program: math. It does not scatter sqrt, pi, floor and the rest loose in your file. Everything inside has to be reached through the module's name, with a dot:

import math

print(math.sqrt(144))
print(math.pi)
print(type(math))

12.0
3.141592653589793

The dot means "inside". Read math.sqrt as "the sqrt that lives inside math". Notice also that math has a type of its own - module - just as 7 has type int.

Giving a module a nickname. If a module name is long or you use it constantly, import ... as renames it:

import math as m

side = 7
print("Area of square plot :", m.pow(side, 2), "sq m")
print("Diagonal of the plot:", round(m.sqrt(2 * side * side), 2), "m")

Area of square plot : 49.0 sq m
Diagonal of the plot: 9.9 m

After import math as m, the name math does not work - only m does. The nickname replaces the original, it does not sit alongside it, so math.sqrt(4) would raise NameError: name 'math' is not defined.

Seeing what is inside a module. The built-in dir() lists every name a module offers:

import math
print(dir(math)[:8])
print(len(dir(math)))

['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin']
67

Sixty-seven names in one small module on Python 3.13 (the exact count varies a little between versions). You only need the nine your syllabus lists, but dir() is genuinely useful when you are stuck and cannot remember a spelling.

Typing math. in front of everything gets tiring. The from statement lets you pull chosen names straight into your own program, so no prefix is needed.

from math import sqrt, pi

print(sqrt(625))
print(pi)

25.0
3.141592653589793

Now here is the trade-off. from math import sqrt, pi brings in sqrt and pi - and nothing else, not even the name math. So this fails:

from math import sqrt, pi
print(math.sqrt(625))

The last line of the traceback:

NameError: name 'math' is not defined. Did you forget to import 'math'?

Python's own hint is slightly misleading here - you did import from math, you just never asked for the module object itself. Remember it as a rule: plain import gives you the module; from gives you the pieces. They are opposite ends of the same trade.

Renaming on the way in. as works with from too:

from statistics import mean as average
from math import sqrt as root

marks = [72, 65, 88, 91, 54]
print("Average marks:", average(marks))
print("Root of 81   :", root(81))

Average marks: 74
Root of 81   : 9.0

Importing everything with *. The star means "every public name in this module":

from math import *
from statistics import *

print(floor(4.9), ceil(4.1))
print(mean([10, 20, 30]))

4 5
20

Convenient - and this is where students lose marks. When you dump every name from a module into your program, a name can silently overwrite one that was already there. Watch:

print(pow(2, 10))          # built-in pow
from math import *
print(pow(2, 10))          # math.pow has now taken over the name

1024
1024.0

Same call, same arguments, different answer. Python has a built-in pow() that returns an int; math also has a pow(), and it always returns a float. The star import replaced one with the other, without a single warning. In a program that later did bill[pow(2, 3)], that 8.0 would stop the program with TypeError: list indices must be integers or slices, not float.

The reverse happens too - your own variable can wipe out an imported function:

from math import pow
from statistics import mean

pow = 5          # our own variable, same name
print(pow)
print(pow(2, 3)) # Python now looks at the number 5

5
TypeError: 'int' object is not callable

"'int' object is not callable" always means the same thing: you put brackets after something that is not a function. Here it is the integer 5, because pow stopped being a function the moment you assigned to it. This is why the safe habit - and the one to use in an exam unless the question says otherwise - is plain import math with the dot prefix. It makes the source of every name obvious and nothing can be overwritten by accident.

Worked example - a shop bill using all three forms.

import math, random          # two modules on one line
from statistics import mean  # one name pulled out of a third

random.seed(42)
bill = [249.50, 1199.00, 75.25, 640.75]

print("Items         :", bill)
print("Total (Rs)    :", sum(bill))
print("Rounded up    : Rs", math.ceil(sum(bill)))
print("Average item  : Rs", round(mean(bill), 2))
print("Lucky coupon  :", random.randint(1000, 9999))

Items         : [249.5, 1199.0, 75.25, 640.75]
Total (Rs)    : 2164.5
Rounded up    : Rs 2165
Average item  : Rs 541.12
Lucky coupon  : 2824

math and random keep their prefixes; mean was pulled out and is used bare. Both styles happily coexist in one file. (random.seed(42) is there so this page prints the same coupon number every time - more on that in the random section.)

The math module holds the number-crunching tools. Your syllabus names exactly nine items from it, and every one is below with its real output.

The two constants. pi and e are values, not functions - no brackets. Writing math.pi() is an error.

import math

print("pi   =", math.pi)
print("e    =", math.e)
print("sqrt(2)   =", math.sqrt(2))
print("ceil(4.1) =", math.ceil(4.1))
print("floor(4.9)=", math.floor(4.9))
print("ceil(-4.1)  =", math.ceil(-4.1))
print("floor(-4.1) =", math.floor(-4.1))
print("pow(2, 5) =", math.pow(2, 5))
print("fabs(-7)  =", math.fabs(-7))

pi   = 3.141592653589793
e    = 2.718281828459045
sqrt(2)   = 1.4142135623730951
ceil(4.1) = 5
floor(4.9)= 4
ceil(-4.1)  = -4
floor(-4.1) = -5
pow(2, 5) = 32.0
fabs(-7)  = 7.0

Read the negative cases carefully. ceil(-4.1) is -4, not -5. ceil always moves up the number line and floor always moves down. On the number line -4 is above -4.1. Students who think of ceil as "round away from zero" get this wrong every single time. Nor is ceil the same as int(): int() chops towards zero, so int(-4.1) gives -4 (which matches ceil by luck) but int(4.9) gives 4 while math.ceil(4.9) gives 5. Keep the picture of the number line, not of zero.

math.fabs vs abs, math.pow vs pow. Python already has built-in abs() and pow(). The math versions do the same arithmetic but always hand back a float:

import math

print(math.fabs(-7), abs(-7))
print(math.pow(2, 5), pow(2, 5), 2 ** 5)
print(type(math.fabs(-7)), type(abs(-7)))

7.0 7
32.0 32 32
 

Three ways to get 32, and only math.pow gives you 32.0. Board questions love this difference, so remember: of the nine math items in your syllabus, everything returns a float except ceil() and floor(), which return int. (The wider module does contain a few other int-returning functions, such as factorial() and gcd(), but those are not in your syllabus and will not be asked.)

Trigonometry - the angle is in radians. This is the single biggest mistake with sin, cos and tan. They do not take degrees.

import math

print("sin(0)        =", math.sin(0))
print("cos(0)        =", math.cos(0))
print("tan(0)        =", math.tan(0))
print("sin(pi/2)     =", math.sin(math.pi / 2))
print("cos(pi/2)     =", math.cos(math.pi / 2))
print("tan(pi/4)     =", math.tan(math.pi / 4))

sin(0)        = 0.0
cos(0)        = 1.0
tan(0)        = 0.0
sin(pi/2)     = 1.0
cos(pi/2)     = 6.123233995736766e-17
tan(pi/4)     = 0.9999999999999999

Two of those look wrong and are not. cos(pi/2) should be exactly 0, and it prints 6.123233995736766e-17 - that is 0.0000000000000000612, effectively zero. tan(pi/4) should be exactly 1 and prints 0.9999999999999999. The reason is that math.pi is itself a rounded-off decimal; pi cannot be stored exactly in binary, so pi/2 is a hair off the true right angle. In real programs you wrap such results in round().

Converting degrees to radians. Multiply by math.pi / 180:

import math

deg = 30
rad = deg * math.pi / 180
print("30 degrees =", rad, "radians")
print("sin(30) =", round(math.sin(rad), 4))
print("cos(60) =", round(math.cos(60 * math.pi / 180), 4))
print("tan(45) =", round(math.tan(45 * math.pi / 180), 4))

30 degrees = 0.5235987755982988 radians
sin(30) = 0.5
cos(60) = 0.5
tan(45) = 1.0

Those are the values you learnt in Maths, so the conversion is right.

Worked example - buying a ladder. A ladder leans against a wall at 65 degrees and its foot is 2.5 m from the wall. How long is the ladder, how high does it reach, and what size should you buy?

import math

angle_deg = 65
foot = 2.5
angle_rad = angle_deg * math.pi / 180

length = foot / math.cos(angle_rad)
height = length * math.sin(angle_rad)

print("Ladder length :", round(length, 2), "m")
print("Wall height   :", round(height, 2), "m")
print("Buy a ladder of at least", math.ceil(length), "m")

Ladder length : 5.92 m
Wall height   : 5.36 m
Buy a ladder of at least 6 m

math.ceil is exactly right for the last line. You cannot buy 5.92 m of ladder, and rounding down to 5 m would leave you short. Whenever the real-world answer is "you need at least this much", reach for ceil.

The random module produces numbers you cannot predict - for dice games, OTPs, shuffled question papers, lucky-draw coupons. Your syllabus names three functions: random(), randint() and randrange().

Before anything else: output changes every run. If you run any snippet in this section on your own machine you will get different numbers, and that is correct behaviour, not a mistake. To print stable outputs on this page, most snippets below start with random.seed(n), which fixes the starting point of the number generator so the same sequence comes out every time. seed() is not in your syllabus list - it is used here purely so you can check the printed outputs against your own run. Remove the seed line and the numbers become genuinely unpredictable again.

Proof that a seed really does pin the sequence - this file was run twice and gave identical output both times:

import random

random.seed(10)          # fixes the sequence
print(random.random())
print(random.random())
print(random.randint(1, 6))
print(random.randrange(1, 6))
print(random.randrange(0, 50, 10))

0.5714025946899135
0.4288890546751146
5
1
10

random() - a float between 0 and 1. It takes no arguments. The range is written [0.0, 1.0): the square bracket means 0.0 can come out, the round bracket means 1.0 never does. Two hundred thousand calls confirm it:

import random
random.seed(0)
lo = 1.0
hi = 0.0
for i in range(200000):
    r = random.random()
    if r < lo:
        lo = r
    if r > hi:
        hi = r
print("lowest seen :", lo)
print("highest seen:", hi)
print("Was 1.0 ever produced?", hi == 1.0)

lowest seen : 1.224005981570464e-05
highest seen: 0.9999965148287956
Was 1.0 ever produced? False

On its own a number between 0 and 1 is not much use, so you scale it:

import random

random.seed(7)
r = random.random()
print("random()          :", r)
print("scaled to 0-100   :", r * 100)
print("marks out of 100  :", int(r * 100))
print("1 to 6 the hard way:", int(random.random() * 6) + 1)

random()          : 0.32383276483316237
scaled to 0-100   : 32.38327648331624
marks out of 100  : 32
1 to 6 the hard way: 1

randint(a, b) - both ends included. This is the one that behaves differently from everything else in Python, so it is worth burning in. randint(1, 5) really can give you 5.

randrange(start, stop) - stop excluded. It follows exactly the same rules as range(), which you already know from loops. randrange(1, 5) can never give 5.

Here they are side by side, each called a thousand times, with every new value collected into a list:

import random

random.seed(1)
a = []
b = []
for i in range(1000):
    x = random.randint(1, 5)
    if x not in a:
        a.append(x)
    y = random.randrange(1, 5)
    if y not in b:
        b.append(y)

print("randint(1, 5)   produced:", sorted(a))
print("randrange(1, 5) produced:", sorted(b))

randint(1, 5)   produced: [1, 2, 3, 4, 5]
randrange(1, 5) produced: [1, 2, 3, 4]

That is the whole difference, and it is worth a mark in almost every paper.

randrange with one argument, and with a step. Again, identical to range():

import random

random.seed(5)
vals = []
for i in range(500):
    v = random.randrange(3)
    if v not in vals:
        vals.append(v)
print("randrange(3) gives:", sorted(vals))

vals2 = []
for i in range(2000):
    v = random.randrange(5, 30, 5)
    if v not in vals2:
        vals2.append(v)
print("randrange(5, 30, 5) gives:", sorted(vals2))

randrange(3) gives: [0, 1, 2]
randrange(5, 30, 5) gives: [5, 10, 15, 20, 25]

Note that 30 never appears - the stop value is excluded even when a step is given.

Worked example - a UPI-style OTP and a seat allotment.

import random

random.seed(2026)
otp = ""
for i in range(6):
    otp = otp + str(random.randint(0, 9))
print("Your UPI OTP is", otp)

# a step size: even seat numbers from 0 to 18, since 20 is excluded
random.seed(2026)
print("Seat allotted:", random.randrange(0, 20, 2))

Your UPI OTP is 158813
Seat allotted: 2

randint(0, 9) is used because a digit of an OTP must be able to be 9. If you wrote randrange(0, 9) the stop value would be excluded and your OTP could never contain a 9. That is not merely cosmetic: the number of possible OTPs would fall from 10 ** 6 = 1000000 to 9 ** 6 = 531441, so the code would be almost twice as easy to guess.

Worked example - picking a random item from a list. The index must be a valid position, so the range runs from 0 to len(list) - 1:

import random
CITY = ["DELHI", "MUMBAI", "CHENNAI", "KOLKATA"]
random.seed(3)
for i in range(4):
    n = random.randint(0, 3)
    print(CITY[n], end="  ")
print()

MUMBAI  MUMBAI  CHENNAI  KOLKATA

With four cities you need indexes 0, 1, 2, 3 - so randint(0, 3) or, equivalently, randrange(0, 4). Getting that boundary wrong is the classic IndexError, and it is exactly what the board's "possible output" questions are testing.

Averages come up constantly - class results, cricket scores, monthly bills. The statistics module gives you the three measures of central tendency without writing a line of arithmetic. Your syllabus names mean(), median() and mode().

import statistics

marks = [78, 65, 92, 65, 88]
print("mean  :", statistics.mean(marks))
print("median:", statistics.median(marks))
print("mode  :", statistics.mode(marks))
print("sorted:", sorted(marks))

mean  : 77.6
median: 78
mode  : 65
sorted: [65, 65, 78, 88, 92]

Check it by hand. Mean = (78+65+92+65+88)/5 = 388/5 = 77.6. For the median the list has to be in order - [65, 65, 78, 88, 92] - and the middle of five values is the third, which is 78. You do not have to sort the list yourself; median() sorts internally. The mode is 65 because it appears twice and everything else appears once.

The even-length trap. When the count is even there is no single middle value, so median() averages the two middle ones - and an average of two integers is a float:

import statistics

a = [10, 20, 30, 40]
print("median of", a, "=", statistics.median(a))
b = [10, 20, 30]
print("median of", b, "=", statistics.median(b))
print("mean of", a, "=", statistics.mean(a))
print("mean of [1, 2] =", statistics.mean([1, 2]))
print("mean of [1, 2, 4] =", statistics.mean([1, 2, 4]))

median of [10, 20, 30, 40] = 25.0
median of [10, 20, 30] = 20
mean of [10, 20, 30, 40] = 25
mean of [1, 2] = 1.5
mean of [1, 2, 4] = 2.3333333333333335

Look at the first and third lines together. For the same list [10, 20, 30, 40], the median prints 25.0 and the mean prints 25. That is not a typo:

import statistics

print(type(statistics.mean([10, 20, 30, 40])), statistics.mean([10, 20, 30, 40]))
print(type(statistics.median([10, 20, 30, 40])), statistics.median([10, 20, 30, 40]))
print(type(statistics.median([10, 20, 30])), statistics.median([10, 20, 30]))

 25
 25.0
 20

The rule is: mean() returns an int when the division comes out exact and all the data are ints, otherwise a float. median() returns one of the actual data values when the count is odd (so int here), and a computed average when the count is even (so float). If a question shows an even-length list, write the median with the .0.

mode() and ties. mode() returns the most frequent value. It works on strings too, not just numbers:

import statistics

print("mode of [1, 1, 2, 2, 3] =", statistics.mode([1, 1, 2, 2, 3]))
print("mode of ['pen','book','pen','bag'] =", statistics.mode(['pen', 'book', 'pen', 'bag']))
print("mode of a tuple (4, 4, 9) =", statistics.mode((4, 4, 9)))

mode of [1, 1, 2, 2, 3] = 1
mode of ['pen','book','pen','bag'] = pen
mode of a tuple (4, 4, 9) = 4

In the first list, 1 and 2 both appear twice. From Python 3.8 onwards mode() no longer complains about a tie - it returns whichever of the tied values appears first in the data, which here is 1. Older books say this raises StatisticsError; that was true up to Python 3.7 and is no longer the behaviour. Also note that all three functions accept any sequence - list, tuple or range - not just a list.

Empty data is an error. There is no average of nothing:

import statistics
print(statistics.mean([]))

statistics.StatisticsError: mean requires at least one data point

Worked example - a class report card. This one pulls in math as well, which is how these modules actually get used:

import statistics
import math

names = ["Aarav", "Diya", "Kabir", "Meera", "Rohan", "Sana"]
marks = [88, 72, 88, 57, 95, 72]

print("Name   : Marks")
for i in range(len(names)):
    print(names[i], ":", marks[i])

print()
print("Class average :", statistics.mean(marks))
print("Rounded (2 dp):", round(statistics.mean(marks), 2))
print("Median        :", statistics.median(marks))
print("Mode          :", statistics.mode(marks))
print("Highest       :", max(marks))
print("Lowest        :", min(marks))
print("Average shown on report card:", math.ceil(statistics.mean(marks)))

Name   : Marks
Aarav : 88
Diya : 72
Kabir : 88
Meera : 57
Rohan : 95
Sana : 72

Class average : 78.66666666666667
Rounded (2 dp): 78.67
Median        : 80.0
Mode          : 88
Highest       : 95
Lowest        : 57
Average shown on report card: 79

Three things to notice. The median is 80.0 because six is an even count - sorted the marks are [57, 72, 72, 88, 88, 95] and (72+88)/2 = 80.0. The mode is 88 even though 72 also appears twice, because 88 comes first in the original list. And max() and min() are ordinary built-ins - they need no import at all, so do not go looking for them in statistics.