10 Shocking Issues You Can Do with Python’s time module

Picture by Editor | ChatGPT

# Introduction

 
Most Python builders are acquainted with the time module, for its useful capabilities similar to time.sleep(). This makes the modiule the go-to for pausing execution, a easy however important device. Nevertheless, the time module is much extra versatile, providing a set of capabilities for exact measurement, time conversion, and formatting that usually go unnoticed. Exploring these capabilities can unlock extra environment friendly methods to deal with time-related duties in your information science and different coding tasks.

I’ve gotten some flack for the naming of earlier “10 Shocking Issues” articles, and I get it. “Sure, it’s so very stunning that I can carry out date and time duties with the datetime module, thanks.” Legitimate criticism. Nevertheless, the identify is sticking as a result of it is catchy, so take care of it 🙂

In any case, listed below are 10 stunning and helpful issues you are able to do with Python’s time module.

# 1. Precisely Measure Elapsed Wall-Clock Time with time.monotonic()

 
Whilst you would possibly routinely go for time.time() to measure how lengthy a operate takes, it has a crucial flaw: it’s primarily based on the system clock, which could be modified manually or by community time protocols. This may result in inaccurate and even detrimental time variations. A extra strong answer is time.monotonic(). This operate returns the worth of a monotonic clock, which can not go backward and is unaffected by system time updates. This actually does make it the perfect alternative for measuring durations reliably.

import time

start_time = time.monotonic()

# Simulate a activity
time.sleep(2)

end_time = time.monotonic()
length = end_time - start_time

print(f"The duty took {length:.2f} seconds.")

Output:

The duty took 2.01 seconds.

# 2. Measure CPU Processing Time with time.process_time()

 
Generally, you do not care in regards to the complete time handed (wall-clock time). As a substitute, you would possibly need to know the way a lot time the CPU truly spent executing your code. That is essential for benchmarking algorithm effectivity, because it ignores time spent sleeping or ready for I/O operations. The time.process_time() operate returns the sum of the system and consumer CPU time of the present course of, offering a pure measure of computational effort.

import time

start_cpu = time.process_time()

# A CPU-intensive activity
complete = 0
for i in vary(10_000_000):
    complete += i

end_cpu = time.process_time()
cpu_duration = end_cpu - start_cpu

print(f"The CPU-intensive activity took {cpu_duration:.2f} CPU seconds.")

Output:

The CPU-intensive activity took 0.44 CPU seconds.

# 3. Get Excessive-Precision Timestamps with time.perf_counter()

 
For extremely exact timing, particularly for very quick durations, time.perf_counter() is a vital device. It returns the worth of a high-resolution efficiency counter, which is essentially the most correct clock accessible in your system. This can be a system-wide depend, together with time elapsed throughout sleep, which makes it good for benchmark situations the place each nanosecond counts.

import time

start_perf = time.perf_counter()

# A really quick operation
_ = [x*x for x in range(1000)]

end_perf = time.perf_counter()
perf_duration = end_perf - start_perf

print(f"The quick operation took {perf_duration:.6f} seconds.")

Output:

The quick operation took 0.000028 seconds.

# 4. Convert Timestamps to Readable Strings with time.ctime()

 
The output of time.time() is a float representing seconds because the “epoch” (January 1, 1970, for Unix methods). Whereas helpful for calculations, it’s not human-readable. The time.ctime() operate takes this timestamp and converts it into a normal, easy-to-read string format, like ‘Thu Jul 31 16:32:30 2025’.

import time

current_timestamp = time.time()
readable_time = time.ctime(current_timestamp)

print(f"Timestamp: {current_timestamp}")
print(f"Readable Time: {readable_time}")

Output:

Timestamp: 1754044568.821037
Readable Time: Fri Aug  1 06:36:08 2025

# 5. Parse Time from a String with time.strptime()

 
For instance you have got time info saved as a string and must convert it right into a structured time object for additional processing. time.strptime() (string parse time) is your operate. You present the string and a format code that specifies how the date and time parts are organized. It returns a struct_time object, which is a tuple containing parts — like 12 months, month, day, and so forth — which may then be extracted.

import time

date_string = "31 July, 2025"
format_code = "%d %B, %Y"

time_struct = time.strptime(date_string, format_code)

print(f"Parsed time construction: {time_struct}")
print(f"12 months: {time_struct.tm_year}, Month: {time_struct.tm_mon}")

Output:

Parsed time construction: time.struct_time(tm_year=2025, tm_mon=7, tm_mday=31, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=212, tm_isdst=-1)
12 months: 2025, Month: 7

# 6. Format Time into Customized Strings with time.strftime()

 
The other of parsing is formatting. time.strftime() (string format time) takes a struct_time object (just like the one returned by strptime or localtime) and codecs it right into a string in accordance with your specified format codes. This provides you full management over the output, whether or not you like “2025-07-31” or “Thursday, July 31”.

import time

# Get present time as a struct_time object
current_time_struct = time.localtime()

# Format it in a customized manner
formatted_string = time.strftime("%Y-%m-%d %H:%M:%S", current_time_struct)
print(f"Customized formatted time: {formatted_string}")

day_of_week = time.strftime("%A", current_time_struct)
print(f"At present is {day_of_week}.")

Output:

Customized formatted time: 2025-08-01 06:41:33
At present is Friday

# 7. Get Primary Timezone Info with time.timezone and time.tzname

 
Whereas the datetime module (and libraries like pytz) are higher for advanced timezone dealing with, the time module affords some fundamental info. time.timezone supplies the offset of the native non-DST (Daylight Financial savings Time) timezone in offset seconds west of UTC, whereas time.tzname is a tuple containing the names of the native non-DST and DST timezones.

import time

# Offset in seconds west of UTC
offset_seconds = time.timezone

# Timezone names (customary, daylight saving)
tz_names = time.tzname

print(f"Timezone offset: {offset_seconds / 3600} hours west of UTC")
print(f"Timezone names: {tz_names}")

Output:

Timezone offset: 5.0 hours west of UTC
Timezone names: ('EST', 'EDT')

# 8. Convert Between UTC and Native Time with time.gmtime() and time.localtime()

 
Working with completely different timezones could be difficult. A standard follow is to retailer all time information in Coordinated Common Time (UTC) and convert it to native time just for show. The time module facilitates this with time.gmtime() and time.localtime(). These capabilities take a timestamp in seconds and return a struct_time object — gmtime() returns it in UTC, whereas localtime() returns it in your system’s configured timezone.

import time

timestamp = time.time()

# Convert timestamp to struct_time in UTC
utc_time = time.gmtime(timestamp)

# Convert timestamp to struct_time in native time
local_time = time.localtime(timestamp)

print(f"UTC Time: {time.strftime('%Y-%m-%d %H:%M:%S', utc_time)}")
print(f"Native Time: {time.strftime('%Y-%m-%d %H:%M:%S', local_time)}")

Output:

UTC Time: 2025-08-01 10:47:58
Native Time: 2025-08-01 06:47:58

# 9. Carry out the Inverse of time.time() with time.mktime()

 
time.localtime() converts a timestamp right into a struct_time object, which is beneficial… however how do you go within the reverse course? The time.mktime() operate does precisely this. It takes a struct_time object (representing native time) and converts it again right into a floating-point quantity representing seconds because the epoch. That is then helpful for calculating future or previous timestamps or performing date arithmetic.

import time

# Get present native time construction
now_struct = time.localtime()

# Create a modified time construction for one hour from now
future_struct_list = checklist(now_struct)
future_struct_list[3] += 1 # Add 1 to the hour (tm_hour)
future_struct = time.struct_time(future_struct_list)

# Convert again to a timestamp
future_timestamp = time.mktime(future_struct)

print(f"Present timestamp: {time.time():.0f}")
print(f"Timestamp in a single hour: {future_timestamp:.0f}")

Output:

Present timestamp: 1754045415
Timestamp in a single hour: 1754049015

# 10. Get Thread-Particular CPU Time with time.thread_time()

 
In multi-threaded functions, time.process_time() provides you the overall CPU time for all the course of. However what if you wish to profile the CPU utilization of a selected thread? On this case, time.thread_time() is the operate you might be searching for. This operate returns the sum of system and consumer CPU time for the present thread, permitting you to determine which threads are essentially the most computationally costly.

import time
import threading

def worker_task():
    start_thread_time = time.thread_time()

    # Simulate work
    _ = [i * i for i in range(10_000_000)]

    end_thread_time = time.thread_time()

    print(f"Employee thread CPU time: {end_thread_time - start_thread_time:.2f}s")

# Run the duty in a separate thread
thread = threading.Thread(goal=worker_task)
thread.begin()
thread.be part of()

print(f"Complete course of CPU time: {time.process_time():.2f}s")

Output:

Employee thread CPU time: 0.23s
Complete course of CPU time: 0.32s

# Wrapping Up

 
The time module is an integral and highly effective section of Python’s customary library. Whereas time.sleep() is undoubtedly its most well-known operate, its capabilities for timing, length measurement, and time formatting make it a useful device for all kinds of practically-useful duties.

By shifting past the fundamentals, you may be taught new methods for writing extra correct and environment friendly code. For extra superior, object-oriented date and time manipulation, make sure you take a look at stunning issues you are able to do with the datetime module subsequent.
 
 

Matthew Mayo (@mattmayo13) holds a grasp’s diploma in laptop science and a graduate diploma in information mining. As managing editor of KDnuggets & Statology, and contributing editor at Machine Studying Mastery, Matthew goals to make advanced information science ideas accessible. His skilled pursuits embrace pure language processing, language fashions, machine studying algorithms, and exploring rising AI. He’s pushed by a mission to democratize information within the information science neighborhood. Matthew has been coding since he was 6 years outdated.