How to learn the Python time module

The time module mainly contains various classes and functions that provide date and time functions. This module not only provides the function of formatting date and time into string, but also the function of recovering date and time from string.

Import the time module in the Python interactive interpreter, and then enter the [e for e in dir(time) if not e.startswith('_')] command to see all the attributes and functions contained in the module :

[ e for e indir(time)if not e.startswith('_')]['altzone','asctime','clock','ctime','daylight','get_clock_info','gmtime','localtime','mktime','monotonic','perf_counter','process_time','sleep','strftime','strptime','struct_time','time','timezone','tzname']

A time.struct_time class is provided in the time module. This class represents a time object. It mainly contains 9 attributes. The information of each attribute is shown in the following table:

Table 1 The meaning of each attribute in the time.struct_time class

For example, Python can use time.struct_time(tm_year=2018, tm_mon=5, tm_mday=2, tm_hour=8, tm_min=0, tm_sec=30, tm_wday=3, tm_yday=1, tm_isdst=0) to clearly represent time .

In addition, Python can also use a tuple containing 9 elements to represent time. The 9 elements of this tuple have a one-to-one correspondence with the 9 attributes in the struct_time object. For example, the program can use (2018, 5, 2, 8, 0, 30, 3, 1, 0) to represent time.

The commonly used functions in the date and time module are as follows:

time.asctime([t]): Convert a time tuple or struct_time to a time string. If the parameter t is not specified, the current time will be converted by default.

time.ctime([secs]): Convert the time represented by seconds into a time string.

time.gmtime([secs]): Convert the time represented by seconds into a struct_time object. If no parameters are passed in, the current time is used.

time.localtime([secs]): Convert the time represented by seconds into a struct_time object representing the current time. If no parameters are passed in, the current time is used.

time.mktime(t): It is the inverse function of localtime, used to convert the time represented by the struct_time object or tuple into how many seconds have passed since 0:00 on January 1, 1970.

time.perf_counter(): Returns the value of the performance counter. In seconds.

time.process_time(): Returns the time that the current process uses the CPU. In seconds.

time.sleep(secs): Pause for secs and do nothing.

time.strftime(format[, t]): Format a time tuple or struct_time object into a time string in the specified format. If the parameter t is not specified, the current time will be converted by default.

time.strptime(string[, format]): Parse string format time into struct_time object.

time.time(): Returns how many seconds have passed since 0:00 on January 1, 1970.

time.timezone: Returns the time offset of the local time zone in seconds.

time.tzname: Returns the name of the local time zone.

The following program demonstrates the function of the time block:

import time
# Convert current time to time string
print(time.asctime())
# Convert the specified time into a time string, the last 3 elements of the time tuple are not set
print(time.asctime((2018,2,4,11,8,23,0,0,0))) # Mon Feb 411:08:232018
# Convert the time represented by seconds to a time string
print(time.ctime(30)) # Thu Jan 108:00:301970
# Convert time represented by seconds to struct_time object.
print(time.gmtime(30))
# Convert current time to struct_time object.
print(time.gmtime())
# Convert the time represented by the number of seconds into a struct representing the current time_time object
print(time.localtime(30))
# Convert time in tuple format to time represented by seconds
print(time.mktime((2018,2,4,11,8,23,0,0,0))) # 1517713703.0
# Returns the value of the performance counter
print(time.perf_counter())
# Returns the CPU time used by the current process
print(time.process_time())
# time.sleep(10)
# Convert the current time to a string in the specified format
print(time.strftime('%Y-%m-%d %H:%M:%S'))
st ='March 20, 2018'
# Restore the specified time string to struct_time object.
print(time.strptime(st,'%Y year%m month%d day'))
# Returns how many seconds have passed since 0:00 on January 1, 1970, 1970.
print(time.time())
# Returns the time offset of the local time zone in seconds
print(time.timezone) #Exported in Dongba District in China-28800

Run the above program, you can see the following output:

Fri Feb 2211:28:392019
Mon Feb 411:08:232018
Thu Jan 108:00:301970
time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=30, tm_wday=3, tm_yday=1, 
tm_isdst=0)
time.struct_time(tm_year=2019, tm_mon=2, tm_mday=22, tm_hour=3, tm_min=28, tm_sec=39, tm_wday=4, tm_yday=53, 
tm_isdst=0)
time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=8, tm_min=0, tm_sec=30, tm_wday=3, tm_yday=1, 
tm_isdst=0)1517713703.00.00.1406252019-02-2211:28:39
time.struct_time(tm_year=2018, tm_mon=3, tm_mday=20, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=79, 
tm_isdst=-1)1550806119.4960592-28800

The two functions strftime() and strptime() in the time module are inverse functions of each other, where strftime() is used to convert struct_time objects or time tuples into time strings; and the strptime() function is used to convert time strings It is a struct_time object. Both functions involve writing format templates. For example, in the above program, %Y represents the year, %m represents the month, %d represents the day, %H represents the hour, %M represents the minute, and %S represents the second. The commands supported by the time format string required by these two functions are shown in the following table:

Knowledge point expansion:

time module

This module provides various time-related functions. For related functions, please refer to the datetime and calendarat modules.

This module does not provide all functions on all platforms, and varies by platform

The following is an explanation of some terms and conventions

• The initial time varies by platform. For Unix platforms, the initial time is 1970,01,01,00:00:00 (UTC). To view the initial time of each operating platform, you can use the time.gmtime(0) function.
• On all POSIX platforms, the number of seconds since the initial time does not include leap seconds
• The functions in this module may not handle dates and times before the initial time and in the distant future. The future demarcation point is 2038 for 32-bit operating systems.
• UTC is Coordinated Universal Time (previously known as Greenwich Mean Time, GMT). The abbreviation UTC is not a mistake, but a compromise between English and French.
• DST is Daylight Saving Time, and at certain times of the year, the time zone is usually adjusted by one hour. DST rules are magical (determined by local laws) and change every year.
• The accuracy of various real-time functions may be lower than the accuracy recommended by the unit representing its value or parameter.

The above is how to learn the details of the Python time module. For more detailed information about the Python time module, please follow other related articles on ZaLou.Cn!