Skip to content

A Practical Guide to Using Python Modules for Math, Dates, and File I/O

Updated: at 02:12 AM

Python is a powerful, general-purpose programming language used for a wide range of applications from web development to data science. One of the key strengths of Python is its extensive standard library and ecosystem of third-party modules. These modules provide reusable, well-tested functionality that can help developers quickly implement common tasks without having to write all the code from scratch. This practical guide will provide an overview of using Python modules for math, date and time manipulation, and file input/output (I/O) operations with relevant code examples.


Python modules are simply Python code files containing definitions and statements designed to provide useful functions and classes. They help organize code into reusable pieces that can be easily imported and utilized in other programs. The Python standard library contains many built-in modules for common programming tasks while third-party modules like NumPy, Pandas, requests etc. can be installed to supplement the standard library.

Key benefits of using modules in Python include:

This guide will demonstrate the import statement for accessing module contents, discuss some commonly used built-in modules, and present example programs for math calculations, date-time manipulations, and file I/O operations using relevant modules.

The Import Statement

The import statement is used to give access to a module’s contents in another Python code file. The basic syntax is:

import module_name

This imports the entire module_name module and makes its functions, classes, variables etc. available in the current namespace. Elements from the module can then be accessed using module_name.element_name syntax.

For example:

import math


Imports math module and prints the value of pi (3.1415…) from it.

Specific elements can also be selectively imported from a module as:

from module_name import element1, element2

This imports only element1 and element2 from module_name into the current namespace. The module name prefix is no longer needed to access these elements.

For example:

from math import pi, sqrt


Imports just pi and sqrt from the math module.

Now let’s look at some practical examples of modules usage for math, dates and file I/O.

Math Modules

Python comes equipped with the math module in its standard library to carry out mathematical tasks. It contains mathematical constants like pi, math functions for calculations on real numbers, such as sqrt, sin, cos etc., and functions that operate on integers, like gcd for greatest common divisor.

Let’s implement some common math operations using the math module:

Calculating the Hypotenuse of a Right Triangle

The Pythagorean theorem gives the relationship between sides of a right triangle as:

hypotenuse**2 = base**2 + height**2

Here is how to calculate the hypotenuse using the math.sqrt() function:

import math

base = 3
height = 4

# Calculate hypotenuse
hypotenuse = math.sqrt(base**2 + height**2)

# 5.0

Calculating Factorial of a Number

The factorial of a number n is given by:

n! = 1 x 2 x 3 x ... x n

Here is a function to calculate factorial using a for loop and the method which multiplies a sequence of numbers:

import math

def factorial(n):
  result = 1
  for i in range(2, n+1):
    result =[result, i])

  return result

# 120

Finding GCD of Two Numbers

The greatest common divisor (GCD) of two numbers is the largest number that divides both integers.

We can use math.gcd() to find it easily:

import math

a = 48
b = 18

gcd = math.gcd(a, b)

# 6

These examples demonstrate how the math module can be used to simplify math heavy tasks in Python. Many more mathematical functions are available in this module like math.ceil(), math. floor(), math.log() etc.

The datetime Module

The datetime module in Python provides classes for manipulating dates and times easily. Let’s go through some examples:

Getting Current Date and Time

We can get the current date and time as a datetime object using and extract just the date or time components from it:

from datetime import datetime

today =

# Date: 2023-03-07

print('Time:', today.time())
# Time: 11:20:05.000021

The .date() method returns just the date portion while .time() gives just the time.

Formatting Date and Time

The date and time can be formatted to custom string outputs:

from datetime import datetime

now =

print(now.strftime('%A %d %B, %Y'))
# Tuesday 07 February, 2023

print(now.strftime('%I:%M %p'))
# 10:24 AM

Various directives like %d, %B, %I etc. can be used in the format string to get different outputs.

Performing Date Arithmetic

We can perform arithmetic on datetime objects to add or subtract time intervals.

For example, to get the date for the next day:

from datetime import datetime, timedelta

today =
next_day = today + timedelta(days = 1)

print('Today:', today)
# Today: 2023-02-08 10:30:00.000058

print('Next Day:', next_day)
# Next Day: 2023-02-09 10:30:00.000058

The timedelta passed to .now() shifts it by 1 day to return tomorrow’s date.

Various time intervals like hours, minutes, weeks etc. can be added or subtracted using timedelta.

These are just some basic examples of how the datetime module can be used for date and time manipulations in Python.

File Input/Output Using the io and os Modules

Python provides the io and os modules in its standard library to handle input/output operations on files.

Opening and Closing Files

A file has to be opened before reading or writing using the built-in open() function. We also need to close the file when operations are finished using the .close() method.

file = open('data.txt', 'r')
# Perform file operations

The first argument is the file name and second parameter is the mode - 'r' for read, 'w' for write etc.

We can use a context manager to automatically close the file:

with open('data.txt', 'r') as file:
  # File operations here

# File is closed automatically at end

Reading and Writing Files

For text files, we can use the .read() method to read the entire contents to a string:

with open('data.txt', 'r') as file:
  data =


To read line by line, we can use a for loop:

with open('data.txt', 'r') as file:
  for line in file:

For writing, we use the 'w' mode. The .write() method puts data into the file:

with open('new_file.txt', 'w') as file:
  file.write('This is some sample text')

File Management Using os Module

The os module contains many useful methods for file management like renaming/deleting files, making directories etc:

import os

# Rename file
os.rename('old-name.txt', 'new-name.txt')

# Delete file

# Make new folder

It can also be used to get file info:

import os

print('File size:', os.path.getsize('data.txt'))
print('Modification time:', os.path.getmtime('data.txt'))

These are some examples of handling files and directories with Python. The io and os modules provide many additional functions like walking directories, reading CSVs etc.


Python modules are an essential part of the language used to extend its base capabilities for specialized domains like math, science, web programming, data analysis and more. The standard library contains many built-in modules with reusable functions and classes while third-party modules provide even more functionality.

This guide provided an overview of modules and import statements and demonstrated sample code for mathematical calculations, date-time manipulations and file I/O operations using relevant built-in modules like math, datetime, io and os. Modules form the basic building blocks that make Python a versatile, full-fledged programming language suitable for a wide range of tasks. Learning to effectively utilize the standard and external modules is key to unlocking Python’s capabilities for software development.