Python Time Module

In this article, we will discuss the time module and various functions provided by this module with the help of good examples. 

As the name suggests Python time module allows to work with time in Python. It allows functionality like getting the current time, pausing the Program from executing, etc. So before starting with this module, we need to import it. 

Importing time module

The time module comes with Python’s standard utility module, so there is no need to install it externally. We can simply import it using the import statement.

import time

What is epoch?

The epoch is the point where the time starts and is platform-dependent. On Windows and most Unix systems, the epoch is January 1, 1970, 00:00:00 (UTC), and leap seconds are not counted towards the time in seconds since the epoch. To check what the epoch is on a given platform we can use time.gmtime(0).

Example: Getting epoch

The code uses the time module to print the result of time.gmtime(0), which represents the time in the GMT (Greenwich Mean Time) timezone at the Unix epoch (January 1, 1970, 00:00:00 UTC).

import time
print(time.gmtime(0))

Output:

time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)

Note: The time before the epoch can still be represented in seconds but it will be negative. For example, 31 December 1969 will be represented as -86400 seconds.

Getting current time in seconds since epoch

time.time() methods return the current time in seconds since epoch. It returns a floating-point number.

Example: Current time in seconds since epoch

The code uses the time module to retrieve the current time in seconds since the Unix epoch (January 1, 1970).

import time
curr = time.time()
print("Current time in seconds since epoch =", curr)

Current time in seconds since epoch = 1627908387.764925

Getting time string from seconds

time.ctime() function returns a 24 character time string but takes seconds as argument and computes time till mentioned seconds. If no argument is passed, time is calculated till the present.

Example: Getting time string from seconds

The code uses the time module to convert a specified timestamp (1627908313.717886) into a human-readable date and time format.

import time
curr = time.ctime(1627908313.717886)
print("Current time:", curr) 

Current time: Mon Aug  2 12:45:13 2021

Delaying Execution of Programs

Execution can be delayed using time.sleep() method. This method is used to halt the program execution for the time specified in the arguments.

Example: Delaying execution time of programs in Python.

This code uses the time module to introduce a one-second delay using time.sleep(1) inside a loop that iterates four times.

import time
for i in range(4):
    time.sleep(1)
    print(i)

0
1
2
3

time.struct_time Class

Struct_time class helps to access local time i.e. non-epochal timestamps. It returns a named tuple whose value can be accessed by both index and attribute name. Its object contains the following attributes – 

This class contains various functions. Let’s discuss each function in detail.

time.localtime() method

localtime() method returns the struct_time object in local time. It takes the number of seconds passed since epoch as an argument. If the seconds parameter is not given then the current time returned by time.time() method is used.

Example: Getting local time from epoch

The code uses the time module to convert a specified timestamp (1627987508.6496193) into a time.struct_time object representing the corresponding date and time.

import time
obj = time.localtime(1627987508.6496193)
print(obj)

Output

time.struct_time(tm_year=2021, tm_mon=8, tm_mday=3, tm_hour=16, tm_min=15, tm_sec=8, tm_wday=1, tm_yday=215, tm_isdst=0)

time.mktime() method

time.mktime() is the inverse function of time.localtime() which converts the time expressed in seconds since the epoch to a time.struct_time object in local time.

Example: Converting the struct_time object to seconds since epoch

This code first uses the time module to convert a specified timestamp (1627987508.6496193) into a time.struct_time object in the GMT (Greenwich Mean Time) timezone using time.gmtime(). Then, it uses time.mktime() to convert this time.struct_time object back into a timestamp.

import time
obj1 = time.gmtime(1627987508.6496193)
time_sec = time.mktime(obj1)
print("Local time (in seconds):", time_sec)

Local time (in seconds): 1627987508.0

time.gmtime() method

time.gmtime() is used to convert a time expressed in seconds since the epoch to a time.struct_time object in UTC in which tm_isdst attribute is always 0. If the seconds parameter is not given then the current time returned by time.time() method is used.

Example: Use of time.gmtime() method

The code uses the time module to convert a specified timestamp (1627987508.6496193) into a time.struct_time object representing the corresponding date and time in the GMT (Greenwich Mean Time) timezone.

import time
obj = time.gmtime(1627987508.6496193)
print(obj)

Output

time.struct_time(tm_year=2021, tm_mon=8, tm_mday=3, tm_hour=10, tm_min=45, tm_sec=8, tm_wday=1, tm_yday=215, tm_isdst=0)

time.strftime() method

time.strftime() function converts a tuple or struct_time representing a time as returned by gmtime() or localtime() to a string as specified by the format argument. If t is not provided, the current time as returned by localtime() is used. The format must be a string. ValueError is raised if any field in t is outside of the allowed range.

Example: Converting struct_time object to a string using strftime() method

The code uses the gmtime function from the time module to convert a specified timestamp (1627987508.6496193) into a formatted string using strftime. The output represents the date and time in the GMT (Greenwich Mean Time) timezone in the format specified by the format string.

from time import gmtime, strftime
s = strftime("%a, %d %b %Y %H:%M:%S", 
             gmtime(1627987508.6496193))
print(s)

Tue, 03 Aug 2021 10:45:08

time.asctime() method

time.asctime() method is used to convert a tuple or a time.struct_time object representing a time as returned by time.gmtime() or time.localtime() method to a string of the following form:

Day Mon Date Hour:Min:Sec Year

Example: Converting tuple to time.struct_time object to string

This code uses the time module to convert a specified timestamp (1627987508.6496193) into a human-readable date and time format using time.asctime(). It does so both for the GMT (Greenwich Mean Time) timezone and the local timezone.

import time
obj = time.gmtime(1627987508.6496193)
time_str = time.asctime(obj)
print(time_str)
obj = time.localtime(1627987508.6496193)
time_str = time.asctime(obj)
print(time_str)

Tue Aug  3 10:45:08 2021
Tue Aug  3 10:45:08 2021

time.strptime() method

time.strptime() method converts the string representing time to the struct_time object.

Example: Converting string to struct_time object.

This code uses the time module to parse a formatted string representing a date and time and convert it into a time.struct_time object. The time.strptime() function is used for this purpose.

import time
string = "Tue, 03 Aug 2021 10:45:08"
obj = time.strptime(string, "%a, %d %b %Y %H:%M:%S")
print(obj)

Output

time.struct_time(tm_year=2021, tm_mon=8, tm_mday=3, tm_hour=10, tm_min=45, tm_sec=8, tm_wday=1, tm_yday=215, tm_isdst=-1)

Python Time Module – FAQs

What is Module Time in Python?

The time module in Python provides various functions for working with time, including pausing program execution and retrieving the current time. The functions in this module handle time-related tasks, such as converting between different time representations (e.g., seconds since the epoch to a structured time.struct_time object), measuring time intervals, and implementing delays.

What is time() in Python?

time() is a function in the Python time module that returns the current time in seconds since the epoch as a floating point number. The epoch is defined as the point where the time starts, and it is platform-dependent. For Unix systems, the epoch is January 1, 1970, 00:00:00 (UTC). You can use this function to timestamp events or measure durations.

import time

current_time = time.time()
print("Current time in seconds since the epoch:", current_time)

How to Install Time Module in Python?

The time module is part of the Python Standard Library, which means it comes pre-installed with Python and does not require any additional installation. You can directly import and use it in your Python scripts without any setup.

What is %%time?

%%time is not a Python command but a magic command for Jupyter Notebooks and IPython environments. It is used to measure the execution time of a single cell in a Jupyter Notebook. When you place %%time at the top of a cell, it reports the time taken to execute the cell.

%%time
# Example of using %%time in a Jupyter Notebook cell
import time
time.sleep(2)  # Sleep for 2 seconds

What is time.sleep() in Python?

time.sleep() is a function in the time module that pauses the execution of the program for the specified number of seconds. The argument can be a floating point number to indicate more precise sleep times (like fractions of a second). This function is useful for delaying actions, throttling CPU usage, or simulating delays in your programs.

import time

print("Start")
time.sleep(5)  # Sleep for 5 seconds
print("End after 5 seconds")

Using these time-related functionalities allows you to manage time and delays in your Python applications effectively, whether for handling real-time data, creating pauses in games and simulations, or synchronizing events

N

nikhilaggarwal3

Follow

Improve