前言

(资料图片)

本系列（指Python Moudules系列）每篇介绍一个或多个内容没有特别多模块

模块介绍依赖官方文档（/zh-cn//library/）或其他第三方官方文档，主要是对其内容的补充和拓展

内容大部分来源官方文档，少部分来源网络。太过深奥的内容会只写出不介绍，或省略，或省略掉太过深奥的部分（例如省略部分参数），或通过补充介绍（补充介绍的前面通常会有参考网址）

注意内容非常依赖编号。内容中类的展示方式是"编号<数字>."表示类的构造方法（__init__），"编号<数字>.<数字>"表示类的方法或属性，方法一般是实例方法，其他方法会在前面备注，属性一般是实例属性，类属性会在后面备注。如果构造方法无需传参会直接展示类名

使用Python版本，但也会补充高版本的修改和添加内容

系列WPS笔记及其他内容的百度网盘链接：

/s/1fTwjyoM81_OOAccPNhGE9Q?pwd=h3fg

颜色代表含义：

淡灰色：注释，一般前面有#

绿色：示例

橙色：拓展

紫色：示例中的input用户输入内容

红色、蓝色：突出或装饰文字作用

部分内容可能不严谨或者错误，欢迎指出

一、time——时间的访问和转换

(1)、概述

time内置模块提供了各种与时间相关的函数

(2)、术语和惯例的解释

1. epoch（纪元）

时间开始的点，epoch是1970年1月1日00:00:00（UTC），是(0)的返回值

2. seconds since the epoch（自纪元以来的秒数/时间戳/Unix时间/POSIX时间戳）

指自epoch时间点以来经过的总秒数，通常不包括闰秒

3. 处理日期范围

此模块中的功能可能无法处理纪元之前或将来的远期日期和时间。未来的截止点由C库决定；对于32位系统通常在2038年

# 64位实测能到3000年左右（使用ctime()函数测试）

4. UTC

协调时间时，Coordinated Universal Time的缩写。以前也被称为格林威治标准时间（GMT）

# 使用UTC而不是CUT作为缩写是英文与法语（Temps Universel Coordonné）之间妥协的结果，不是低级错误

5. DST

夏令时，Daylight Saving Time的缩写。在一年的某一段时间中将当地时间调整（通常）一小时。DST的规则非常神奇（由当地法律确定），并且每年的起止时间都不同。C语言库中有一个表格，记录了各地的夏令时规则（实际上，为了灵活性，C语言库通常是从某个系统文件中读取这张表）。从这个角度而言，这张表是夏令时规则的唯一权威真理

补充：夏令时  # 摘抄自百度百科

是一种为节约能源而人为规定地方时间的制度。一般在天亮早的夏季人为将时间调快一小时，可以使人早起早睡，减少照明量，以充分利用光照资源，从而节约照明用电

6. 精度

由于平台限制，各种实时函数的精度可能低于其值或参数所要求（或给定）的精度。例如，在大多数Unix系统上，时钟频率仅为每秒50或100次

另一方面，time()和sleep()的精度优于它们的Unix等价物

(1)、时间元组/时间值序列/struct_time类

很多Python函数使用一个元组装起来的9组数字处理时间，也就是时间元组。它是一个带有具名元组接口的对象，存在以下值：

# 与C结构不同，月份值是[1, 12]的范围而不是[0, 11]

# 可以使用类的实例化创建时间元组，传入至少长度为9的序列（只取前9个元素）。传入的长度不正确或具有错误类型的元素时会引发TypeError

# 0是时间元组中任何位置的合法参数；如果它通常是非法的，则该值被强制改为正确的值

# 实测在版本中0不能作为年，但在版本中可以

补充：具名元组/命名元组（named tuple）

指任何继承自元组，并且其中的可索引元素还能用名称属性访问的类。例如_time类和_result类

(1)、部分函数

1. time()

返回以浮点数表示的自纪元以来的秒数。闰秒的处理取决于平台。在Windows和大多数Unix系统中，闰秒不计入从epoch开始的秒数。这通常被称为Unix时间

# 即使时间总是作为浮点数返回，但并非所有系统都提供高于1秒的精度

# 如果在两次调用之间设置系统时钟，它可以返回比先前调用更低的值

2. sleep(secs)

暂停执行调用线程达到给定的秒数。参数可以是浮点数，以指示更精确的睡眠时间

3. gmtime([secs])

将自纪元以来的秒数表示的时间转换为UTC的时间元组，其中dst标志始终为零

secs——自纪元以来的秒数。如果未提供或为None，则使用time()所返回的当前时间。一秒内的小数将被忽略

4. localtime([secs])

与gmtime()相似但转换为当地时间。当DST适用于给定时间时，dst标志设置为1

secs——同gmtime()

如果时间戳超出平台C localtime()或gmtime()函数支持的范围，此函数可能引发OverflowError。而在localtime()或gmtime()失败时会引发OSError

5. mktime(t)

localtime()的反函数。返回值是一个浮点数，以便与time()兼容

t——时间元组或完整的9元组（因为需要dst标志；如果它是未知的则使用-1），它表示当地时间而不是UTC

如果输入值不能表示为有效时间，则OverflowError或ValueError将会被引发（这取决于Python或底层C库是否捕获到无效值）。它可以生成时间的最早日期取决于平台

# UTC的时间元组转换为自纪元以来的秒数使用calendar模块的timegm()函数

示例：

运行结果：  # 其中一次运行结果（修改了电脑时间）

_time(tm_year=2050, tm_mon=5, tm_mday=4, tm_hour=21, tm_min=55, tm_sec=56, tm_wday=2, tm_yday=124, tm_isdst=0)

_time(tm_year=2050, tm_mon=5, tm_mday=5, tm_hour=5, tm_min=55, tm_sec=56, tm_wday=3, tm_yday=125, tm_isdst=0)

2535314156

2050

2050

6. asctime([t])

转换由gmtime()或localtime()所返回的时间元组t为以下形式的字符串：“Sun Jun 20 23:21:05 1993”。日期字段的长度为两个字符，如果日期只有一个数字则会以空格填充，例如“Wed Jun  9 04:26:40 1993”

如果t未提供，则会使用localtime()所返回的当前时间。此函数不会使用区域设置信息

# 与同名的C函数不同，asctime()不添加尾随换行符

7. ctime([secs])

转换自纪元以来的秒数为asctime()函数所示形式的字符串

如果secs未提供或为None，则使用time()所返回的当前时间。ctime(secs)等价于asctime(localtime(secs))。此函数不会使用区域设置信息

8. time_ns()

与time()相似，但返回时间为用整数表示的自epoch以来所经过的纳秒数

9. thread_time()

（以小数表示的秒为单位）返回当线程的系统和用户CPU时间的总计值。它不包括睡眠状态（调用sleep()）所消耗的时间。根据定义它只作用于线程范围。返回值的参考点未被定义，因此只有两次调用之间的差值才是有效的

使用thread_time_ns()以避免float类型导致的精度缺失

10. thread_time_ns()

与thread_time()相似，但返回纳秒时间

示例：

运行结果：  # 其中一次运行结果

Mon Apr 27 01:46:40 1970

Sat Mar  3 17:46:40 1973

Mon Apr 27 01:46:40 1970

Sat Mar  3 17:46:40 1973

2535314154265000000

经过秒数（浮点型）：

经过纳秒（整型）：577203700ns

经过秒数（浮点型）：

经过纳秒（整型）：499203200ns

11. strftime(format[, t])

转换由gmtime()或localtime()所返回的时间元组t为format参数指定的字符串。如果未提供t，则使用由localtime()返回的当前时间。format必须是一个字符串。如果t中的任何字段超出允许的范围，则引发ValueError

格式化符号如下：

%a：本地化的缩写星期名称

# 本地化使用locale模块设置

%A：本地化的完整星期名称

%b：本地化的缩写月份名称

%B：本地化的完整月份名称

%c：本地化的适当日期和时间表示

%d：十进制数[01, 31]表示的月中的一天

%H：十进制数[00, 23]表示的小时（24小时制）

%I：十进制数[01, 12]表示的小时（12小时制）

%j：十进制数[001, 366]表示的年中的一天

%m：十进制数[01, 12]表示的月

%M：十进制数[00, 59]表示的分钟

%p：本地化的AM或PM

%S：十进制数[00, 61]表示的秒

%U：十进制数[00, 53]表示的一年中的星期数（星期日作为一周的第一天）。在第一个星期日之前的新年（公历新年，也就是元旦）中的所有日子都被认为是在第0周

%w：十进制[0, 6]表示的周中的一天（0是星期日）

%W：十进制数[00, 53]表示的一年中的星期数（星期一作为一周的第一天）。在第一个星期一之前的新年中的所有日子都被认为是在第0周

%x：本地化的适当日期表示

%X：本地化的适当时间表示

%y：十进制数[00, 99]表示的没有世纪的年份

%Y：十进制数（四位数）表示的带世纪的年份

%z：时区偏移以格式+HHMM或-HHMM形式的UTC/GMT的正或负时差指示，其中H表示十进制小时数字，M表示小数分钟数字[-23:59, +23:59]

%Z：当前的时区名称（如果不存在时区，则不包含字符）

# 在高版本%Z已弃用

%%：字符“%”

# 在某些平台上，可选的字段宽度和精度规范可紧跟在'%'之后

某些平台还支持其他的格式化符号，上面只列出具有ANSI C标准化的含义的格式化符号，其他部分格式化符号如下：

%n：换行符

%t：水平制表符

%C：十进制数[00, 99]表示的世纪

%h：与“%b”相同

%D：等价于“%m/%d/%y”

%F：等价于“%Y-%m-%d”

%R：等价于“%H:%M”

%T：等价于“%H:%M:%S”

# ISO 8601年份见datetime模块()方法

%g：十进制数[00, 99]表示的没有世纪的年份

%G：十进制数（四位数）表示的带世纪的ISO 8601年份

%V：十进制数[01, 53]表示的ISO 8601周序号

%u：十进制数[1, 7]表示的ISO 8601周日期，其中1表示星期一

示例：

运行结果1：  # 其中一次运行结果

2001/9/9 1:46:40, 2001/9/9 1:46:40

缩写星期名称：周日，完整星期名称：星期日

缩写月份名称：九月，完整月份名称：九月

上午或下午：上午

世纪：20，没有世纪的年份：01，带世纪的年份：2001

%D：09/09/01，%F：2001-09-09

%R：01:46，%T：01:46:40

运行结果2：  # 去掉设置地区

Sun Sep  9 01:46:40 2001, 09/09/01 01:46:40

缩写星期名称：Sun，完整星期名称：Sunday

缩写月份名称：Sep，完整月份名称：September

上午或下午：AM

世纪：20，没有世纪的年份：01，带世纪的年份：2001

%D：09/09/01，%F：2001-09-09

%R：01:46，%T：01:46:40

12. strptime(string[, format])

根据格式format解析表示时间的字符串string。返回值是一个时间元组

format——同strftime()，默认为匹配ctime()所返回的格式“%a %b %d %H:%M:%S %Y”

如果string不能根据format来解析，或者解析后它有多于的数据，则会引发ValueError

# 注意，ctime()不会使用区域设置，但此函数会使用区域设置

当无法推断出更准确的值时，用于填充任何缺失数据的默认值是(1900, 1, 1, 0, 0, 0, 0, 1, -1)。string和format必须都为字符串

format中的仅支持具有ANSI C标准化的含义的格式化符号

# 也就是像%D、%F这些的不支持

# %y会按照POSIX和ISO C标准进行转换：数值69--99映射为1969--1999，而数值0--68被映射为2000--2068

# 如果使用%I来解析小时，%p会影响输出小时字段（不加%p默认上午）

# %U和%W用于指定星期几和年份时计算日期，否则忽略

# %G、%V、%u可用于此函数，%G和%V使用时必须%G、%V、(%A, %a, %w, %u)一起使用

13. monotonic()

（以小数表示的秒为单位）返回一个单调时钟的值，即不能倒退的时钟。该时钟不受系统时钟更新的影响。返回值的参考点未被定义，因此只有两次调用之间的差值才是有效的

使用monotonic_ns()以避免float类型导致的精度损失

14. monotonic_ns()

与monotonic相似，但返回时间为纳秒数

15. perf_counter()

（以小数表示的秒为单位）返回一个性能计数器的值，即用于测量较短持续时间的具有最高有效精度的时钟。它会包括睡眠状态所消耗的时间并且作用于全系统范围。返回值的参考点未被定义，因此只有两次调用之间的差值才是有效的

使用perf_counter_ns()以避免float类型导致的精度损失

16. perf_counter_ns()

与perf_counter()相似，但返回时间为纳秒数

17. process_time()

（以小数表示的秒为单位）返回当前进程的系统和用户CPU时间的总计值。它不包括睡眠状态所消耗的时间。根据定义它只作用于进程范围。返回值的参考点未被定义，因此只有两次调用之间的差值才是有效的

使用process_time_ns()以避免float类型导致的精度损失

18. process_time_ns()

与process_time()相似，但返回时间为纳秒数

示例1：

运行结果：  # 其中一次运行结果

格式：年-月-日 时:分:秒

2000-1-1 1:0:0

2000-01-01 01:00:00

格式：12小时制 AM/PM

5 pm

05 PM

没有%p默认AM： 05 AM

格式：年 星期 第几个星期（星期一算一周第一天）

2000 0 5

2000-02-06  # 计算2000年第5个星期日

格式：年 星期 第几个星期（星期一算一周第一天）

2000 0 6

2000-02-13  # 计算2000年第6个星期日

示例2：

运行结果：  # 其中一次运行结果

单调时钟：

性能计数器：

当前进程：

(2)、时区常量

1. altzone

本地DST时区的偏移量，以UTC为单位的秒数，如果已定义。如果当地DST时区在UTC以东（如在西欧，包括英国），则是负数。只有当daylight非零时才使用它

2. daylight

如果定义了DST时区，则为非零

3. timezone

本地（非DST）时区的偏移量，UTC以西的秒数（西欧大部分地区为负，美国为正，英国为零）

4. tzname

两个字符串的元组：第一个是本地非DST时区的名称，第二个是本地DST时区的名称。如果未定义DST时区，则不应使用第二个字符串

# 对于上述时区常量，该值由模块加载时有效的时区规则确定，或者最后一次tzset()被调用时，并且在过去的时间可能不正确。建议使用来自localtim()结果的tm_gmtoff和tm_zone来获取时区信息

# tzset()函数可用性Unix

二、calendar——日历相关函数

(1)、概述

calendar内置模块提供了与日历相关的实用函数。默认情况下，这些日历把星期一当做一周的第一天，星期天为一周的最后一天（按照欧洲惯例）。可以用setfirstweekday()函数/方法设置一周的第一天为星期天（6）或者其他任意一天。使用整数作为指定日期的参数

# 根据ISO 8601标准，还规定了0和负数年份。0年指公元前1年，-1年指公元前2年，以此类推

(2)、数据属性

# “calendar.数据属性”获取

1. day_name

在当前语言环境下表示星期几的数组

2. day_abbr

在当前语言环境下表示星期几缩写的数组

3. month_name

在当前语言环境下表示月份的数组。遵循一月的月号为1的通常惯例，所以它的长度为13且month_name[0]是空字符串

4. month_abbr

在当前语言环境下表示月份缩写的数组。遵循一月的月号为1的通常惯例，所以它的长度为13且month_name[0]是空字符串

5. MONDAY/TUESDAY/WEDNESDAY/THURSDAY/FRIDAY/SATURDAY/SUNDAY

星期内序号的别名，其中MONDAY是0、SUNDAY是6

(3)、函数

1. setfirstweekday(weekday)

设置一周的开始（0表示星期一，6表示星期天）

# 可使用提供的几个常量（MONDAY, TUESDAY...）设置

2. firstweekday()

返回当前设置的每星期的第一天的数值

3. isleap(year)

如果year是闰年则返回True，否则返回False

4. leapdays(y1, y2)

返回在范围y1至y2（不包含y2）之间的闰年的年数，其中y1和y2

是年份

# 此函数适用于跨越一个世纪变化的范围

5. weekday(year, month, day)

返回给定日期的星期（0是星期一）

示例：

运行结果：  # 其中一次运行结果

['星期一', '星期二', '星期三', '星期四', '星期五', '星期六', '星期日']

['周一', '周二', '周三', '周四', '周五', '周六', '周日']

['', '一月', '二月', '三月', '四月', '五月', '六月', '七月', '八月', '九月', '十月', '十一月', '十二月']

['', '一月', '二月', '三月', '四月', '五月', '六月', '七月', '八月', '九月', '十月', '十一月', '十二月']

0

2

True

True

5

5

6. weekheader(n)

返回一个包含星期几缩写名的头。n指定星期几缩写的字符宽度

# 当n >= 9时是星期的全称而不是缩写

7. monthrange(year, month)

返回指定年份的指定月份的第一天是星期几和这个月的天数

8. monthcalendar(year, month)

返回表示一个月的日历的矩阵。每一行代表一周，月份外的日子由零表示

每周从周一开始，除非使用setfirstweekday()改变设置

示例：

运行结果：

(5, 31)

[[0, 0, 0, 0, 0, 1, 2], [3, 4, 5, 6, 7, 8, 9], [10, 11, 12, 13, 14, 15, 16], [17, 18, 19, 20, 21, 22, 23], [24, 25, 26, 27, 28, 29, 30], [31, 0, 0, 0, 0, 0, 0]]

January 2000

Mon Tue Wed Thu Fri Sat Sun

1   2

3   4   5   6   7   8   9

10  11  12  13  14  15  16

17  18  19  20  21  22  23

24  25  26  27  28  29  30

31

# 这里显得不齐是因为字体原因：数字、字母和空格宽度不同

# 也可以设置中文环境将weekheader输出变为"周一、周二..."，这里不使用的原因同上

9. month(theyear, themonth, w=0, l=0)

使用TextCalendar类的formatmonth()以多行字符串形式返回月份日历

# 月份日历的效果与上个示例打印的日历相同

# month()和calendar()具体说明见TextCalendar类

10. prmonth(theyear, themonth, w=0, l=0)

打印由month()返回的一个月的日历

# 相当于print(())

11. calendar(year, w=2, l=1, c=6, m=3)

使用TextCalendar类的formatyear()以多行字符串的形式返回整年的3列的日历

12. prcal(year, w=2, l=1, c=6, m=3)

打印由calendar()返回的整年的日历

13. timegm(tuple)

将UTC的时间元组转换为自纪元以来的秒数，()的反函数。返回值是一个整数

(4)、类

1. Calendar(firstweekday=0)

创建一个Calendar对象，这个对象提供了一些可被用于准备日历数据格式化的方法。这个类本身不执行任何格式化操作。这部分任务应由子类来完成

firstweekday——指定每星期第一天的整数。0是星期一（默认值），6是星期天

. getfirstweekday()

获取当前设置的每星期的第一天的数值

. setfirstweekday(firstweekday)

设置一周的开始（0表示星期一，6表示星期天）

# 这是设置Calendar对象的一周的开始

. firstweekday属性

当前设置的每星期的第一天

# 这是property类的实例，获取属性值是调用getfirstweekday()方法，设置属性值是调用setfirstweekday()方法

. iterweekdays()

返回一个迭代器，迭代器的内容为一星期的数字。迭代器的第一个值与firstweekday属性的值一致

. itermonthdates(year, month)

. itermonthdays(year, month)

. itermonthdays2(year, month)

. itermonthdays3(year, month)

. itermonthdays4(year, month)

都是返回一个迭代器，迭代器的内容为year年month月的所有日期，日期包含了本月头尾用于组成完整一周的日期。区别如下：

itermonthdates()返回的日期是对象

itermonthdays()返回的日期为当月每一天的日期对应的天数。对于不在当月的日期。显示为0

itermonthdays2()迭代器中的元素为一个由日期和代表星期几的数字组成的元组

itermonthdays3()迭代器的元素为一个由年，月，日组成的元组

itermonthdays4()迭代器的元素为一个由年，月，日和代表星期几组成的元组

. monthdatescalendar(year, month)

. monthdayscalendar(year, month)

. monthdays2calendar(year, month)

都是返回返回一个表示指定年月的周列表。区别如下：

monthdatescalendar()的周列表由七个对象组成

monthdayscalendar()的周列表由七个代表日期的数字组成，不在这个月的日期为0

monthdays2calendar()的周列表由七个代表日期的数字和代表周几的数字组成的二元元组

. yeardatescalendar(year, width=3)

. yeardayscalendar(year, width=3)

. yeardays2calendar(year,width=3)

都是返回可以用来格式化的指定年月的数据，返回值是一个列表，列表是月份组成的行。每一行包含了最多width个月（默认为3）。每个月包含了4到6周。区别主要是周列表的区别，与编号, , 的区别相同

示例：

运行结果：

3

3

[4, 5, 6, 0, 1, 2, 3]

----------------------

1999-12-31 <class ''>

0

(0, 4)

(1999, 12, 31)

(1999, 12, 31, 4)

----------------------

[(1999, 12, 31), (2000, 1, 1), (2000, 1, 2), (2000, 1, 3), (2000, 1, 4), (2000, 1, 5), (2000, 1, 6)]

[0, 1, 2, 3, 4, 5, 6]

[(0, 4), (1, 5), (2, 6), (3, 0), (4, 1), (5, 2), (6, 3)]

[0, 1, 2, 3, 4, 5, 6]

2. TextCalendar(firstweekday=0)

生成纯文本日历的类

# 这个类是Calendar类的子类，构造方法同Calendar类

# 下面展示的方法是官方文档中出示的方法

. formatmonth(theyear, themonth, w=0, l=0)

返回一个多行字符串来表示指定年月的日历。w为日期的宽度，但始终保持日期居中。l指定每星期占用的行数。以上这些还依赖于构造方法或者setfirstweekday()方法指定的一周的第一天是哪一天

. prmonth(theyear, themonth, w=0, l=0)

打印由formatmonth()返回的一个月的日历

. formatyear(theyear, w=2, l=1, c=6, m=3)

返回一个多行字符串，这个字符串为一个m列日历。可选参数w, l和c分别表示日期的宽度，每星期占用的行数，和月之间的间隔。同样以上这些还依赖于构造方法或者setfirstweekday()方法指定的一周的第一天是哪一天

. pryear(theyear, w=2, l=1, c=6, m=3)

打印由formatyear()返回的整年的日历

3. HTMLCalendar(firstweekday=0)

生成HTML日历的类

# 这个类也是Calendar类的子类，构造方法同Calendar类

# 下面展示的方法是官方文档中出示的方法

. formatmonth(theyear, themonth, withyear=True)

返回一个HTML表格作为指定年月的日历

withyear——如果为True（默认值），则年份将会包含在表头，否则只显示月份

. formatyear(theyear, width=3)

返回一个HTML表格作为指定年份的日历

width——用于规定每一行显示月份的数量（默认为3）

. formatyearpage(theyear, width=3, css='', encoding=None)

返回一个完整的HTML页面作为指定年份的日历

width——用于规定每一行显示月份的数量（默认为3）

css——层叠样式表的名字。如果不使用任何层叠样式表，可以使用None

encoding——输出页面的编码（默认为系统的默认编码）

# 重载下列属性可以自定义应用日历的样式

. cssclasses类属性

一个对应星期一到星期天的CSS class列表。默认列表为

cssclasses = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"]

列表的长度必须为7

. cssclass_noday类属性

工作日的CSS类在上个月或下个月发生

. cssclasses_weekday_head类属性

用于标题行中的工作日名称的CSS类列表。默认值与cssclasses相同

. cssclass_month_head类属性

月份的头CSS类（由formatmonthname()使用）。默认值为"month"

. cssclass_month类属性

某个月的月历的CSS类（由formatmonth()使用）。默认值为"month"

. cssclass_year类属性

某年的年历的CSS类（由formatyear()使用）。默认值为"year"

. cssclass_year_head类属性

年历的表头CSS类（由formatyear()使用）。默认值为"year"

4. LocaleTextCalendar(firstweekday=0, locale=None)

5. LocaleHTMLCalendar(firstweekday=0, locale=None)

在构造方法中传递一个语言环境locale，并且返回的月份和星期几的名称是在特定语言环境locale中

# 分别是TextCalendar和HTMLCalendar的子类

# 两个类的构造方法、formatweekday()和formatmonthname()方法会暂时将LC_TIME的locale改为指定的locale。由于当前的区域设置是进程范围的设置，因此它们不是线程安全的

二、datetime——基本日期和时间类型

(1)、概述

datetime内置模块提供用于处理日期和时间的类

(2)、感知型对象和简单型对象

日期和时间对象可以根据它们是否包含时区信息而分为“感知型”和“简单型”

1. 感知型对象

感知型对象是用来表示一个没有解释空间的固定时间点。在充分掌握应用性算法和政治性时间调整信息例如时区和夏令时的情况下，一个感知型对象就能相对于其他感知型对象来精确定位自身时间点

2. 简单型对象

简单型对象不论表示的是UTC、当地时间还是某个其他时区的时间完全取决于具体程序。简单型对象没有包含足够多的信息来无歧义地相对于其他date/time对象来定位自身时间点

简单型对象更易于理解和使用，代价则是忽略了某些现实性考量

# 也就是感知型对象表示一个固定时间点，简单型对象表示的时间点取决具体程序

3. 应用感知型对象

datetime和time对象具有一个可选的时区信息属性tzinfo，它可被设为抽象类tzinfo的子类的一个实例

这些tzinfo对象会捕获与UTC时间的差值、时区名称以及夏令时是否生效等信息

datetime模块值提供了一个具体的tzinfo类，即timezone类

补充：抽象基类/抽象类（abstract base class,ABC）

# 参考知乎89549054、百度百科、官方文档

1.抽象函数/纯虚函数（pure virtual function）

抽象函数只有函数名、参数和返回值类型，不需要函数体，它的实现需要让子类去实现

2.抽象基类作用

·处理继承问题方面更加规范、系统

·明确调用之间的相互关系

·使得继承层次更加清晰

·限定子类实现的方法

3.概念

# 这里的“函数”和“方法”为同一意思

抽象基类是对鸭子类型的补充，它提供了一种定义接口的新方式

抽象基类必须包含一个抽象函数，它是一个不完整的类，既有自己实现的方法，也有需要子类重写的方法（抽象方法）

抽象基类不可以被实例化。子类需要实现基类指定的抽象方法

# 可以使用abc模块创建自己的ABC

(3)、常量

1. MINYEAR

date或datetime对象允许的最小年份。常量MINYEAR是1

2. MAXYEAR

date或datetime对象允许的最大年份。常量MAXYEAR是9999

# 在版添加了UTC常量，是的别名

(4)、类

datetime模块定义了date、time、datetime、timedelta、tzinfo和timezone类，这些类型共享这些通用特性：

· 这些类型的对象都是不可变的

· 这些类型的对象都是可哈希的（可作为字典的键）

· 这些类型的对象支持通过pickle模块进行高效的封存（进行序列化）

子类关系如下：

object

timedelta

tzinfo

timezone

time

date

datetime

对象是感知型还是简单型：

date类型的对象都是简单型的

datetime对象d在以下条件同时成立时将是感知型的，其他情况是简单型的：

· 不为None

· (d)不返回None

time对象t在以下条件同时成立时将是感知型的，其他情况是简单型的：

· 不为None

· (None)不返回None

感知型和简单型之间的区别不适用于timedelta对象

1. timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)

timedelta对象表示两个date或者time的时间间隔

所有参数可选且默认值为0。这些参数可以是整数或浮点数，正数或负数

days——天

seconds——秒

microseconds——微秒

milliseconds——毫秒

minutes——分钟

hours——小时

weeks——星期

只有days, seconds和microseconds会存储在内部。参数单位的换算规则如下：

· 1毫秒会转换成1000微秒

· 1分钟会转换成60秒

· 1小时会转换成3600秒

· 1星期会转换成7天

并且days, seconds和microseconds会经标准化处理以保证表达方式的唯一性，即：

· 0 <= microseconds < 1000000

· 0 <= seconds < 3600*24（一天的秒数）

· -999999999 <= days <= 999999999

如果有任何参数为浮点型并且microseconds的值为小数的情况下，从所有参数中余下的微秒数将被合并，并使用四舍五入偶不入奇的规则将总计值舍入到最接近的整数微秒值。否则转换和标准化过程将是完全精确的（不会丢失信息）

如果标准化后的days数值超过了指定范围，将会抛出OverflowError异常

示例：

运行结果：

(days=8, seconds=10000, microseconds=20000)

(0) (microseconds=2)

(days=-1, seconds=86399, microseconds=999999)

-1 day, 23:59:

. 类属性

. min

最小的timedelta类对象，timedelta(-999999999)

. max

最大的timedelta类对象，timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999)

. resolution

两个不相等的timedelta类对象最小的时间间隔，timedelta(microseconds=1)

# 因为标准化的缘故， > -，-不是一个timedelta 类对象

. 实例属性（只读）

. days

天，值范围[-999999999, 999999999]

. seconds

秒，值范围[0, 86399]

. microseconds

微秒，值范围[0, 999999]

. 支持的运算

. t1 = t2 + t3

t2和t3的和。运算后t1 - t2 == t3 and t1 - t3 == t2必为真值。(1)

. t1 = t2 - t3

t2减t3的差。运算后t1 == t2 - t3 and t2 == t1 == t3必为真值。(1)

# 通常t2 - t3与t2 + (-t3)是等价的，除非t3等于；这种情况下t2 - t3会返回结果，t2 + (-t3)会溢出

. t1 = t2 * i或t1 = i * t2

乘以一个整数。运算后假如i != 0则t1 // i == t2必为真值

通常，t1 * i == t1 * (i-1) + t1为真值。(1)

. t1 = t2 * f或t1 = f * t2

乘以一个浮点数。结果会被舍入到timedelta最接近的整数倍。精度使用四舍五偶入奇不入规则

. f = t2 / t3

总时间t2除以时间间隔t3。返回一个float对象。(3)

. t1 = t2 / f或t1 = t2 / i

除以一个浮点数或整数。结果会被舍入到timedelta最接近的整数倍。精度使用四舍五偶入奇不入规则

. t1 = t2 // i或t1 = t2 // t3

整除向下取整。第一种情况返回timedelta对象，第二种情况返回整数。(3)

. t1 = t2 % t3

取余。余数为一个timedelta对象。(3)

. q, r = divmod(t1, t2)

计算出商和余数：q = t1 // t2, r = t1 % t2。q是一个整数，r是一个timedelta对象

. +t1

返回一个相同数值的timedelta对象

. -t1

等价于timedelta(-, -, -)和t1 * -1。(1)

. abs(t)

当 >= 0时等于+t，当 < 0时等于-t。(2)

. str(t)

返回一个形如[D day[s], ][H]H:MM:SS[.UUUUUU]的字符串，当t为负数的时候，D也为负数

. repr(t)

返回一个timedelta对象的字符串表示形式，作为附带正规属性值的构造器调用

注释：

1.结果准确，但可能会溢出

2.结果准确，不会溢出

3.除以0将会抛出ZeroDivisionError异常

. ==, !=

可以跟任何类型的对象比较

. <, >, <=, >=

只能和timedelta对象比较，否则引发TypeError

# 在布尔运算中，timedelta(0)视为False，其他视为True

. 实例方法

. total_seconds()

返回时间间隔（timedelta对象）包含了多少秒。等价于td / timedelta(seconds=1)。其他单位可直接用除法形式（例如td / timedelta(microseconds=1)）

# 时间间隔较大时，结果中的微秒将会失真（大多数平台上大于270年视为一个较大的时间间隔）

示例：

2. date(year, month, day)

date对象代表一个理想化历法中的日期（年、月和日），即当今的格列高利历（公元）向前后两个方向无限延伸

公元1年1月1日是第1日，公元1年1月2日是第2日，以此类推

year——年，MINYEAR <= year <= MAXYEAR

month——月，1 <= month <= 12

day——日，1 <= day <= 给定年月对应的天数

如果参数不在这些范围内，则抛出ValueError异常

. 类属性

. min

最小的日期，date(MINYEAR, 1, 1)

. max

最大的日期，date(MAXYEAR, 12, 31)

. resolution

两个日期对象的最小间隔，timedelta(days=1)

. 实例属性（只读）

. year

年，值范围[MINYEAR, MAXYEAR]

. month

月，值范围[1, 12]

. day

天，值范围[1, 给定年月对应的天数]

. 类方法

. today()

返回当前的本地日期，返回date对象

这等价于(())

. fromtimestamp(timestamp)

返回对应于时间戳timestamp的当地时间，返回date对象

如果时间戳数值超出所在平台C localtime()函数支持的范围则引发OverflowError，在localtime()出错时会引发OSError。在时间戳概念包含闰秒的非POSIX系统上，闰秒会被忽略

. fromordinal(ordinal)

返回对应于预期格列高利历序号的日期，其中公元1年1月1日的序号为1，返回date对象

除非1 <= ordinal <= ()否则会引发ValueError。对于任意日期d，(()) == d

# toordinal()实例方法是返回日期的预期格列高利历序号

. fromisoformat(date_string)

返回一个对应于YYYY-MM-DD格式给出的date_string的date对象。这是()实例方法的逆操作

# 在版支持任何有效的ISO 8601格式日期字符串，除了序号日期

. fromisocalendar(year, week, day)

返回指定year, week和day所对应ISO历法日期的date，这是()实例方法的逆操作

# 具体见()实例方法

. 支持的运算

. date2 = date1 + timedelta

date1加上天，返回date对象。(1)

. date2 = date1 - timedelta

date1减去天，返回date对象。(1)

. timedelta = date1 - date2

date1减去date2的天数，返回timedelta对象

此值完全精确且不会溢出。运算后和均为0

注释：

和会被忽略。如果运算后小于MINYEAR或大于MAXYEAR则会引发OverflowError

. ==, !=

可以跟任何类型的对象比较

. <, >, <=, >=

只能和date对象比较，否则引发TypeError。如果比较目标具有timetuple()，也可能返回NotImplemented

# 时间早的被认为小于时间晚的

# 在布尔运算中，所有date对象都会被视为True

补充：NotImplemented内置常量

# 双目运算也就是二元运算

应由双目运算特殊方法（如__eq__(), __lt__()等）或原地双目运算符特殊方法（赋值运算特殊方法）返回的特殊值，用于表明运算没有针对其他类型的实现

它不应在布尔运算中被求值。它是类型的唯一实例

当双目运算特殊方法（或赋值运算特殊方法）返回此常量时，解析器将尝试对另一种类型（或其他的一些回滚操作，取决于运算符）的反射操作。如果所有尝试都返回此常量，则解析器将引发适当的异常

示例1：  # NotImplemented常量

运行结果：

A类__gt__()执行

B类__lt__()执行

A类__lt__()执行

B类__gt__()执行

'<' not supported between instances of 'A' and 'B'

示例2：  # date类

运行结果：  # 其中一次运行结果

2000-01-01 2050-05-05 2001-09-09 2000-03-21 2000-01-02 2000-01-03

2000-01-02 1999-12-31

80 days, 0:00:00

False True

True

. 实例方法/特殊方法

. replace(year=, month=, day=)

返回一个具有同样值的date对象，除非通过任何关键字参数给出某些形参的新值

. timetuple()

返回一个_time（时间元组）

hours, minutes和seconds值均为0，且DST标志为-1

此函数等价于：

_time((, , , 0, 0, 0, (), yday, -1))

其中yday = () - date(, 1, 1).toordinal() + 1是当前年份中的日期序号，1月1日的序号为1

. toordinal()

返回日期的预期格列高利历序号，其中公元1年1月1日的序号为1。fromordinal()的逆方法

. weekday()

返回一个整数代表星期几，星期一为0，星期天为6

. isoweekday()

返回一个整数代表星期几，星期一为1，星期天为7

. isocalendar()

返回一个三元组(ISO年份, ISO周序号, ISO周日期)

# 在版返回具名元组：year, week和weekday

ISO历法是一种被广泛使用的格列高利历

ISO年由52或53个完整星期构成，每个星期开始于星期一结束于星期日。（格列高利）历法的一年中第一个包含星期四的星期是一个ISO年的第一个星期。这被称为1号星期，这个星期四所在的ISO年与其所在的格列高利年相同

例如，公元2000年第一个有星期四的是6号，则6号所在的这个星期是ISO年的第一个星期（1号星期），即3号~9号。也就是ISO年2000年开始于2000年1月3日星期一。相应的，ISO年1999年结束于2000年1月2日

. isoformat()

返回一个ISO 8601格式YYYY-MM-DD来表示日期的字符串

# 在版之前是fromisoformat()的逆操作

. __str__()

对于date对象d，str(d)等价于()

. ctime()

返回一个表示日期的字符串

此方法等效于：

((()))

# 在原生C ctime()函数(()会发起调用该函数，但()则不会)遵循C标准的平台上

. strftime(format)

返回一个由显式格式字符串所指明的代表日期的字符串。表示时、分或秒的格式代码值将为0

# 格式化符号见time模块strftime()函数

. __format__(format)

与()相同。此方法使得date对象能进行f-string格式化或()格式化

示例：

运行结果：

_time(tm_year=2000, tm_mon=1, tm_mday=3, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=3, tm_isdst=-1)

730122 2000-01-03

0 1

(2000, 1, 1) 2000-01-03

2000-01-03 2000-01-03 2000-01-03 2000-01-03

Mon Jan  3 00:00:00 2000

3. time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold)

time对象代表某日的（本地）时间，它独立于任何特定日期，并可通过tzinfo对象来调整

所有参数都是可选的，除tzinfo默认值为0

hour——小时，0 <= hour < 24

minute——分钟，0 <= minute < 60

second——秒，0 <= second < 60

microsecond——微秒，0 <= microsecond < 1000000

tzinfo——见tzinfo类。可以是None（默认值），或tzinfo子类的实例

fold——用于在重复的时间段中消除边界时间歧义。（当夏令时结束时回拨时钟或由于政治原因导致当明时区的UTC时差减少就会出现重复的时间段。）取值0(1)表示两个时刻早于（晚于）所代表的同一边界时间，fold in [0, 1]

参数给出范围外的值将引发ValueError

. 类属性

. min

最早可表示的时间，time(0, 0, 0, 0)

. max

最晚可表示的时间，time(23, 59, 59, 999999)

. resolution

两个时间对象的最小间隔，timedelta(microseconds=1)

# time对象不支持算术运算

. 实例属性（只读）

. hour

小时，值范围range(24)

. minute

分钟，值范围range(60)

. second

秒，值范围range(60)

. microsecond

微秒，值范围range(1000000)

. tzinfo

作为tzinfo参数被传给time构造方法的对象，没传入值则为None

. fold

值范围[0, 1]

. 比较运算

time对象支持time与time的比较，当a时间在b之前则认为a小于b

简单型比较感知型会引发TypeError，在相等比较中简单型永远不等于感知型

感知型和感知型比较分以下两种情况：

1.具有相同的tzinfo属性，则该属性会被忽略并对基本时间值比较

2.具有不同的tzinfo属性，则两个比较方将首先减去它们的UTC时差（从()获取）来进行调整

当time对象与不同类型对象比较时会引发TypeError，除非比较运算符是==或!=（这两种情况会分别返回False或True）

# 在布尔运算中，所有time对象都会被视为True

. 方法

. 类方法fromisoformat(time_string)

返回对应于()所提供的某种time_string格式的time。支持以下格式的字符串：

HH[:MM[:SS[.fff[fff]]]][+HH:MM[:SS[.ffffff]]]

# 具体见下个方法

# 在版支持任何有效的ISO 8601格式时间字符串

. isoformat(timespec='auto')

返回表示为下列ISO 8601格式之一的时间字符串：

如果utcoffset()返回None：

1.如果microsecond为0，HH:MM:SS

2.如果microsecond不为0，HH:MM:

如果utcoffset()不返回None：

1.如果microsecond为0，HH:MM:SS+HH:MM[:SS[.ffffff]]

2.如果microsecond不为0，HH:MM:+HH:MM[:SS[.ffffff]]

timespec——要包含的额外时间组件（默认为'auto'），可选择以下的值：

'auto'：如果microsecond为0，则与'seconds'相同，否则与'microseconds'相同

'hours'：以两个数码HH格式包含hour

'minutes'：以HH:MM格式包含hour和minute

'seconds'：以HH:MM:SS格式包含hour, minute和second

'milliseconds'：以HH:MM:格式包含完整时间，但将秒值的小数部分（微秒）截断至毫秒  # 截断而不是舍入

'microseconds'：以HH:MM:格式包含完整时间

对于无效的timespec参数将引发ValueError

. replace(hour=, minute=, second=, microsecond=, tzinfo=, *, fold=0)

返回一个具有同样值的time对象，除非通过任何关键字参数给出某些形参的新值

# 注意可以指定tzinfo=None从一个感知型time对象创建一个简单型time对象，而不必转换时间数据

. utcoffset()

. dst()

. tzname()

如果tzinfo为None，则返回None；否则返回.同名方法(None)，如果后者不返回None或者一个幅度小于一天的timedelta对象（在tzname()方法中是不返回None或者一个字符串对象）则引发异常

# 具体见tzinfo类

. __str__()

对于time对象t，str(t)等价于()

. strftime(format)

返回一个由显式格式字符串所指明的代表时间的字符串

# 格式化符号见time模块strftime()函数

. __format__(format)

与()相同。此方法使得time对象能进行f-string格式化或()格式化

示例：

运行结果：

12:30: 11:00:00 12:00:00+08:00 12:00:00+07:00

True True False

12:30 12:30:

8:00:00 None UTC+08:00

12/00/00/+0800

4. datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)

datetime对象是包含来自date对象和time对象的所有信息的单一对象。datetime类是date类的子类

与date对象一样，datetime假定当前的格列高利历向前后两个方向无限延伸；与time对象一样，datetime假定每一天恰好有3600*24秒

year, month和day参数是必须的，参数说明见date类和time类的相应参数

参数给出范围外的值将引发ValueError

. 类属性

. min

最早可表示的datetime对象，datetime(MINYEAR, 1, 1, tzinfo=None)

. max

最晚可表示的datetime对象，datetime(MAXYEAR, 12, 31, 23, 59, 59, 999999, tzinfo=None)

. resolution

两个datetime对象的最小间隔，timedelta(microseconds=1)

. 实例属性（只读）

实例属性对应构造方法中的每个参数

. 支持的运算

. datetime2 = datetime1 + timedelta

. datetime2 = datetime1 - timedelta

. timedelta = datetime1 - datetime2

. 比较运算

支持的运算与date类支持的运算大体相同，区别在不止是计算日期且有简单型和感知型间的计算：

· 对感知型的计算不会进行时区调整

· 从一个datetime减去一个datetime的两个操作数均为简单型或感知型，感知型之间的计算类似于time中的比较运算：具有相同tzinfo属性会忽略此属性，具有不同tzinfo属性会将两个datetime先转换为简单型UTC日期时间再计算

· 比较运算参考date类和time类的比较运算

. 类方法

. today()

返回表示当前地方时的datetime对象，其中tzinfo为None。返回简单型的datetime对象

等价于：

(())

或不带tz形参的now()

. now(tz=None)

返回表示当地地方时的datetime对象。当tz为None时返回简单型的datetime对象，不为None时返回感知型的datetime对象

tz——当地日期和时间转换到的tz时区。如果为None（默认值），类似于today()；如果不为None，则必须是tzinfo子类的一个实例

# 该方法会在可能的情况下提供比通过()时间戳所获时间值更高的精度

. utcnow()

返回表示当前UTC时间的datetime对象，其中tzinfo为None。返回简单型的datetime对象

# 推荐使用()来创建感知型的当前UTC时间的datetime对象

. fromtimestamp(timestamp, tz=None)

返回对应于时间戳timestamp的本地日期和时间。当tz为None时返回简单型的datetime对象，不为None时返回感知型的datetime对象

tz——同now()

如果时间戳数值超出所在平台C localtime()函数支持的范围则引发OverflowError，在localtime()出错时会引发OSError。在时间戳概念包含闰秒的非POSIX系统上，闰秒会被忽略

. utcfromtimestamp(timestamp)

返回对应于时间戳timestamp的UTC日期和时间，其中tzinfo值为None。返回简单型的datetime对象

如果时间戳数值超出所在平台C gmtime()函数支持的范围则引发OverflowError，在gmtime()出错时会引发OSError

在POSIX兼容的平台上，它等价于以下表达式：

datetime(1970, 1, 1, tzinfo=) + timedelta(seconds=timestamp)

# 这种形式总是支持完整年份范围：[MINYEAR, MAXYEAR]

# 推荐使用fromtimestamp(timestamp, tz=)来创建感知型的特定UTC时间戳的datetime对象

. fromordinal(ordinal)

类似()，返回对应于预期格列高利历序号的datetime对象

结果的hour, minute, second和microsecond值均为0，并且tzinfo值为None。返回简单型的datetime对象

. combine(date, time[, tzinfo])

返回一个新的datetime对象，对象的日期部分等于给定的date对象的值，而时间部分等于给定的time对象的值。如果date是一个datetime对象，它的时间部分和tzinfo属性会被忽略

tzinfo——如果给出，则使用给出值设置结果的tzinfo属性，否则使用time参数的tzinfo属性

对于任意datetime对象d，d == ((), (), )

. fromisoformat(date_string)

返回对应于()和()所提供的某种date_string格式的datetime。支持以下格式的字符串：

YYYY-MM-DD[*HH[:MM[:SS[.fff[fff]]]][+HH:MM[:SS[.ffffff]]]]

其中*可以匹配任意的单个字符

# 在版支持任何有效的ISO 8601格式日期时间字符串

. fromisocalendar(year, week, day)

返回指定year, week和day所对应ISO历法日期的datetime，这是()实例方法的逆操作

该datetime对象的非日期部分将使用其标准默认值来填充

. strptime(date_string, format)

返回一个对应于date_string，根据format进行解析得到的datetime对象

默认值为1900-01-01T00:00:。任何未在格式字符串中指定的部分都将从默认值中提取

等价于：

datetime(*((date_string, format)[0:6]))

# 无法解析引发ValueError

# 格式化符号见time模块strftime()函数

示例：

运行结果：  # 其中一次运行结果

2000-01-01 12:00:00 2000-01-01 08:00:00+08:00 2000-01-03 00:00:00

2000-01-01 16:00:00+08:00 2000-01-01 00:00:00+08:00

1 day, 12:00:00

2000-01-01 12:30:00+07:00

2050-05-05 05:55:

2050-05-05 05:55:+08:00

2050-05-04 21:55:

. 实例方法/特殊方法

. date()

返回具有同样year, month和day值的date对象

. time()

返回具有同样hour, minute, second, microsecond和fold值的time对象。tzinfo值为None

. timetz()

返回具有同样hour, minute, second, microsecond, fold和tzinfo值的time对象

. replace(year=, month=, day=, hour=, minute=, second=, microsecond=, tzinfo=, *, fold=0)

返回一个具有同样值的datetime对象，除非通过任何关键字参数给出某些形参的新值

# 注意可以指定tzinfo=None从一个感知型datetime对象创建一个简单型datetime对象，而不必转换日期和时间数据

. utcoffset()

. dst()

. tzname()

同time类的同名方法

. astimezone(tz=None)

返回一个具有新的tzinfo属性tz的datetime对象，并会调整日期和时间数据使得结果对应的UTC时间与调用实例self对应的UTC时间相同，但结果的时区为tz时区的本地时间。如果self为简单型，则会被假定为基于系统时区表示的时间

tz——如果为None（默认值），则会假定目标时区为系统的本地时区。时区名称和时差值将从OS获取；如果不为None，则必须是一个tzinfo子类的实例，并且其utcoffset()和dst()方法不可返回None

# 只要附加一个时区对象tz到datetime对象dt而不调整日期和时间数据请使用(tzinfo=tz)。只要从感知型datetime对象dt去掉时区对象请使用(tzinfo=None)

# 注意默认的()方法在tzinfo的子类中可以被重载，从而影响astimezone()的返回结果

忽略出错的情况，此函数的行为类似于：

def astimezone(self, tz):

if is tz:

return self

# 将self转换为UTC时间，并附加新的时区对象

utc = (self - ()).replace(tzinfo=tz)

# 将UTC时间转换为tz时区的本地时间

return (utc)

. timetuple()

返回一个_time（时间元组）

此函数等价于：

_time((, , ,

, , ,

(), yday, dst))

其中yday = () - date(, 1, 1).toordinal() + 1是当前年份中的日期序号，1月1日的序号为1

结果的tm_isdst标志的设定根据dst()方法：

· 如果tzinfo为None或dst()返回None，则设为-1

· 否则如果dst()返回一个非零值，则设为1

· 否则设为0

. utctimetuple()

如果datetime实例d为简单型，类似于()，但tm_isdst强制设为0

# DST对于UTC时间永远无效

如果d为感知型，d会通过减去()来标准化为UTC时间，并返回该标准化时间所对应的_time。tm_isdst会强制设为0

# 注意如果为MINYEAR或MAXYEAR并且UTC调整超出一年的边界则可能引发OverflowError

# 最好使用感知型日期时间来表示UTC时间

使用(tzinfo=)可以使一个表示UTC的简单型改为感知型

. toordinal()

返回日期的预期格列高利历序号。与().toordinal()相同

. timestamp()

返回对应于datetime实例的时间戳

简单型datetime实例会假定为代表本地时间；感知型datetime实例返回值的计算方式为：

(dt - datetime(1970, 1, 1, tzinfo=)).total_seconds()

# 时间戳0秒epoch是UTC时间1970年1月1日00:00:00

# 此方法依赖于平台C mktime()函数来执行转换。由于在许多平台上datetime支持的范围比mktime()更广，对于极其遥远的过去或未来的日期时间此方法可能引发OverflowError或OSError

. weekday()

返回一个整数代表星期几，星期一为0，星期天为6。相当于().weekday()

. isoweekday()

返回一个整数代表星期几，星期一为1，星期天为7。相当于().isoweekday()

. isocalendar()

返回一个三元组(ISO年份, ISO周序号, ISO周日期)。相当于().isocalendar()

# 在版返回具名元组：year, week和weekday

. isoformat(sep='T', timespec='auto')

返回一个以ISO 8601格式表示的日期和时间字符串

sep——单个分隔字符，会被放在结果的日期和时间两部分之间，默认为'T'

返回格式和timespec参数类似()方法，区别是在结果字符串前面加上：YYYY-MM-DDT

. __str__()

对于datetime对象d，str(d)等价于(' ')

. ctime()

返回一个表示日期和时间的字符串

无论输入的是感知型还是简单型，输出字符串都不包含时区信息

此方法等效于：

((()))

# 在原生C ctime()函数(()会发起调用该函数，但()则不会)遵循C标准的平台上

. strftime(format)

返回一个由显式格式字符串所指明的代表日期和时间的字符串

# 格式化符号见time模块strftime()函数

. __format__(format)

与()相同。此方法使得datetime对象能进行f-string格式化或()格式化

示例：

运行结果：

2000-01-01

12:00:00

12:00:00+08:00

2000-01-01 12:00:00

2000-01-01 04:00:00+00:00

_time(tm_year=2000, tm_mon=1, tm_mday=1, tm_hour=4, tm_min=0, tm_sec=0, tm_wday=5, tm_yday=1, tm_isdst=0)

2000-01-01T12:00:00+08:00

2000-01-01/12:00:00+08:00

2000-01-01/12+08:00

补充：strftime()和strptime()格式化符号与time模块中的不同和补充

%Y：在用strptime()方法解析<1000的年份时，必须加零填充为4位数字宽度

%S：不支持闰秒，所以范围是[00, 59]

%f：十进制数[000000, 999999]表示的微秒，在strptime()方法中使用时，可接受一至六个数码及左边的零填充

%z：UTC偏移量，格式为±HHMM[SS[.ffffff]]（简单型对象则为空字符串）

%Z：时区名称（简单型对象则为空字符串）

# 在版添加了%:z，是UTC偏移量，格式为±HH:MM[:SS[.ffffff]]

# %z当时差为整数秒时ffffff部分将被省略，当时差为整数分钟时ffffff和SS部分都将被省略

%G和%V：使用时必须%G、%V、(%A, %a, %w, %u)一起使用

在strptime()方法使用时，前导零在格式%d, %m, %H, %I, %M, %S, %j, %U, %W和%V中，格式%y需要有前导零

# 如果在strptime()中多个格式化符号紧跟在一起，则传入数字会先满足每个格式化符号至少需要的数字，再从左到右依次满足（见示例）

示例：

运行结果：

+ UTC+06:08:

0002-01-01 00:00: / 2000-01-04 00:00:00

1234-05-06 00:00:00 / 4567-08-09 00:00:

5. tzinfo抽象基类

此类不应该被直接实例化。需定义子类来捕获有关特定时区的信息

# 对于序列化操作有特殊要求：一个tzinfo子类必须具有可不带参数调用的__init__()方法，否则它虽然可以被pickled，但可能无法再次unpickled

子类可能需实现以下方法。具体实现的方法取决于感知型datetime对象如何使用它

# 下列方法只简略介绍，具体见官方文档

. utcoffset(dt)

将本地时间与UTC时差返回为一个timedelta对象，如果本地时区在UTC以东则为正值。 如果本地时区在UTC以西则为负值

表示与UTC的总计时差（代表时区和DST调整的和）。UTC时差不确定则返回None。UTC时差的幅度必须小于1天

如果utcoffset()返回值不为None，则dst()也不应返回None

默认实现会引发NotImplementedError

. dst(dt)

将DST调整返回为一个timedelta对象

如果DST信息位置则返回None；未启用则返回timedelta(0)；启用则将差值作为一个timedelta对象返回

默认实现会引发NotImplementedError

. tzname(dt)

将对应于datetime对象dt的时区名称作为字符串返回，未知返回None

默认实现会引发NotImplementedError

. fromutc(dt)

在调用()时调整日期和时间数据

默认实现见官方文档

# 这些方法会被datetime或time对象调用。datetime对象会将自身作为传入参数，而time对象会将None作为传入参数

6. timezone(offset, name=None)

timezone类是tzinfo的子类，它的每个实例都代表一个以与UTC的固定时差来定义的时区。此类的对象不能代表某些特殊地点的时区信息（那些一年不同日期使用不同时差之类的地点）

offset——必须指定为一个timedelta对象，表示本地时间与UTC的时差。它必须严格限制于-timedelta(hours=24)和timedelta(hours=24)之间，否则会引发ValueError

name——如果指定则必须是一个字符串，它将被用作()的返回值

. utc类属性

UTC时区，timezone(timedelta(0))

. utcoffset(dt)

返回当timezone实例被构造时指定的固定值offset。dt参数会被忽略。返回值是一个timedelta实例，其值等于本地时间与UTC之间的时差

. tzname(dt)

返回当timezone实例被构造时指定的固定值name

如果在构造时没有提供name，则根据offset值按以下规则生成：

· 如果offset为timedelta(0)，则名称为"UTC"

· 否则为字符串UTC±HH:MM，其中±是offset的正负号，HH和MM分别为表示和的两个数码

. dst(dt)

总是返回None

. fromutc(dt)

返回dt + offset。dt参数必须是一个感知型datetime实例，且是self

. __str__()

对于timezone对象tz，str(tz)等价于(None)