Python中的日期和时间

Python处理时间的对象很多，常用的有time、datetime和calendar等。本文对常用的时间对象的使用进行学习。在开始学习具体的对象前，先学习几个计算机的时间概念。

UTC（全球标准时间）:是全球范围内计时的科学标准，它基于精心维护的原子钟，在全球范围内精确到微秒，由于英文（CUT）和法文（TUC）的缩写不同，作为妥协，简称UTC。作为全球最精确的时间系统，天文学家、航海家、“太空跟踪网”(DSN) 以及其他科学性学科都使用它,它的参考点是英国格林威治标准时间（GMT）：地球本初子午线的午夜，也是 UTC 的午夜 (00:00:00.000000)。本地时间是根据地球上不同时区所处的位置调整 UTC 得来的，比如当美国加州的太平洋时间为正午12:00:00 时，UTC 为 20:00:00。

夏令时（DST）:表示为了节约能源， 人为规定时间的意思。也叫夏时制，夏时令（Daylight Saving Time：DST），又称"日光节约时制"和"夏令时间”，在这一制度实行期间所采用的统一时间称为“夏令时间”。一般在天亮早的夏季人为将时间调快一小时，可以使人早起早睡，减少照明量，以充分利用光照资源，从而节约照明用电。各个采纳夏时制的国家具体规定不同。全世界有近110个国家每年要实行夏令时。

感知型”和“简单型”对象：日期和时间对象可以根据它们是否包含时区信息而分为“感知型”和“简单型”两类。充分掌握应用性算法和政治性时间调整信息例如时区和夏令时的情况下，一个 感知型 对象就能相对于其他感知型对象来精确定位自身时间点。 感知型对象是用来表示一个没有解释空间的固定时间点。简单型对象没有包含足够多的信息来无歧义地相对于其他 date/time 对象来定位自身时间点。

时间戳：Unix时间戳是从1970年1月1日（UTC/GMT的午夜）开始所经过的秒数，不考虑闰秒。 Unix时间戳（英文为Unix epoch, Unix time, POSIX time 或 Unix timestamp）

import time 
time.time() 
1625483470.3409266

datetime模块

datetime 模块中的常用类即date、datetime、time、timedelta、timezone、tzinfo。其中date、datetime、time三个类有非常相似的属性和方法。

datetime模块中常用的对象：

对象	描述	类型
MAXYEAR	9999，指能支持的最大年份	int
MINYEAR	1，指能支持的最小年份	int
date	简单型日期，常用的属性有year, month, day	type
datetime	表示日期时间的类，常用的属性有hour, minute, second, microsecond	type
datetime_CAPI	后面详细描述	'PyCapsule' 类
sys	各种系统信息	'module'类
time	表示时间的类，包含属性：hour、minute、second、microsecond 、tzinfo	type
timedelta	表示时间间隔，即两个时间点的间隔。在日期上做天days，小时hour，分钟，秒，毫秒，微妙的时间计算	type
timezone	表示时区的类	type
tzinfo	时区的相关信息	type

datetime.date

语法：

datetime.date(year, month, day)

参数：

1. year年份、month月份及day日期，所有参数都是必要的， 参数必须是在下面范围内的整数
2. MINYEAR <= year <= MAXYEAR
3. 1 <= month <= 12
4. 1 <= day<= 给定年月对应的天数

import datetime
t = datetime.date(2019,8,26)
print(type(t))
print(t.day,t.month,t.year) # 
26 8 2019

主要属性

date.min、date.max、date.resolution

date.min:最小日期

date.max:最大日期

date.resolution: 两个日期对象的最小间隔

from datetime import date

print(date.min) #0001-01-01
print(date.max) #9999-12-31
print(date.resolution) #1 day, 0:00:00

date.year、date.month、date.day

分别是年、月、日

from datetime import date

today = date.today()
print(f'{today.year=}')
print(f'{today.month=}')
print(f'{today.day=}')

‘’’
today.year=2023
today.month=9
today.day=7
‘’’

主要方法

获取今天日期

classmethod date.today()

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

from datetime import date 
date.today()
datetime.date(2021, 7, 4)

时间戳转换为date

classmethod date.fromtimestamp(timestamp)

返回对应于POSIX时间戳的当地时间，例如 time.time() 返回的就是时间戳。注意： unix时间戳是从1970年1月1日（UTC/GMT的午夜）开始所经过的秒数，不考虑闰秒。

from datetime import date
date.fromtimestamp(1339119900000/1e3).strftime('%Y-%m-%d %H:%M')
'2012-06-07 00:00'
date.fromtimestamp(1339120800000/1e3).strftime('%Y-%m-%d %H:%M')
'2012-06-07 00:00'

字符串与date的相互转换

date.fromisoformat(date_string)

返回一个对应于以 YYYY-MM-DD 格式给出的 date_string 的 date 对象

>>>from datetime import date
>>>date.fromisoformat('2019-12-04')
datetime.date(2019, 12, 4)
>>>date.fromisoformat('20191204')
datetime.date(2019, 12, 4)
>>>date.fromisoformat('2021-W01-1')
datetime.date(2021, 1, 4)

这是 date.isoformat() 的逆操作。 它只支持 YYYY-MM-DD 格式。 更通用的要用strptime

d.isoformat()
'2002-03-11'

__str__()也是等价于date.isoformat()

from datetime import date
date(2021, 10, 1).__str__()
'2021-10-01'


str(date(2021, 10, 1))
'2021-10-01'

日期格式化

date.strftime(format)

将给定格式的日期时间对象转换为字符串

import datetime


dt=datetime.date(2021, 10, 1)#创建一个日期对象
dt.strftime("%Y-%m-%d")
'2021-10-01'


dt.strftime("%Y年%m月%d日")
'2021年10月01日'


dt.strftime("%Y//%m//%d")
'2021//10//01'


dt.strftime("%Y-%m-%d %H:%M")
'2021-10-01 00:00'


dt.strftime("%A, %d. %B %Y %I:%M%p")
'Friday, 01. October 2021 12:00AM'

__format__()与 date.strftime() 相同。

格式化代码

以下列表显示了 1989 版 C 标准所要求的全部格式代码，它们在带有标准 C 实现的所有平台上均可用。 

指令	含意	示例	备注
%a	当地工作日的缩写。	Sun, Mon, ..., Sat (en_US); So, Mo, ..., Sa (de_DE)	(1)
%A	本地化的星期中每日的完整名称。	Sunday, Monday, ..., Saturday (en_US); Sonntag, Montag, ..., Samstag (de_DE)	(1)
%w	以十进制数显示的工作日，其中0表示星期日，6表示星期六。	0, 1, ..., 6
%d	补零后，以十进制数显示的月份中的一天。	01, 02, ..., 31	(9)
%b	当地月份的缩写。	Jan, Feb, ..., Dec (en_US); Jan, Feb, ..., Dez (de_DE)	(1)
%B	本地化的月份全名。	January, February, ..., December (en_US); Januar, Februar, ..., Dezember (de_DE)	(1)
%m	补零后，以十进制数显示的月份。	01, 02, ..., 12	(9)
%y	补零后，以十进制数表示的，不带世纪的年份。	00, 01, ..., 99	(9)
%Y	十进制数表示的带世纪的年份。	0001, 0002, ..., 2013, 2014, ..., 9998, 9999	(2)
%H	以补零后的十进制数表示的小时（24 小时制）。	00, 01, ..., 23	(9)
%I	以补零后的十进制数表示的小时（12 小时制）。	01, 02, ..., 12	(9)
%p	本地化的 AM 或 PM 。	AM, PM (en_US); am, pm (de_DE)	(1), (3)
%M	补零后，以十进制数显示的分钟。	00, 01, ..., 59	(9)
%S	补零后，以十进制数显示的秒。	00, 01, ..., 59	(4), (9)
%f	微秒作为一个十进制数，零填充到 6 位。	000000, 000001, ..., 999999	(5)
%z	UTC 偏移量，格式为 ±HHMM[SS[.ffffff]] （如果是简单型对象则为空字符串）。	(空), +0000, -0400, +1030, +063415, -030712.345216	(6)
%Z	时区名称（如果对象为简单型则为空字符串）。	(空), UTC, GMT	(6)
%j	以补零后的十进制数表示的一年中的日序号。	001, 002, ..., 366	(9)
%U	以补零后的十进制数表示的一年中的周序号（星期日作为每周的第一天）。 在新的一年中第一个星期日之前的所有日子都被视为是在第 0 周。	00, 01, ..., 53	(7), (9)
%W	以补零后的十进制数表示的一年中的周序号（星期一作为每周的第一天）。 在新的一年中第一个星期一之前的所有日子都被视为是在第 0 周。	00, 01, ..., 53	(7), (9)
%c	本地化的适当日期和时间表示。	Tue Aug 16 21:30:00 1988 (en_US); Di 16 Aug 21:30:00 1988 (de_DE)	(1)
%x	本地化的适当日期表示。	08/16/88 (None); 08/16/1988 (en_US); 16.08.1988 (de_DE)	(1)
%X	本地化的适当时间表示。	21:30:00 (en_US); 21:30:00 (de_DE)	(1)
%%	字面的 '%' 字符。	%

为了方便起见，还包括了C89标准不需要的其他一些指令。这些参数都对应于ISO 8601日期值。

指令	含意	示例	备注
%G	带有世纪的 ISO 8601 年份，表示包含大部分 ISO 星期 (%V) 的年份。	0001, 0002, ..., 2013, 2014, ..., 9998, 9999	(8)
%u	以十进制数显示的 ISO 8601 星期中的日序号，其中 1 表示星期一。	1, 2, ..., 7
%V	以十进制数显示的 ISO 8601 星期，以星期一作为每周的第一天。 第 01 周为包含 1 月 4 日的星期。	01, 02, ..., 53	(8), (9)

这些代码可能不是在所有平台上都可与 strftime() 方法配合使用。 

替换日期

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

返回被替换了年、月、日的日期，如果都没指定参数，返回一个具有同样值的日期

from datetime import date
d = date(2002, 12, 31)
d.replace(day=26)
#datetime.date(2002, 12, 26)

转换C标准格式

date.timetuple(d)

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

d = date(2002, 12, 31)
date.timetuple(d)
time.struct_time(tm_year=2002, tm_mon=12, tm_mday=31, 
tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=365, 
tm_isdst=-1)

date.ctime()

返回一个表示日期的字符串，在原生 C ctime() 函数 (time.ctime() 会发起调用该函数，但 date.ctime() 则不会) 遵循 C 标准的平台上。

from datetime import date
date(2021, 10, 1).ctime()
'Fri Oct  1 00:00:00 2021'

date.ctime() 等效于 time.ctime(time.mktime(d.timetuple()))

d=date(2021, 10, 1)
import time
time.ctime(time.mktime(d.timetuple()))
'Fri Oct  1 00:00:00 2021'

星期几

date.weekday()

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

date.isoweekday()

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

print(f'{date(2023,9,7).weekday()=}') #date(2023,9,7).weekday()=3
print(f'{date(2023,9,7).isoweekday()=}') #date(2023,9,7).weekday()=4

支持的运算

运算	结果：
date2 = date1 + timedelta	date2 将为 date1 之后的 timedelta.days 日。 (1)
date2 = date1 - timedelta	计算 date2 的值使得 date2 + timedelta == date1。 (2)
timedelta = date1 - date2	(3)
date1 < date2	如果 date1 的时间在 date2 之前则认为 date1 小于 date2 。 (4)

注释：

1. 如果 timedelta.days > 0 则 date2 将在时间线上前进，如果 timedelta.days < 0 则将后退。 操作完成后 date2 - date1 == timedelta.days。 timedelta.seconds 和 timedelta.microseconds 会被忽略。 如果 date2.year 将小于 MINYEAR 或大于 MAXYEAR 则会引发 OverflowError。
2. timedelta.seconds 和 timedelta.microseconds 会被忽略。
3. 此值完全精确且不会溢出。 操作完成后 timedelta.seconds 和 timedelta.microseconds 均为 0，并且 date2 + timedelta == date1。
4.  日期比较时，如果两个值不都是日期，会引发 TypeError。

在布尔运算中，所有 date 对象都会被视为真值。

>>>import time
>>>from datetime import date
>>>today = date.today()
>>>today
datetime.date(2007, 12, 5)
>>>today == date.fromtimestamp(time.time())
True
>>>my_birthday = date(today.year, 6, 24)
>>>if my_birthday < today:
    my_birthday = my_birthday.replace(year=today.year + 1)
>>>my_birthday
datetime.date(2008, 6, 24)
>>>time_to_birthday = abs(my_birthday - today)
>>>time_to_birthday.days
202

datetime.time

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

语法： 

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

1. 所有参数都是可选的，tzinfo 可以是 None，或者是一个 tzinfo 子类的实例。 其余的参数必须是在下面范围内的整数：
2. 0 <= hour < 24
3. 0 <= minute < 60
4. 0 <= second < 60
5. 0 <= microsecond < 1000000
6. fold in [0, 1]

主要属性

time.min、time.max、time.resolution

分别是最小、最大时间、最小时间间隔

from datetime import time

print(f'{time.min=}')
print(f'{time.max=}')
print(f'{time.resolution=}')

# time.min=datetime.time(0, 0)
# time.max=datetime.time(23, 59, 59, 999999)
# time.resolution=datetime.timedelta(microseconds=1)

time.hour、time.minute、time.second、time. microsecond

分别标识时间对象的小时、分钟、秒和毫秒

from datetime import time

t0 = time(18,26,31,100)

print(f'{t0.hour=}')
print(f'{t0.minute=}')
print(f'{t0.second=}')
print(f'{t0.microsecond=}')

# t0.hour=18
# t0.minute=26
# t0.second=31
# t0.microsecond=100

时区time.tzinfo

返回时区信息

time.fold

主要方法

字符串与time转换

time.isoformat(timespec='auto')

格式化为标准时间的字符串

from datetime import time
t = time(hour=12, minute=34, second=56, microsecond=123456)
t.isoformat()
'12:34:56.123456'


t.isoformat(timespec='minutes')
'12:34'


dt = time(hour=12, minute=34, second=56, microsecond=0)
dt.isoformat(timespec='microseconds')
'12:34:56.000000'


dt.isoformat(timespec='auto')
'12:34:56'

按标准格式从字符串转换为time

time.fromisoformat(time_string)

返回对应于 time.isoformat() 所提供的某种 time_string 格式的 time。 特别地，此函数支持以下格式的字符串：HH[:MM[:SS[.fff[fff]]]][+HH:MM[:SS[.ffffff]]]

time.fromisoformat('04:23:01')
 datetime.time(4, 23, 1)


time.fromisoformat('04:23:01.000384')
datetime.time(4, 23, 1, 384)


time.fromisoformat('04:23:01+04:00')
datetime.time(4,23,1, tzinfo=datetime.timezone(datetime.timedelta(seconds=14400)))

__str__()

str(t) 等价于 t.isoformat()

time.strftime(format)

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

from datetime import time
t = time(hour=12, minute=3, second=56)
t.strftime('%H:%M:%S')
#用:分隔
'12:03:56'
#用%分隔
t.strftime('%H%%%M%%%S')
'12%03%56'

__format__()

与 time.strftime() 相同

替换时间

time.replace(hour=self.hour, minute=self.minute, second=self.second,

microsecond=self.microsecond, tzinfo=self.tzinfo, *, fold=0)

返回指定替换的时间，如果都没指定，返回同样时间的值

t = time(hour=12, minute=34, second=56, microsecond=123456)
t.replace(hour=23, minute=12,)
datetime.time(23, 12, 56, 123456)

datetime.datetime

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

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

year, month 和 day 参数是必须的。 tzinfo 可以是 None 或者是一个 tzinfo 子类的实例。 其余的参数必须是在下面范围内的整数：

• MINYEAR <= year <= MAXYEAR,
• 1 <= month <= 12,
• 1 <= day <= 指定年月的天数,
• 0 <= hour < 24,
• 0 <= minute < 60,
• 0 <= second < 60,
• 0 <= microsecond < 1000000,
• fold in [0, 1].

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

主要属性

支持date和time的全部属性。

主要方法

获取当日时间

classmethod datetime.today()

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

等价于：

datetime.fromtimestamp(time.time())

classmethod datetime.now(tz=None)

返回表示当前地方时的 date 和 time 对象。

如果可选参数 tz 为 None 或未指定，这就类似于 today()，但该方法会在可能的情况下提供比通过 time.time() 时间戳所获时间值更高的精度（例如，在提供了 C gettimeofday() 函数的平台上就可以做到这一点）。

如果 tz 不为 None，它必须是 tzinfo 子类的一个实例，并且当前日期和时间将被转换到 tz 时区。

此函数可以替代 today() 和 utcnow()。

classmethod datetime.utcnow()

返回表示当前 UTC 时间的 date 和 time，其中 tzinfo 为 None。

这类似于 now()，但返回的是当前 UTC 日期和时间，类型为简单型 datetime 对象。 感知型的当前 UTC 日期时间可通过调用 datetime.now(timezone.utc) 来获得。

由于简单型 datetime 对象会被许多 datetime 方法当作本地时间来处理，最好是使用感知型日期时间对象来表示 UTC 时间。 因此，创建表示当前 UTC 时间的对象的推荐方式是通过调用 datetime.now(timezone.utc)。

时间戳与datetime转换

classmethod datetime.fromtimestamp(timestamp, tz=None)

返回 POSIX 时间戳对应的本地日期和时间，如 time.time() 返回的。 如果可选参数 tz 指定为 None 或未指定，时间戳将转换为平台的本地日期和时间，并且返回的 datetime 对象将为简单型。

如果 tz 不为 None，它必须是 tzinfo 子类的一个实例，并且时间戳将被转换到 tz 指定的时区。

fromtimestamp() 可能会引发 OverflowError，如果时间戳数值超出所在平台 C localtime() 或 gmtime() 函数的支持范围的话，并会在 localtime() 或 gmtime() 报错时引发 OSError。 通常该数值会被限制在 1970 年至 2038 年之间。 请注意在时间戳概念包含闰秒的非 POSIX 系统上，闰秒会被 fromtimestamp() 所忽略，结果可能导致两个相差一秒的时间戳产生相同的 datetime 对象。 相比 utcfromtimestamp() 更推荐使用此方法。

在 3.3 版更改: 引发 OverflowError 而不是 ValueError，如果时间戳数值超出所在平台 C localtime() 或 gmtime() 函数的支持范围的话。 并会在 localtime() 或 gmtime() 出错时引发 OSError 而不是 ValueError。

classmethod datetime.utcfromtimestamp(timestamp)

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

这可能引发 OverflowError，如果时间戳数值超出所在平台 C gmtime() 函数的支持范围的话，并会在 gmtime() 报错时引发 OSError。 通常该数值会被限制在 1970 至 2038 年之间。

要得到一个感知型 datetime 对象，应调用 fromtimestamp():

datetime.fromtimestamp(timestamp, timezone.utc)
在 POSIX 兼容的平台上，它等价于以下表达式:

datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(seconds=timestamp)
不同之处在于后一种形式总是支持完整年份范围：从 MINYEAR 到 MAXYEAR 的开区间。

警告 由于简单型 datetime 对象会被许多 datetime 方法当作本地时间来处理，最好是使用感知型日期时间对象来表示 UTC 时间。 因此，创建表示特定 UTC 时间戳的日期时间对象的推荐方式是通过调用 datetime.fromtimestamp(timestamp, tz=timezone.utc)。
在 3.3 版更改: 引发 OverflowError 而不是 ValueError，如果时间戳数值超出所在平台 C gmtime() 函数的支持范围的话。 并会在 gmtime() 出错时引发 OSError 而不是 ValueError。

组合时间和日期

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

将日期和时间对象组合成一个datetime对象。

任意的 datetime object d：

 d == datetime.combine(d.date(), d.time(), d.tzinfo). 

字符串与datetime的转换

classmethod datetime.fromisoformat(date_string)

将datetime转换为标准字符串

>>>from datetime import datetime
>>>datetime.fromisoformat('2011-11-04')
datetime.datetime(2011, 11, 4, 0, 0)
>>>datetime.fromisoformat('20111104')
datetime.datetime(2011, 11, 4, 0, 0)
>>>datetime.fromisoformat('2011-11-04T00:05:23')
datetime.datetime(2011, 11, 4, 0, 5, 23)
>>>datetime.fromisoformat('2011-11-04T00:05:23Z')
datetime.datetime(2011, 11, 4, 0, 5, 23, tzinfo=datetime.timezone.utc)
>>>datetime.fromisoformat('20111104T000523')
datetime.datetime(2011, 11, 4, 0, 5, 23)
>>>datetime.fromisoformat('2011-W01-2T00:05:23.283')
datetime.datetime(2011, 1, 4, 0, 5, 23, 283000)
>>>datetime.fromisoformat('2011-11-04 00:05:23.283')
datetime.datetime(2011, 11, 4, 0, 5, 23, 283000)
>>>datetime.fromisoformat('2011-11-04 00:05:23.283+00:00')
datetime.datetime(2011, 11, 4, 0, 5, 23, 283000, tzinfo=datetime.timezone.utc)
>>>datetime.fromisoformat('2011-11-04T00:05:23+04:00')   
datetime.datetime(2011, 11, 4, 0, 5, 23,tzinfo=datetime.timezone(datetime.timedelta(seconds=14400)))

classmethod datetime.strptime(date_string, format)

按格式转换

支持的运算

datetime.timedelta

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天。

日期、秒、微秒都是标准化的，所以它们的表达方式也是唯一的，例：

• 0 <= microseconds < 1000000
• 0 <= seconds < 3600*24 (一天的秒数)
• -999999999 <= days <= 999999999

>>>from datetime import timedelta
>>>delta = timedelta(
    days=50,
    seconds=27,
    microseconds=10,
    milliseconds=29000,
    minutes=5,
    hours=8,
    weeks=2
)
>>># Only days, seconds, and microseconds remain
>>>delta
datetime.timedelta(days=64, seconds=29156, microseconds=10)

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

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

请注意对负数值进行标准化的结果可能会令人感到惊讶。 例如:

>>>from datetime import timedelta
>>>d = timedelta(microseconds=-1)
>>>(d.days, d.seconds, d.microseconds)
(-1, 86399, 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)(6)
t1 = t2 * i or t1 = i * t2	乘以一个整数。运算后假如 i != 0 则 t1 // i == t2 必为真值。
	In general, t1 * i == t1 * (i-1) + t1 is true. (1)
t1 = t2 * f or t1 = f * t2	乘以一个浮点数，结果会被舍入到 timedelta 最接近的整数倍。 精度使用四舍五偶入奇不入规则。
f = t2 / t3	总时间 t2 除以间隔单位 t3 (3)。 返回一个 float对象。
t1 = t2 / f or t1 = t2 / i	除以一个浮点数或整数。 结果会被舍入到 timedelta 最接近的整数倍。 精度使用四舍五偶入奇不入规则。
t1 = t2 // i or t1 = t2 // t3	计算底数，其余部分（如果有）将被丢弃。在第二种情况下，将返回整数。 （3）
t1 = t2 % t3	余数为一个 timedelta 对象。(3)
q, r = divmod(t1, t2)	通过 : q = t1 // t2 (3) and r = t1 % t2 计算出商和余数。q是一个整数，r是一个 timedelta 对象。
+t1	返回一个相同数值的 timedelta 对象。
-t1	等价于 timedelta(-t1.days, -t1.seconds, -t1.microseconds), 和 t1* -1. (1)(4)
abs(t)	当 t.days >= 0 时等于 +t, 当 t.days < 0 时 -t 。 (2)
str(t)	返回一个形如 [D day[s], ][H]H:MM:SS[.UUUUUU] 的字符串，当 t 为负数的时候， D 也为负数。 (5)
repr(t)	返回一个 timedelta 对象的字符串表示形式，作为附带正规属性值的构造器调用。

tzinfo对象、timezone对象

tzinfo是一个抽象基类，也就是说该类不应被直接实例化，指示特定时区的信息。

datetime 模块提供了 timezone，这是 tzinfo 的一个简单实体子类，它能以与 UTC 的固定差值来表示不同的时区，例如 UTC 本身或北美的 EST 和 EDT。

timezone 类是 tzinfo 的子类，它的每个实例都代表一个以与 UTC 的固定时差来定义的时区。

此类的对象不可被用于代表某些特殊地点的时区信息，这些地点在一年的不同日期会使用不同的时差，或是在历史上对民用时间进行过调整。

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

name 参数是可选的。 如果指定则必须为一个字符串，它将被用作 datetime.tzname() 方法的返回值。

import datetime
dt = datetime.datetime(2022, 9, 10, 1, 21, 32, 676435)
tm = datetime.timezone(datetime.timedelta(hours = 2), name = "CET")
dt = dt.astimezone(tm)
print("CET:", dt)
print("UTC Offset:", tm.utcoffset(None))
print("Name of the Timezone:", tm.tzname(None))
print("DST: ", tm.dst(None))
print("From UTC:", tm.fromutc(dt))

‘’'
CET: 2022-09-10 03:21:32.676435+02:00
UTC Offset: 2:00:00
Name of the Timezone: CET
DST: None
From UTC: 2022-09-10 05:21:32.676435+02:00
‘''

上面的代码首先创建了一个datetime 对象，并使用timezone 类声明了一个时区。我们声明CET，它是UTC+02:00 。

接下来，使用datetime 对象上可用的astimezone() ，我们创建了一个有时间区的日期时间对象。我们使用tzinfo 抽象类所包含的、在timezone 类中实现的所有四个方法。

由于没有关于日照周期的细节，dst() 方法返回None 。

time模块

time 模块既有时间处理的，也有转换时间格式的。time模块有许多UNIX和C的痕迹，它们很像的与UNIX和C的函数，可以和C进行通用。理解上如果对C不是很了解，可能会存在一些困难，在写C接口时，可能会用到它们，其他场景建议不要直接使用，以免出现问题难以解决。

重要属性

time.timezone

本地时区（未启动夏令时）距离格林威治的偏移秒数（>0，美洲;<=0大部分欧洲，亚洲，非洲）。

time.tzname

返回一个元组，即（所在标准时间区的名字，夏令时区名字）

time.altzone

返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。

>>> import time
>>> print ("time.altzone %d " % time.altzone)
time.altzone -28800 

time.daylight

本地时间是否是夏令时间

>>> import time
>>> time.daylight
0

常用方法

time.time( )

返回当前时间的时间戳（1970纪元后经过的浮点秒数）。

>>> import time
>>> time.time()
1694098216.907698

time.localtime([secs]）

不带参数是获取当前时间的时间元组：

>>> time.localtime()
time.struct_time(tm_year=2023, tm_mon=9, tm_mday=7, tm_hour=22, tm_min=48, tm_sec=2, tm_wday=3, tm_yday=250, tm_isdst=0)

接收时间戳（如time.time()返回的值）并返回当地时间下的时间元组

>>> import time
>>> time.localtime(1694098216.907698)
time.struct_time(tm_year=2023, tm_mon=9, tm_mday=7, tm_hour=22, tm_min=50, tm_sec=16, tm_wday=3, tm_yday=250, tm_isdst=0)

time.gmtime([secs])

接收时间戳并返回格林威治天文时间下的时间元组

>>> import time
>>> time.gmtime(time.time())
time.struct_time(tm_year=2023, tm_mon=9, tm_mday=7, tm_hour=14, tm_min=53, tm_sec=45, tm_wday=3, tm_yday=250, tm_isdst=0)

time.mktime(tupletime)

接受时间元组并返回时间戳（1970纪元后经过的浮点秒数）。

>>> time.mktime(time.localtime())
1694098540.0

time.asctime([tupletime])

将时间元组转化为字符串

>>> import time
>>> t = time.localtime()
>>> print ("time.asctime(t): %s " % time.asctime(t))
time.asctime(t): Thu Sep  7 22:59:41 2023 

如果不带参数，直接将当前时间转化为字符串：

>>> time.asctime()
'Thu Sep  7 23:01:00 2023'

time.ctime([secs])

将时间戳转化为字符串，相当于是time.asctime(time.localtime([secs])
如果未给定时间戳，就是当前时间

>>> import time
>>> time.time()
1694099035.372949
>>> time.ctime()
'Thu Sep  7 23:04:05 2023'
>>> time.ctime(1694099035.372949)
'Thu Sep  7 23:03:55 2023'

time.sleep(secs)
推迟调用线程的运行，secs指秒数。

import time

print ("Start : %s" % time.ctime())
time.sleep( 5 )
print ("End : %s" % time.ctime())

time.strftime(fmt[,tupletime])

接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。

>>> import time
>>> print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
2016-04-07 11:18:05

​​​​​​​time.strptime(str,fmt='%a %b %d %H:%M:%S %Y')

根据fmt的格式把一个时间字符串解析为时间元组。

>>> import time
>>> struct_time = time.strptime("30 Nov 00", "%d %b %y")
>>> print ("返回元组: ", struct_time)
返回元组:  time.struct_time(tm_year=2000, tm_mon=11, tm_mday=30, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=335, tm_isdst=-1)

time.tzset()

根据环境变量TZ重新初始化时间相关设置。

time.perf_counter()

返回计时器的精准时间（系统的运行时间），包含整个系统的睡眠时间。由于返回值的基准点是未定义的，所以，只有连续调用的结果之间的差才是有效的。

import time

scale = 50 

print("执行开始".center(scale//2,"-"))  # .center() 控制输出的样式，宽度为 25//2，即 22，汉字居中，两侧填充 -

start = time.perf_counter() # 调用一次 perf_counter()，从计算机系统里随机选一个时间点A，计算其距离当前时间点B1有多少秒。当第二次调用该函数时，默认从第一次调用的时间点A算起，距离当前时间点B2有多少秒。两个函数取差，即实现从时间点B1到B2的计时功能。
for i in range(scale+1):   
    a = '*' * i             # i 个长度的 * 符号
    b = '.' * (scale-i)  # scale-i） 个长度的 . 符号。符号 * 和 . 总长度为50 
    c = (i/scale)*100  # 显示当前进度，百分之多少
    dur = time.perf_counter() - start    # 计时，计算进度条走到某一百分比的用时
    print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c,a,b,dur),end='')  # \r用来在每次输出完成后，将光标移至行首，这样保证进度条始终在同一行输出，即在一行不断刷新的效果；{:^3.0f}，输出格式为居中，占3位，小数点后0位，浮点型数，对应输出的数为c；{}，对应输出的数为a；{}，对应输出的数为b；{:.2f}，输出有两位小数的浮点数，对应输出的数为dur；end=''，用来保证不换行，不加这句默认换行。
    time.sleep(0.1)     # 在输出下一个百分之几的进度前，停止0.1秒
print("\n"+"执行结果".center(scale//2,'-'))

time.perf_counter_ns()

与time.perf_counter()用法一样，但时间上精确到纳秒

>>> time.perf_counter_ns()
78724518597220
>>> time.perf_counter()
78727.953504732

time.process_time()

返回当前进程执行 CPU 的时间总和(以秒为单位时间的浮点值)，不包含睡眠时间。由于返回值的基准点是未定义的，所以，只有连续调用的结果之间的差才是有效的。

# Python program to show time by process_time()  
from time import process_time 
  
# assigning n = 50  
n = 50 
  
# Start the stopwatch / counter  
t1_start = process_time()  
   
for i in range(n):
    print(i, end =' ') 
  
print()  
  
# Stop the stopwatch / counter 
t1_stop = process_time() 
   
print("Elapsed time:", t1_stop, t1_start)  
   
print("Elapsed time during the whole program in seconds:", t1_stop-t1_start) 

time.process_time_ns()

与time.process_time()用法一致，但是时间采用纳秒

>>> time.process_time_ns()
146499000
>>> time.process_time()
0.147873

日历模块

此模块的函数都是日历相关的，例如打印某月的字符月历。

星期一是默认的每周第一天，星期天是默认的最后一天。更改设置需调用calendar.setfirstweekday()函数。

函数及描述
calendar.calendar(year,w=2,l=1,c=6) 返回一个多行字符串格式的 year 年年历，3 个月一行，间隔距离为 c。 每日宽度间隔为w字符。每行长度为 21* W+18+2* C。l 是每星期行数。
calendar.firstweekday( ) 返回当前每周起始日期的设置。默认情况下，首次载入 calendar 模块时返回 0，即星期一。
calendar.isleap(year) 是闰年返回 True，否则为 False。 >>> import calendar >>> print(calendar.isleap(2000)) True >>> print(calendar.isleap(1900)) False
calendar.leapdays(y1,y2) 返回在Y1，Y2两年之间的闰年总数。
calendar.month(year,month,w=2,l=1) 返回一个多行字符串格式的year年month月日历，两行标题，一周一行。每日宽度间隔为w字符。每行的长度为7* w+6。l是每星期的行数。
calendar.monthcalendar(year,month) 返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。Year年month月外的日期都设为0;范围内的日子都由该月第几日表示，从1开始。
calendar.monthrange(year,month) 返回两个整数。第一个是该月的星期几，第二个是该月有几天。星期几是从0（星期一）到 6（星期日）。 >>> import calendar >>> calendar.monthrange(2014, 11) (5, 30) (5, 30)解释：5 表示 2014 年 11 月份的第一天是周六，30 表示 2014 年 11 月份总共有 30 天。
calendar.prcal(year, w=0, l=0, c=6, m=3) 相当于 print (calendar.calendar(year, w=0, l=0, c=6, m=3))。
calendar.prmonth(theyear, themonth, w=0, l=0) 相当于 print(calendar.month(theyear, themonth, w=0, l=0))。
calendar.setfirstweekday(weekday) 设置每周的起始日期码。0（星期一）到6（星期日）。
calendar.timegm(tupletime) 和time.gmtime相反：接受一个时间元组形式，返回该时刻的时间戳（1970纪元后经过的浮点秒数）。
calendar.weekday(year,month,day) 返回给定日期的日期码。0（星期一）到6（星期日）。月份为 1（一月） 到 12（12月）。

#!/usr/bin/python

import time
import calendar


# （1）当前时间戳
time.time()
# 1538271871.226226


# （2）时间戳 → 时间元组，默认为当前时间
# time.struct_time(tm_year=2018, tm_mon=9, tm_mday=3, tm_hour=9, tm_min=4, tm_sec=1, tm_wday=6, tm_yday=246, tm_isdst=0)
time.localtime()
time.localtime(1538271871.226226)


# （3）时间戳 → 可视化时间
# time.ctime(时间戳)，默认为当前时间
time.ctime(1538271871.226226)


# （4）时间元组 → 时间戳
# 1538271871
time.mktime((2018, 9, 30, 9, 44, 31, 6, 273, 0))


# （5）时间元组 → 可视化时间
# time.asctime(时间元组)，默认为当前时间
time.asctime()
time.asctime((2018, 9, 30, 9, 44, 31, 6, 273, 0))
time.asctime(time.localtime(1538271871.226226))


# （6）时间元组 → 可视化时间（定制）
# time.strftime(要转换成的格式，时间元组)
time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())


# （7）可视化时间（定制） → 时间元祖
# time.strptime(时间字符串，时间格式)
print(time.strptime('2018-9-30 11:32:23', '%Y-%m-%d %H:%M:%S'))


# （8）浮点数秒数，用于衡量不同程序的耗时，前后两次调用的时间差
time.clock()