← Back to course index Module 5 · Functions & Modules

Python Built-in Modules

A module is just a code library. Discover what's available with help('modules'), then take a hands-on tour of math, random, time, and os.

Overview

This topic covers Python modules — what they are, how to discover which ones are available, and how to use some of the most common built-in modules (math, random, time, os) through hands-on examples in Jupyter Notebook.

Key Concepts

A module is essentially a code library — a file containing a set of functions you want to use in your application.
Python ships with many built-in modules you can use without installing anything extra.
You can list all available modules using help('modules').
Modules must be imported before their functions can be used.
Trying to import a module that doesn't exist raises a ModuleNotFoundError.

Detailed Explanation

What are Modules?

"Consider a module to be the same as a code library. A file containing a set of functions you want to include in your application."

Examples of Python modules covered in this lesson:

math
random
os
time

Listing All Available Modules

You can see every module installed/available in your Python environment with:

help('modules')

What happens:

It prints: Please wait a moment while I gather a list of all available modules...
You may see a deprecation warning like:
```
ShimWarning: The `IPython.kernel` package has been deprecated since IPython 4.0.
You should import from ipykernel or jupyter_client instead.
```
⚠️ This is just a warning from the IPython/Jupyter internals — it does not stop the module list from being generated, and can generally be ignored.
It then prints a huge list of module names in columns (e.g., numpy, pandas, os, time, math, random, sklearn, matplotlib, sqlite3, threading, json-related modules, win32* modules on Windows, etc.). This list includes:
- Standard library modules (e.g., os, time, math, random, json, csv, threading, sqlite3)
- Third-party/installed packages (e.g., numpy, pandas, matplotlib, sklearn, sqlalchemy)
- Internal/private modules (prefixed with _, e.g., _ast, _bisect, _codecs)

💡 Tip: help('modules') is a great way to explore what's available in your environment, but the output can be long — scroll through it or search for a keyword.

Importing a Module

Before using any function from a module, you must import it:

import math
import random
import os
import time

Important Point: If you misspell a module name or import something that isn't a real module, Python raises a ModuleNotFoundError.

Example of an error:

import mathrhe

ModuleNotFoundError: No module named 'mathrhe'

C vs Python — importing a library:

	C	Python
Bring in a library	`#include <stdio.h>`	`import math`
Syntax	`#include <filename.h>`	`import module_name`
When it happens	Preprocessor step (before compilation)	Runtime (when the line executes)

Same purpose in both — reuse existing code — just a different keyword and mechanism.

Things to Remember:

Module names are case-sensitive and must match exactly.
ModuleNotFoundError means Python cannot find any module with that exact name — check spelling first.

The math Module

Used for mathematical operations.

Function	Example	Result	Description
`math.pi`	`math.pi`	`3.141592653589793`	Value of π
`math.e`	`math.e`	`2.718281828459045`	Euler's number
`math.factorial(n)`	`math.factorial(5)`	`120`	Factorial of n (5! = 120)
`math.ceil(x)`	`math.ceil(6.3)`	`7`	Rounds up to the nearest integer
`math.floor(x)`	`math.floor(6.9)`	`6`	Rounds down to the nearest integer
`math.sqrt(x)`	`math.sqrt(100)`	`10.0`	Square root (always returns a float)

Key takeaway: ceil() always rounds up, floor() always rounds down — regardless of the decimal value (e.g., 6.1 would still floor to 6 and ceil to 7).

The random Module

Used for generating random numbers and shuffling data.

import random

random.randint(1, 100)   # Returns a random integer between 1 and 100 (inclusive)

Example output: 54

a = [1, 2, 3, 4, 5]
random.shuffle(a)        # Shuffles the list IN PLACE (no return value needed)
a

Example output: [1, 4, 5, 2, 3] (order will vary each run)

Important Points:

random.randint(a, b) → returns a random integer N such that a <= N <= b (both bounds inclusive).
random.shuffle(list) → shuffles the given list in place; it modifies the original list rather than returning a new one.

The time Module

Used for working with time-related values.

import time

time.time()     # Returns current time as a Unix timestamp (seconds since epoch)

Example output: 1625459281.405317

time.ctime()    # Converts current time into a human-readable string

Example output: 'Mon Jul 5 09:58:08 2021'

time.sleep(1)   # Pauses program execution for the given number of seconds

Example demonstrating time.sleep():

print("Hello")
time.sleep(1)
print("World")

Output:

Hello
World

("Hello" prints, then execution pauses for 1 second, then "World" prints.)

Important Points:

time.time() → raw numeric timestamp (useful for measuring elapsed time / performance).
time.ctime() → human-friendly formatted date/time string.
time.sleep(seconds) → delays/pauses code execution — useful for simulating wait times or throttling loops.

The os Module

Used to interact with the operating system (files, directories, paths).

import os

os.getcwd()     # Returns the current working directory

Example output:

'C:\\Users\\91842\\100-days-of-python\\day9-builtins'

os.listdir()    # Lists all files and folders in the current directory

Example output:

['.ipynb_checkpoints', 'built-in-functions.ipynb', 'built-in-modules.ipynb']

Important Points:

os.getcwd() → "get current working directory" — shows where your script/notebook is running from.
os.listdir() → lists contents (files + folders) of a directory (defaults to current directory if no path is given).
The os module also has many other functions (seen while autocompleting in the notebook): os.getenv(), os.getlogin(), os.getpid(), os.getppid(), os.get_exec_path(), os.get_terminal_size(), etc. — these deal with environment variables, process IDs, and terminal info.

Commands / Syntax Summary

# Discover all available modules
help('modules')

# Import modules
import math
import random
import os
import time

# math module
math.pi
math.e
math.factorial(5)
math.ceil(6.3)
math.floor(6.9)
math.sqrt(100)

# random module
random.randint(1, 100)
random.shuffle(my_list)

# time module
time.time()
time.ctime()
time.sleep(seconds)

# os module
os.getcwd()
os.listdir()

Things to Remember

Module = code library (a file of pre-written functions/tools).
Always import a module before using its functions — using the exact, correct name.
help('modules') lists every module available in your current environment (built-in + installed packages).
math → mathematical constants & operations (pi, e, factorial, ceil, floor, sqrt).
random → randomness (randint for random integers, shuffle for shuffling a list in place).
time → time-related operations (time() for timestamp, ctime() for readable time, sleep() to pause execution).
os → operating system interaction (getcwd() for current directory, listdir() to list directory contents).
A wrong/misspelled module name → ModuleNotFoundError: No module named '...'.

Quick Revision

Python modules are reusable code libraries. Use help('modules') to see all available ones, and import <module_name> to bring one into your program. Four commonly used built-in modules:

math — constants (pi, e) and operations (factorial, ceil, floor, sqrt).
random — randint(a, b) for random integers, shuffle(list) to randomize a list in place.
time — time() for a raw timestamp, ctime() for a readable date/time, sleep(n) to pause execution for n seconds.
os — getcwd() to get the current directory, listdir() to list files/folders in it.

If you import something that doesn't exist, Python throws ModuleNotFoundError: No module named '<name>' — always double-check spelling.