class QDateTime#

QDateTime 类提供日期和时间功能。更多信息...

摘要#

方法#

静态函数#

注意

本文档可能包含从 C++ 自动翻译到 Python 的片段。我们随时欢迎对片段翻译的贡献。如果您发现翻译问题，也可以通过在 https:/bugreports.qt.io/projects/PYSIDE 上创建一个故障单来告知我们

详细说明#

一个 QDateTime 对象根据时间表示法编码日历日期和时间（称为“日期时间”）。它结合了QDate和QTime类的功能。它可以从系统时钟读取当前的日期时间。它提供比较日期时间的函数，以及通过添加秒数、天数、月份或年数来操作日期时间的函数。

QDateTime可以根据本地时间、UTC、指定的UTC偏移量或指定的时区来描述日期时间。这些时间表示法中的每一个都可以封装在QTimeZone类的适当实例中。例如，“Europe/Berlin”时区将应用德国使用的时间节约规则。相比之下，从UTC到+3600秒的固定偏移量比UTC快一个小时（通常以ISO标准表示法写成“UTC+01:00”），没有日间节省问题。当使用本地时间或指定时区时，会考虑时区转换（见下文）。QDateTime的timeSpec()会告诉您正在使用哪种时间表示法的四种类型之一；它的timeRepresentation()提供了一个关于该时间表示法的完整描述，作为一个QTimeZone。

QDateTime 对象通常通过在构造函数中明确给出日期和时间来创建，或者使用静态函数，例如 currentDateTime() 或 fromMSecsSinceEpoch()。可以使用 setDate() 和 setTime() 修改日期和时间。还可以使用 setMSecsSinceEpoch() 函数设置日期时间，该函数接收自1970年1月1日起的毫秒时间戳。函数 fromString() 根据用于在字符串中解释日期的日期格式，返回一个 QDateTime。

currentDateTime() 返回一个表达相对于特定时间表示（如本地时间，默认值）的当前日期和时间的 QDateTime。函数 currentDateTimeUtc() 返回一个相对于 UTC 的当前日期和时间表达方式；它等同于 QDateTime::currentDateTime(QTimeZone::UTC)。

date() 和 time() 函数提供了对日期时间中的日期和时间部分的访问。函数 toString() 以文本格式提供相同的信息。

QDateTime 提供了一整套操作符来比较两个 QDateTime 对象，其中较小的表示较早，较大的表示较晚。

您可以使用addMSecs()(增加/减少毫秒)、addSecs()(增加/减少秒)或addDays()(增加/减少天)来增加（或减少）日期时间。同样，您可以使用addMonths()和addYears()。函数daysTo()返回两个日期时间之间的天数，secsTo()返回两个日期时间之间的秒数，而msecsTo()返回两个日期时间之间的毫秒数。这些操作可感知夏令时（DST）和其他适用的时间区域转移。

使用toTimeZone()将日期时间重新表达为不同的时间表示。通过传递代表本地时间、UTC或相对于UTC的固定偏移的轻量级QTimeZone，可以将日期时间转换为对应的时间表示；或者，您可以传递完整的时间区域（其timeSpec()是Qt::TimeZone）以替代。

备注

注意

QDateTime不计入闰秒。

注意

所有转换为字符串格式和从字符串格式转换的操作都使用C区域设置。有关本地化转换，请参阅QLocale。

注意

格里历没有公元0年。该年份的日期被认为是无效的。公元前1年是“耶稣纪元前1年”或“公历纪元前1年”。公元1年1月1日之前的一天是公元前1年12月31日。

注意

使用本地时间（默认）或指定的时间区域意味着需要解决与transitions相关的任何问题。因此，对这样的QDateTime实例的操作（包括构造它们）可能比使用UTC或相对于UTC的固定偏移更昂贵。

有效日期范围

QDateTime 能表示的值范围取决于内部存储实现。当前 QDateTime 存储在 qint64 中，作为一个序列毫秒值，编码日期和时间。这限制了日期范围约为 ±292 百万年，相比 QDate 的 ±20 亿年范围。在创建带有极端值的 QDateTime 时必须注意不要超出存储范围。支持的值的确切范围取决于所使用的时间表示方法。

时区使用#

QDateTime 使用系统的时区信息来确定当前本地时区和其与 UTC 的偏移量。如果系统配置不正确或未更新，QDateTime 将给出错误的结果。

QDateTime 同样使用系统提供的信息来确定其他时区与 UTC 的偏移。如果这些信息不完整或过时，QDateTime 将给出错误的结果。更多详情请参阅 QTimeZone 文档。

在现代化的 Unix 系统上，这意味着当可能时，QDateTime 常常有关历史转换（包括夏令时，见下文）的准确信息。在系统不支持历史时区数据的 Windows 上，时区转换（包括夏令时）的准确性不受维护。然而，通过 ICU 库构建 Qt 将使 QTimeZone 技术与 Unix 上的时区数据库相同。

时区转换#

QDateTime 考虑了时区转换，包括标准时间和夏令时（DST）之间的转换，以及当区域更改其标准偏移时出现的转换。例如，如果转换是在凌晨 2 点，时钟前进到凌晨 3 点，则从 02:00:00 到 02:59:59.999 之间有一个“缺失”的小时。这种转换被称为“向前飞跃”，而跳过的这些时间没有意义。当转换另一方时，称为“回退”，一个时间间隔会重复，首先是旧区域（通常是 DST），然后是新区域（通常是标准时间），因此这个时间间隔中的时间是模糊的。

一些区域使用“反转”时差制，即在夏季使用标准时间和在冬季使用夏令时（减小时差）。对于这类区域，春季逆向变化仍然发生在春季并跳过一小时，但这是从夏令时过渡出来的；而秋季回拨仍然重复一个秋季小时，但这是进入夏令时的过渡。

将UTC时间（或与UTC有固定偏差的时间）转换后，在任何时区内总会有一个明确的合法结果。然而，当将日期和时间组合生成datetime时，相对于本地时间或特定时区，名义结果可能落入过渡期，使其无效或产生歧义。可能发生此类情况的解决方案会包含一个resolve参数：如果请求的datetime是合法的且无歧义的，则总是忽略该参数。请参阅TransitionResolution以了解它可以控制的选项。在Qt 6.7之前，其LegacyBehavior等价项被选中。

对于跳过的春季前时间间隔，使用任何偏移量解释请求的时间都会得到实际时间，这是使用另一个偏移量的时候；所以对于resolve传递TransitionResolution::RelativeToBefore将实际上得到过渡之后的时间，而这将是如果没有过渡发生的请求表示形式。同样，对于resolve的TransitionResolution::RelativeToAfter，结果是一个过渡之前的时间，而这将是如果过渡提前发生所请求的表示。

当QDateTime执行算术运算时，如使用addDay()或addSecs()，它会注意产生一个合法的结果。例如，在从02:00到03:00进行春季前拨的一天，将01:59:59加上一秒将得到03:00:00。在之前的一天将02:30加一天将得到过渡之日的03:30，而通过调用addDay(-1)从过渡后的一天的02:30减去一天将得到过渡之日的01:30。虽然addSecs()会提供给定秒数偏移的时间，但addDays()会调整日期，并且只有当否则得到无效结果时才会调整时间。在春季前拨的前一天将03:00应用addDays(1)只会得到过渡之日的03:00，尽管后者只是前者的23小时后；但应用addSecs(24 * 60 * 60)将在过渡之日得到04:00，因为那是24小时后。典型的过渡会使得某些日子的时间长度为23或25小时。

对于系统time_t能够表示的日期时间（在32位time_t系统上从1901-12-14到2038-01-18；如果类型是64位，则QDateTime可以表示整个范围），标准系统API用于确定本地时间与UTC的偏差。对于这些系统API未处理的日期时间（可能包括time_t范围内的某些日期时间），如果可用，使用systemTimeZone()或尽力估计。无论如何，使用的偏移信息取决于系统，可能不完整，或对于过去的日期，可能存在历史不准确性。此外，对于未来的日期，本地时区偏移量和夏令时规则在日期到来之前可能发生变化。

整日过渡#

少数时区在穿越自己的国际日期变更线时跳过或重复了整个一天。对于这些时区，daysTo()将不知晓重复或缺失，只使用日历日期的差异；相比之下，msecsTo()和secsTo()知道真实的时间间隔。同样地，addMSecs()和addSecs()直接对应于经过的时间，而addDays()、addMonths()和addYears()则遵循正规日历，除非落在间隙或重复中需要解决因重复或省略而产生的歧义或无效性。

注意

在日历改变期间“丢失”的日期，例如从朱利安历到格里历，不影响QDateTime。尽管两个日历对日期的描述不同，但改变之间的连续日子由连续的QDate实例描述，每个实例比前一个实例晚一天，无论是按照日历还是按照它们的toJulianDay()值。相反，一个时区跳过或复制一天是在改变其对时间的描述，而不改变日期，尽管它在一个完整的24小时之内完成了这个动作。

UTC偏差#

UTC偏移距离是以格林尼治东部秒数来衡量的。特定日期和时间所描述的时刻（如某一日的中午）取决于使用的时间表示法。那些UTC偏移量较大的描述了较早的时刻，而那些UTC偏移量较小的描述了较晚的时刻，无论使用何种日期时间组合。

对于UTC的偏移没有明确规定的大小限制，但在使用`toString()` 和 `fromString()` 方法时，这些方法使用±hh:mm格式，实际上限制了范围在±99小时和59分钟，并且只能是整数分钟。注意，目前没有任何时区偏移量超出±14小时的范围，并且所有已知的偏移量都是五分钟的倍数。历史上的时区范围更广，可能包含秒的偏移；这些最后的无法在字符串中可靠地表示。

另请参阅

QDate QTime QTimeZone

class TransitionResolution#

此枚举用于解决落在 时区转换 中的日期时间组合。

当以本地时间或具有夏令时的时区为条件构造日期时间，或使用`setDate()`，`setTime()`或`setTimeZone()`方法修改日期时间时，给定的参数可能表示没有意义或在该时区中有两种可能意义的时间表示。这些时间表示称为转换。在两种情况下，我们都可以简单地返回一个无效的日期时间，以表示该操作未定义。在模糊的情况下，我们可以选择其中两个可能的时间之一。当没有意义时，我们可以选择转换之两侧的时间，这些时间可能可靠地代表了所期望的时间。例如，当从较早的时间推进时，我们可以选择转换后实际是所求较早时间所述时间的实际持续时间的时间。这里指定的选项配置了如何执行此类选择。

常量

描述

QDateTime.TransitionResolution.Reject

将转换中的任何时间视为无效。这可能确实是这样，也可能是有歧义的。

QDateTime.TransitionResolution.RelativeToBefore

选择时间，就好像在转换之前向前移动。这使用转换前的偏移量来解释请求的时间，如果需要，会将结果转换为结果时间有效的偏移量。

QDateTime.TransitionResolution.RelativeToAfter

从转换后的时间开始按时间倒退选择一个时间。这使用转换后有效的偏移量来解释请求的时间，并在需要的情况下将结果转换为结果时间有效的偏移量。

QDateTime.TransitionResolution.PreferBefore

选择转换之前的时间,

QDateTime.TransitionResolution.PreferAfter

选择转换之后的时间。

QDateTime.TransitionResolution.PreferStandard

选择转换标准时间一侧的时间。

QDateTime.TransitionResolution.PreferDaylightSaving

选择转换夏令时一侧的时间。

QDateTime.TransitionResolution.LegacyBehavior

是RelativeToBefore的别名，用作TransitionResolution参数的默认值，因为它最接近Qt 6.7之前的行为。

对于addDays()、addMonths()或addYears()，当添加正值时使用 RelativeToBefore，添加负值时使用 RelativeToAfter。

注意

在夏令时时增加UTC偏移量的时区（称为“正夏令时”），PreferStandard是RelativeToAfter的别名，PreferDaylightSaving是RelativeToBefore的别名。在冬天偏移UTC减少的时区（称为“负夏令时”）中，情况相反，前提是操作系统报告了-，就像大多数平台一样，表示datetime是否在夏令时或标准时间。对于某些平台，即使对于具有TimeZone datingtimes的时区，QTimeZone也必须假设与UTC偏移量较小的一侧是标准时间，从而有效地假设正夏令时。

以下表说明了QDateTime构造函数如何在一个当地时间在02:00和03:00之间转换的日期上请求02:30，两个时间侧分别为名义标准时间（LST）和夏令时时间（LDT），在不同情况下如何解析请求。转换类型可能是跳过一个小时或重复一个小时。转换类型和参数resolve的值确定选择给定日期上的实际哪个时间。首先，正面夏令时的常见情况，其中

之前

02:00–03:00

之后

解决

选择

LST

跳过

LDT

RelativeToBefore

03:30 LDT

LST

跳过

LDT

RelativeToAfter

01:30 LST

LST

跳过

LDT

PreferBefore

01:30 LST

LST

跳过

LDT

PreferAfter

03:30 LDT

LST

跳过

LDT

PreferStandard

01:30 LST

LST

跳过

LDT

PreferDaylightSaving

03:30 LDT

LDT

重复

LST

RelativeToBefore

02:30 LDT

LDT

重复

LST

RelativeToAfter

02:30 LST

LDT

重复

LST

PreferBefore

02:30 LDT

LDT

重复

LST

PreferAfter

02:30 LST

LDT

重复

LST

PreferStandard

02:30 LST

LDT

重复

LST

PreferDaylightSaving

02:30 LDT

其次，对于负夏令时的情况，使用冬天的LDT，跳过一个小时过渡到夏天的LST，然后回转到冬天的正夏令时重复一个小时。

LDT

跳过

LST

RelativeToBefore

03:30 LST

LDT

跳过

LST

RelativeToAfter

01:30 LDT

LDT

跳过

LST

PreferBefore

01:30 LDT

LDT

跳过

LST

PreferAfter

03:30 LST

LDT

跳过

LST

PreferStandard

03:30 LST

LDT

跳过

LST

PreferDaylightSaving

01:30 LDT

LST

重复

LDT

RelativeToBefore

02:30 LST

LST

重复

LDT

RelativeToAfter

02:30 LDT

LST

重复

LDT

PreferBefore

02:30 LST

LST

重复

LDT

PreferAfter

02:30 LDT

LST

重复

LDT

PreferStandard

02:30 LST

LST

重复

LDT

PreferDaylightSaving

02:30 LDT

可以使用“拒绝”来提示相关的QDateTime API返回一个无效的日期时间对象，以便您的代码能够自行处理转换，例如通过警告用户所选日期时间处于转换间隔内，给他们机会解决冲突或歧义。使用此代码可能会有助于确定在本机（或用户的）解决方案中使用的相关信息。如果转换的开始或结束，或转换本身，是正确的解决方案，可以使用QTimeZone的转换API来获取该信息。您可以通过使用secsTo()来测量前一天的午时和后一天的午时之间的实际时间来确定转换是重复的还是跳过的间隔。跳过的间隔（如夏令时）的结果将少于48小时，而重复的间隔（如冬令时）的结果将大于48小时。

注意

当指定了除“拒绝”以外的解决方案时，如果可能，将返回一个有效的QDateTime对象。如果请求的日期时间落在间隔中，返回的日期时间将不具有请求的time() -或者在某些情况下，如果整日被跳过，是date()。因此，您可以通过比较请求的日期时间与日期和时间的差异来检测何时遇到间隔。

与其他日期时间软件的关系#

Python编程语言的日期时间API有一个对应于RelativeToBefore（fold = True）和RelativeToAfter（fold = False）的fold参数。

用于替换JavaScript中Date的Temporal建议为解决转换提供了四个选项，作为disambiguation参数的值。其'reject'会抛出一个异常，大致对应于产生无效结果的Reject。其'earlier'和'later'选项对应于PreferBefore和PreferAfter。其'compatible'选项对应于RelativeToBefore（以及Python的fold = True）。

另请参阅

Timezone transitions TransitionResolution

6.7 版本中新加入。

class YearRange#

这个枚举类型描述了由 QDateTime 表示的格里高利日历年份的范围

常量

描述

QDateTime.YearRange.First

表示年中之后的年份

QDateTime.YearRange.Last

表示年中之前的年份

所有严格位于这两个年份之间的日期也可以表示。注意，然而，格里高利日历没有公元0年。

注意

QDate 可以描述更广范围内的日期。对于大多数用途，这几乎没有差别，因为 QDateTime 可以支持的年份范围为1970年前后2900万年。

另请参阅

isValid() QDate

__init__(date, time[, resolve=QDateTime.TransitionResolution.LegacyBehavior])#
参数：

这是一个重载函数。

使用本地时间构建一个具有给定 date 和 time 的日期时间。

如果 date 是有效的而 time 不是，则使用午夜作为时间。如果 date 和 time 描述的时间接近本地时间转换的过渡时刻，则 resolve 控制如何解决这种情况。

注意

在 Qt 6.7 之前，此函数的版本缺少 resolve 参数，因此没有解决与转换相关的歧义的方法。

__init__(date, time, spec[, offsetSeconds=0])
参数：

使用 QDateTime(date, time) 或 QDateTime(date, time, QTimeZone::fromSecondsAheadOfUtc(offsetSeconds))。

使用给定的 date 和 time 构建一个日期时间，使用 spec 和 offsetSeconds 秒所隐含的时间表示。

如果 date 有效且 time 无效，则时间将被设置为午夜。

如果 spec 不是 OffsetFromUTC，则 offsetSeconds 将会被忽略。如果 spec 是 OffsetFromUTC 且 offsetSeconds 为 0，则 timeSpec() 将被设置为 UTC，即 0 秒的偏移。

如果 spec 是 TimeZone，则 spec 将被设置为 LocalTime，即当前系统时区。要创建一个 TimeZone 日期时间，使用正确的构造函数。

如果 date 超出了 QDateTime 表示日期的范围，则结果是无效的。如果 spec 是 LocalTime 并且系统的时区跳过了给定的日期和时间，则结果是无效的。

__init__(date, time, timeZone[, resolve=QDateTime.TransitionResolution.LegacyBehavior])
参数：

使用给定的 date 和 time，以及由 timeZone 描述的时间表示来构建日期时间。

如果date有效而time无效，则时间将设置为午夜。如果timeZone无效，则日期时间将无效。如果date和time描述的是ποινο χρόνου για την παράβαση τουtimeZone nearby transition, resolve controls how this situation is resolved.

注意

在 Qt 6.7 之前，此函数的版本缺少 resolve 参数，因此没有解决与转换相关的歧义的方法。

__init__(other)
参数：

other – QDateTime

构建一个other的时间日期副本。

__init__(arg__1, arg__2, arg__3, arg__4, arg__5, arg__6)
参数：

  • arg__1 – int

  • arg__2 – int

  • arg__3 – int

  • arg__4 – int

  • arg__5 – int

  • arg__6 – int

__init__(arg__1, arg__2, arg__3, arg__4, arg__5, arg__6, arg__7[, arg__8=Qt.LocalTime])
参数：

  • arg__1 – int

  • arg__2 – int

  • arg__3 – int

  • arg__4 – int

  • arg__5 – int

  • arg__6 – int

  • arg__7 – int

  • arg__8 – TimeSpec

__init__(arg__1, arg__2, arg__3, arg__4, arg__5, arg__6, arg__7[, arg__8=Qt.LocalTime])
参数：

  • arg__1 – int

  • arg__2 – int

  • arg__3 – int

  • arg__4 – int

  • arg__5 – int

  • arg__6 – int

  • arg__7 – int

  • arg__8 – int

__init__()

构建一个空的时间日期，名义上使用本地时间。

空的时间日期是无效的，因为它的时间和日期无效。

__reduce__()#
返回类型：

object

__repr__()#
返回类型：

object

addDays(days)#
参数：

days – 整数

返回类型：

QDateTime

返回一个包含日期时间的 QDateTime 对象，这个时间对象比当前对象的时间提前 ndays 天（如果 ndays 为负数，则为晚于）。

如果 timeSpec() 是 LocalTime 或 TimeZone，并且所得的日期和时间落在标准时间和夏令时转换时段内，则结果将正好处于转换时分的另一端。如果转换发生在凌晨2点，时钟向前到3点，则2点和3点之间目标的结果将被调整为在2点之前（如果 ndays < 0）或之后3点（否则）。

另请参阅

daysTo() addMonths() addYears() addSecs() Timezone transitions

addMSecs(msecs)#
参数：

msecs – 整数

返回类型：

QDateTime

返回一个包含日期时间对象的 QDateTime，这个时间对象比当前对象的时间提前 msecs 毫秒（如果 msecs 为负数，则为晚于）。

如果此日期时间无效，将返回无效的日期时间。

addMonths(months)#
参数：

months – int

返回类型：

QDateTime

返回一个包含日期时间对象（nmonths）月份之后（nmonths为负数则结果相反）的 QDateTime 对象。

如果 timeSpec() 为 LocalTime 或 TimeZone，并且结果的日期时间落在了标准时间和夏令时过渡的小时内，则结果将恰好在时间改变方向之前（如果 nmonths 小于 0，则结果将在2点之前调整；否则在3点之后调整）。

另请参阅

daysTo() addDays() addYears() addSecs() Timezone transitions

addSecs(secs)#
参数：

secs – int

返回类型：

QDateTime

返回一个包含日期时间对象（s）秒之后（s为负数则结果相反）的 QDateTime 对象。

如果此日期时间无效，将返回无效的日期时间。

addYears(years)#
参数：

years – int

返回类型：

QDateTime

返回一个包含nyears年后（或如果nyears为负数则 earlier）的日期和时间对象的QDateTime对象。

如果timeSpec()是LocalTime或TimeZone，并且得到的日期和时间落在了标准时间和夏令时转换时，结果将是在这个时差之后的区间内，朝着变化的方向。如果转换是在凌晨 2 点进行，并且时钟向前调到 3 点，那么 2 点和 3 点之间的结果将被调整为落在 2 点之前（如果nyears < 0）或之后。

另请参阅

daysTo() addDays() addMonths() addSecs() Timezone transitions

静态currentDateTime(zone)
参数：

zone – QTimeZone

返回类型：

QDateTime

返回系统时钟的当前日期和时间，使用由zone描述的时间表示。如果省略zone，则使用本地时间。

静态currentDateTime()
返回类型：

QDateTime

这是一个重载函数。

静态currentDateTimeUtc()
返回类型：

QDateTime

返回系统时钟的当前日期和时间，以UTC表示。

与currentDateTime(QTimeZone::UTC)等效。

静态currentMSecsSinceEpoch()#
返回类型：

int

返回自1970年1月1日起的当前UTC时间的毫秒数。

这个数值类似于POSIX中的time_t变量，但以毫秒为单位而不是秒。

静态currentSecsSinceEpoch()#
返回类型：

int

返回自1970年1月1日起的当前UTC时间的秒数。

这个数值类似于POSIX中的time_t变量。

date()#
返回类型：

QDate

返回datetime的日期部分。

daysTo(arg__1)#
参数：

arg__1 – QDateTime

返回类型：

int

警告

本节包含从C++到Python自动翻译的代码片段，可能包含错误。

返回从当前datetime到其他datetime的天数。天数是午夜之间的次数。这意味着从23:55到第二天0:05的10分钟差算作一天。

如果其他datetime早于当前datetime，返回的值是负数。

示例

startDate = QDateTime(QDate(2012, 7, 6), QTime(8, 30, 0))
endDate = QDateTime(QDate(2012, 7, 7), QTime(16, 30, 0))
print("Days from startDate to endDate: ", startDate.daysTo(endDate))
startDate = QDateTime(QDate(2012, 7, 6), QTime(23, 55, 0))
endDate = QDateTime(QDate(2012, 7, 7), QTime(0, 5, 0))
print("Days from startDate to endDate: ", startDate.daysTo(endDate))
qSwap(startDate, endDate) # Make endDate before startDate.
print("Days from startDate to endDate: ", startDate.daysTo(endDate))

另请参阅

addDays() secsTo() msecsTo()

staticfromMSecsSinceEpoch(msecs, timeZone)#
参数：
返回类型：

QDateTime

这是一个重载函数。

返回一个datetime对象，表示自1970年1月1日UTC时间开始后的给定毫秒数msecs所代表的具体时刻，由timeZone指定。默认时间表示为本地时间。

请注意，存在一些值为msecs的值可能位于QDateTime的有效范围之外，包括负数和正数。对于这些值，此函数的行为是未定义的。

staticfromMSecsSinceEpoch(msecs, spec[, offsetFromUtc=0])
参数：

  • msecs – 整数

  • spec – TimeSpec

  • offsetFromUtc – int

返回类型：

QDateTime

这是一个重载函数。

传递一个QTimeZone对象，或者省略spec和offsetSeconds。

返回一个datetime对象，表示自1970年1月1日UTC时间开始后的给定的毫秒数msecs所代表的具体时刻，由spec和offsetSeconds指定。

请注意，存在一些值为msecs的值可能位于QDateTime的有效范围之外，包括负数和正数。对于这些值，此函数的行为是未定义的。

如果spec不是OffsetFromUTC，则忽略offsetSeconds。如果spec是OffsetFromUTC且offsetSeconds为0，则使用UTC作为spec，因为UTC的偏移量为零。

如果 spec 是 TimeZone，则将使用 LocalTime 替换它，相当于使用当前系统时区（但表示方式不同）。

静态fromMSecsSinceEpoch(msecs)
参数：

msecs – 整数

返回类型：

QDateTime

这是一个重载函数。

静态fromSecsSinceEpoch(secs)#
参数：

secs – int

返回类型：

QDateTime

这是一个重载函数。

静态fromSecsSinceEpoch(secs, spec[, offsetFromUtc=0])
参数：

  • secs – int

  • spec – TimeSpec

  • offsetFromUtc – int

返回类型：

QDateTime

这是一个重载函数。

传递一个QTimeZone对象，或者省略spec和offsetSeconds。

返回一个表示自1970年1月1日UTC开始后的指定秒数（code class="docutils literal notranslate">secs）的日期时间对象，描述方式由 spec 和 offsetSeconds 指定。

请注意，对于可能超出 QDateTime 有效范围的 secs 值（无论是负数还是正数），此函数的行为是未定义的。

如果spec不是OffsetFromUTC，则忽略offsetSeconds。如果spec是OffsetFromUTC且offsetSeconds为0，则使用UTC作为spec，因为UTC的偏移量为零。

如果 spec 是 TimeZone，则将使用 LocalTime 替换它，相当于使用当前系统时区（但表示方式不同）。

静态fromSecsSinceEpoch(secs, timeZone)
参数：
返回类型：

QDateTime

这是一个重载函数。

返回一个表示自1970年1月1日UTC开始后的指定秒数（code class="docutils literal notranslate">secs）的日期时间对象，描述方式由 timeZone 指定。默认的时间表示方式是本地时间。

请注意，对于可能超出 QDateTime 有效范围的 secs 值（无论是负数还是正数），此函数的行为是未定义的。

静态fromString(string, format, baseYear, cal)#
参数：

  • string – str

  • format – str

  • baseYear – int

  • cal – QCalendar

返回类型：

QDateTime

警告

本节包含从C++到Python自动翻译的代码片段，可能包含错误。

返回由字符串 string 和指定的格式 format 表示的 QDateTime，如果字符串无法解析，则返回一个无效的日期时间。

如果提供，则使用日历cal，否则使用公历。

当format只指定年份的最后两位时，从baseYear开始的100年是首先考虑的候选年份。在6.7之前，没有baseYear参数，始终使用1900年。这是baseYear的默认值，选择从那时起的年份直到1999年。在某些情况下，其他字段可能导致选择下个或上个世纪，以得到与所有给定字段一致的结果。有关详细信息，请参阅fromString()。

除了在格式字符串中用于表示日期和时间各部分的认可表达式外，通过fromString()和fromString()，此方法还支持

表达式

输出

t

时区（偏移量、名称、“Z”或带有“UTC”前缀的偏移量）

tt

无冒号的偏移量格式时区（例如“+0200”）

ttt

带有冒号的偏移量格式时区（例如“+02:00”）

tttt

时区名称（例如“Europe/Berlin”）。认可的名称是QTimeZone已知名称，这取决于使用的操作系统。

如果没有‘t’格式说明符，则使用系统的本地时区。关于所有其他字段的默认值，请参阅fromString()和fromString()。

例如

dateTime = QDateTime.fromString("1.30.1", "M.d.s")
# dateTime is January 30 in 1900 at 00:00:01.
dateTime = QDateTime.fromString("12", "yy")
# dateTime is January 1 in 1912 at 00:00:00.

所有其他输入字符都将被视为文本。任何包含在单引号之间的非空字符序列也将被视为（去掉引号）文本，而不是作为表达式解释。

time1 = QTime.fromString("131", "HHh")
# time1 is 13:00:00
time1 = QTime.fromString("1apA", "1amAM")
# time1 is 01:00:00
dateTime2 = QDateTime.fromString("M1d1y9800:01:02",()
                                            "'M'M'd'd'y'yyhh:mm:ss")
# dateTime is 1 January 1998 00:01:02

如果格式不满足，将返回无效的QDateTime。如果格式满足但字符串string表示的日期时间无效（例如，由于时区转换而跳过的间隙），将返回有效的QDateTime，它表示最近的有效的日期时间。

没有前导零（d，M，h，m，s，z）的表达式将贪婪。这意味着它们将使用两位数（或z的三个，即使这会让它们超出范围并/或让其他部分留下的数字太少）。

dateTime = QDateTime.fromString("130", "Mm") # invalid()

这可能意味着00:30.00的1月1日，但M将抓取两位数字。

字符串中指定错误的字段将导致无效的 QDateTime 返回。例如，考虑以下代码，其中两位数的年份 12 被读取为 1912（见下表中的所有字段默认值）；得到的日期时间无效，因为 1912 年 4 月 23 日是星期二，不是星期一

string = "Monday, 23 April 12 22:51:41"
format = "dddd, d MMMM yy hh:mm:ss"
invalid = QDateTime.fromString(string, format)

正确的代码如下

string = "Tuesday, 23 April 12 22:51:41"
format = "dddd, d MMMM yy hh:mm:ss"
valid = QDateTime.fromString(string, format)

注意

日期和月份名称以及上午/下午指示符必须使用英语（C区域设置）。如果需要识别本地化的月份和日期名称或本地化的上午/下午形式，请使用 system() .toDateTime()。

注意

如果重复出现格式字符的次数多于使用该格式字符的最长表达式，则格式中的这部分将被读取为多个表达式，它们之间没有分隔符；上面的最长，可能重复，最多与它的副本数量相同，以可能为较短的表达式的残留物结束。因此，'tttttt' 会与 "Europe/BerlinEurope/Berlin" 匹配，并将时区设置为柏林时间；如果日期时间字符串包含“Europe/BerlinZ”，则会产生不一致的结果，导致无效的日期时间。

另请参阅

toString() fromString() fromString() toDateTime()

static fromString(string, format[, baseYear=QLocale.DefaultTwoDigitBaseYear])
参数：

  • string – str

  • format – str

  • baseYear – int

返回类型：

QDateTime

这是一个重载函数。

使用默认构造的 QCalendar .

static fromString(string, format, cal)
参数：

  • string – str

  • format – str

  • cal – QCalendar

返回类型：

QDateTime

这是一个重载函数。

static fromString(string[, format=Qt.TextDate])
参数：
返回类型：

QDateTime

使用给定的格式返回表示字符串的 QDateTime，如果无法完成则返回无效的日期时间。

关于TextDate的说明：仅识别英语的简写月份名称（例如“Jan”简写形式或“January”全称形式）。

另请参阅

toString 方法 toDateTime

静态fromString(string, format, baseYear, cal)
参数：

  • string – str

  • format – str

  • baseYear – int

  • cal – QCalendar

返回类型：

QDateTime

这是一个重载函数。

static fromString(string, format, cal)
参数：

  • string – str

  • format – str

  • cal – QCalendar

返回类型：

QDateTime

这是一个重载函数。

static fromString(string, format[, baseYear=QLocale.DefaultTwoDigitBaseYear])
参数：

  • string – str

  • format – str

  • baseYear – int

返回类型：

QDateTime

这是一个重载函数。

使用默认构造的 QCalendar .

static fromString(string, format, cal)
参数：

  • string – str

  • format – str

  • cal – QCalendar

返回类型：

QDateTime

这是一个重载函数。

static fromString(string, format[, baseYear=QLocale.DefaultTwoDigitBaseYear])
参数：

  • string – str

  • format – str

  • baseYear – int

返回类型：

QDateTime

这是一个重载函数。

使用默认构造的 QCalendar .

static fromString(string[, format=Qt.TextDate])
参数：
返回类型：

QDateTime

这是一个重载函数。

静态fromString(string, format, baseYear, cal)
参数：

  • string – str

  • format – str

  • baseYear – int

  • cal – QCalendar

返回类型：

QDateTime

这是一个重载函数。

isDaylightTime()#
返回类型：

bool

返回此日期时间为夏令时。

如果TimeSpec不是LocalTime或TimeZone，则总是返回false。

另请参阅

timeSpec()

isNull()#
返回类型：

bool

如果日期和时间都是null，则返回true；否则返回false。空的日期时间无效。

另请参阅

isNull isNull isValid

isValid()#
返回类型：

bool

如果此日期时间表示一个确定的时间点，则返回true，否则返回false。

当时间表示为特定时区或本地时间时，某些日期上的某些时间可能在该时区表示中跳过，例如夏令时过渡时跳过一小时（通常在春天的夜晚）时。例如，如果夏令时在凌晨2点结束，时钟提前到3点，那么那天从02:00:00到02:59:59.999的日期时间无效。

另请参阅

YearRange isValid isValid

msecsTo(arg__1)#
参数：

arg__1 – QDateTime

返回类型：

int

返回从当前日期时间到 other 日期时间的毫秒数。如果 other 日期时间早于当前日期时间，则返回的值是负数。

在执行比较之前，将两个日期时间转换为 UTC，以确保如果其中一个日期时间适用于夏令时（DST），另一个则不适用，结果仍然正确。

如果任一日期时间无效，则返回 0。

offsetFromUtc()#
返回类型：

int

返回此日期时间相对于 UTC 的偏移量（以秒为单位）。

结果取决于 timeSpec()

  • Qt::UTC 偏移量为 0。

  • Qt::OffsetFromUTC 偏移量为最初设置的值。

  • Qt::LocalTime 返回本地时间相对于 UTC 的偏移量。

  • Qt::TimeZone 返回所使用时区的偏移量。

对于最后两个，将返回在当前日期和时间时的偏移量，考虑到夏令时偏移。偏移量是本地时间或给定时区时间与 UTC 时间之间的差异；在位于 UTC 之前的时区（东经本初子午线）上是正值，在位于 UTC 之后的时区（西经本初子午线）上是负值。

另请参阅

setOffsetFromUtc()

__ne__(rhs)#
参数：

rhs – QDateTime

返回类型：

bool

如果 lhs 与 rhs 不同，则返回 true；否则返回 false。

如果日期、时间或时区组件中的任何一个不同，则两个日期时间不同。自 5.14 版本起，所有无效的日期时间都相等（并且都小于所有有效的日期时间）。

另请参阅

operator==()

__lt__(rhs)#
参数：

rhs – QDateTime

返回类型：

bool

如果 lhs 早于 rhs，则返回 true；否则返回 false。

如果日期、时间或时区组件中的任何一个不同，则两个日期时间不同。自 5.14 版本起，所有无效的日期时间都相等（并且都小于所有有效的日期时间）。

另请参阅

operator==()

__le__(rhs)#
参数：

rhs – QDateTime

返回类型：

bool

如果 lhs 早于或等于 rhs，则返回 true；否则返回 false。

如果日期、时间或时区组件中的任何一个不同，则两个日期时间不同。自 5.14 版本起，所有无效的日期时间都相等（并且都小于所有有效的日期时间）。

另请参阅

operator==()

__eq__(rhs)#
参数：

rhs – QDateTime

返回类型：

bool

如果 lhs 与 rhs 相同，则返回 true；否则返回 false。

如果日期、时间或时区组件中的任何一个不同，则两个日期时间不同。自 5.14 版本起，所有无效的日期时间都相等（并且都小于所有有效的日期时间）。

另请参阅

operator!=() operator operator>() operator>=()

__gt__(rhs)#
参数：

rhs – QDateTime

返回类型：

bool

如果 lhs 晚于 rhs，则返回 true；否则返回 false。

如果日期、时间或时区组件中的任何一个不同，则两个日期时间不同。自 5.14 版本起，所有无效的日期时间都相等（并且都小于所有有效的日期时间）。

另请参阅

operator==()

__ge__(rhs)#
参数：

rhs – QDateTime

返回类型：

bool

如果 lhs 晚于或等于 rhs，则返回 true；否则返回 false。

如果日期、时间或时区组件中的任何一个不同，则两个日期时间不同。自 5.14 版本起，所有无效的日期时间都相等（并且都小于所有有效的日期时间）。

另请参阅

operator==()

secsTo(arg__1)#
参数：

arg__1 – QDateTime

返回类型：

int

警告

本节包含从C++到Python自动翻译的代码片段，可能包含错误。

返回从当前时间到其他时间的时间差（秒数）。如果其他时间早于当前时间，返回的值是负数。

在执行比较之前，将两个时间日期转换为 UTC，以确保如果其中一个时间日期适用夏令时（DST）但另一个不适用时，结果仍然正确。

如果任一日期时间无效，则返回 0。

示例

now = QDateTime.currentDateTime()
xmas = QDateTime(QDate(now.date().year(), 12, 25).startOfDay())
qDebug("There are %d seconds to Christmas", now.secsTo(xmas))

另请参阅

addSecs() daysTo() secsTo()

setDate(date[, resolve=QDateTime.TransitionResolution.LegacyBehavior])#
参数：

将此时间日期的日期部分设置为 date。

如果尚未设置时间，则将其设置为午夜。如果 date 无效，则此 QDateTime 将变为无效。

如果 date 和 time() 描述了这个 datetime 时间表示方式的转换时刻，则 resolve 控制如何解决这种情况。

注意

在 Qt 6.7 之前，此函数的版本缺少 resolve 参数，因此没有解决与转换相关的歧义的方法。

另请参阅

date() setTime() setTimeZone()

setMSecsSinceEpoch(msecs)#
参数：

msecs – 整数

设置 datetime 表示从 1970 年 1 月 1 日开始 UTC 时间的给定数量（以毫秒为单位）的一个时刻。

在不支持时区的系统中，此函数的行为将视为本地时间为 UTC。

请注意，向 msecs 传递 qint64 （std::numeric_limits<qint64>::min()）的最小值会导致未定义的行为。

setOffsetFromUtc(offsetSeconds)#
参数：

offsetSeconds – int

请使用 setTimeZone （ fromSeconds AheadOfUtc （offsetSeconds））代替

将 timeSpec() 设置为 OffsetFromUTC 并将偏移量设置为 offsetSeconds。datetime 可能指向不同的时间点。

最大的偏移和最小的偏移分别为 14 个正负小时。如果 offsetSeconds 大于或小于该值，则结果为未定义。

如果 offsetSeconds 为 0，则 timeSpec() 将被设置为 UTC 。

setSecsSinceEpoch(secs)#
参数：

secs – int

将日期时间设置为表示自 1970 年起始之后的给定为 secs 秒的时刻。

在不支持时区的系统中，此函数的行为将视为本地时间为 UTC。

setTime(time[, resolve=QDateTime.TransitionResolution.LegacyBehavior])#
参数：

将此日期时间的时部分设置为 time。如果 time 无效，此函数将其设置为午夜。因此，可以通过将其设置为默认的 QTime 来清除 QDateTime 中设置的任何时间。

QDateTime dt = QDateTime::currentDateTime();
dt.setTime(QTime());

如果 date() 和 time 描述的时刻接近此日期时间的表示法的转换点，则 resolve 控制如何解决这种情况。

注意

在 Qt 6.7 之前，此函数的版本缺少 resolve 参数，因此没有解决与转换相关的歧义的方法。

另请参阅

time() setDate() setTimeZone()

setTimeSpec(spec)#
参数：

spec – TimeSpec

警告

本节包含从C++到Python自动翻译的代码片段，可能包含错误。

请使用 setTimeZone() 方法代替

将此 datetime 使用的时指定为 spec。datetime 可能指向不同的时间点。

如果 spec 是 OffsetFromUTC，则 timeSpec() 将被设置为 UTC，即有效的偏移量为 0。

如果 spec 是 TimeZone，则 spec 将被设置为 LocalTime，即当前系统时区。

示例

local = QDateTime(QDateTime.currentDateTime())
print("Local time is:", local)
UTC = QDateTime(local)
UTC.setTimeSpec(Qt.UTC)
print("UTC time is:", UTC)
print("There are", local.secsTo(UTC), "seconds difference between the datetimes.")

另请参阅

setTimeZone() timeSpec() toTimeSpec() setDate() setTime()

setTimeZone(toZone[, resolve=QDateTime.TransitionResolution.LegacyBehavior])#
参数：

将此 datetime 使用的时区设置为 toZone。

datetime 可能指向不同的时间点。它使用 toZone 的时间表示，这可能会改变其未变更的 date() 和 time() 的含义。

如果 toZone 无效，则 datetime 将无效。否则，调用后此 datetime 的 timeSpec() 将匹配 toZone.timeSpec()。

如果 date() 和 time() 描述的是接近 toZone 转换时刻的时刻，则 resolve 控制如何解决这种情况。

注意

在 Qt 6.7 之前，此函数的版本缺少 resolve 参数，因此没有解决与转换相关的歧义的方法。

另请参阅

timeRepresentation() timeZone() TimeSpec

swap(other)#
参数：

other – QDateTime

与 other 交换此时间日期。此操作非常快且永远不会失败。

time()#
返回类型：

QTime

返回时间日期中的时间部分。

timeRepresentation()#
返回类型：

QTimeZone

返回一个 QTimeZone，用以指明此时间日期如何表示时间。

返回的 timeSpec() 的 QTimeZone 将与该 datetime 的一致；如果不是 TimeZone，则返回的 QTimeZone 是时间表示。当它们的 timeSpec() 是 OffsetFromUTC 时，返回的 QTimeZone 的 fixedSecondsAheadOfUtc() 提供偏移量。当 timeSpec() 是 TimeZone 时，QTimeZone 对象本身就是该时区的完整表示。

timeSpec()#
返回类型：

TimeSpec

返回 datetime 的时间指定。

它将时间表示分类为本地时间、UTC、从 UTC 的固定偏移量（不指示偏移量）或时区（不给出该时区的详细信息）。等同于 timeRepresentation().timeSpec()。

timeZone()#
返回类型：

QTimeZone

返回 datetime 的时区。

结果与 timeRepresentation().asBackendZone() 相同。在所有情况下，结果的 timeSpec() 是 TimeZone。

当 `timeSpec()` 是 `LocalTime` 时，结果将描述在调用此方法时的时间的本地时间。它不会反映系统时区之后的更改，即便是从中获取它的 `QDateTime` 对象改变了。

timeZoneAbbreviation()#
返回类型：

str

返回此日期时间的时区缩写。

返回的字符串取决于 `timeSpec()`

注意

缩写不保证是唯一的，即不同时区可能有相同的缩写。对于 LocalTime 和 TimeZone ，当由宿主系统返回时，缩写可能是本地化的。

另请参阅

`timeSpec()` `abbreviation()`

toLocalTime()#
返回类型：

QDateTime

警告

本节包含从C++到Python自动翻译的代码片段，可能包含错误。

返回此日期时间转换到本地时间后的副本。

结果表示与此时相同的时间点，等于此日期时间。

示例

UTC = QDateTime(QDateTime.currentDateTimeUtc())
local = QDateTime(UTC.toLocalTime())
print("UTC time is:", UTC)
print("Local time is:", local)
print("No difference between times:", UTC.secsTo(local))

另请参阅

toTimeZone() toUTC() toOffsetFromUtc()

toMSecsSinceEpoch()#
返回类型：

int

返回一个表示自1970年1月1日起至当前日期的UTC时间的时间戳（毫秒）。

在不支持时区的系统中，此函数的行为将视为本地时间为 UTC。

如果这个对象中存储的日期时间无效，这个函数的行为是未定义的。但对于所有有效的日期，这个函数返回唯一的值。

toOffsetFromUtc(offsetSeconds)#
参数：

offsetSeconds – int

返回类型：

QDateTime

返回与给定的 offsetSeconds 相对应的 OffsetFromUTC 配置的当前日期时间的副本。相当于 toTimeZone(QTimeZone::fromSecondsAheadOfUtc(offsetSeconds))。

如果 offsetSeconds 等于 0，则返回 UTC 日期时间。

结果表示与此时相同的时间点，等于此日期时间。

toPython()#
返回类型：

object

toSecsSinceEpoch()#
返回类型：

int

返回自1970年1月1日起至当前日期的UTC时间的时间戳（秒）。

在不支持时区的系统中，此函数的行为将视为本地时间为 UTC。

如果这个对象中存储的日期时间无效，这个函数的行为是未定义的。但对于所有有效的日期，这个函数返回唯一的值。

toString(format)#
参数：

format – str

返回类型：

str

这是一个重载函数。

toString(format, cal)
参数：
返回类型：

str

toString([格式=Qt.TextDate])
参数：

格式 - DateFormat

返回类型：

str

这是一个重载函数。

以指定的 格式 将日期时间作为字符串返回。

如果 格式 为 TextDate ，字符串将采用默认方式格式化。日期和月份名称将使用英文。这种格式的示例是“Wed May 20 03:40:13 1998”。有关本地化格式化，请参阅 toString() 。

如果 格式 为 ISODate ，字符串格式对应于 ISO 8601 对日期和时间表示的扩展规范，形式为 yyyy-MM-ddTHH:mm:ss[Z|±HH:mm]，具体取决于 timeSpec() 的 QDateTime 。如果 timeSpec() 是 UTC ，将附加 Z 到字符串；如果 timeSpec() 是 OffsetFromUTC ，将附加从 UTC 的小时和分钟偏移量到字符串。要在 ISO 8601 日期中包含毫秒，请使用与 yyyy-MM-ddTHH:mm:ss.zzz[Z|±HH:mm] 对应的 格式 ISODateWithMs 。

如果 格式 为 RFC2822Date ，字符串将按照 RFC 2822 进行格式化。

如果日期时间为无效值，将返回空字符串。

警告

toString() 仅对于年范围为 0 到 9999 的年份有效。

另请参阅

fromString() toString() toString() toString()

toString(format)
参数：

format – str

返回类型：

str

这是一个重载函数。

toString(format, cal)
参数：
返回类型：

str

toTimeSpec(spec)#
参数：

spec – TimeSpec

返回类型：

QDateTime

警告

本节包含从C++到Python自动翻译的代码片段，可能包含错误。

请使用 toTimeZone() 代替。

返回此日期时间的副本，将其转换为给定的 spec。

结果表示与此时相同的时间点，等于此日期时间。

如果 spec 是 OffsetFromUTC，则它被设置为 UTC。要设置为从 UTC 的固定偏移量，请使用 toTimeZone() 或 toOffsetFromUtc()。

如果 spec 是 TimeZone，则它被设置为 LocalTime，即本地时区。要设置指定的时区，请使用 toTimeZone()。

示例

local = QDateTime(QDateTime.currentDateTime())
UTC = QDateTime(local.toTimeSpec(Qt.UTC))
print("Local time is:", local)
print("UTC time is:", UTC)
print("No difference between times:", local.secsTo(UTC))

另请参阅

setTimeSpec() timeSpec() toTimeZone()

toTimeZone(toZone)#
参数：

toZone – QTimeZone

返回类型：

QDateTime

警告

本节包含从C++到Python自动翻译的代码片段，可能包含错误。

返回此日期时间转换为指定 timeZone 的副本。

结果表示与此时相同的时间点，等于此日期时间。

结果描述了在 timeZone 的时间表示中的时间点。例如

local = QDateTime(QDateTime.currentDateTime())
UTC = QDateTime(local.toTimeSpec(QTimeZone.UTC))
print("Local time is:", local)
print("UTC time is:", UTC)
print("No difference between times represented:", local.secsTo(UTC))

如果 timeZone 无效，则日期时间将无效。否则，返回的日期时间的 timeSpec() 将与 timeZone.timeSpec() 匹配。

toUTC()#
返回类型：

QDateTime

警告

本节包含从C++到Python自动翻译的代码片段，可能包含错误。

返回此日期时间转换为 UTC 的副本。

结果表示与此时相同的时间点，等于此日期时间。

示例

local = QDateTime(QDateTime.currentDateTime())
UTC = QDateTime(local.toUTC())
print("Local time is:", local)
print("UTC time is:", UTC)
print("No difference between times:", local.secsTo(UTC))

另请参阅

toTimeZone() toLocalTime() toOffsetFromUtc()