时间常用模块time、datetime使用整理

python官方文档链接
内容介绍大多资料收集于官网文档，详情可点击上方官方文档链接；

一、time模块

1. 基本术语解释

• epoch 是时间开始的点，并且取决于平台。对于Unix， epoch 是1970年1月1日00:00:00（UTC）。要找出给定平台上的 epoch ，请查看 time.gmtime(0) 。

• 术语 Unix 纪元秒数 是指自国际标准时间 1970 年 1 月 1 日零时以来经过的总秒数，通常不包括 闰秒。 在所有符合 POSIX 标准的平台上，闰秒都会从总秒数中被扣除。

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

• 函数 strptime() 在接收到 %y 格式代码时可以解析 2 位数的年份。 当解析 2 位数年份时，会按照 POSIX 和 ISO C 标准进行转换：数值 69–99 映射为 1969–1999，而数值 0–68 被映射为 2000–2068。

• 时间值由 gmtime()，localtime() 和 strptime() 返回，并被 asctime()， mktime() 和 strftime() 接受，是一个 9 个整数的序列。 gmtime()， localtime() 和 strptime() 的返回值还提供各个字段的属性名称。

2. 相关函数

2.1 time.time()

• 返回以浮点数表示的从 epoch 开始的秒数的时间值.
• 返回的数字 time() 可以通过将其传递给 gmtime() 函数或转换为UTC中更常见的时间格式（即年、月、日、小时等）或通过将它传递给 localtime() 函数获得本地时间。在这两种情况下都返回一个 struct_time 对象，日历日期组件可以从中作为属性访问。

t = time.time()
# t:1589111305.5538309
t1 = gmtime(t)
# t1:time.struct_time(tm_year=2020, tm_mon=5, tm_mday=10, tm_hour=11, tm_min=48, tm_sec=25, tm_wday=6, tm_yday=131, tm_isdst=0)
year = struct_time.tm_year
# year: 2020
t2 = time.localtime(t)
# t2: time.struct_time(tm_year=2020, tm_mon=5, tm_mday=10, tm_hour=19, tm_min=48, tm_sec=25, tm_wday=6, tm_yday=131, tm_isdst=0)
# 中国的时区是东八区，在UTC的时间上加8个小时，返回中国本地时间

2.2. time.gmtime([secs])

• 将以自 epoch 开始的秒数表示的时间转换为 UTC 的 struct_time ，其中 dst 标志始终为零。 如果未提供 secs 或为 None ，则使用 time() 所返回的当前时间。 一秒以内的小数将被忽略。

2.3 time.localtime([secs])

• 与 gmtime() 相似但转换为当地时间。如果未提供 secs 或为 None ，则使用由 time() 返回的当前时间。当 DST 适用于给定时间时，dst标志设置为 1 。

2.4 time.mktime(t)

• 这是 localtime() 的反函数。它的参数是 struct_time 或者完整的 9 元组（因为需要 dst 标志；如果它是未知的则使用 -1 作为dst标志），它表示 local 的时间，而不是 UTC 。它返回一个浮点数，以便与 time() 兼容。如果输入值不能表示为有效时间，则 OverflowError 或 ValueError 将被引发（这取决于Python或底层C库是否捕获到无效值）。它可以生成时间的最早日期取决于平台。

a = "Sat Mar 28 22:24:24 2016"
# time.strptime方法将字符串按照格式转化成struct_time，time.mktime再接受struct_time参数转化成浮点时间
t = time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y"))
# t: 1459175064.0

2.5 time.perf_counter()

• 返回性能计数器的值（以小数秒为单位），即具有最高可用分辨率的时钟，以测量短持续时间。它确实包括睡眠期间经过的时间，并且是系统范围的。返回值的参考点未定义，因此只有连续调用结果之间的差异才有效。（3.3版本）
• time.perf_counter_ns()函数类同，返回的是纳秒；（3.7版本）

2.6 time.process_time()

• 返回当前进程的系统和用户CPU时间总和的值（以小数秒为单位）。它不包括睡眠期间经过的时间。根据定义，它在整个进程范围中。返回值的参考点未定义，因此只有连续调用结果之间的差异才有效。（3.3版本）
• time.process_time_ns()函数类同，返回的时间是纳秒；

2.7 time.sleep(secs)

• 暂停执行调用线程达到给定的秒数。参数可以是浮点数，以指示更精确的睡眠时间。实际的暂停时间可能小于请求的时间，因为任何捕获的信号将在执行该信号的捕获例程后终止 sleep() 。此外，由于系统中其他活动的安排，暂停时间可能比请求的时间长任意量。

'''制作一个loading的加载缓冲文字块'''
start = time.perf_counter()
for num in range(20):
    print('\rloading{}'.format('.' * (num % 5)),end='')
    time.sleep(0.5)
    print('\r{}'.format(' '* 20),end='')
end = time.perf_counter()
print('\rload complete!\nuse time:{0:.2f}s.'.format(end-start))

效果如下：

2.8 time.strftime(format[, t])

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

date_str = time.strftime('%Y-%m-%d',time.localtime())
# date_str: '2020-05-10'

format格式：

• 注释:
  当与 strptime() 函数一起使用时，如果使用 %I 指令来解析小时， %p 指令只影响输出小时字段。
  范围真的是 0 到 61 ；值 60 在表示 leap seconds 的时间戳中有效，并且由于历史原因支持值 61 。
  当与 strptime() 函数一起使用时， %U 和 %W 仅用于指定星期几和年份的计算。

2.9 time.strptime(string[,format])

• 根据格式解析表示时间的字符串。 返回值为一个被 gmtime() 或 localtime() 返回的 struct_time 。
• format 参数使用与 strftime() ；使用的指令相同的指令。它默认为匹配 ctime() 返回格式的 “%a %b %d %H:%M:%S %Y”` 。如果 string*不能根据 *format 解析，或者解析后它有多余的数据，则引发 ValueError 。当无法推断出更准确的值时，用于填充任何缺失数据的默认值是 (1900, 1, 1, 0, 0, 0, 0, 1, -1) 。 string 和 format 都必须是字符串。

t = time.strptime('2020-5-10','%Y-%m-%d')
# t: time.struct_time(tm_year=2020, tm_mon=5, tm_mday=10, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=131, tm_isdst=-1)

2.10 time.struct_time

• 返回的时间值序列的类型为 gmtime() 、 localtime() 和 strptime() 。它是一个带有 named tuple 接口的对象：可以通过索引和属性名访问值。
  

t = time.struct_time((2020,5,10,1,1,1,1,1,1))
month = t.tm_mon
# month: 5

---

二、datetime模块

1. 主要类对象

• class datetime.date
  一个理想化的简单型日期，它假设当今的公历在过去和未来永远有效。 属性: year, month, and day。
• class datetime.time
  一个独立于任何特定日期的理想化时间，它假设每一天都恰好等于 246060 秒。 （这里没有“闰秒”的概念。） 包含属性: hour, minute, second, microsecond 和 tzinfo。
• class datetime.datetime
  日期和时间的结合。属性：year, month, day, hour, minute, second, microsecond, and tzinfo.
• class datetime.timedelta
  表示两个 date 对象或者 time 对象,或者 datetime 对象之间的时间间隔，精确到微秒。
  date, datetime, time 和 timezone 类型共享这些通用特性:
  • 这些类型的对象都是不可变的。
  • 这些类型的对象是可哈希的，这意味着它们可被作为字典的键。
  • 这些类型的对象支持通过 pickle 模块进行高效的封存。

2. timedelta类

2.1 类相关说明

• timedelta 对象表示两个 date 或者 time 的时间间隔。
  class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)
• 所有参数都是可选的并且默认为 0。 这些参数可以是整数或者浮点数，也可以是正数或者负数。
• 只有 days, seconds 和 microseconds 会存储在内部。 参数单位的换算规则如下：
  • 1毫秒会转换成1000微秒。
  • 1分钟会转换成60秒。
  • 1小时会转换成3600秒。
  • 1星期会转换成7天。
• 并且 days, seconds, microseconds 会经标准化处理以保证表达方式的唯一性，即：
  • 0 <= microseconds < 1000000
  • 0 <= seconds < 3600*24 (一天的秒数)
  • -999999999 <= days <= 999999999

delta = datetime.timedelta(
	days=100,
	minutes=100,
	hours=200,
	weeks=2,
    microseconds=100,
    milliseconds=100000,
)
# delta: datetime.timedelta(days=122, seconds=34900, microseconds=100)
# 自动发成了转化，转化只保留了三个参数信息

2.2 类的属性

• timedelta.min
  时间间隔的最小值：timedelta(-999999999)
• timedelta.max
  最大值:timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999)
• timedelta.resolution
  两个不相等的 timedelta 类对象最小的间隔为 timedelta(microseconds=1)。
  需要注意的是，因为标准化的缘故，timedelta.max > -timedelta.min，-timedelta.max 不可以表示一个 timedelta 类对象。
• 只读属性
  days：-999999999 至 999999999 ，含999999999
  seconds：0 至 86399，包含86399
  microseconds：0 至 999999，包含999999

delta = datetime.timedelta(days=10,minutes=20)
delta.days
# 10
delta.seconds
# 1200

如果是增加或减少n个月可以使用dateutil模块

from dateutil.relativedelta import  relativedelta
import datetime
t = datetime.date(2020,1,31)
t1 = t + relativedelta(months=1)
# t1: datetime.date(2020, 2, 29)
# 2月没有31天，返回29天，月份最后一天；

2.3 支持的运算

2.4 timedelta.total_seconds()

• 返回时间间隔包含了多少秒。造价于 td / timedelta(seconds=1)。对于其它单位可以直接使用除法的形式 (例如 td / timedelta(microseconds=1))。
• 需要注意的是，时间间隔较大时，这个方法的结果中的微秒将会失真（大多数平台上大于270年视为一个较大的时间间隔）。

3. date类

3.1 相关介绍

• date 对象代表一个理想化历法中的日期（年、月和日），即当今的格列高利历向前后两个方向无限延伸。公元 1 年 1 月 1日是第 1 日，公元 1 年 1 月 2 日是第 2 日，依此类推。
• class datetime.date(year, month, day)
  所有参数都是必要的。 参数必须是在下面范围内的整数：
  • MINYEAR <= year <= MAXYEAR
  • 1 <= month <= 12
  • 1 <= 日期 <= 给定年月对应的天数

import datetime
t = datetime.date(2020,5,10)
# t: datetime.date(2020, 5, 10)

3.2 date类方法

3.2.1 date.today()

• 返回当前的本地日期，等价于date.fromtimestamp(time.time())

3.2.2 date.fromtimestamp(timestamp)

• 返回时间戳对应的日期

3.2.3 date.fromordinal(ordinal)

• 返回对应于预期格列高利历序号的日期，其中公元 1 年 1 月 1 晶的序号为 1。
• 除非 1 <= ordinal <= date.max.toordinal() 否则会引发 ValueError。对于任意日期 d，date.fromordinal(d.toordinal()) == d

3.2.4 date.fromisoformat(date_string)

• 返回一个对应于以 YYYY-MM-DD 格式给出的 date_string 的 date 对象。(3.7版本)
• 这是 date.isoformat() 的逆操作。 它只支持 YYYY-MM-DD 格式。

datetime.date.fromisoformat('2020-05-10')
# datetime.date(2020, 5, 10)
# 这里的月份比如填入两位：05，填5会报错;

3.2.5 classmethod date.fromisocalendar(year, week, day)

• 返回指定 year, week 和 day 所对应 ISO 历法日期的 date。 这是函数 date.isocalendar() 的逆操作。(3.8版本)

3.3 date类属性

• date.min
  最小的日期 date(MINYEAR, 1, 1) 。
• date.max
  最大的日期 ，date(MAXYEAR, 12, 31)。
• date.resolution
  两个日期对象的最小间隔，timedelta(days=1)
• date.year
  返回日期的年
• date.month
  返回日期的月份：1-12
• date.day
  返回日期的年月下天数

3.4 date方法

3.4.1 date.replace(year=self.year, month=self.month, day=self.day)

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

dt = datetime.date(2020,3,31)
dt.replace(month=2)
# 2月没有31天，报错ValueError；
dt.replace(month=5)
# datetime.date(2020, 5, 31)

3.4.2 date.timetuple()

• 返回一个 time.struct_time，即 time.localtime() 所返回的类型。
• hours, minutes 和 seconds 值均为 0，且 DST 旗标值为 -1
• date.timetuple()等价于

  time.struct_time((d.year, d.month, d.day, 0, 0, 0, d.weekday(), yday, -1))
  

3.4.3 date.weekday()

• 返回一个整数代表星期几，星期一为0，星期天为6。例如， date(2002, 12, 4).weekday() == 2，表示的是星期三。

3.4.4 date.isoweekday()

• 返回一个整数代表星期几，星期一为1，星期天为7。例如：date(2002, 12, 4).isoweekday() == 3,表示星期三。

3.4.5 date.isocalendar()

• 返回一个三元元组，(ISO year, ISO week number, ISO weekday)
• ISO 历法是一种被广泛使用的格列高利历。
• ISO 年由 52 或 53 个完整星期构成，每个星期开始于星期一结束于星期日。 一个 ISO 年的第一个星期就是（格列高利）历法的一年中第一个包含星期四的星期。 这被称为 1 号星期，这个星期四所在的 ISO 年与其所在的格列高利年相同。

'''
2020年1月1号为20年的第一周，19年12月30日为20年第一周的第一天:1;
20年1月5号为20年第一周的最后一天:7
'''
datetime.date(2019,12,30).isocalendar()
# (2020, 1, 1)
datetime.date(2020,1,5).isocalendar()
# (2020, 1, 7)

3.4.6 date.toordinal()

• 返回日期的预期格列高利历序号，其中公元 1 年 1 月 1 日的序号为 1。 对于任意 date 对象 d，date.fromordinal(d.toordinal()) == d。

3.4.7 date.isoformat()

• 返回一个以 ISO 8601 格式 YYYY-MM-DD 来表示日期的字符串。
• 这是 date.fromisoformat() 的逆操作。

datetime.date(2020,5,10).isoformat()
# '2020-05-10'

3.4.8 date.str()

• 对于日期对象 d, str(d) 等价于 d.isoformat()

datetime.date(2020,5,10).__str__()
# '2020-05-10'

3.4.9 date.ctime()

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

datetime.date(2020,5,10).ctime()
# 'Sun May 10 00:00:00 2020'
# 等价于
time.ctime(time.mktime(d.timetuple()))

3.4.10 date.strftime(format)

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

t = datetime.date(2020,5,10)
t_str = t.strftime('%Y%m%d')
t1 = datetime.datetime.strptime(t_str,'%Y%m%d')
# t: datetime.date(2020, 5, 10)
# t_str: '20200510'
# t1: datetime.datetime(2020, 5, 10, 0, 0)

3.4.11 date.format(format)

• 与date.strftime()方法相同

4. datetime类

4.1 类相关说明

• datetime 对象是包含来自 date 对象和 time 对象的所有信息的单一对象。
• class datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)
  • year, month 和 day 参数是必须的。

4.2 datetime类方法

4.2.1 datetime.today()

• 返回表示当前地方时的 datetime 对象，其中 tzinfo 为 None。，等价于datetime.fromtimestamp(time.time())

t = datetime.datetime.today()
t1 = datetime.fromtimestamp(time.time())
# datetime.datetime(2020, 5, 10, 23, 59, 44, 967247)
t2 = datetime.datetime.now()
# datetime.datetime(2020, 5, 11, 0, 0, 9, 125297)

4.2.2 datetime.now(tz=None)

• 返回表示当前地方时的 date 和 time 对象。
• 如果可选参数 tz 为 None 或未指定，这就类似于 today()，但该方法会在可能的情况下提供比通过 time.time() 时间戳所获时间值更高的精度（例如，在提供了 C gettimeofday() 函数的平台上就可以做到这一点）。
• 如果 tz 不为 None，它必须是 tzinfo 子类的一个实例，并且当前日期和时间将被转换到 tz 时区。
• 此函数可以替代 today() 和 utcnow()。

4.2.3 datetime.utcnow()

• 返回表示当前 UTC 时间的 date 和 time，其中 tzinfo 为 None。
• 这类似于 now()，但返回的是当前 UTC 日期和时间，类型为简单型 datetime 对象。 感知型的当前 UTC 日期时间可通过调用 datetime.now(timezone.utc) 来获得。 另请参阅 now()。

4.2.4 datetime.fromtimestamp(timestamp, tz=None)

• 返回对应于 POSIX 时间戳例如 time.time() 的返回值的本地日期和时间。 如果可选参数 tz 为 None 或未指定，时间戳会被转换为所在平台的本地日期和时间，返回的 datetime 对象将为天真型。
• 如果 tz 不为 None，它必须是 tzinfo 子类的一个实例，并且时间戳将被转换到 tz 指定的时区。

4.2.5 datetime.utcfromtimestamp(timestamp)

• 返回对应于 POSIX 时间戳的 UTC datetime，其中 tzinfo 值为 None。 （结果为简单型对象。）

4.2.6 datetime.fromordinal(ordinal)

• 返回对应于预期格列高利历序号的 datetime，其中公元 1 年 1 月 1 日的序号为 1。 除非 1 <= ordinal <= datetime.max.toordinal() 否则会引发 ValueError。 结果的 hour, minute, second 和 microsecond 值均为 0，并且 tzinfo 值为 None。

4.2.7 datetime.combine(date, time, tzinfo=self.tzinfo)

• 返回一个新的 datetime 对象，对象的日期部分等于给定的 date 对象的值，而其时间部分等于给定的 time 对象的值。 如果提供了 tzinfo 参数，其值会被用来设置结果的 tzinfo 属性，否则将使用 time 参数的 tzinfo 属性。
• 对于任意 datetime 对象 d，d == datetime.combine(d.date(), d.time(), d.tzinfo)。 如果 date 是一个 datetime 对象，它的时间部分和 tzinfo 属性(3.6版本添加参数)会被忽略。

4.2.8 datetime.fromisoformat(date_string)

• 返回一个对应于 date.isoformat() 和 datetime.isoformat() 所提供的某一种 date_string 的 datetime 对象。（3.7版本）
• 支持的格式：

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

4.2.9 datetime.fromisocalendar(year, week, day)

• 返回以 year, week 和 day 值指明的 ISO 历法日期所对应的 datetime。 该datetime 对象的非日期部分将使用其标准默认值来填充。 这是函数 datetime.isocalendar() 的逆操作。

4.2.10 datetime.strptime(date_string, format)

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

t_str = '2020-5-10'
t = datetime.datetime.strptime(t_str,'%Y-%m-%d')

# 字符串转化日期，如果知道日期格式的话，使用下面方式比strptime要快五六倍。
def parse_ymd(s):
    year_s, mon_s, day_s = s.split('-')
    return datetime.date(int(year_s), int(mon_s), int(day_s))

4.3 类属性

• datetime.min
• datetime.max
• datetime.resolution
  两个不相等的 datetime 对象之间可能的最小间隔，timedelta(microseconds=1)
• datetime.year
• datetime.month
• datetime.day
• datetime.hour
  取值范围是 range(24)
• datetime.minute
  取值范围是 range(60)
• datetime.second
  取值范围是 range(60)
• datetime.microsecond
  取值范围是 range(1000000)。
• datetime.tzinfo
  作为 tzinfo 参数被传给 datetime 构造器的对象，如果没有传入值则为 None。
• datetime.flod
  取值范围是 [0, 1]。 用于在重复的时间段中消除边界时间歧义。 （当夏令时结束时回拨时钟或由于政治原因导致当明时区的 UTC 时差减少就会出现重复的时间段。） 取值 0 (1) 表示两个时刻早于（晚于）所代表的同一边界时间。(3.6版本)

4.4 实例方法

4.4.1 datetime.date()

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

4.4.2 datetime.time()

• 返回具有同样 hour, minute, second, microsecond 和 fold 值的 time 对象。 tzinfo 值为 None。 另请参见 timetz() 方法。
• 在 3.6 版更改: fold 值会被复制给返回的 time 对象。

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

• 返回一个具有同样属性值的 datetime，除非通过任何关键字参数为某些属性指定了新值。 请注意可以通过指定 tzinfo=None 来从一个感知型 datetime 创建一个简单型 datetime 而不必转换日期和时间数据。

4.4.4 datetime.timetuple()

• 返回一个 time.struct_time，即 time.localtime() 所返回的类型。

4.4.5 datetime.toordinal()

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

4.4.6 datetime.timestamp()

• 返回对应于 datetime 实例的 POSIX 时间戳。 此返回值是与 time.time() 返回值类似的 float 对象。
• 简单型 datetime 实例会假定为代表本地时间，并且此方法依赖于平台的 C mktime() 函数来执行转换。 由于在许多平台上 datetime 支持的范围比 mktime() 更广，对于极其遥远的过去或未来此方法可能引发 OverflowError。

4.4.7 datetime.weekday()

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

4.4.8 datetime.isoweekday()

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

4.4.9 datetime.isocalendar()

• 返回一个 3 元组 (ISO 年份, ISO 周序号, ISO 周日期)。 等同于 self.date().isocalendar()

4.4.10 datetime.isoformat(sep=‘T’, timespec=‘auto’)

• 返回一个以 ISO 8601 格式表示的日期和时间字符串：
  YYYY-MM-DDTHH:MM:SS.ffffff，如果 microsecond 不为 0
  YYYY-MM-DDTHH:MM:SS，如果 microsecond 为 0
• 如果 utcoffset() 返回值不为 None，则添加一个字符串来给出 UTC 时差：
  YYYY-MM-DDTHH:MM:SS.ffffff+HH:MM[:SS[.ffffff]]，如果 microsecond 不为 0
  YYYY-MM-DDTHH:MM:SS+HH:MM[:SS[.ffffff]]，如果 microsecond 为 0
• 可选参数 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:SS.sss
  ‘microseconds’: 以 HH:MM:SS.ffffff 格式包含完整时间。

4.4.11 datetime.str()

• 对于 datetime 实例 d，str(d) 等价于 d.isoformat(’ ')。

4.4.12 datetime.ctime()

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

datetime.datetime(2020,5,10,11,30,23).ctime()
# 'Sun May 10 11:30:23 2020'

4.4.13 datetime.strftime(format)

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

4.14 datetime.format(format)

• 与 datetime.strftime() 相同。 此方法使得为 datetime 对象指定以 格式化字符串字面值 表示的格式化字符串以及使用 str.format() 进行格式化成为可能。

5. time类

5.1 相关介绍

• 一个 time 对象代表某日的（本地）时间，它独立于任何特定日期，并可通过 tzinfo 对象来调整。
• class datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)
  • 所有参数都是可选的。 tzinfo 可以是 None，或者是一个 tzinfo 子类的实例。 其余的参数必须是在下面范围内的整数：
    0 <= hour < 24,
    0 <= minute < 60,
    0 <= second < 60,
    0 <= microsecond < 1000000,
    fold in [0, 1].
• 如果给出一个此范围以外的参数，则会引发 ValueError。 所有参数值默认为 0，只有 tzinfo 默认为 None。
• 该类方法、属性大多与date、datetime相同，详情可以dir(datetime.time)

三、calendar模块

1. 常用方法

1.1 calendar.isleap(year)

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

1.2 calendar.weekday(year,month,day)

• 返回指定年、月、日是星期几（0是星期一）

1.3 calendar.monthrange(year,month)

• 返回指定年、月的第一天是星期几，以及这个月的天数

calendar.monthrange(2020,1)
# (2, 31)
# 2020年1月第一天是星期3，这个月有31天

1.4 calendar.timegm(tuple)

• 一个不相关但很好用的函数，它接受一个时间元组例如 time 模块中的 gmtime() 函数的返回并返回相应的 Unix 时间戳值，假定 1970 年开始计数， POSIX 编码。实际上， time.gmtime() 和 timegm() 是彼此相反的。