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

Question

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

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

最好的方法是什么？

Answer 1

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

>>> 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 2

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

Answer 3

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

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

Answer 4

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

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

见问题here

Answer 5

对于适用于 2.X 标准库的内容，请尝试：

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

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

Answer 6

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

包括测试！ :P

Answer 7

isoparse 来自 python-dateutil 的函数

python-dateutil 包具有 dateutil.parser.isoparse 不仅可以解析 RFC 3339 日期时间字符串，如问题中的字符串，还可以解析其他不符合 RFC 3339 的 ISO 8601 日期和时间字符串（例如没有 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 比较

datutil.parser.isoparse 是一个完整的 ISO-8601 格式解析器，但 fromisoformat 故意不是。请参阅后一个函数的文档以了解此警告性警告。 （见this answer）。

Answer 8

如果解析无效的日期字符串，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 9

如果不想使用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 10

现在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 11

这适用于 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 12

Several answers here suggest 使用 datetime.datetime.strptime 解析带有时区的 RFC 3339 或 ISO 8601 日期时间，就像问题中展示的那样：

2008-09-03T20:56:35.450686Z

这是个坏主意。

假设您想要支持完整的 RFC 3339 格式，包括对 UTC 偏移量（非零）的支持，那么这些答案建议的代码不起作用。事实上，它不能工作，因为使用 strptime 解析 RFC 3339 语法是不可能的。 Python 的 datetime 模块使用的格式字符串无法描述 RFC 3339 语法。

问题在于 UTC 偏移量。 RFC 3339 Internet Date/Time Format 要求每个日期时间都包含一个 UTC 偏移量，并且这些偏移量可以是 Z（“祖鲁时间”的缩写）或 +HH:MM 或 -HH:MM 格式，例如 +05:00 或 @ 987654336@.

因此，这些都是有效的 RFC 3339 日期时间：

• 2008-09-03T20:56:35.450686Z
• 2008-09-03T20:56:35.450686+05:00
• 2008-09-03T20:56:35.450686-10:30

唉，strptime 和 strftime 使用的格式字符串没有对应于 RFC 3339 格式的 UTC 偏移量的指令。他们支持的指令的完整列表可以在https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior找到，列表中唯一包含的UTC偏移指令是%z：

%z

+HHMM 或 -HHMM 形式的 UTC 偏移量（如果对象是幼稚的，则为空字符串）。

示例：（空）、+0000、-0400、+1030

这与 RFC 3339 偏移的格式不匹配，事实上，如果我们尝试在格式字符串中使用 %z 并解析 RFC 3339 日期，我们将会失败：

>>> from datetime import datetime
>>> datetime.strptime("2008-09-03T20:56:35.450686Z", "%Y-%m-%dT%H:%M:%S.%f%z")
Traceback (most recent call last):
  File "", line 1, in 
  File "/usr/lib/python3.4/_strptime.py", line 500, in _strptime_datetime
    tt, fraction = _strptime(data_string, format)
  File "/usr/lib/python3.4/_strptime.py", line 337, in _strptime
    (data_string, format))
ValueError: time data '2008-09-03T20:56:35.450686Z' does not match format '%Y-%m-%dT%H:%M:%S.%f%z'
>>> datetime.strptime("2008-09-03T20:56:35.450686+05:00", "%Y-%m-%dT%H:%M:%S.%f%z")
Traceback (most recent call last):
  File "", line 1, in 
  File "/usr/lib/python3.4/_strptime.py", line 500, in _strptime_datetime
    tt, fraction = _strptime(data_string, format)
  File "/usr/lib/python3.4/_strptime.py", line 337, in _strptime
    (data_string, format))
ValueError: time data '2008-09-03T20:56:35.450686+05:00' does not match format '%Y-%m-%dT%H:%M:%S.%f%z'

（实际上，上面的内容正是您在 Python 3 中看到的。在 Python 2 中，我们会因为更简单的原因失败，那就是 strptime does not implement the %z directive at all in Python 2。）

此处推荐strptime 的多个答案都可以通过在其格式字符串中包含文字Z 来解决此问题，该字符串与提问者示例日期时间字符串中的Z 匹配（并丢弃它，生成@987654350 @没有时区的对象）：

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

由于这会丢弃原始日期时间字符串中包含的时区信息，因此我们是否应该将这个结果视为正确是值得怀疑的。但更重要的是，因为这种方法涉及将特定的 UTC 偏移量硬编码到格式字符串中，它会在尝试解析任何具有不同 UTC 偏移量的 RFC 3339 日期时间时阻塞：

>>> datetime.strptime("2008-09-03T20:56:35.450686+05:00", "%Y-%m-%dT%H:%M:%S.%fZ")
Traceback (most recent call last):
  File "", line 1, in 
  File "/usr/lib/python3.4/_strptime.py", line 500, in _strptime_datetime
    tt, fraction = _strptime(data_string, format)
  File "/usr/lib/python3.4/_strptime.py", line 337, in _strptime
    (data_string, format))
ValueError: time data '2008-09-03T20:56:35.450686+05:00' does not match format '%Y-%m-%dT%H:%M:%S.%fZ'

除非您确定只需要支持祖鲁时间的 RFC 3339 日期时间，而不需要支持其他时区偏移的日期时间，否则不要使用 strptime。请改用此处答案中描述的许多其他方法之一。

Answer 13

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

如果您不使用 Django 并且不想使用此处提到的其他库之一，您可以将 the Django source code for dateparse 调整为您的项目。

Answer 14

感谢伟大的Mark Amery's answer 我设计了一个函数来解释所有可能的日期时间 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 15

因为 ISO 8601 允许出现许多可选的冒号和破折号，基本上是CCYY-MM-DDThh:mm:ss[Z|(+|-)hh:mm]。如果要使用 strptime，则需要先去除这些变化。

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

---

如果您只想要一个适用于带有 Z 后缀的 UTC 的基本案例，例如 2016-06-29T19:36:29.3453Z：

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

---

如果您想处理 2016-06-29T19:36:29.3453-0400 或 2008-09-03T20:56:35.450686+05:00 之类的时区偏移量，请使用以下命令。这些会将所有变体转换为没有变量分隔符的东西，例如20080903T205635.450686+0500，使其更一致/更易于解析。

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" )

---

如果您的系统不支持%z strptime 指令（您会看到类似ValueError: 'z' is a bad directive in format '%Y%m%dT%H%M%S.%f%z' 的内容），那么您需要手动偏移Z (UTC) 的时间。注意%z 可能无法在您的系统上运行 python 版本 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 16

def parseISO8601DateTime(datetimeStr):
    import time
    from datetime import datetime, timedelta

    def log_date_string(when):
        gmt = time.gmtime(when)
        if time.daylight and gmt[8]:
            tz = time.altzone
        else:
            tz = time.timezone
        if tz > 0:
            neg = 1
        else:
            neg = 0
            tz = -tz
        h, rem = divmod(tz, 3600)
        m, rem = divmod(rem, 60)
        if neg:
            offset = '-%02d%02d' % (h, m)
        else:
            offset = '+%02d%02d' % (h, m)

        return time.strftime('%d/%b/%Y:%H:%M:%S ', gmt) + offset

    dt = datetime.strptime(datetimeStr, '%Y-%m-%dT%H:%M:%S.%fZ')
    timestamp = dt.timestamp()
    return dt + timedelta(hours=dt.hour-time.gmtime(timestamp).tm_hour)

请注意，如果字符串不以Z 结尾，我们可以使用%z 进行解析。

Answer 17

在不安装第三方模块的情况下，在所有受支持的 Python 版本中将类似 ISO 8601 的日期字符串转换为 UNIX 时间戳或 datetime.datetime 对象的一种直接方法是使用 date parser of 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 18

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 19

我是 iso8601 utils 的作者。可以在on GitHub 或PyPI 上找到它。以下是解析示例的方法：

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

Answer 20

只需使用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())

Documentation

Answer 21

我发现ciso8601 是解析 ISO 8601 时间戳的最快方法。顾名思义，它是用 C 语言实现的。

import ciso8601
ciso8601.parse_datetime('2014-01-09T21:48:00.921000+05:30')

GitHub Repo README 与其他答案中列出的所有其他库相比，其速度提高了 10 倍以上。

我的个人项目涉及大量 ISO 8601 解析。能够切换通话并以 10 倍的速度运行真是太好了。 :)

编辑：我已经成为 ciso8601 的维护者。现在比以往任何时候都快！

Answer 22

从 Python 3.7 开始，strptime 支持 UTC 偏移量中的冒号分隔符 (source)。所以你可以使用：

import datetime
datetime.datetime.strptime('2018-01-31T09:24:31.488670+00:00', '%Y-%m-%dT%H:%M:%S.%f%z')

编辑：

正如 Martijn 所指出的，如果你使用 isoformat() 创建了 datetime 对象，你可以简单地使用 datetime.fromisoformat()

Answer 23

自 Python 3.7 起，datetime 标准库具有反转 datetime.isoformat() 的函数。

classmethod datetime.fromisoformat(date_string):

以date.isoformat() 和datetime.isoformat() 发出的格式之一返回与date_string 对应的datetime。

具体来说，此函数支持以下格式的字符串：

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

* 可以匹配任何单个字符。

注意：这不支持解析任意 ISO 8601 字符串 - 它仅用作 datetime.isoformat() 的逆运算。

例子：

>>> from datetime import datetime
>>> datetime.fromisoformat('2011-11-04')
datetime.datetime(2011, 11, 4, 0, 0)

…

请务必阅读文档中的注意事项！

Answer 24

现在有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 25

最初我尝试过：

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 26

另一种方法是使用专门的 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

documentation for the standard Python function datetime.fromisoformat中也提到了这个功能：

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

Answer 27

其中一个 cmets 的简单选项：将 'Z' 替换为 '+00:00' - 并使用 Python 3.7+ 的 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)

虽然strptime 可以将'Z' 字符解析为UTC，但fromisoformat 的速度要快〜x40（另见：A faster strptime）：

%timeit datetime.fromisoformat(s.replace('Z', '+00:00'))
346 ns ± 22.3 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

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

%timeit dateutil.parser.parse(s)
80.1 µs ± 3.32 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

（Windows 10 上的 Python 3.8.7 x64）

Answer 28

如果还是使用pandas，我可以从pandas 推荐Timestamp。在那里你可以

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

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