Learn more about the time module in python

The content of this article is to share with you an in-depth understanding of the time module in python. It has a certain reference value. Friends in need can refer to it

In Python In , modules related to time processing include: time, datetime and calendar. This article mainly explains the time module.

Before we begin, we must first explain these points:

1. In Python, there are usually several ways to express time: 1 ) timestamp 2) formatted time string 3) tuple (struct_time) with nine elements in total. Since Python's time module implementation mainly calls the C library, each platform may be different.

2. UTC (Coordinated Universal Time) is Greenwich Astronomical Time, world standard time. In China it is UTC 8. DST (Daylight Saving Time) is daylight saving time.

3. Time stamp (timestamp) method: Generally speaking, the timestamp represents the seconds starting from January 1, 1970 00:00:00 The calculated offset. We run "type(time.time())" and the return type is float. Functions that return timestamps mainly include time(), clock(), etc.

4. Tuple (struct_time) method: The struct_time tuple has a total of 9 elements. The functions that return struct_time mainly include gmtime(), localtime(), and strptime(). Several elements in this tuple are listed below:

##5 tm_sec (seconds) 0 - 616 tm_wday（weekday） 0 - 6（0 means Sunday）7 tm_yday (day of the year) 1 - 3668 tm_isdst (whether it is daylight saving time) The default is -1

Then we introduce several commonly used functions in the time module:

1) time.localtime([secs]): Convert a timestamp to the current struct_time for time zone. If the secs parameter is not provided, the current time shall prevail.

>>> time.localtime()
time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=14, tm_min=14, tm_sec=50, tm_wday= 3, tm_yday=125, tm_isdst=0)
>>> time.localtime(1304575584.1361799)
time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=14, tm_min= 6, tm_sec=24, tm_wday=3, tm_yday=125, tm_isdst=0)

2）time.gmtime([secs]): Similar to the localtime() method, the gmtime() method converts a timestamp to a struct_time in the UTC time zone (0 time zone).

>>>time.gmtime()
time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=6, tm_min=19, tm_sec=48, tm_wday=3, tm_yday=125, tm_isdst=0)

Note: tm_wday=3 here represents the day of the week, but it must be based on this return value Pushing it back one day means Thursday, not Wednesday.

3) time.time(): Returns the timestamp of the current time.

>>> time.time()
1304575584.1361799

4) time.mktime(t): Convert a struct_time into a timestamp.

>>> time.mktime(time.localtime())
1304576839.0

5）time.sleep( secs): The thread delays running for the specified time. The unit is seconds.

6) time.clock(): This needs to be noted, has different meanings on different systems. On UNIX systems, it returns the "process time", which is a floating point number (timestamp) expressed in seconds. In WINDOWS, the first call returns the actual time the process is running. The calls after the second time are the running time since the first call to the present. (It is actually based on QueryPerformanceCounter() on WIN32, which is more accurate than millisecond representation)

1. import time    
   if __name__ == '__main__':    
       time.sleep(1)    
       print "clock1:%s" % time.clock()    
       time.sleep(1)    
       print "clock2:%s" % time.clock()    
       time.sleep(1)    
       print "clock3:%s" % time.clock()

clock1:3.35238137808e-006 Run result:

clock2:1.00004944763
clock3:2.00012040636

The first clock() output is the program running Time
The second and third clock() outputs are the time intervals from the first clock

7) time.asctime([t]): Represent a tuple or struct_time representing time in this form: 'Sun Jun 20 23:21:05 1993'. If there are no parameters, time.localtime() will be passed in as a parameter.

>>> time.asctime()
'Thu May 5 14:55:43 2011'

8）time. ctime([secs]): Convert a timestamp (a floating point number calculated in seconds) into the form of time.asctime(). If the parameter is not given or is None, time.time() will be used as the parameter by default. Its function is equivalent to time.asctime(time.localtime(secs)).

>>> time.ctime()
'Thu May 5 14:58:09 2011'
>>> time.ctime(time.time())
'Thu May 5 14:58:39 2011'
>>> time.ctime(1304579615)
'Thu May 5 15:13:35 2011'

9) time.strftime(format[, t]): Put a tuple or struct_time representing time (such as time. localtime() and time.gmtime() return) into a formatted time string. If t is not specified, time.localtime() will be passed in. If any element in the tuple goes out of bounds, a ValueError will be thrown.

Index	Attribute	Values
0	tm_year (year)	For example, 2011
1	tm_mon (month)	1 - 12
2	tm_mday（日）	1 - 31
3	tm_hour（hour）	0 - 23
4	tm_min (minutes)	0 - 59

##%ALocal full week name##%b##%BLocal full month name##%HThe number of days in a day hours (24-hour format, 00 - 23) ##%I##%jDay of the year (001 - 366)%mMonth (01 - 12)##%X Local corresponding time%yRemove the century year (00 - 99)%YComplete year##%Z%%

Note:

1. "%p" is effective only when used in conjunction with "%I".

2. The document emphasizes that it is indeed 0 - 61, not 59, and leap year seconds account for two seconds (sweat one).

3. When using the strptime() function, %U and %W are calculated only when the number of weeks and days in the year are determined.

For example:

>>> time.strftime("%Y-%m-%d %X", time.localtime() )
'2011-05-05 16:37:06'

10）time.strptime(string[, format]): Convert a formatted time string into struct_time. In fact, it is the inverse operation of strftime().

>>> time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X')
time.struct_time(tm_year =2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6, ​​tm_wday=3, tm_yday=125, tm_isdst=-1)

In this function, format defaults to ："%a %b %d %H:%M:%S %Y".

Finally, let’s make a summary of the time module. According to the previous description, there are three expression methods in Python: 1) timestamp 2) tuple or struct_time 3) formatted string.

The transformation between them is shown in the figure:

Related recommendations:

Detailed explanation of Python time

python time library

python time module

Time module analysis of Python time module

Format	Meaning	Remarks
%a	Locale Simplified week name
Local simplified month name
%c	Local corresponding date and time representation
%d	The number of days in a month (01 - 31)
th hour (12-hour format, 01 - 12)
%M	Number of minutes (00 - 59)
%p	The corresponding character of local am or pm	一
%S	Seconds (01 - 61)	二
%U	The number of weeks in the year. (Sunday 00 - 53 is the start of the week.) All days before the first Sunday are placed in week 0.	三
%w	The day of the week (0 - 6, 0 is Sunday)	三
%W	is basically the same as %U, except that %W starts the week on Monday.
%x	Local corresponding date
The name of the time zone (null character if not present)
'%' character

The above is the detailed content of Learn more about the time module in python. For more information, please follow other related articles on the PHP Chinese website!