Have you ever wondered how your computer keeps track of time? Or why the time displayed on your device is always so accurate?
These are just a few questions that the Python time module can answer. Time is a crucial component of any programming language, and the Python time module offers several functions that allow developers to manipulate time in their code.
In this article, we’ll explore the Python time module, starting with an explanation of the epoch and a brief overview of the time module functions. What is the Epoch?
Before we delve into the functions, we need to understand what the epoch is. In simple terms, the epoch refers to a fixed point in time that serves as a reference point for all other times.
In programming, the epoch is commonly used to measure time by counting the number of seconds that have elapsed since the epoch. In Unix-based systems, the epoch is set to January 1, 1970, at 00:00:00 UTC.
This is why you may have noticed that the Unix timestamp for December 31, 1969, is displayed as 0.
Overview of Time Module Functions
The time module in Python provides several functions that allow us to manipulate time in our code. Some of the commonly used functions include time.time()
, time.sleep()
, and time.strftime()
.
1) time.time()
Method
The time.time()
function is used to get the current time as the number of seconds since the epoch.
When called without any arguments, this function returns the current time in seconds since the epoch as a floating-point number. Let’s take a look at an example:
import time
current_time = time.time()
print(current_time)
Output:
1627753804.6740391
In the example above, we first import the time module and then call the time.time()
function to get the current time. The current time is then printed to the console.
As you can see, the current time is returned as a floating-point number, representing the number of seconds since the epoch.
2) time.sleep()
Method
The time.sleep()
function is used to introduce a time-lapse or delay between processes in Python. This is useful when writing programs that require a pause or delay between certain actions.
The syntax for the time.sleep()
function is as follows:
time.sleep(seconds)
Here, ‘seconds’ represents the number of seconds for which the process should be paused. For example, if you want to pause your program for 5 seconds, you would call the time.sleep()
function with an argument of 5:
import time
print("Starting task 1...")
time.sleep(5)
print("Task 1 completed.")
print("Starting task 2...")
time.sleep(3)
print("Task 2 completed.")
Output:
Starting task 1...
Task 1 completed.
Starting task 2...
Task 2 completed.
In the example above, the time.sleep()
function is used to introduce pauses of 5 seconds and 3 seconds between the execution of task 1 and task 2, respectively.
3) time.localtime()
Method
The time.localtime()
function is used to access the local time fields using the struct_time
class in Python.
The struct_time
class provides a way to access various components of the local time, such as the year, month, day, hour, minute, and second. The syntax for the time.localtime()
function is as follows:
time.localtime([seconds])
Here, ‘seconds’ is an optional argument that represents the number of seconds since the epoch.
If no argument is provided, the current local time is used. The time is returned in the form of a struct_time
object, which can be accessed using various attributes such as tm_year
, tm_mon
, tm_mday
, tm_hour
, tm_min
, and tm_sec
.
For example:
import time
local_time = time.localtime()
print("Current Local Time: ", local_time)
print("Year: ", local_time.tm_year)
print("Month: ", local_time.tm_mon)
print("Day: ", local_time.tm_mday)
print("Hour: ", local_time.tm_hour)
print("Minute: ", local_time.tm_min)
print("Second: ", local_time.tm_sec)
Output:
Current Local Time: time.struct_time(tm_year=2021, tm_mon=7, tm_mday=31, tm_hour=11, tm_min=15, tm_sec=59, tm_wday=5, tm_yday=212, tm_isdst=0)
Year: 2021
Month: 7
Day: 31
Hour: 11
Minute: 15
Second: 59
In the example above, we first call the time.localtime()
function to retrieve the current local time and store it in the ‘local_time’ variable. We then access various components of the local time using the struct_time
attributes.
Here, we access the year, month, day, hour, minute, and second components of the local time, respectively.
4) time.ctime()
Method
The time.ctime()
function is used to convert epoch seconds to the current local time string in Python. Epoch seconds refer to the number of seconds since the epoch, which is January 1, 1970, at 00:00:00 UTC.
The syntax for the time.ctime()
function is as follows:
time.ctime([seconds])
Here, the ‘seconds’ argument is the number of seconds since the epoch. If no argument is passed, the current time in seconds since the epoch is used.
The time is returned in the form of a string that represents the current local time. For example:
import time
current_time = time.time()
local_time = time.ctime(current_time)
print("Current Local Time: ", local_time)
Output:
Current Local Time: Sat Jul 31 17:12:21 2021
In the example above, we first retrieve the current time in seconds since the epoch using the time.time()
function and store it in the ‘current_time’ variable. We then call the time.ctime()
function with the ‘current_time’ variable as an argument to convert the epoch seconds to the current local time string.
The resulting time string is stored in the ‘local_time’ variable and printed to the console.
5) time.mktime()
Method
The time.mktime()
function is used to convert a struct_time
object to the number of seconds passed since the epoch.
The struct_time
object is a composite object that represents various components of the local time such as the year, month, day, hour, minute, and second. The syntax for the time.mktime()
function is as follows:
time.mktime(struct_time)
Here, the ‘struct_time’ argument is the struct_time
object that represents the local time.
The time is returned as a floating-point number that represents the number of seconds since the epoch. For example:
import time
current_time = time.localtime()
epoch_time = time.mktime(current_time)
print("Epoch Time: ", epoch_time)
Output:
Epoch Time: 1627755283.0
In the example above, we first call the time.localtime()
function to retrieve the current local time as a struct_time
object. The struct_time
object is stored in the ‘current_time’ variable.
We then call the time.mktime()
function with the ‘current_time’ variable as an argument to convert the struct_time
object to the number of seconds since the epoch. The resulting epoch time is stored in the ‘epoch_time’ variable and printed to the console.
6) time.gmtime()
Method
The time.gmtime()
function is used to access UTC time using the struct_time
class in Python. UTC, or Coordinated Universal Time, is a worldwide time standard that is used to synchronize clocks and timekeeping systems.
The struct_time
class provides a way to access various components of the UTC time, such as the year, month, day, hour, minute, and second. The syntax for the time.gmtime()
function is as follows:
time.gmtime([seconds])
Here, ‘seconds’ is an optional argument that represents the number of seconds since the epoch.
If no argument is provided, the current UTC time is used. The time is returned in the form of a struct_time
object, which can be accessed using various attributes such as tm_year
, tm_mon
, tm_mday
, tm_hour
, tm_min
, and tm_sec
.
For example:
import time
utc_time = time.gmtime()
print("Current UTC Time: ", utc_time)
print("Year: ", utc_time.tm_year)
print("Month: ", utc_time.tm_mon)
print("Day: ", utc_time.tm_mday)
print("Hour: ", utc_time.tm_hour)
print("Minute: ", utc_time.tm_min)
print("Second: ", utc_time.tm_sec)
Output:
Current UTC Time: time.struct_time(tm_year=2021, tm_mon=7, tm_mday=31, tm_hour=13, tm_min=31, tm_sec=17, tm_wday=5, tm_yday=212, tm_isdst=0)
Year: 2021
Month: 7
Day: 31
Hour: 13
Minute: 31
Second: 17
In the example above, we first call the time.gmtime()
function to retrieve the current UTC time and store it in the ‘utc_time’ variable. We then access various components of the UTC time using the struct_time
attributes.
Here, we access the year, month, day, hour, minute, and second components of the UTC time, respectively.
7) time.strptime()
Method
The time.strptime()
function is used to convert a string time to a struct_time
object in Python.
This function is useful when dealing with date and time strings that are in a specific format. The syntax for the time.strptime()
function is as follows:
time.strptime(string, format)
Here, ‘string’ is the time string that needs to be converted, and ‘format’ is a string that contains various format codes that define the format of the input string.
The format codes are used to specify the order and type of the various components of the time string. For example:
import time
date_string = "Sat Jul 31 2021"
date_struct = time.strptime(date_string, "%a %b %d %Y")
print("Date: ", date_struct.tm_mday)
print("Month: ", date_struct.tm_mon)
print("Year: ", date_struct.tm_year)
Output:
Date: 31
Month: 7
Year: 2021
In the example above, we first define a date string that is in the format “Sat Jul 31 2021”. We then call the time.strptime()
function with the date string as the first argument and a format string as the second argument.
The format string “%a %b %d %Y” specifies that the input string includes a weekday abbreviation, a month abbreviation, a day of the month, and a four-digit year. We then access various components of the resulting struct_time
object, such as the day, month, and year.
8) time.strftime()
Method
The time.strftime()
function is used to convert a struct_time
object to a string time using format codes in Python. This function allows for the conversion of time data into a specific format that is more readable and user-friendly.
The syntax for the time.strftime()
function is as follows:
time.strftime(format, struct_time)
Here, ‘format’ is a string that contains various format codes that define the format of the output string, and ‘struct_time’ is the struct_time
object that needs to be converted. The format codes are used to specify the order and type of the various components of the time string.
For example:
import time
current_time = time.localtime()
time_string = time.strftime('%Y-%m-%d %H:%M:%S', current_time)
print("Current Time: ", time_string)
Output:
Current Time: 2021-07-31 15:49:38
In the example above, we first retrieve the current local time as a struct_time
object using the time.localtime()
function. We then call the time.strftime()
function with the struct_time
object and a format string ‘%Y-%m-%d %H:%M:%S’.
This format string specifies the order and type of components for the output string. We then store the resulting time string in the ‘time_string’ variable and print it to the console.
9) time.asctime()
Method
The time.asctime()
function is used to convert a struct_time
object to a string representing the time in Python. This function allows for the conversion of time data into a readable and user-friendly format.
The syntax for the time.asctime()
function is as follows:
time.asctime([struct_time])
Here, ‘struct_time’ is the struct_time
object that needs to be converted. If no argument is passed, the current local time is used.
The returned time is in the form of a string that represents the time. For example:
import time
current_time = time.localtime()
time_string = time.asctime(current_time)
print("Current Time: ", time_string)
Output:
Current Time: Sat Jul 31 14:00:58 2021
In the example above, we first retrieve the current local time as a struct_time
object using the time.localtime()
function. We then call the time.asctime()
function with the struct_time
object to convert it to a string representing the time.
The resulting time string is stored in the ‘time_string’ variable and printed to the console.
Conclusion
In conclusion, the time module in Python provides a range of functions that allow developers to access, convert, and manipulate time and time-related data in their code. By incorporating these functions into your Python programs, you can easily add time conversion and manipulation capabilities to your code.