Python中的日期和时间（一）datetime模块

spiritx

已于 2023-10-26 22:12:24 修改

阅读量348

点赞数

文章标签： python 开发语言

于 2023-09-07 21:27:40 首次发布

本文链接：https://blog.csdn.net/spiritx/article/details/132745015

版权

Python实用教程_spiritx的博客-CSDN博客

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)

参数：

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

import datetime
t = datetime.date(2019,8,26)
print(type(t))
print(t.day,t.month,t.year) # <class 'datetime.date'>
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)

注释：

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

所有参数都是可选的，tzinfo 可以是 None，或者是一个 tzinfo 子类的实例。其余的参数必须是在下面范围内的整数：
0 <= hour < 24
0 <= minute < 60
0 <= second < 60
0 <= microsecond < 1000000
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。

datetime.timestamp()

将datetime类型转换为时间戳。

组合时间和日期

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)

主要的属性

timedelta.days、timedelta.seconds、timedelta.microseconds

时间间隔的天数、秒数和微妙数。

主要的方法

timedelta.total_seconds()

返回时间间隔包含了多少秒。

>>>from datetime import timedelta
>>>year = timedelta(days=1)
>>>timedelta.total_seconds(year)
86400.0

支持的运算

运算	结果：
`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及子类

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 。

ZoneInfo

zoneinfo 模块根据 PEP 615 的最初说明提供了具体的时区实现来支持 IANA 时区数据库。

ZoneInfo 是 datetime.tzinfo 抽象基类的具体实现，其目标是通过构造器、 datetime.replace 方法或 datetime.astimezone 来与 tzinfo 建立关联:

>>>from zoneinfo import ZoneInfo
>>>from datetime import datetime, timedelta

>>>dt = datetime(2020, 10, 31, 12, tzinfo=ZoneInfo("America/Los_Angeles"))
>>>print(dt)
2020-10-31 12:00:00-07:00

>>>dt.tzname()
'PDT'

以此方式构造的日期时间对象可兼容日期时间运算并可在无需进一步干预的情况下处理夏令时转换:

>>>dt_add = dt + timedelta(days=1)

>>>print(dt_add)
2020-11-01 12:00:00-08:00

>>>dt_add.tzname()
'PST'

这些时区还支持在 PEP 495 中引入的 fold。在可能导致时间歧义的时差转换中（例如夏令时到标准时的转换），当 fold=0 时会使用转换之前的时差，而当 fold=1 时则使用转换之后的时差，例如:

>>>dt = datetime(2020, 11, 1, 1, tzinfo=ZoneInfo("America/Los_Angeles"))
>>>print(dt)
2020-11-01 01:00:00-07:00

>>>print(dt.replace(fold=1))
2020-11-01 01:00:00-08:00

当执行来自另一时区的转换时，fold 将被设置为正确的值:

>>>from datetime import timezone
>>>LOS_ANGELES = ZoneInfo("America/Los_Angeles")
>>>dt_utc = datetime(2020, 11, 1, 8, tzinfo=timezone.utc)

# Before the PDT -> PST transition
>>>print(dt_utc.astimezone(LOS_ANGELES))
2020-11-01 01:00:00-07:00

# After the PDT -> PST transition
>>>print((dt_utc + timedelta(hours=1)).astimezone(LOS_ANGELES))
2020-11-01 01:00:00-08:00

zoneinfo 模块不直接提供时区数据，而是在可能的情况下从系统时区数据库或 PyPI 上的第一方包 tzdata 获取时区信息。某些系统，重要的一点是 Windows 系统也包括在内，并没有可用的 IANA 数据库，因此对于要保证获取时区信息的跨平台兼容性的项目，推荐对 tzdata 声明依赖。如果系统数据和 tzdata 均不可用，则所有对 ZoneInfo 的调用都将引发 ZoneInfoNotFoundError。
配置数据源
当 ZoneInfo(key) 被调用时，此构造器首先会在 TZPATH 所指定的目录下搜索匹配 key 的文件，失败时则会在 tzdata 包中查找匹配。此行为可通过三种方式来配置:

默认的 TZPATH 未通过其他方式指定时可在编译时进行配置。

TZPATH 可使用环境变量进行配置。

在运行时，搜索路径可使用 reset_tzpath() 函数来修改。

编译时配置
默认的 TZPATH 包括一些时区数据库的通用部署位置（Windows 除外，该系统没有时区数据的“通用”位置）。在 POSIX 系统中，下游分发者和从源码编译 Python 的开发者知道系统时区数据部署位置，它们可以通过指定编译时选项 TZPATH (或者更常见的是通过配置旗标 --with-tzpath) 来改变默认的时区路径，该选项应当是一个由 os.pathsep 分隔的字符串。

在所有平台上，配置值会在 sysconfig.get_config_var() 中以 TZPATH 键的形式提供。

环境配置
当初始化 TZPATH 时（在导入时或不带参数调用 reset_tzpath() 时），zoneinfo 模块将使用环境变量 PYTHONTZPATH，如果变量存在则会设置搜索路径。

PYTHONTZPATH
这是一个以 os.pathsep 分隔的字符串，其中包含要使用的时区搜索路径。它必须仅由绝对路径而非相对路径组成。在 PYTHONTZPATH 中指定的相对路径部分将不会被使用，但在其他情况下当指定相对路径时的行为该实现是有定义的；CPython 将引发 InvalidTZPathWarning，而其他实现可自由地忽略错误部分或是引发异常。

要设置让系统忽略系统数据并改用 tzdata 包，请设置 PYTHONTZPATH=""。

运行时配置
TZ 搜索路径也可在运行时使用 reset_tzpath() 函数来配置。通常并不建议如此操作，不过在需要使用指定时区路径（或者需要禁止访问系统时区）的测试函数中使用它则是合理的。

zoneinfo.available_timezones()

获取一个包含可用 IANA 时区的在时区路径的任何位置均可用的全部有效键的集合。每次调用该函数时都会重新计算。

此函数仅包括规范时区名称而不包括“特殊”时区如位于 posix/ 和 right/ 目录下的时区或 posixrules 时区。

小心

此函数可能会打开大量的文件，因为确定时区路径上某个文件是否为有效时区的最佳方式是读取开头位置的“魔术字符串”。

'Asia/Hong_Kong':香港时区

'Asia/Shanghai':上海时区

但没找到北京时区

ZoneInfo(key)

ZoneInfo 对象的序列化是基于键的，而不是序列化所有过渡数据，并且基于文件构造的 ZoneInfo 对象（即使是指定了 key 值的对象）不能被封存。

ZoneInfo(key): 当使用主构造器构造时，会基于键序列化一个 ZoneInfo 对象，而当反序列化时，反序列化过程会使用主构造器，因此预期它们与其他对同一时区的引用会是同一对象。

>>> dt = datetime(2023, 9, 8, 21, 41, 6, 305353, tzinfo=zoneinfo.ZoneInfo('Asia/Shanghai'))
>>> f"{dt.isoformat()} [{dt.tzinfo}]"
'2023-09-08T21:41:06.305353+08:00 [Asia/Shanghai]'
>>> dt = datetime(2023, 9, 8, 21, 41, 6, 305353, tzinfo=zoneinfo.ZoneInfo('Pacific/Kwajalein'))
>>> f"{dt.isoformat()} [{dt.tzinfo}]"
'2023-09-08T21:41:06.305353+12:00 [Pacific/Kwajalein]'

spiritx

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Python中的日期和时间（一）datetime模块

Python处理时间的对象很多，常用的有time、datetime和calendar等。本文对常用的时间对象的使用进行学习。在开始学习具体的对象前，先学习几个计算机的时间概念。:是全球范围内计时的科学标准，它基于精心维护的原子钟，在全球范围内精确到微秒，由于英文（CUT）和法文（TUC）的缩写不同，作为妥协，简称UTC。
复制链接

扫一扫