python3标准库time / datetime模块

深碍√TFBOYSˉ_ 2022-05-12 12:20 278阅读 0赞

# 1.有关时间的基本知识点 #

### （1）表示时间的方式 ###

> a）**时间戳**：timestamp
> 
> b）**格式化的时间字符串**：Format string
> 
> c）**共9个元素的元组**：struct\_time

### （2）时间表示方式的说明 ###

> a）**UTC**（Coordinated Universal Time，世界协调时）：亦即格林威治天文时间，世界标准时间。在中国为UTC+8。DST（Daylight Saving Time）即夏令时。
> 
> b）**时间戳**：表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。返回时间戳方式的函数主要有time()，clock()等。
> 
> c）**元组方式**：struct\_time元组共有9个元素，返回struct\_time的函数主要有gmtime()，localtime()，strptime()。

# 2.time模块详解 #

> NAME  
>     time - This module provides various functions to manipulate time values.  
> DESCRIPTION  
>     There are two standard representations of time.  One is the number  
>     of seconds since the Epoch, in UTC (a.k.a. GMT).  It may be an integer  
>     or a floating point number (to represent fractions of seconds).  
>     The Epoch is system-defined; on Unix, it is generally January 1st, 1970.  
>     The actual value can be retrieved by calling gmtime(0).  
>       
>     The other representation is a tuple of 9 integers giving local time.  
>     **The tuple items are:**  
>       year (including century, e.g. 1998)                           \# tm\_year  
>       month (1-12)                                                             \# tm\_mon  
>       day (1-31)                                                                 \# tm\_mday  
>       hours (0-23)                                                              \# tm\_hour  
>       minutes (0-59)                                                          \# tm\_min  
>       seconds (0-59)                                                         \# tm\_sec  
>       weekday (0-6, Monday is 0)                                     \# tm\_wday  
>       Julian day (day in the year, 1-366)                           \# tm\_yday  
>       DST (Daylight Savings Time) flag (-1, 0 or 1)          \# tm\_isdst  
>     If the DST flag is 0, the time is given in the regular time zone;  
>     if it is 1, the time is given in the DST time zone;  
>     if it is -1, mktime() should guess based on the date and time.  
> CLASSES  
>     builtins.tuple(builtins.object)  
>         struct\_time  
>       
>     **class struct\_time(builtins.tuple)**  
>      |  The time value as returned by gmtime(), localtime(), and strptime(), and  
>      |  accepted by asctime(), mktime() and strftime().  May be considered as a  
>      |  sequence of 9 integers.  
>      |    
>      |  Note that several fields' values are not the same as those defined by  
>      |  the C language standard for struct tm.  For example, the value of the  
>      |  field tm\_year is the actual year, not year - 1900.  See individual  
>      |  fields' descriptions for details.  
>      |    
>      |  Method resolution order:  
>      |      struct\_time  
>      |      builtins.tuple  
>      |      builtins.object  
>      |    
>      |  Methods defined here:  
>      |    
>      |  \_\_new\_\_(\*args, \*\*kwargs) from builtins.type  
>      |      Create and return a new object.  See help(type) for accurate signature.  
>      |    
>      |  \_\_reduce\_\_(...)  
>      |      helper for pickle  
>      |    
>      |  \_\_repr\_\_(self, /)  
>      |      Return repr(self).  
>      |    
>      |  ----------------------------------------------------------------------  
>      | ** Data descriptors defined here:**  
>      |    
>      |  tm\_gmtoff  
>      |      offset from UTC in seconds  
>      |    
>      |  tm\_hour  
>      |      hours, range \[0, 23\]  
>      |    
>      |  tm\_isdst  
>      |      1 if summer time is in effect, 0 if not, and -1 if unknown  
>      |    
>      |  tm\_mday  
>      |      day of month, range \[1, 31\]  
>      |    
>      |  tm\_min  
>      |      minutes, range \[0, 59\]  
>      |    
>      |  tm\_mon  
>      |      month of year, range \[1, 12\]  
>      |    
>      |  tm\_sec  
>      |      seconds, range \[0, 61\])  
>      |    
>      |  tm\_wday  
>      |      day of week, range \[0, 6\], Monday is 0  
>      |    
>      |  tm\_yday  
>      |      day of year, range \[1, 366\]  
>      |    
>      |  tm\_year  
>      |      year, for example, 1993  
>      |    
>      |  tm\_zone  
>      |      abbreviation of timezone name  
>      |    
>      |  ----------------------------------------------------------------------  
>      |  Data and other attributes defined here:  
>      |    
>      |  n\_fields = 11  
>      |    
>      |  n\_sequence\_fields = 9  
>      |    
>      |  n\_unnamed\_fields = 0  
>      |    
>      |  ----------------------------------------------------------------------  
>      |  Methods inherited from builtins.tuple:  
>      |    
>      |  \_\_add\_\_(self, value, /)  
>      |      Return self+value.  
>      |    
>      |  \_\_contains\_\_(self, key, /)  
>      |      Return key in self.  
>      |    
>      |  \_\_eq\_\_(self, value, /)  
>      |      Return self==value.  
>      |    
>      |  \_\_ge\_\_(self, value, /)  
>      |      Return self>=value.  
>      |    
>      |  \_\_getattribute\_\_(self, name, /)  
>      |      Return getattr(self, name).  
>      |    
>      |  \_\_getitem\_\_(self, key, /)  
>      |      Return self\[key\].  
>      |    
>      |  \_\_getnewargs\_\_(...)  
>      |    
>      |  \_\_gt\_\_(self, value, /)  
>      |      Return self>value.  
>      |    
>      |  \_\_hash\_\_(self, /)  
>      |      Return hash(self).  
>      |    
>      |  \_\_iter\_\_(self, /)  
>      |      Implement iter(self).  
>      |    
>      |  \_\_le\_\_(self, value, /)  
>      |      Return self<=value.  
>      |    
>      |  \_\_len\_\_(self, /)  
>      |      Return len(self).  
>      |    
>      |  \_\_lt\_\_(self, value, /)  
>      |      Return self<value.  
>      |    
>      |  \_\_mul\_\_(self, value, /)  
>      |      Return self\*value.n  
>      |    
>      |  \_\_ne\_\_(self, value, /)  
>      |      Return self!=value.  
>      |    
>      |  \_\_rmul\_\_(self, value, /)  
>      |      Return self\*value.  
>      |    
>      |  count(...)  
>      |      T.count(value) -> integer -- return number of occurrences of value  
>      |    
>      |  index(...)  
>      |      T.index(value, \[start, \[stop\]\]) -> integer -- return first index of value.  
>      |      Raises ValueError if the value is not present.  
> **FUNCTIONS**  
>    **asctime(...)**  
>         asctime(\[tuple\]) -> string  
>           
>         Convert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.  
>         When the time tuple is not present, current time as returned by localtime()  
>         is used.  
>       
>    **clock(...)**
> 
>         """
> 
>        这个需要注意，在不同的系统上**含义不同**。在UNIX系统上，它返回的是“进程时间”，它是用秒表示的浮点数（时间戳）。而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行时间。（实际上是以WIN32上QueryPerformanceCounter()为基础，它比毫秒表示更为精确）
> 
>         """  
>         clock() -> floating point number  
>           
>         Return the CPU time or real time since the start of the process or since  
>         the first call to clock().  This has as much precision as the system  
>         records.  
>       
>     **ctime(...)**  
>         ctime(seconds) -> string  
>           
>         Convert a time in seconds since the Epoch to a string in local time.  
>         This is equivalent to asctime(localtime(seconds)). When the time tuple is  
>         not present, current time as returned by localtime() is used.  
>       
>     get\_clock\_info(...)  
>         get\_clock\_info(name: str) -> dict  
>           
>         Get information of the specified clock.  
>       
>     **gmtime(...)**  
>         gmtime(\[seconds\]) -> (tm\_year, tm\_mon, tm\_mday, tm\_hour, tm\_min,  
>                                tm\_sec, tm\_wday, tm\_yday, tm\_isdst)  
>           
>         Convert seconds since the Epoch to a time tuple expressing UTC (a.k.a.  
>         GMT).  When 'seconds' is not passed in, convert the current time instead.  
>           
>         If the platform supports the tm\_gmtoff and tm\_zone, they are available as  
>         attributes only.  
>       
>     **localtime(...)**  
>         localtime(\[seconds\]) -> (tm\_year,tm\_mon,tm\_mday,tm\_hour,tm\_min,  
>                                   tm\_sec,tm\_wday,tm\_yday,tm\_isdst)  
>           
>         Convert seconds since the Epoch to a time tuple expressing local time.  
>         When 'seconds' is not passed in, convert the current time instead.  
>       
>     **mktime(...)**  
>         mktime(tuple) -> floating point number  
>           
>         Convert a time tuple in local time to seconds since the Epoch.  
>         Note that mktime(gmtime(0)) will not generally return zero for most  
>         time zones; instead the returned value will either be equal to that  
>         of the timezone or altzone attributes on the time module.  
>       
>     monotonic(...)  
>         monotonic() -> float  
>           
>         Monotonic clock, cannot go backward.  
>       
>     perf\_counter(...)  
>         perf\_counter() -> float  
>           
>         Performance counter for benchmarking.  
>       
>     process\_time(...)  
>         process\_time() -> float  
>           
>         Process time for profiling: sum of the kernel and user-space CPU time. 
> 
>         \# 分析的进程时间:内核和用户空间CPU时间的总和  
>       
>     **sleep(...)**  
>         sleep(seconds)  
>           
>         Delay execution for a given number of seconds.  The argument may be  
>         a floating point number for subsecond precision.  
>       
>     **strftime(...)**  
>         strftime(format\[, tuple\]) -> string  
>           
>         Convert a time tuple to a string according to a format specification.  
>         See the library reference manual for formatting codes. When the time tuple  
>         is not present, current time as returned by localtime() is used.  
>           
>         **Commonly used format codes:**  
>           
>         %Y  Year with century as a decimal number.  
>         %m  Month as a decimal number \[01,12\].  
>         %d  Day of the month as a decimal number \[01,31\].  
>         %H  Hour (24-hour clock) as a decimal number \[00,23\].  
>         %M  Minute as a decimal number \[00,59\].  
>         %S  Second as a decimal number \[00,61\].  
>         %z  Time zone offset from UTC.  
>         %a  Locale's abbreviated weekday name.  
>         %A  Locale's full weekday name.  
>         %b  Locale's abbreviated month name.  
>         %B  Locale's full month name.  
>         %c  Locale's appropriate date and time representation.  
>         %I  Hour (12-hour clock) as a decimal number \[01,12\].  
>         %p  Locale's equivalent of either AM or PM.  
>           
>         Other codes may be available on your platform.  See documentation for  
>         the C library strftime function.  
>       
>     **strptime(...)**  
>         strptime(string, format) -> struct\_time  
>           
>         Parse a string to a time tuple according to a format specification.  
>         See the library reference manual for formatting codes (same as  
>         strftime()).  
>           
>         Commonly used format codes:  
>           
>         %Y  Year with century as a decimal number.  
>         %m  Month as a decimal number \[01,12\].  
>         %d  Day of the month as a decimal number \[01,31\].  
>         %H  Hour (24-hour clock) as a decimal number \[00,23\].  
>         %M  Minute as a decimal number \[00,59\].  
>         %S  Second as a decimal number \[00,61\].  
>         %z  Time zone offset from UTC.  
>         %a  Locale's abbreviated weekday name.  
>         %A  Locale's full weekday name.  
>         %b  Locale's abbreviated month name.  
>         %B  Locale's full month name.  
>         %c  Locale's appropriate date and time representation.  
>         %I  Hour (12-hour clock) as a decimal number \[01,12\].  
>         %p  Locale's equivalent of either AM or PM.  
>           
>         Other codes may be available on your platform.  See documentation for  
>         the C library strftime function.  
>       
>     **time(...)**  
>         time() -> floating point number  
>           
>         Return the current time in seconds since the Epoch.  
>         Fractions of a second may be present if the system clock provides them.  
> DATA  
>     altzone = -32400  
>     daylight = 0  
>     timezone = -28800  
>     tzname = ('ÖÐ¹ú±ê×¼Ê±¼ä', 'ÖÐ¹úÏÄÁîÊ±')  
> FILE  
>     (built-in)
> 
> ![70][]
> 
> [参考博客][Link 1]

# 3.datetime模块详解 #

# 4.格式参照 #

%a    本地（locale）简化星期名称    
    %A    本地完整星期名称    
    %b    本地简化月份名称    
    %B    本地完整月份名称    
    %c    本地相应的日期和时间表示    
    %d    一个月中的第几天（01 - 31）    
    %H    一天中的第几个小时（24小时制，00 - 23）    
    %I    第几个小时（12小时制，01 - 12）    
    %j    一年中的第几天（001 - 366）    
    %m    月份（01 - 12）    
    %M    分钟数（00 - 59）    
    %p    本地am或者pm的相应符 
    %S    秒（01 - 61） 
    %U    一年中的星期数。（00 - 53星期天是一个星期的开始。）第一个星期天之前的所有天数都放在第0周。
    %w    一个星期中的第几天（0 - 6，0是星期天）
    %W    和%U基本相同，不同的是%W以星期一为一个星期的开始。    
    %x    本地相应日期    
    %X    本地相应时间    
    %y    去掉世纪的年份（00 - 99）    
    %Y    完整的年份    
    %Z    时区的名字（如果不存在为空字符）    
    %%    ‘%’字符

# 5.程序实例 #

### （1）time模块 ###

import time
    
    
    # 返回处理器时间
    print(time.clock())
    
    # 返回与utc时间的时间差,以秒计算
    print(time.altzone)
    
    # 返回时间格式"Fri Aug 19 11:14:16 2016"  == 将时间元组转换成字符串
    print(time.asctime())
    
    # 返回本地时间[时间戳]的struct_time对象格式
    print(time.localtime(time.time()))
    
    # 返回utc时间的struct_time时间对象格式
    print(time.gmtime(time.time()))
    print("*" * 100)
    
    # 将struct_time转换成"Fri Aug 19 11:14:16 2016"
    print(time.asctime(time.localtime()))
    
    # 将时间戳转换为格式化字符串"Fri Aug 19 11:14:16 2016"
    print(time.ctime(time.time()))
    
    # ----------------------------------------------------------------
    
    # 将 日期字符串 转成 struct时间对象格式
    string_2_struct = time.strptime("2016/05/22", "%Y/%m/%d")
    print(string_2_struct)
    print("*" * 100)
    
    # 将struct时间对象转成时间戳
    struct_2_stamp = time.mktime(string_2_struct)
    print(struct_2_stamp)
    print("*" * 100)
    
    # ----------------------------------------------------------------
    
    # 时间戳转换为字符串
    print(time.strftime("%Y - %m - %d", time.gmtime(time.time())))
    print(time.strftime("%Y - %m - %d", time.localtime()))

### （2）datetime模块 ###

import datetime
    import time
    
    
    # datetime.datetime.now()相当于调用了datetime.datetime.fromtimestamp(time.time())
    print(datetime.datetime.now())
    print(datetime.datetime.fromtimestamp(time.time()))  # <class 'datetime.datetime'>
    
    # 当前时间加3天
    print(datetime.datetime.now() + datetime.timedelta(3))
    
    # 当前时间减3天
    print(datetime.datetime.now() + datetime.timedelta(-3))
    
    # 当前时间加3小时
    print(datetime.datetime.now() + datetime.timedelta(hours=3))
    
    # 当前时间加30分钟
    print(datetime.datetime.now() + datetime.timedelta(minutes=30))
    
    # datetime对象的时间替换
    c_time = datetime.datetime.now()
    print(c_time.replace(hour=2, minute=2))

[70]: /images/20220512/b985a8ba03584662b440c3bb1818f089.png
[Link 1]: http://blog.51cto.com/egon09/1840425