如何解析 ISO 8601 格式的日期和时间？

Question

我需要解析 RFC 3339 字符串，如 "2008-09-03T20:56 :35.450686Z" 转换为 Python 的 datetime 类型。

我在中找到了 strptime Python标准库，但是不是很方便。

做这个的最好方式是什么？

Answer 1

最初我尝试使用：

from operator import neg, pos
from time import strptime, mktime
from datetime import datetime, tzinfo, timedelta

class MyUTCOffsetTimezone(tzinfo):
    @staticmethod
    def with_offset(offset_no_signal, signal):  # type: (str, str) -> MyUTCOffsetTimezone
        return MyUTCOffsetTimezone((pos if signal == '+' else neg)(
            (datetime.strptime(offset_no_signal, '%H:%M') - datetime(1900, 1, 1))
          .total_seconds()))

    def __init__(self, offset, name=None):
        self.offset = timedelta(seconds=offset)
        self.name = name or self.__class__.__name__

    def utcoffset(self, dt):
        return self.offset

    def tzname(self, dt):
        return self.name

    def dst(self, dt):
        return timedelta(0)


def to_datetime_tz(dt):  # type: (str) -> datetime
    fmt = '%Y-%m-%dT%H:%M:%S.%f'
    if dt[-6] in frozenset(('+', '-')):
        dt, sign, offset = strptime(dt[:-6], fmt), dt[-6], dt[-5:]
        return datetime.fromtimestamp(mktime(dt),
                                      tz=MyUTCOffsetTimezone.with_offset(offset, sign))
    elif dt[-1] == 'Z':
        return datetime.strptime(dt, fmt + 'Z')
    return datetime.strptime(dt, fmt)

但这在负时区上不起作用。 然而，我在 Python 3.7.3 中工作得很好：

from datetime import datetime


def to_datetime_tz(dt):  # type: (str) -> datetime
    fmt = '%Y-%m-%dT%H:%M:%S.%f'
    if dt[-6] in frozenset(('+', '-')):
        return datetime.strptime(dt, fmt + '%z')
    elif dt[-1] == 'Z':
        return datetime.strptime(dt, fmt + 'Z')
    return datetime.strptime(dt, fmt)

一些测试，请注意，输出仅因微秒精度而异。 在我的机器上达到了 6 位精度，但是 YMMV：

for dt_in, dt_out in (
        ('2019-03-11T08:00:00.000Z', '2019-03-11T08:00:00'),
        ('2019-03-11T08:00:00.000+11:00', '2019-03-11T08:00:00+11:00'),
        ('2019-03-11T08:00:00.000-11:00', '2019-03-11T08:00:00-11:00')
    ):
    isoformat = to_datetime_tz(dt_in).isoformat()
    assert isoformat == dt_out, '{} != {}'.format(isoformat, dt_out)

Answer 2

感谢 Mark Amery 的回答，我设计了函数来解释日期时间的所有可能的 ISO 格式：

class FixedOffset(tzinfo):
    """Fixed offset in minutes: `time = utc_time + utc_offset`."""
    def __init__(self, offset):
        self.__offset = timedelta(minutes=offset)
        hours, minutes = divmod(offset, 60)
        #NOTE: the last part is to remind about deprecated POSIX GMT+h timezones
        #  that have the opposite sign in the name;
        #  the corresponding numeric value is not used e.g., no minutes
        self.__name = '<%+03d%02d>%+d' % (hours, minutes, -hours)
    def utcoffset(self, dt=None):
        return self.__offset
    def tzname(self, dt=None):
        return self.__name
    def dst(self, dt=None):
        return timedelta(0)
    def __repr__(self):
        return 'FixedOffset(%d)' % (self.utcoffset().total_seconds() / 60)
    def __getinitargs__(self):
        return (self.__offset.total_seconds()/60,)

def parse_isoformat_datetime(isodatetime):
    try:
        return datetime.strptime(isodatetime, '%Y-%m-%dT%H:%M:%S.%f')
    except ValueError:
        pass
    try:
        return datetime.strptime(isodatetime, '%Y-%m-%dT%H:%M:%S')
    except ValueError:
        pass
    pat = r'(.*?[+-]\d{2}):(\d{2})'
    temp = re.sub(pat, r'\1\2', isodatetime)
    naive_date_str = temp[:-5]
    offset_str = temp[-5:]
    naive_dt = datetime.strptime(naive_date_str, '%Y-%m-%dT%H:%M:%S.%f')
    offset = int(offset_str[-4:-2])*60 + int(offset_str[-2:])
    if offset_str[0] == "-":
        offset = -offset
    return naive_dt.replace(tzinfo=FixedOffset(offset))

Answer 3

对于与 2.X 标准库一起使用的东西，请尝试：

calendar.timegm(time.strptime(date.split(".")[0]+"UTC", "%Y-%m-%dT%H:%M:%S%Z"))

calendar.timegm 是 time.mktime 缺少的 gm 版本。

Answer 4

如果解析无效的日期字符串，python-dateutil 将抛出异常，因此您可能需要捕获该异常。

from dateutil import parser
ds = '2012-60-31'
try:
  dt = parser.parse(ds)
except ValueError, e:
  print '"%s" is an invalid date' % ds

Answer 5

datetime.fromisoformat() 在 Python 3.11 中得到改进，可解析大多数 ISO 8601 格式

datetime.fromisoformat() 现在可用于解析大多数 ISO 8601 格式，除了那些支持小数小时和分钟的格式。 以前，此方法仅支持 datetime.isoformat() 可以发出的格式。

>>> from datetime import datetime
>>> 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)

Answer 6

现在有 Maya: Datetimes for Humans™，来自流行的 Requests: HTTP for Humans™ 包的作者：

>>> import maya
>>> str = '2008-09-03T20:56:35.450686Z'
>>> maya.MayaDT.from_rfc3339(str).datetime()
datetime.datetime(2008, 9, 3, 20, 56, 35, 450686, tzinfo=<UTC>)

Answer 7

因为 ISO 8601 允许存在可选冒号和破折号的多种变体，基本上是 CCYY-MM-DDThh:mm:ss[Z|(+|-)hh:mm]。 如果您想使用 strptime，您需要首先删除这些变体。

目标是生成 utc 日期时间对象。

---

If you just want a basic case that work for UTC with the Z suffix like 2016-06-29T19:36:29.3453Z:

datetime.datetime.strptime(timestamp.translate(None, ':-'), "%Y%m%dT%H%M%S.%fZ")

---

If you want to handle timezone offsets like 2016-06-29T19:36:29.3453-0400 or 2008-09-03T20:56:35.450686+05:00 use the following. These will convert all variations into something without variable delimiters like 20080903T205635.450686+0500 making it more consistent/easier to parse.

import re
# this regex removes all colons and all 
# dashes EXCEPT for the dash indicating + or - utc offset for the timezone
conformed_timestamp = re.sub(r"[:]|([-](?!((\d{2}[:]\d{2})|(\d{4}))$))", '', timestamp)
datetime.datetime.strptime(conformed_timestamp, "%Y%m%dT%H%M%S.%f%z" )

---

If your system does not support the %z strptime directive (you see something like ValueError: 'z' is a bad directive in format '%Y%m%dT%H%M%S.%f%z') then you need to manually offset the time from Z (UTC). Note %z may not work on your system in python versions < 3 as it depended on the c library support which varies across system/python build type (i.e. Jython, Cython, etc.).

import re
import datetime

# this regex removes all colons and all 
# dashes EXCEPT for the dash indicating + or - utc offset for the timezone
conformed_timestamp = re.sub(r"[:]|([-](?!((\d{2}[:]\d{2})|(\d{4}))$))", '', timestamp)

# split on the offset to remove it. use a capture group to keep the delimiter
split_timestamp = re.split(r"[+|-]",conformed_timestamp)
main_timestamp = split_timestamp[0]
if len(split_timestamp) == 3:
    sign = split_timestamp[1]
    offset = split_timestamp[2]
else:
    sign = None
    offset = None

# generate the datetime object without the offset at UTC time
output_datetime = datetime.datetime.strptime(main_timestamp +"Z", "%Y%m%dT%H%M%S.%fZ" )
if offset:
    # create timedelta based on offset
    offset_delta = datetime.timedelta(hours=int(sign+offset[:-2]), minutes=int(sign+offset[-2:]))
    # offset datetime with timedelta
    output_datetime = output_datetime + offset_delta

Answer 8

如果无论如何使用 pandas ，我可以推荐 时间戳来自pandas。 你可以在这里

ts_1 = pd.Timestamp('2020-02-18T04:27:58.000Z')    
ts_2 = pd.Timestamp('2020-02-18T04:27:58.000')

咆哮：令人难以置信的是，我们在 2021 年仍然需要​​担心日期字符串解析之类的事情。

Answer 9

Django 的 parse_datetime() 函数支持带有 UTC 偏移量的日期：

parse_datetime('2016-08-09T15:12:03.65478Z') =
datetime.datetime(2016, 8, 9, 15, 12, 3, 654780, tzinfo=<UTC>)

因此它可以用于解析整个项目中字段中的 ISO 8601 日期：

from django.utils import formats
from django.forms.fields import DateTimeField
from django.utils.dateparse import parse_datetime

class DateTimeFieldFixed(DateTimeField):
    def strptime(self, value, format):
        if format == 'iso-8601':
            return parse_datetime(value)
        return super().strptime(value, format)

DateTimeField.strptime = DateTimeFieldFixed.strptime
formats.ISO_INPUT_FORMATS['DATETIME_INPUT_FORMATS'].insert(0, 'iso-8601')

Answer 10

在所有受支持的 Python 版本中，将类似 ISO 8601 的日期字符串转换为 UNIX 时间戳或 datetime.datetime 对象（无需安装第三方模块）的一种直接方法是使用 SQLite 的日期解析器。

#!/usr/bin/env python
from __future__ import with_statement, division, print_function
import sqlite3
import datetime

testtimes = [
    "2016-08-25T16:01:26.123456Z",
    "2016-08-25T16:01:29",
]
db = sqlite3.connect(":memory:")
c = db.cursor()
for timestring in testtimes:
    c.execute("SELECT strftime('%s', ?)", (timestring,))
    converted = c.fetchone()[0]
    print("%s is %s after epoch" % (timestring, converted))
    dt = datetime.datetime.fromtimestamp(int(converted))
    print("datetime is %s" % dt)

输出：

2016-08-25T16:01:26.123456Z is 1472140886 after epoch
datetime is 2016-08-25 12:01:26
2016-08-25T16:01:29 is 1472140889 after epoch
datetime is 2016-08-25 12:01:29

Answer 11

另一种方法是使用 ISO-8601 的专用解析器，即使用 dateutil 解析器的 isoparse 函数：

from dateutil import parser

date = parser.isoparse("2008-09-03T20:56:35.450686+01:00")
print(date)

输出：

2008-09-03 20:56:35.450686+01:00

该函数在 标准 Python 函数 datetime.fromisoformat 的文档：

功能更齐全的 ISO 8601 解析器，dateutil.parser.isoparse 是
在第三方包 dateutil 中可用。

Answer 12

我是 iso8601utils 的作者。 它可以在 GitHub 或 PyPI。 以下是解析示例的方法：

>>> from iso8601utils import parsers
>>> parsers.datetime('2008-09-03T20:56:35.450686Z')
datetime.datetime(2008, 9, 3, 20, 56, 35, 450686)

Answer 13

我已经为 ISO 8601 标准编写了一个解析器并将其放在 GitHub 上： https://github.com/盒装/iso8601。 此实现支持规范中的所有内容，但持续时间、间隔、周期间隔和 Python datetime 模块支持的日期范围之外的日期除外。

包括测试！ ：P

Answer 14

如果你不想使用dateutil，你可以尝试这个功能：

def from_utc(utcTime,fmt="%Y-%m-%dT%H:%M:%S.%fZ"):
    """
    Convert UTC time string to time.struct_time
    """
    # change datetime.datetime to time, return time.struct_time type
    return datetime.datetime.strptime(utcTime, fmt)

测试：

from_utc("2007-03-04T21:08:12.123Z")

结果：

datetime.datetime(2007, 3, 4, 21, 8, 12, 123000)

Answer 15

这适用于 Python 3.2 及以上版本的 stdlib（假设所有时间戳均为 UTC）：

from datetime import datetime, timezone, timedelta
datetime.strptime(timestamp, "%Y-%m-%dT%H:%M:%S.%fZ").replace(
    tzinfo=timezone(timedelta(0)))

例如，

>>> datetime.utcnow().replace(tzinfo=timezone(timedelta(0)))
... datetime.datetime(2015, 3, 11, 6, 2, 47, 879129, tzinfo=datetime.timezone.utc)

Answer 16

如果您使用 Django，它提供了 dateparse 模块接受一堆类似于 ISO 格式的格式，包括时区。

如果您不使用 Django 并且不想使用此处提到的其他库之一，您可以调整 dateparse 的 Django 源代码到您的项目。

Answer 17

只需使用 python-dateutil 模块：

>>> import dateutil.parser as dp
>>> t = '1984-06-02T19:05:00.000Z'
>>> parsed_t = dp.parse(t)
>>> print(parsed_t)
datetime.datetime(1984, 6, 2, 19, 5, tzinfo=tzutc())

文档

Answer 18

我发现 ciso8601 是解析 ISO 8601 时间戳的最快方法。

它还完全支持 RFC 3339，并具有严格解析 RFC 3339 时间戳的专用功能。

用法示例：

>>> import ciso8601
>>> ciso8601.parse_datetime('2014-01-09T21')
datetime.datetime(2014, 1, 9, 21, 0)
>>> ciso8601.parse_datetime('2014-01-09T21:48:00.921000+05:30')
datetime.datetime(2014, 1, 9, 21, 48, 0, 921000, tzinfo=datetime.timezone(datetime.timedelta(seconds=19800)))
>>> ciso8601.parse_rfc3339('2014-01-09T21:48:00.921000+05:30')
datetime.datetime(2014, 1, 9, 21, 48, 0, 921000, tzinfo=datetime.timezone(datetime.timedelta(seconds=19800)))

GitHub Repo README 显示了它们与所有其他答案中列出的其他库。

我的个人项目涉及大量 ISO 8601 解析。 能够转接电话并加快速度真是太好了。 :)

编辑：我从此成为 ciso8601 的维护者。 现在比以前更快了！

Answer 19

如今，Arrow 也可以用作第三方解决方案：

>>> import arrow
>>> date = arrow.get("2008-09-03T20:56:35.450686Z")
>>> date.datetime
datetime.datetime(2008, 9, 3, 20, 56, 35, 450686, tzinfo=tzutc())

Answer 20

import re
import datetime
s = "2008-09-03T20:56:35.450686Z"
d = datetime.datetime(*map(int, re.split(r'[^\d]', s)[:-1]))

Answer 21

从 Python 3.7 开始，strptime 支持 UTC 偏移量中的冒号分隔符（源）。 因此，您可以使用：

import datetime

def parse_date_string(date_string: str) -> datetime.datetime
    try:
       return datetime.datetime.strptime(date_string, '%Y-%m-%dT%H:%M:%S.%f%z')
    except ValueError:
       return datetime.datetime.strptime(date_string, '%Y-%m-%dT%H:%M:%S%z')

编辑：

正如 Martijn 所指出的，如果您使用 isoformat() 创建了 datetime 对象，则只需使用 datetime.fromisoformat() 即可。

编辑 2：

正如 Mark Amery 所指出的，我添加了一个 try.. except 块来解释丢失的小数秒。

Answer 22

您得到的确切错误是什么？ 是不是像下面这样？

>>> datetime.datetime.strptime("2008-08-12T12:20:30.656234Z", "%Y-%m-%dT%H:%M:%S.Z")
ValueError: time data did not match format:  data=2008-08-12T12:20:30.656234Z  fmt=%Y-%m-%dT%H:%M:%S.Z

如果是，您可以将输入字符串拆分为“.”，然后将微秒添加到您获得的日期时间中。

尝试这个：

>>> def gt(dt_str):
        dt, _, us= dt_str.partition(".")
        dt= datetime.datetime.strptime(dt, "%Y-%m-%dT%H:%M:%S")
        us= int(us.rstrip("Z"), 10)
        return dt + datetime.timedelta(microseconds=us)

>>> gt("2008-08-12T12:20:30.656234Z")
datetime.datetime(2008, 8, 12, 12, 20, 30, 656234)

Answer 23

Python >= 3.11

fromisoformat 现在直接解析 Z：

from datetime import datetime

s = "2008-09-03T20:56:35.450686Z"

datetime.fromisoformat(s)
datetime.datetime(2008, 9, 3, 20, 56, 35, 450686, tzinfo=datetime.timezone.utc)

Python 3.7 到 3.10

来自注释之一的简单选项：将 'Z' 替换为 '+00:00' - 并使用 fromisoformat：

from datetime import datetime

s = "2008-09-03T20:56:35.450686Z"

datetime.fromisoformat(s.replace('Z', '+00:00'))
# datetime.datetime(2008, 9, 3, 20, 56, 35, 450686, tzinfo=datetime.timezone.utc)

为什么更喜欢 fromisoformat？

虽然 strptime 的 %z 可以将 'Z' 字符解析为 UTC，但 fromisoformat 速度更快by ~ x40 （对于 Python 3.11 甚至是 ~x60）：（

from datetime import datetime
from dateutil import parser

s = "2008-09-03T20:56:35.450686Z"

# Python 3.11+
%timeit datetime.fromisoformat(s)
85.1 ns ± 0.473 ns per loop (mean ± std. dev. of 7 runs, 10,000,000 loops each)

# Python 3.7 to 3.10
%timeit datetime.fromisoformat(s.replace('Z', '+00:00'))
134 ns ± 0.522 ns per loop (mean ± std. dev. of 7 runs, 10,000,000 loops each)

%timeit parser.isoparse(s)
4.09 µs ± 5.2 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)

%timeit datetime.strptime(s, '%Y-%m-%dT%H:%M:%S.%f%z')
5 µs ± 9.26 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)

%timeit parser.parse(s)
28.5 µs ± 99.2 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

GNU/Linux 上的 Python 3.11.3 x64）

另请参阅：更快的 strptime

Answer 24

尝试 iso8601 模块； 它正是这样做的。

python.org wiki 的 WorkingWithTime 页面上还提到了其他几个选项。

Answer 25

请注意，在 Python 2.6+ 和 Py3K 中，%f 字符捕获微秒。

>>> datetime.datetime.strptime("2008-09-03T20:56:35.450686Z", "%Y-%m-%dT%H:%M:%S.%fZ")

请参阅问题此处

Answer 26

从 Python 3.7 开始，您基本上可以不用使用 datetime.datetime.strptime 来解析 RFC 3339 日期时间，如下所示：

from datetime import datetime

def parse_rfc3339(datetime_str: str) -> datetime:
    try:
        return datetime.strptime(datetime_str, "%Y-%m-%dT%H:%M:%S.%f%z")
    except ValueError:
        # Perhaps the datetime has a whole number of seconds with no decimal
        # point. In that case, this will work:
        return datetime.strptime(datetime_str, "%Y-%m-%dT%H:%M:%S%z")

这有点尴尬，因为我们需要尝试两种不同的格式字符串才能同时支持这两种格式带有秒数小数部分的日期时间（例如 2022-01-01T12:12:12.123Z）和不带秒数的日期时间（例如 2022-01-01T12:12:12Z），两者在 RFC 3339 下都是有效的。但只要我们执行那一点点复杂的逻辑，这就是有效的。

关于此方法需要注意的一些注意事项：

• 从技术上来看，它并不完全支持 RFC 3339，因为 RFC 3339 奇怪地允许您使用空格而不是 T 来分隔日期和日期。尽管 RFC 3339 声称是 ISO 8601 的概要文件，但 ISO 8601 不允许这样做。 如果您想支持 RFC 3339 的这个愚蠢的怪癖，您可以将 datetime_str = datetime_str.replace(' ', 'T') 添加到函数的开头。
• 我上面的实现比严格的 RFC 3339 解析器应该稍微宽松一些，因为它允许时区偏移，例如不带冒号的 +0500 ，而 RFC 3339 不支持。 如果您不仅想解析已知的 RFC-3339 日期时间，还想严格验证您获得的日期时间是否为 RFC 3339，请使用其他方法或添加您自己的逻辑来验证时区偏移量格式。
• 此函数肯定不支持所有 ISO 8601，其中包含比 RFC 3339 更多的格式。（例如 2009-W01-1 code> 是有效的 ISO 8601 日期。）
• 它在 Python 3.6 或更早版本中不起作用，因为在那些旧版本中 %z 说明符仅匹配时区偏移量，例如 +0500 或 -0430 或 +0000，而不是 RFC 3339 时区偏移量，如 +05:00 或 - 04:30 或 Z。

Answer 27

从 Python 3.11 开始，标准库的 datetime.fromisoformat 支持任何有效的 ISO 8601 输入。 在早期版本中，它仅解析特定的子集，请参阅文档中的警告注释。 如果您在不属于该子集的字符串上使用 Python 3.10 或更早版本（如问题中所示），请参阅标准库外部函数的其他答案。 文档：

类方法 <代码>datetime.fromisoformat(date_string)：

返回与任何有效 ISO 8601 格式的 date_string 相对应的 datetime，但以下情况除外：

1. 时区偏移量可能包含小数秒。
2. T 分隔符可以替换为任何单个 unicode 字符。
3. 目前不支持序数日期。
4. 不支持小数小时和分钟。

示例：

<前><代码>>>> 从日期时间导入日期时间
>>>>> datetime.fromisoformat('2011-11-04')
日期时间. 日期时间(2011, 11, 4, 0, 0)
>>>>> datetime.fromisoformat('20111104')
日期时间. 日期时间(2011, 11, 4, 0, 0)
>>>>> datetime.fromisoformat('2011-11-04T00:05:23')
日期时间. 日期时间(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')
日期时间. 日期时间(2011, 11, 4, 0, 5, 23)
>>>>> datetime.fromisoformat('2011-W01-2T00:05:23.283')
日期时间. 日期时间(2011, 1, 4, 0, 5, 23, 283000)
>>>>> datetime.fromisoformat('2011-11-04 00:05:23.283')
日期时间. 日期时间(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(秒=14400)))

3.7 版中的新增功能。

在版本 3.11 中进行了更改：以前，此方法仅支持 date.isoformat() 或 datetime.isoformat() 可以发出的格式。

Answer 28

python-dateutil 中的 isoparse 函数

python-dateutil 包有 < code>dateutil.parser.isoparse 不仅可以解析 RFC 3339 日期时间字符串（如问题中的字符串），还可以解析其他 ISO 8601 不符合 RFC 3339 的日期和时间字符串（例如没有 UTC 偏移量的字符串，或仅表示日期的字符串）。

>>> import dateutil.parser
>>> dateutil.parser.isoparse('2008-09-03T20:56:35.450686Z') # RFC 3339 format
datetime.datetime(2008, 9, 3, 20, 56, 35, 450686, tzinfo=tzutc())
>>> dateutil.parser.isoparse('2008-09-03T20:56:35.450686') # ISO 8601 extended format
datetime.datetime(2008, 9, 3, 20, 56, 35, 450686)
>>> dateutil.parser.isoparse('20080903T205635.450686') # ISO 8601 basic format
datetime.datetime(2008, 9, 3, 20, 56, 35, 450686)
>>> dateutil.parser.isoparse('20080903') # ISO 8601 basic format, date only
datetime.datetime(2008, 9, 3, 0, 0)

python-dateutil 包还具有 <代码>dateutil.parser.parse。 与isoparse相比，它可能不太严格，但是它们都非常宽容，并且会尝试解释您传入的字符串。如果您想消除任何误读的可能性，您需要使用比这两个函数更严格的函数。

与 Python 3.7+ 内置 datetime 的比较。 datetime.fromisoformat

dateutil.parser.isoparse 是一个完整的 ISO-8601 格式解析器，但在 Python ≤ 3.10 中 fromisoformat 是故意的不是。。 在 Python 3.11 中，fromisoformat 支持有效 ISO 8601 中的几乎所有字符串。有关此警告的警告，请参阅 fromisoformat 的文档。 （请参阅此答案）。