Getting Current Time in Milliseconds in Python

Introduction

In many applications, measuring time with precision is crucial. Whether it’s for performance benchmarking or logging events with timestamps, obtaining the current time in milliseconds can be vital. In this tutorial, we’ll explore how to achieve this using Python, which offers several ways to get high-resolution time measurements.

Understanding Time Functions in Python

Python provides various functions and modules for working with dates and times:

• time module: Offers functions to work with system time.
• datetime module: Provides classes for manipulating dates and times more flexibly.

We’ll focus on using these tools to obtain the current time in milliseconds since the epoch (January 1, 1970).

Method 1: Using time.time()

The time.time() function from Python’s time module returns the current time in seconds since the epoch as a floating-point number. To convert this into milliseconds:

import time

def current_milli_time():
    return round(time.time() * 1000)

# Example usage:
print(current_milli_time())

This function multiplies the seconds by 1,000 to convert them to milliseconds and rounds the result to get an integer value.

Method 2: Using time.time_ns() (Python 3.7+)

For higher precision, Python 3.7 introduced time.time_ns(), which returns time in nanoseconds since the epoch:

import time

ms = time.time_ns() // 1_000_000

# Example usage:
print(ms)

By using integer division (//), we convert nanoseconds to milliseconds, ensuring an accurate integer result.

Method 3: Using datetime.datetime.now()

The datetime module provides another way to achieve the same goal by capturing microseconds and calculating the millisecond value:

from datetime import datetime

def current_milli_time_with_datetime():
    dt = datetime.now()
    return int(dt.timestamp() * 1000)

# Example usage:
print(current_milli_time_with_datetime())

This method uses datetime.now() to get the current date and time, then converts it to a timestamp (in seconds) using .timestamp(), finally multiplying by 1,000 to convert to milliseconds.

Method 4: Calculating Unix Timestamp in Milliseconds

For UTC-based timestamps, you can manually calculate the difference from the epoch:

import datetime

def timestamp_millisec_64():
    return int((datetime.datetime.utcnow() - datetime.datetime(1970, 1, 1)).total_seconds() * 1000)

# Example usage:
print(timestamp_millisec_64())

This function computes the time difference from the epoch to the current UTC time and converts it into milliseconds.

Conclusion

Different methods in Python provide flexibility depending on your requirements for precision and whether you need local or UTC time. For most applications needing millisecond precision, using time.time_ns() is recommended for its simplicity and high resolution. However, if you’re working with legacy code or require timezone awareness, the datetime module might be more appropriate.

Remember to choose the method that best fits your specific use case while considering factors like performance overhead and accuracy needs.