Python Time Module: A How-To Guide

Navigate to:

This post was written by Keshav Malik. Scroll down for the author’s bio.

The Python time module is a powerful tool for working with times and dates in both simple and complex ways, allowing you to easily manipulate dates, format strings, calculate durations, and more.

You can make your programming tasks much easier if you know how to use the time module effectively. In this guide, we’ll show you how to use it and provide examples of everyday tasks so that you can apply them to your own projects. Let’s get started!


Getting started with the time module

The time module in Python provides various time-related methods that developers can use. You don’t have to install it externally as it’s part of the Python module (similar to other modules, such as os).

The time module provides a range of functions that allow users to perform tasks such as formatting strings, calculating durations, dealing with time zones, and more.

Real-life examples

Time and date are fundamental elements of programming in Python. By leveraging the range of available tools, developers can use time and date manipulation for various applications. Here are a few practical examples:

  1. Scheduling tasks: With the aid of calendar libraries, developers can build applications that schedule tasks based on specific dates and times, such as alerts or event reminders. For instance, an app could remind users to complete certain activities before a particular date or send out emails at predetermined intervals.

  2. Bank transactions: Developers can use Python’s time module to ensure accuracy when dealing with financial transactions, such as tracking payments and deposits. This is obviously important for any applications that deal with banking and finance.

  3. User input validation: When accepting user input in the form of dates and times, developers typically use the POSIX timestamp representation so that it can be validated quickly and easily using functions like ‘strftime()’ in Python to check if a given value is valid or not.

  4. Logging data: Storing timestamps with logging data is also standard practice when developing programs. It helps track activity throughout the system more effectively by providing valuable context as to what happened at particular times. This data can then be used to find patterns in user behavior, identify errors faster, and even implement predictive analytics to forecast outcomes based on past trends.

  5. Game development: Many games require accurate representations of time values for various aspects, such as respawn timers, loading animations, and map rotations. All these elements are usually coded using timestamps for precision to run smoothly in real-time scenarios. Likewise, simple timing mechanisms like countdown clocks are often necessary during gameplay to add tension and create more dynamic gaming experiences without manually resetting timers every time the game restarts due to server issues or other complications.

Time values in Python

Time values in Python are typically represented as the number of seconds that have elapsed since the Unix epoch, which is a date and time reference point that starts on January 1, 1970 (00:00:00 UTC).

These timestamps represent the global standard for tracking time in computer systems. Through this system, any given moment can be represented using a simple integer value, making it easy to compare different points in time.

Getting the current time and date

Using the time() method, developers can fetch the current time in seconds since the epoch.

import time

current_time = time.time()
print(f"Current time (in seconds): {current_time}")

current_utc_time = time.gmtime()
print(f"Current UTC time: {current_utc_time}")

Developers can also create a more user-friendly date and time using the strftime time function. We will discuss this function in a later section.

import time

# Current time in seconds since the epoch
current_time = time.time()

# Convert the current time to a time tuple
current_time_tuple = time.localtime(current_time)

# Get the current date as a string in the format "MM/DD/YYYY"
current_date = time.strftime("%m/%d/%Y", current_time_tuple)
current_time_string = time.strftime("%H:%M:%S", current_time_tuple)

print("The current time is", current_time_string)
print("Today's date is", current_date)

Getting the current day (of the week) using the time module

You can also find out what day of the week it is using the time module, but it’s a little complicated.

import time

# Get the current time in seconds since the epoch
current_time = time.time()

# Convert the current time to a time tuple
current_time_tuple = time.localtime(current_time)

# Get the current day of the week as an integer (Monday is 0 and Sunday is 6)
current_day = current_time_tuple.tm_wday

# Convert the integer to the corresponding weekday name
weekday_names = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
current_weekday_name = weekday_names[current_day]

print("Today is", current_weekday_name)

An optimal way is to use the datetime module.

import datetime

current_date =
current_day = current_date.strftime("%A")
print("Today is", current_day)

Understanding time formatting

The time module in Python provides several functions to format time values into strings. The most commonly used function is strftime(), which stands for “string format time”.

The strftime function allows developers to convert timestamps into different formats for easy storage and display. This function takes two parameters, the format string and the timestamp value (in UTC/GMT time) that you wish to convert.


import time

current_time = time.localtime()
formatted_time = time.strftime("%Y-%m-%d %H:%M:%S", current_time)


Here’s what these symbols (%Y, %m, etc.) mean:

  • %Y: Year with the century as a decimal number (e.g., 2023)

  • %m: Month as a zero-padded decimal number (e.g., 02 for February)

  • %d: Day of the month as a zero-padded decimal number (e.g., 18)

  • %H: Hour (24-hour clock) as a zero-padded decimal number (e.g., 08 for 8:00 a.m.)

  • %M: Minute as a zero-padded decimal number (e.g., 30)

  • %S: Second as a zero-padded decimal number (e.g., 45)

Parsing date/time strings

Until now, we’ve only covered working with, creating, and formatting strings in your own program, but in some cases you’ll get time data from external sources. For example, you might use an integrated API that sends you weather data each minute. The API response might contain timestamps. If so, you have to parse the timestamp before you can use it in your application. The time module provides strptime() function, which can parse date/time strings into a time tuple.

Here’s a code snippet that shows how this function works.

import time

# Dummy weather data as a dictionary with a 'time' key
weather_data = {
    'temperature': 25,
    'humidity': 80,
    'pressure': 1013,
    'time': '2022-05-15 14:30:00'

# Parse the date/time string into a time tuple using strptime
time_tuple = time.strptime(weather_data['time'], "%Y-%m-%d %H:%M:%S")

# Print the parsed time tuple

The code above prints a time tuple that contains the individual components of the date and time, such as the year, month, day, hour, minute, and second. You can use this data to perform various operations, such as date/time arithmetic and comparisons.

Measuring time intervals

Measuring time intervals in Python involves calculating the difference between two given points in time. This is important when you’re creating scheduling apps, tracking user behavior, and analyzing performance data. To measure the time interval between two specific points in time, the time module provides a set of functions and modules that you can use together to achieve this result.

import time

# Record the start time
start_time = time.time()

# Perform some time-consuming operation (Sleep for example)

# Record the end time
end_time = time.time()

# Calculate the elapsed time
elapsed_time = end_time - start_time

print("Elapsed time: {:.2f} seconds".format(elapsed_time)) # Elapsed time: 2.01 seconds

If you need a more accurate result, you can always use the perf_counter() function. This returns a floating-point value representing the time (in seconds) with greater precision than time() on most systems. Here’s an example:

import time

# Record the start time
start_time = time.perf_counter()

# Perform some time-consuming operation

# Record the end time
end_time = time.perf_counter()

# Calculate the elapsed time
elapsed_time = end_time - start_time

print("Elapsed time: {:.6f} seconds".format(elapsed_time)) # Elapsed time: 2.005048 seconds

Comparing time values

Comparing time values in Python can be tricky as there is no universal standard for defining and storing time values. Let’s look at how you can compare time values in Python.


Comparing time values as strings:

import time

# Get current time as a string
current_time_str = time.strftime("%H:%M:%S")

# Check if the current time is after 9:00 AM
if current_time_str > "09:00:00":
    print("It's after 9:00 AM")
    print("It's before 9:00 AM")

Comparing time values as seconds (since the beginning of the epoch):

import time

# Get current time as seconds since the epoch
current_time_sec = time.time()

# Wait for 5 seconds (any random time-consuming task)

# Get current time again
new_time_sec = time.time()

# Calculate the time difference
time_diff = new_time_sec - current_time_sec

# Check if the time difference is at least 5 seconds
if time_diff >= 5:
    print("At least 5 seconds have passed")
    print("Less than 5 seconds have passed")


The Python time module is an invaluable resource for any developer who’s working with date and time data. This tutorial covered the various functions available in the module and showed you how to use it. With this knowledge at your disposal, you’ll have the tools to build powerful applications related to dates and times. Whether you need to measure elapsed time or perform calculations on dates, the Python time module will help make these tasks much more accessible.

About the author:

This post was written by Keshav Malik, a highly skilled and enthusiastic Security Engineer. Keshav has a passion for automation, hacking, and exploring different tools and technologies. With a love for finding innovative solutions to complex problems, Keshav is constantly seeking new opportunities to grow and improve as a professional. He is dedicated to staying ahead of the curve and is always on the lookout for the latest and greatest tools and technologies.