How to get Epoch/UNIX timestamps in python

Epoch time, also known as Unix time or POSIX time, is a way to represent a point in time as a single numeric value. It is the number of seconds that have elapsed since the Unix epoch, which is defined as 00:00:00 Coordinated Universal Time (UTC) on January 1, 1970. Epoch time is widely used in computing, as it provides a common reference point for time-related calculations and comparisons. In Python, getting epoch time is straightforward, and there are several methods to do so.

In this article, we will explore how to get epoch time in Python, different ways to fetch it, and real-world use cases for working with epoch time.

Using the time Module

The time module in Python provides several functions for working with time, including getting the current epoch time. The most common method is to use the time.time() function, which returns the current epoch time in seconds as a floating-point number.

import time



epoch_time = time.time()

print("Current epoch time:", epoch_time)

This code snippet utilizes the time module to fetch the current epoch time. The time.time() function provides a floating-point number representing the number of seconds that have passed since the Unix epoch (January 1, 1970). The retrieved value is printed as the current epoch time.

Use Case 1: Data Logging and timestamps

import time

In this use case, we import the time module to facilitate data logging with timestamps. It's a common practice to record data alongside timestamps to track when specific events or data points occurred. By in time.time() as we did in the previous code snippet, we obtain the current epoch time, which we can then incorporate into log entries or data records.

data = "Sensor data reading..."

epoch_time = int(time.time())

log_entry = f"{data} - timestamp: {epoch_time}"

print(log_entry)

Here, we create a simulated data entry, and in time.time(), we extract the current epoch time. This time value is then included in the log entry, enabling precise time tracking for the recorded data.

Use Case 2: Comparing Time Intervals

import time

When we need to measure the duration between two events or determine the time taken to complete a task, we can utilize the time module. The code snippet begins by recording the start time in time.time() and similarly records the end time. The difference between the two timestamps provides the time taken for the task, which is printed as "Time taken" in seconds.

start_time = time.time()



# Perform some task or operation



end_time = time.time()

time_elapsed = end_time - start_time

print("Time taken:", time_elapsed, "seconds")

Using the datetime Module

You can also obtain epoch time in the datetime module in Python. This method is useful if you need to work with date and time objects.

from datetime import datetime

Here, we import the datetime module to work with date and time objects. The datetime.now() function is used to retrieve the current date and time, which can then be converted to epoch time in the timestamp() method.

current_time = datetime.now()

epoch_time = current_time.timestamp()

print("Current epoch time:", epoch_time)

In this code snippet, we create a datetime object to represent the current date and time. The timestamp() method converts this object to epoch time, allowing for precise time-related calculations and comparisons.

Use Case 3: Caching and Expiry

from datetime from datetime, timedelta

When working with caching mechanisms or managing data that has an expiration time, the datetime module is a valuable tool. In this use case, we set a cache entry with a specified expiry time in the datetime module. The timedelta class allows us to define a time duration. We calculate the epoch time of the expiry point by adding this duration to the current time.

cache = {}

cache_key = "cached_data"

expiry_time = datetime.now() + timedelta(minutes=10)

epoch_expiry_time = int(expiry_time.timestamp())

cache[cache_key] = "Cached data that expires at " + str(epoch_expiry_time)

Additionally, we can check if the cache has expired by comparing the current time to the calculated epoch expiry time. If the current time is greater, the cache is considered expired, and actions such as refreshing the cached data can be triggered.

Use Case 4: Synchronization Across Systems

import time

Epoch time is instrumental when it comes to synchronizing data or events across different systems or devices. In this scenario, we utilize the time module to send a timestamp to another system. The timestamp is essentially an epoch time value, serving as a universal reference for time. On the receiving system, we can compare the received timestamp to the current time for synchronization purposes.

current_time = int(time.time())

send_data_to_other_system(current_time)

On the receiving end, the received timestamp is compared to the current time. If the received timestamp is greater, it indicates that the data has arrived from the future, which can be an important consideration for certain applications.

Using the calendar Module

The calendar module in Python provides another way to access epoch time. This module allows us to convert the current time into epoch time, much like the time module. Here, we demonstrate how to extract the epoch time in the calendar module.

import calendar

epoch_time = calendar.timegm(time.gmtime())

print("Current epoch time:", epoch_time)

This code snippet employs the calendar module to calculate epoch time. The calendar.timegm(time.gmtime()) combination converts the current time to a struct_time object in time.gmtime() and subsequently utilizes calendar.timegm() to yield the epoch time.

Use Case 5: File Modification timestamps

import os

When dealing with files and file systems, it's often necessary to work with file modification timestamps. In this use case, we extract the modification timestamp of a file in the os module and the calendar module. The os.path.getmtime() function retrieves the file's modification time, which is then converted to epoch time in calendar.timegm(time.gmtime(modification_time)). This allows for precise tracking of when the file was last modified.

file_path = "example.txt"

modification_time = os.path.getmtime(file_path)

Convert the modification time to epoch time

epoch_modification_time = calendar.timegm(time.gmtime(modification_time))

print(f"{file_path} was last modified at epoch time: {epoch_modification_time}")

Use Case 6: Event Scheduling

import time

Epoch time is instrumental for event scheduling in event-driven programming. It enables precise timing for critical processes. In this example, we schedule an event to occur in the future by adding a time duration to the current epoch time. A while loop continuously checks the current time and compares it to the scheduled event time. When the event time is reached, the event is triggered.

event_time = int(time.time()) + 3600  # 1 hour from now

While True:

    current_time = int(time.time())

    if current_time >= event_time:

        print("Event occurred!")

        break

    else:

        time.sleep(60)  # Check every minute

These example codes showcase how epoch time can be effectively applied in various real-world scenarios. Whether you are logging data, measuring time intervals, managing cache expiry, synchronizing systems, handling file timestamps, or scheduling events, epoch time serves as a versatile tool in Python, facilitating precise and consistent time-related operations.