datetime 对象¶
一个 datetime 对象是一个包含来自 date 对象和 time 对象所有信息的单一对象。
像 date 对象一样，datetime 假设当前的公历（格里高利历）向两个方向无限延伸；像 time 对象一样，datetime 假设每天恰好有 3600*24 秒。
构造函数：
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。
在 3.6 版本发生变更: 添加了 fold 参数。
其他构造函数，均为类方法：
classmethod datetime.today()¶
返回当前的本地日期和时间，tzinfo 为 None。
等价于：
datetime.fromtimestamp(time.time())
另请参见 now()、fromtimestamp()。
此方法在功能上等同于 now()，但没有 tz 参数。
classmethod datetime.now(tz=None)¶
返回当前的本地日期和时间。
如果可选参数 tz 为 None 或未指定，这类似于 today()，但如果可能，它提供的精度比通过 time.time() 时间戳获得的精度更高（例如，在提供 C 语言 gettimeofday() 函数的平台上可能如此）。
如果 tz 不为 None，它必须是 tzinfo 子类的实例，并且当前的日期和时间会转换为 tz 的时区。
此函数优于 today() 和 utcnow()。
备注
后续对 datetime.now() 的调用可能返回相同的时间点，具体取决于底层时钟的精度。
classmethod datetime.utcnow()¶
返回当前的 UTC 日期和时间，tzinfo 为 None。
这类似于 now()，但返回的是当前的 UTC 日期和时间，作为一个幼稚型 datetime 对象。可以通过调用 datetime.now(timezone.utc) 来获得一个感知型的当前 UTC 日期时间。另请参见 now()。
警告
由于幼稚型 datetime 对象被许多 datetime 方法视作本地时间，因此推荐使用感知型 datetime 来表示 UTC 时间。因此，创建表示当前 UTC 时间的对象的推荐方法是调用 datetime.now(timezone.utc)。
自 3.12 版本起不推荐使用: 请改用带 UTC 的 datetime.now()。
classmethod datetime.fromtimestamp(timestamp, tz=None)¶
返回与 POSIX 时间戳对应的本地日期和时间，例如 time.time() 返回的时间戳。如果可选参数 tz 为 None 或未指定，时间戳会转换为平台的本地日期和时间，返回的 datetime 对象是幼稚型的。
如果 tz 不为 None，则它必须是 tzinfo 子类的实例，并且时间戳会转换为 tz 所在的时区。
如果时间戳超出了平台 C 的 localtime() 或 gmtime() 函数所支持的值范围，fromtimestamp() 可能会引发 OverflowError；如果 localtime() 或 gmtime() 失败，则会引发 OSError。这个范围通常被限制在 1970 年到 2038 年之间。请注意，在那些将闰秒包含在其时间戳概念中的非 POSIX 系统上，闰秒会被 fromtimestamp() 忽略，因此可能出现两个相差一秒的时间戳产生相同的 datetime 对象。此方法优于 utcfromtimestamp()。
在 3.3 版更改: 如果时间戳超出了平台 C 的 localtime() 或 gmtime() 函数支持的值范围，则会引发 OverflowError 而不是 ValueError。如果 localtime() 或 gmtime() 失败，则会引发 OSError 而不是 ValueError。
在 3.6 版更改: fromtimestamp() 可能会返回 fold 属性设置为 1 的实例。
classmethod datetime.utcfromtimestamp(timestamp)¶
返回与 POSIX 时间戳对应的 UTC datetime，其中 tzinfo 为 None。（结果对象是朴素的。）
如果时间戳超出了平台 C 的 gmtime() 函数所支持的值范围，此方法可能会引发 OverflowError；如果 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 对象视为本地时间，因此推荐使用感知的 datetime 对象来表示 UTC 时间。因此，创建代表 UTC 特定时间戳的对象的推荐方法是调用 datetime.fromtimestamp(timestamp, tz=timezone.utc)。
在 3.3 版更改: 如果时间戳超出了平台 C 的 gmtime() 函数支持的值范围，则会引发 OverflowError 而不是 ValueError。如果 gmtime() 失败，则会引发 OSError 而不是 ValueError。
自 3.12 版本起弃用: 请改用带 UTC 的 datetime.fromtimestamp()。
classmethod datetime.fromordinal(ordinal)¶
返回对应于预期公历序数的 datetime，其中第 1 年的 1 月 1 日的序数为 1。除非 1 <= ordinal <= datetime.max.toordinal()，否则会引发 ValueError。结果的小时、分钟、秒和微秒都为 0，且 tzinfo 为 None。
classmethod datetime.combine(date, time, tzinfo=time.tzinfo)¶
返回一个新的 datetime 对象，其日期部分等于给定的 date 对象的日期部分，时间部分等于给定的 time 对象的时间部分。如果提供了 tzinfo 参数，其值将用于设置结果的 tzinfo 属性，否则将使用 time 参数的 tzinfo 属性。如果 date 参数是 datetime 对象，其时间部分和 tzinfo 属性将被忽略。
对于任何 datetime 对象 d，d == datetime.combine(d.date(), d.time(), d.tzinfo) 成立。
在 3.6 版更改: 添加了 tzinfo 参数。
classmethod datetime.fromisoformat(date_string)¶
返回与任何有效的 ISO 8601 格式的 date_string 对应的 datetime，但有以下例外：
时区偏移量可以有小数秒。
T 分隔符可以被任何单个 unicode 字符替换。
不支持小数小时和分钟。
目前不支持降低精度的日期（YYYY-MM, YYYY）。
目前不支持扩展日期表示法（±YYYYYY-MM-DD）。
目前不支持序数日期（YYYY-OOO）。
示例：
>>> 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)))
在 3.7 版本加入。
在 3.11 版更改: 以前，此方法只支持 date.isoformat() 或 datetime.isoformat() 可以生成的格式。
classmethod datetime.fromisocalendar(year, week, day)¶
返回与由年、周和日指定的 ISO 日历日期相对应的 datetime。datetime 的非日期部分将使用其正常的默认值填充。这是 datetime.isocalendar() 函数的逆操作。
在 3.8 版本加入。
classmethod datetime.strptime(date_string, format)¶
返回一个根据 format 解析 date_string 后得到的 datetime 对象。
如果 format 不包含微秒或时区信息，这等同于：
datetime(*(time.strptime(date_string, format)[0:6]))
如果 date_string 和 format 无法被 time.strptime() 解析，或者它返回的值不是一个时间元组，则会引发 ValueError。另请参见 strftime() 和 strptime() 的行为 和 datetime.fromisoformat()。
在 3.13 版更改: 如果 format 指定了月份中的某一天但没有指定年份，现在会发出一个 DeprecationWarning。这是为了避免在寻求仅解析月份和日期的代码中出现四年一次的闰年错误，因为在格式中缺少年份时使用的默认年份不是闰年。这样的 format 值可能会在 Python 3.15 版本中引发错误。解决方法是在你的 format 中始终包含年份。如果解析的 date_string 值没有年份，请在解析前明确添加一个闰年：
>>> from datetime import datetime
>>> date_string = "02/29"
>>> when = datetime.strptime(f"{date_string};1984", "%m/%d;%Y") # Avoids leap year bug.
>>> when.strftime("%B %d")
'February 29'
类属性：
datetime.min¶
可表示的最早的 datetime，即 datetime(MINYEAR, 1, 1, tzinfo=None)。
datetime.max¶
可表示的最晚的 datetime，即 datetime(MAXYEAR, 12, 31, 23, 59, 59, 999999, tzinfo=None)。
datetime.resolution¶
两个不相等的 datetime 对象之间可能的最小差值，即 timedelta(microseconds=1)。
实例属性（只读）：
datetime.year¶
介于 MINYEAR 和 MAXYEAR 之间（含）。
datetime.month¶
介于 1 和 12 之间（含）。
datetime.day¶
介于 1 和给定年份给定月份的天数之间。
datetime.hour¶
在 range(24) 范围内。
datetime.minute¶
在 range(60) 范围内。
datetime.second¶
在 range(60) 范围内。
datetime.microsecond¶
在 range(1000000) 范围内。
datetime.tzinfo¶
传递给 datetime 构造函数的 tzinfo 参数的对象，如果没有传递则为 None。
datetime.fold¶
在 [0, 1] 范围内。用于在重复的时间区间内消除时钟时间的歧义。（当夏令时结束时钟回拨，或当前时区的 UTC 偏移因政治原因减少时，会出现重复的时间区间。）值 0 和 1 分别表示具有相同墙上时钟时间表示的两个时刻中较早和较晚的一个。
在 3.6 版本加入。
支持的操作：
操作
结果
datetime2 = datetime1 + timedelta
(1)
datetime2 = datetime1 - timedelta
(2)
timedelta = datetime1 - datetime2
(3)
datetime1 == datetime2
datetime1 != datetime2
相等性比较。(4)
datetime1 < datetime2
datetime1 > datetime2
datetime1 <= datetime2
datetime1 >= datetime2
顺序比较。(5)
datetime2 是从 datetime1 移除了 timedelta 持续时间后的结果，如果 timedelta.days > 0 则时间向前移动，如果 timedelta.days < 0 则向后移动。结果具有与输入 datetime 相同的 tzinfo 属性，并且之后 datetime2 - datetime1 == timedelta。如果 datetime2.year 会小于 MINYEAR 或大于 MAXYEAR，则会引发 OverflowError。请注意，即使输入是感知的对象，也不会进行时区调整。
计算 datetime2 使得 datetime2 + timedelta == datetime1。与加法一样，结果具有与输入 datetime 相同的 tzinfo 属性，并且即使输入是感知的，也不会进行时区调整。
从一个 datetime 减去另一个 datetime 的操作仅在两个操作数都是朴素的，或都是感知的情况下才被定义。如果一个是感知的而另一个是朴素的，则会引发 TypeError。
如果两者都是朴素的，或者两者都是感知的且具有相同的 tzinfo 属性，那么 tzinfo 属性将被忽略，结果是一个 timedelta 对象 t，使得 datetime2 + t == datetime1。在这种情况下不进行时区调整。
如果两者都是感知的且具有不同的 tzinfo 属性，a-b 的行为就好像 a 和 b 首先被转换成了朴素的 UTC datetime。结果是 (a.replace(tzinfo=None) - a.utcoffset()) - (b.replace(tzinfo=None) - b.utcoffset())，但实现上不会溢出。
datetime 对象如果表示相同的日期和时间（考虑到时区），则它们是相等的。
朴素和感知的 datetime 对象永远不相等。
如果两个比较对象都是感知的，并且具有相同的 tzinfo 属性，那么 tzinfo 和 fold 属性将被忽略，只比较基础的 datetime。如果两个比较对象都是感知的，但具有不同的 tzinfo 属性，比较的行为就好像比较对象首先被转换成了 UTC datetime，但实现上不会溢出。处于重复时间区间内的 datetime 实例永远不等于其他时区中的 datetime 实例。
当 datetime1 在时间上早于 datetime2 时（考虑到时区），认为 datetime1 小于 datetime2。
在朴素和感知的 datetime 对象之间进行顺序比较会引发 TypeError。
如果两个比较对象都是感知的，并且具有相同的 tzinfo 属性，那么 tzinfo 和 fold 属性将被忽略，只比较基础的 datetime。如果两个比较对象都是感知的，但具有不同的 tzinfo 属性，比较的行为就好像比较对象首先被转换成了 UTC datetime，但实现上不会溢出。
在 3.3 版更改: 感知和朴素的 datetime 实例之间的相等性比较不再引发 TypeError。
在 3.13 版本发生变更: datetime 对象与非 datetime 子类的 date 子类的实例之间的比较，不再将后者转换为 date，从而忽略时间部分和时区。可以通过在子类中重写特殊的比较方法来更改默认行为。
实例方法：
datetime.date()¶
返回具有相同年、月、日的 date 对象。
datetime.time()¶
返回具有相同小时、分钟、秒、微秒和 fold 的 time 对象。tzinfo 为 None。另请参见 timetz() 方法。
在 3.6 版更改: fold 值被复制到返回的 time 对象中。
datetime.timetz()¶
返回具有相同小时、分钟、秒、微秒、fold 和 tzinfo 属性的 time 对象。另请参见 time() 方法。
在 3.6 版更改: fold 值被复制到返回的 time 对象中。
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，而无需转换日期和时间数据。
datetime 对象也受通用函数 copy.replace() 支持。
在 3.6 版本发生变更: 添加了 fold 参数。
datetime.astimezone(tz=None)¶
返回一个带有新 tzinfo 属性 tz 的 datetime 对象，并调整日期和时间数据，使结果与 self 表示的 UTC 时间相同，但在 tz 的本地时间中。
如果提供了 tz，它必须是 tzinfo 子类的实例，并且其 utcoffset() 和 dst() 方法不能返回 None。如果 self 是朴素的，则假定它表示系统时区中的时间。
如果不带参数调用（或使用 tz=None），则假定目标时区为系统本地时区。转换后的 datetime 实例的 .tzinfo 属性将被设置为一个 timezone 的实例，其时区名称和偏移量从操作系统获取。
如果 self.tzinfo 是 tz，则 self.astimezone(tz) 等于 self：不执行日期或时间数据的调整。否则，结果是时区 tz 中的本地时间，表示与 self 相同的 UTC 时间：在 astz = dt.astimezone(tz) 之后，astz - astz.utcoffset() 将具有与 dt - dt.utcoffset() 相同的日期和时间数据。
如果你只想将一个 timezone 对象 tz 附加到一个 datetime dt 上，而不调整日期和时间数据，请使用 dt.replace(tzinfo=tz)。如果你只想从一个感知的 datetime dt 中移除 timezone 对象，而不转换日期和时间数据，请使用 dt.replace(tzinfo=None)。
请注意，默认的 tzinfo.fromutc() 方法可以在 tzinfo 子类中被重写，以影响 astimezone() 返回的结果。忽略错误情况，astimezone() 的行为类似于：
def astimezone(self, tz):
if self.tzinfo is tz:
return self
# Convert self to UTC, and attach the new timezone object.
utc = (self - self.utcoffset()).replace(tzinfo=tz)
# Convert from UTC to tz's local time.
return tz.fromutc(utc)
在 3.3 版更改: tz 现在可以省略。
在 3.6 版更改: astimezone() 方法现在可以在被假定为表示系统本地时间的朴素实例上调用。
datetime.utcoffset()¶
如果 tzinfo 是 None，则返回 None，否则返回 self.tzinfo.utcoffset(self)，如果后者没有返回 None 或一个大小小于一天的 timedelta 对象，则引发异常。
在 3.7 版更改: UTC 偏移量不再限制为整数分钟。
datetime.dst()¶
如果 tzinfo 是 None，则返回 None，否则返回 self.tzinfo.dst(self)，如果后者没有返回 None 或一个大小小于一天的 timedelta 对象，则引发异常。
在 3.7 版更改: DST 偏移量不再限制为整数分钟。
datetime.tzname()¶
如果 tzinfo 是 None，则返回 None，否则返回 self.tzinfo.tzname(self)，如果后者没有返回 None 或一个字符串对象，则引发异常。
datetime.timetuple()¶
返回一个 time.struct_time，类似于 time.localtime() 返回的类型。
d.timetuple() 等价于：
time.struct_time((d.year, d.month, d.day,
d.hour, d.minute, d.second,
d.weekday(), yday, dst))
其中 yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1 是当前年份中的天数，1 月 1 日为 1。结果的 tm_isdst 标志根据 dst() 方法设置：如果 tzinfo 是 None 或 dst() 返回 None，则 tm_isdst 设置为 -1；否则如果 dst() 返回一个非零值，tm_isdst 设置为 1；否则 tm_isdst 设置为 0。
datetime.utctimetuple()¶
如果 datetime 实例 d 是朴素的，这与 d.timetuple() 相同，只是无论 d.dst() 返回什么，tm_isdst 都会被强制为 0。UTC 时间永远不会有夏令时。
如果 d 是感知的，d 会通过减去 d.utcoffset() 被标准化为 UTC 时间，并返回标准化时间的 time.struct_time。tm_isdst 被强制为 0。请注意，如果 d.year 是 MINYEAR 或 MAXYEAR 并且 UTC 调整跨越了年份边界，可能会引发 OverflowError。
警告
因为许多 datetime 方法将朴素的 datetime 对象视为本地时间，所以推荐使用感知的 datetime 来表示 UTC 时间；因此，使用 datetime.utctimetuple() 可能会产生误导性的结果。如果你有一个表示 UTC 的朴素 datetime，使用 datetime.replace(tzinfo=timezone.utc) 使其变为感知的，然后你就可以使用 datetime.timetuple() 了。
datetime.toordinal()¶
返回日期的预期公历序数。与 self.date().toordinal() 相同。
datetime.timestamp()¶
返回与 datetime 实例对应的 POSIX 时间戳。返回值是一个 float，类似于 time.time() 返回的值。
朴素的 datetime 实例被假定为表示本地时间，此方法依赖于平台 C 的 mktime() 函数来执行转换。由于 datetime 在许多平台上支持的值范围比 mktime() 更广，对于遥远的过去或未来的时间，此方法可能会引发 OverflowError 或 OSError。
对于感知的 datetime 实例，返回值的计算方式为：
(dt - datetime(1970, 1, 1, tzinfo=timezone.utc)).total_seconds()
在 3.3 版本加入。
在 3.6 版更改: timestamp() 方法使用 fold 属性来消除重复时间区间内的歧义。
备注
没有方法可以直接从一个表示 UTC 时间的朴素 datetime 实例获取 POSIX 时间戳。如果你的应用程序使用这种约定，并且你的系统时区未设置为 UTC，你可以通过提供 tzinfo=timezone.utc 来获取 POSIX 时间戳：
timestamp = dt.replace(tzinfo=timezone.utc).timestamp()
或者直接计算时间戳：
timestamp = (dt - datetime(1970, 1, 1)) / timedelta(seconds=1)
datetime.weekday()¶
返回星期几的整数表示，其中星期一为 0，星期日为 6。与 self.date().weekday() 相同。另请参见 isoweekday()。
datetime.isoweekday()¶
返回星期几的整数表示，其中星期一为 1，星期日为 7。与 self.date().isoweekday() 相同。另请参见 weekday()、isocalendar()。
datetime.isocalendar()¶
返回一个包含三个组件的命名元组：year、week 和 weekday。与 self.date().isocalendar() 相同。
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
示例：
>>> from datetime import datetime, timezone
>>> datetime(2019, 5, 18, 15, 17, 8, 132263).isoformat()
'2019-05-18T15:17:08.132263'
>>> datetime(2019, 5, 18, 15, 17, tzinfo=timezone.utc).isoformat()
'2019-05-18T15:17:00+00:00'
可选参数 sep（默认为 'T'）是一个单字符分隔符，放在结果的日期和时间部分之间。例如：
>>> from datetime import tzinfo, timedelta, datetime
>>> class TZ(tzinfo):
... """A time zone with an arbitrary, constant -06:39 offset."""
... def utcoffset(self, dt):
... return timedelta(hours=-6, minutes=-39)
...
>>> datetime(2002, 12, 25, tzinfo=TZ()).isoformat(' ')
'2002-12-25 00:00:00-06:39'
>>> datetime(2009, 11, 27, microsecond=100, tzinfo=TZ()).isoformat()
'2009-11-27T00:00:00.000100-06:39'
可选参数 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 格式包含完整时间。
备注
被排除的时间部分会被截断，而不是四舍五入。
对于无效的 timespec 参数，将引发 ValueError。
>>> from datetime import datetime
>>> datetime.now().isoformat(timespec='minutes')
'2002-12-25T00:00'
>>> dt = datetime(2015, 1, 1, 12, 30, 59, 0)
>>> dt.isoformat(timespec='microseconds')
'2015-01-01T12:30:59.000000'
在 3.6 版更改: 添加了 timespec 参数。
datetime.__str__()¶
对于一个 datetime 实例 d，str(d) 等价于 d.isoformat(' ')。
datetime.ctime()¶
返回一个表示日期和时间的字符串：
>>> from datetime import datetime
>>> datetime(2002, 12, 4, 20, 30, 40).ctime()
'Wed Dec 4 20:30:40 2002'
输出字符串将*不*包含时区信息，无论输入是感知的还是朴素的。
d.ctime() 等价于：
time.ctime(time.mktime(d.timetuple()))
在原生 C ctime() 函数（time.ctime() 会调用，但 datetime.ctime() 不会调用）符合 C 标准的平台上。
datetime.strftime(format)¶
返回一个由显式格式字符串控制的表示日期和时间的字符串。另请参见 strftime() 和 strptime() 的行为 和 datetime.isoformat()。
datetime.__format__(format)¶
与 datetime.strftime() 相同。这使得在格式化字符串字面值中以及使用 str.format() 时可以为 datetime 对象指定格式字符串。另请参见 strftime() 和 strptime() 的行为 和 datetime.isoformat()。
使用示例：datetime¶
使用 datetime 对象的示例：
>>> from datetime import datetime, date, time, timezone
>>> # Using datetime.combine()
>>> d = date(2005, 7, 14)
>>> t = time(12, 30)
>>> datetime.combine(d, t)
datetime.datetime(2005, 7, 14, 12, 30)
>>> # Using datetime.now()
>>> datetime.now()
datetime.datetime(2007, 12, 6, 16, 29, 43, 79043) # GMT +1
>>> datetime.now(timezone.utc)
datetime.datetime(2007, 12, 6, 15, 29, 43, 79060, tzinfo=datetime.timezone.utc)
>>> # Using datetime.strptime()
>>> dt = datetime.strptime("21/11/06 16:30", "%d/%m/%y %H:%M")
>>> dt
datetime.datetime(2006, 11, 21, 16, 30)
>>> # Using datetime.timetuple() to get tuple of all attributes
>>> tt = dt.timetuple()
>>> for it in tt:
... print(it)
...
2006 # year
11 # month
21 # day
16 # hour
30 # minute
0 # second
1 # weekday (0 = Monday)
325 # number of days since 1st January
-1 # dst - method tzinfo.dst() returned None
>>> # Date in ISO format
>>> ic = dt.isocalendar()
>>> for it in ic:
... print(it)
...
2006 # ISO year
47 # ISO week
2 # ISO weekday
>>> # Formatting a datetime
>>> dt.strftime("%A, %d. %B %Y %I:%M%p")
'Tuesday, 21. November 2006 04:30PM'
>>> 'The {1} is {0:%d}, the {2} is {0:%B}, the {3} is {0:%I:%M%p}.'.format(dt, "day", "month", "time")
'The day is 21, the month is November, the time is 04:30PM.'
下面的示例定义了一个 tzinfo 子类，用于捕获阿富汗喀布尔的时区信息，该地区在 1945 年之前使用 UTC+4，之后使用 UTC+4:30：
from datetime import timedelta, datetime, tzinfo, timezone
class KabulTz(tzinfo):
# Kabul used +4 until 1945, when they moved to +4:30
UTC_MOVE_DATE = datetime(1944, 12, 31, 20, tzinfo=timezone.utc)
def utcoffset(self, dt):
if dt.year < 1945:
return timedelta(hours=4)
elif (1945, 1, 1, 0, 0) <= dt.timetuple()[:5] < (1945, 1, 1, 0, 30):
# An ambiguous ("imaginary") half-hour range representing
# a 'fold' in time due to the shift from +4 to +4:30.
# If dt falls in the imaginary range, use fold to decide how
# to resolve. See PEP495.
return timedelta(hours=4, minutes=(30 if dt.fold else 0))
else:
return timedelta(hours=4, minutes=30)
def fromutc(self, dt):
# Follow same validations as in datetime.tzinfo
if not isinstance(dt, datetime):
raise TypeError("fromutc() requires a datetime argument")
if dt.tzinfo is not self:
raise ValueError("dt.tzinfo is not self")
# A custom implementation is required for fromutc as
# the input to this function is a datetime with utc values
# but with a tzinfo set to self.
# See datetime.astimezone or fromtimestamp.
if dt.replace(tzinfo=timezone.utc) >= self.UTC_MOVE_DATE:
return dt + timedelta(hours=4, minutes=30)
else:
return dt + timedelta(hours=4)
def dst(self, dt):
# Kabul does not observe daylight saving time.
return timedelta(0)
def tzname(self, dt):
if dt >= self.UTC_MOVE_DATE:
return "+04:30"
return "+04"
使用上面的 KabulTz：
>>> tz1 = KabulTz()
>>> # Datetime before the change
>>> dt1 = datetime(1900, 11, 21, 16, 30, tzinfo=tz1)
>>> print(dt1.utcoffset())
4:00:00
>>> # Datetime after the change
>>> dt2 = datetime(2006, 6, 14, 13, 0, tzinfo=tz1)
>>> print(dt2.utcoffset())
4:30:00
>>> # Convert datetime to another time zone
>>> dt3 = dt2.astimezone(timezone.utc)
>>> dt3
datetime.datetime(2006, 6, 14, 8, 30, tzinfo=datetime.timezone.utc)
>>> dt2
datetime.datetime(2006, 6, 14, 13, 0, tzinfo=KabulTz())
>>> dt2 == dt3
True