In this tutorial, we will learn about Python Timer Functions. Python’s time module simplifies time and date manipulation in various ways. It equips you with versatile tools to handle time-related tasks efficiently, all without needing to fiddle with timestamps or strings. Instead, you work with time and date objects.
Additionally, the time module provides a range of functions that empower programmers to manage time-related tasks seamlessly. You can seamlessly integrate the time module into your existing Python code to measure code performance, enabling you to analyze its efficiency.
RELATED POST: Python Timeit Module
Different ways to use Python Timer functions
- Python time structure
- Python Time epoch
- Python time.time()
- Python time.ctime()
- Python time.sleep()
- Python time.gmtime()
- Python time.clock()
- Python time.Thread_time()
- Python time.Process_time()
- Python time.perf_counter()
- Python time.timezone()
How to use Python time Structure?
In Python, you can work with time and date information using the time module, which provides the struct_time object. The struct_time object in Python represents a point in time as a collection of attributes like year, month, day, hour, minute, second, and more. It’s often used for manipulating and formatting time and date information.
Syntax :
To obtain a struct_time object, you can use functions like time.localtime() or time.gmtime() for the current local time or UTC, respectively.
import time
current_local_time = time.localtime()
current_utc_time = time.gmtime()
Example :
import time
# Get the current local time as a struct_time object
current_local_time = time.localtime()
# Print the components of the struct_time object
print("Year:", current_local_time.tm_year)
print("Month:", current_local_time.tm_mon)
print("Day:", current_local_time.tm_mday)
print("Hour:", current_local_time.tm_hour)
print("Minute:", current_local_time.tm_min)
print("Second:", current_local_time.tm_sec)
Output :
Year: 2023
Month: 9
Day: 4
Hour: 12
Minute: 30
Second: 0
Output may vary depending on the current time.
In this example, we import the time module and use time.localtime() to obtain the current local time as a struct_time object. Then, we access various components of the struct_time object, such as year, month, day, hour, minute, and second, using the appropriate attributes. The output will display the components of the current local time, but the values may vary depending on when you run the code.
How to use Python Time epoch?
In Python, the “epoch” refers to a specific point in time used as a reference for measuring time intervals. The Unix epoch, commonly used in Python, is defined as January 1, 1970, at 00:00:00 UTC (Coordinated Universal Time). It represents the starting point from which time is measured as the number of seconds that have elapsed since that moment.
Syntax :
To get the current epoch time, simply use the time.time() function from the time module.
import time
current_epoch_time = time.time()
Example :
import time
# Get the current epoch time
current_epoch_time = time.time()
print("Current Epoch Time:", current_epoch_time)
Output :
Current Epoch Time: 1667903200.123456
In this example, we start by importing the time module. After that, we use the time.time() function to fetch the current epoch time. What you get as a result is a floating-point number that signifies the seconds passed since the Unix epoch. Keep in mind that the output may change depending on when you run the code, but it’ll generally follow the format demonstrated above.
Python time.time() function
The Python time.time() function is your go-to tool for getting the current time in seconds since the epoch (January 1, 1970). It’s handy for tasks like measuring time intervals, benchmarking code execution, and many other time-related operations. This function gives you the current time in seconds since the Unix epoch (which started on January 1, 1970, at 00:00:00 UTC).
Syntax :
import time
current_time = time.time()
Example :
import time
# Get the current time in seconds since the epoch
current_time = time.time()
print("Current Time (Seconds since Epoch):", current_time)
Output :
Current Time (Seconds since Epoch): 1667903200.123456
In this example, we’ll use the time module. We import it, call time.time(), and then store the result in a variable called current_time. The output will be a floating-point number that shows the number of seconds since the Unix epoch. Keep in mind that this value can vary depending on when you run the code.
How to use Python time.ctime() function?
The time.ctime() function in Python is used to convert a time expressed in seconds since the epoch (returned by time.time()) into a human-readable string in the form of “Day Month Year Hour:Minute:Second Year.” It’s a convenient way to display time information in a more readable format.
Syntax :
import time
formatted_time = time.ctime(timestamp)
Example :
import time
# Get the current timestamp
current_timestamp = time.time()
# Convert the timestamp to a human-readable time string
formatted_time = time.ctime(current_timestamp)
print("Formatted Time:", formatted_time)
Output :
Formatted Time: Thu Sep 1 12:34:56 2023
In this example, we start by grabbing the current timestamp using time.time(). Afterward, we use time.ctime() to transform this timestamp into a user-friendly time string. The result will look like “Day Month DayOfMonth Hour:Minute:Second Year.” Keep in mind that the specific details will change based on when you execute the code.
How to use Python time.sleep() function?
The time.sleep() function in Python is used to introduce delays in your code, pausing the execution for a specified number of seconds. It’s often employed for tasks like creating delays between actions or controlling the timing of certain operations.
Syntax :
import time
time.sleep(seconds)
Example :
import time
print("Starting...")
time.sleep(2) # Pause for 2 seconds
print("...Done!")
Output
Starting...
...Done!
In this example, we initiate the process, and then use time.sleep(2) to pause it for 2 seconds. After the pause, the program continues with the execution, printing “…Done!” to the console. The specific duration can be adjusted based on your needs.
Python time.gmtime() function
The time.gmtime() function in Python to convert a timestamp in seconds into a time tuple representing the Coordinated Universal Time (UTC).
Syntax :
import time
utc_time_tuple = time.gmtime(timestamp)
Example :
import time
# Get a timestamp for a specific time (e.g., September 4, 2023, 12:30:00 UTC)
timestamp = time.mktime((2023, 9, 4, 12, 30, 0, 0, 0, 0))
# Convert the timestamp to a UTC time tuple
utc_time_tuple = time.gmtime(timestamp)
print("UTC Time Tuple:", utc_time_tuple)
Output :
UTC Time Tuple: time.struct_time(tm_year=2023, tm_mon=9, tm_mday=4, tm_hour=12, tm_min=30, tm_sec=0, tm_wday=0, tm_yday=247, tm_isdst=0)
In this example, we begin by setting a timestamp for a particular time (September 4, 2023, 12:30:00 UTC) using time.mktime(). After that, we employ time.gmtime() to transform this timestamp into a UTC time tuple. The outcome is a time.struct_time object that accurately represents the specified UTC time.
How to use Python time.clock() function?
The time.clock() measures the CPU time consumed by your program and returns the value in seconds. It is often used for profiling and performance measurement.
Syntax :
import time
cpu_time = time.clock()
Example :
import time
# Start the timer
start_time = time.clock()
# Simulate a time-consuming task
for _ in range(1000000):
pass
# Stop the timer
end_time = time.clock()
# Calculate the elapsed CPU time
elapsed_time = end_time - start_time
print("Elapsed CPU Time:", elapsed_time, "seconds")
Output :
Elapsed CPU Time: 0.012345 seconds
In this example, we start by initializing a timer using time.clock() as a Python Timer Function to measure CPU time. Next, we simulate a time-consuming task, and upon completion, we halt the timer to compute the elapsed CPU time. The resulting value will be in seconds, providing insight into the CPU time consumed by the task.
How to use Python time.Thread_time() function?
Python’s time.thread_time() function is used to measure the CPU time consumed by the current thread. It’s often used for profiling and performance measurement in multi-threaded programs.
Syntax :
import time
cpu_time = time.thread_time()
Example :
import time
# Start the timer
start_time = time.thread_time()
# Simulate a time-consuming task
for _ in range(1000000):
pass
# Stop the timer
end_time = time.thread_time()
# Calculate the elapsed CPU time
elapsed_time = end_time - start_time
print("Elapsed CPU Time:", elapsed_time, "seconds")
Output:
Elapsed CPU Time: 0.012345 seconds
In this example, we start by initializing a timer using time.thread_time() as a Python Timer Function to measure CPU time for the current thread. After, we simulate a time-consuming task and then stop the timer to calculate the elapsed CPU time. The resulting value, given in seconds, signifies the CPU time consumed by the task.
Python time.process_time() function
time.process_time() returns the CPU time in seconds used by your Python program since it started running.
Syntax :
import time
cpu_time = time.process_time()
Example :
import time
# Record the starting CPU time
start_time = time.process_time()
# Simulate a time-consuming computation
for _ in range(1000000):
pass
# Record the ending CPU time
end_time = time.process_time()
# Calculate the CPU time elapsed during the computation
elapsed_time = end_time - start_time
print("CPU Time Elapsed:", elapsed_time, "seconds")
Output :
CPU Time Elapsed: 0.015625 seconds
In this example, we kick things off by recording the initial CPU time using time.process_time() as a Python Timer Function. Subsequently, we proceed to simulate a computationally intensive task using a loop. Once the computation wraps up, we capture the concluding CPU time. Lastly, we compute and display the CPU time that transpired during the computation. It’s worth noting that the resulting output may fluctuate based on your system’s performance, but it will generally follow a format akin to the one displayed above.
How to use Python time.Perf_counter() function?
time.perf_counter() in Python to measure the execution time of code with high precision. It returns a floating-point number representing the time in seconds since an unspecified point in the past.
Syntax :
import time
start_time = time.perf_counter()
# Your code here
end_time = time.perf_counter()
elapsed_time = end_time - start_time
Example :
import time
# Record the starting time
start_time = time.perf_counter()
# Simulate some time-consuming task
for _ in range(1000000):
_ = 2 * 2
# Record the ending time
end_time = time.perf_counter()
# Calculate the elapsed time
elapsed_time = end_time - start_time
print(f"Elapsed Time: {elapsed_time:.6f} seconds")
Output :
Elapsed Time: 0.000125 seconds
In this example, we use time.perf_counter() to measure the execution time of a simple loop. We record the starting and ending times, calculate the elapsed time, and then print the result. The output will vary depending on your system’s performance but will be in a similar format as shown above.
How to use Python time.timezone() function?
In Python, you can access the time.timezone attribute to obtain the time zone offset in seconds that separates local time from Coordinated Universal Time (UTC).
Syntax :
import time
timezone_offset_seconds = time.timezone
Example :
import time
# Get the time zone offset in seconds
timezone_offset_seconds = time.timezone
# Calculate the offset in hours and minutes
offset_hours = abs(timezone_offset_seconds) // 3600
offset_minutes = (abs(timezone_offset_seconds) % 3600) // 60
# Determine if the time zone is ahead or behind UTC
if timezone_offset_seconds >= 0:
offset_direction = "ahead of"
else:
offset_direction = "behind"
print(f"The local time zone is {offset_direction} UTC by {offset_hours} hours and {offset_minutes} minutes.")
Output :
The local time zone is behind UTC by 7 hours and 0 minutes.
In this example, we start by utilizing time.timezone to fetch the time zone offset in seconds. Next, we calculate the offset in hours and minutes, and from there, we establish whether the local time zone is ahead of or behind UTC. The resulting output will indicate both the direction and the magnitude of the time zone offset.
