原文： http://zetcode.com/gui/pyqt5/datetime/

PyQt5 教程的这一部分显示了如何在 PyQt5 中使用日期和时间。

QDate，QTime，QDateTime

PyQt5 具有QDate，QDateTime和QTime类，可用于日期和时间。 QDate是用于使用公历中的日历日期的类。 它具有确定日期，比较或操纵日期的方法。 QTime类使用时钟时间。 它提供了比较时间，确定时间的方法以及其他各种时间操纵方法。 QDateTime是将QDate和QTime对象结合为一个对象的类。

当前日期和时间

PyQt5 具有currentDate()，currentTime()和currentDateTime()方法来确定当前日期和时间。

current_date_time.py

  1. #!/usr/bin/python3
  3. from PyQt5.QtCore import QDate, QTime, QDateTime, Qt
  5. now = QDate.currentDate()
  7. print(now.toString(Qt.ISODate))
  8. print(now.toString(Qt.DefaultLocaleLongDate))
  10. datetime = QDateTime.currentDateTime()
  12. print(datetime.toString())
  14. time = QTime.currentTime()
  16. print(time.toString(Qt.DefaultLocaleLongDate))

该示例以各种格式打印当前日期，日期和时间以及时间。

  1. now = QDate.currentDate()

currentDate()方法返回当前日期。

  1. print(now.toString(Qt.ISODate))
  2. print(now.toString(Qt.DefaultLocaleLongDate))

通过将Qt.ISODate和Qt.DefaultLocaleLongDate值传递给toString()方法，以两种不同的格式打印日期。

  1. datetime = QDateTime.currentDateTime()

currentDateTime()返回当前日期和时间。

  1. time = QTime.currentTime()

最后，currentTime()方法返回当前时间。

  1. $ ./current_date_time.py 
  2. 2017-09-11
  3. Monday, September 11, 2017
  4. Mon Sep 11 12:37:45 2017
  5. 12:37:45 PM CEST

这是输出。

UTC 时间

我们的星球是一个球体； 它绕其轴旋转。 地球向东旋转，因此太阳在不同位置的不同时间升起。 地球大约每 24 小时旋转一次。 因此，世界被划分为 24 个时区。 在每个时区，都有一个不同的本地时间。 夏令时通常会进一步修改此本地时间。

实际需要一个全球时间。 全球时间可以避免时区和夏令时的混淆。 UTC（世界标准时间）被选为主要时间标准。 UTC 用于航空，天气预报，飞行计划，空中交通管制通关和地图。 与当地时间不同，UTC 不会随季节变化而变化。

utc_local.py

  1. #!/usr/bin/python3
  3. from PyQt5.QtCore import QDateTime, Qt
  5. now = QDateTime.currentDateTime()
  7. print("Local datetime: ", now.toString(Qt.ISODate))
  8. print("Universal datetime: ", now.toUTC().toString(Qt.ISODate))
  10. print("The offset from UTC is: {0} seconds".format(now.offsetFromUtc()))

该示例确定当前的通用和本地日期和时间。

  1. print("Local datetime: ", now.toString(Qt.ISODate))

currentDateTime()方法返回表示为本地时间的当前日期和时间。 我们可以使用toLocalTime()将世界时转换为当地时间。

  1. print("Universal datetime: ", now.toUTC().toString(Qt.ISODate))

我们通过日期时间对象中的toUTC()方法获得了通用时间。

  1. print("The offset from UTC is: {0} seconds".format(now.offsetFromUtc()))

offsetFromUtc()以秒为单位给出了通用时间和本地时间之间的时差。

  1. $ ./utc_local.py 
  2. Local datetime:  2017-09-11T13:01:58
  3. Universal datetime:  2017-09-11T11:01:58Z
  4. The offset from UTC is: 7200 seconds

这是输出。

天数

特定月份的天数通过daysInMonth()方法返回，一年中的天数通过daysInYear()方法返回。

days.py

  1. #!/usr/bin/python3
  3. from PyQt5.QtCore import QDate, Qt
  5. now = QDate.currentDate()
  7. d = QDate(1945, 5, 7)
  9. print("Days in month: {0}".format(d.daysInMonth()))
  10. print("Days in year: {0}".format(d.daysInYear()))

该示例显示所选日期的月份和年份中的天数。

  1. $ ./days.py 
  2. Days in month: 31
  3. Days in year: 365

这是输出。

天数差异

daysTo()方法返回从一个日期到另一个日期的天数。

xmas.py

  1. #!/usr/bin/python3
  3. from PyQt5.QtCore import QDate
  5. xmas1 = QDate(2016, 12, 24)
  6. xmas2 = QDate(2017, 12, 24)
  8. now = QDate.currentDate()
  10. dayspassed = xmas1.daysTo(now)
  11. print("{0} days have passed since last XMas".format(dayspassed))
  13. nofdays = now.daysTo(xmas2)
  14. print("There are {0} days until next XMas".format(nofdays))

该示例计算从上一个 XMas 经过的天数以及直到下一个 XMas 为止的天数。

  1. $ ./xmas.py 
  2. 261 days have passed since last XMas
  3. There are 104 days until next XMas

这是输出。

日期时间算法

我们通常需要在日期时间值上加上或减去天，秒或年。

arithmetic.py

  1. #!/usr/bin/python3
  3. from PyQt5.QtCore import QDateTime, Qt
  5. now = QDateTime.currentDateTime()
  7. print("Today:", now.toString(Qt.ISODate))
  8. print("Adding 12 days: {0}".format(now.addDays(12).toString(Qt.ISODate)))
  9. print("Subtracting 22 days: {0}".format(now.addDays(-22).toString(Qt.ISODate)))
  11. print("Adding 50 seconds: {0}".format(now.addSecs(50).toString(Qt.ISODate)))
  12. print("Adding 3 months: {0}".format(now.addMonths(3).toString(Qt.ISODate)))
  13. print("Adding 12 years: {0}".format(now.addYears(12).toString(Qt.ISODate)))

该示例确定当前日期时间，并添加或减去天，秒，月和年。

  1. $ ./arithmetics.py 
  2. Today: 2017-09-11T13:15:24
  3. Adding 12 days: 2017-09-23T13:15:24
  4. Subtracting 22 days: 2017-08-20T13:15:24
  5. Adding 50 seconds: 2017-09-11T13:16:14
  6. Adding 3 months: 2017-12-11T13:15:24
  7. Adding 12 years: 2029-09-11T13:15:24

这是示例输出。

夏令时

夏令时（DST）是在夏季的几个月中增加时钟的一种做法，因此晚上的夏时制持续时间更长。 在春季开始时将时间向前调整一小时，在秋季将时间向后调整为标准时间。

daylight_saving.py

  1. #!/usr/bin/python3
  3. from PyQt5.QtCore import QDateTime, QTimeZone, Qt
  5. now = QDateTime.currentDateTime()
  7. print("Time zone: {0}".format(now.timeZoneAbbreviation()))
  9. if now.isDaylightTime():
  10.     print("The current date falls into DST time")
  11. else:
  12.     print("The current date does not fall into DST time")

该示例检查日期时间是否在夏时制中。

  1. print("Time zone: {0}".format(now.timeZoneAbbreviation()))

timeZoneAbbreviation()方法返回日期时间的时区缩写。

  1. if now.isDaylightTime():

如果日期时间落在夏令时，则isDaylightTime()返回。

  1. $ ./daylight_saving.py 
  2. Time zone: CEST
  3. The current date falls into DST time

当前日期为夏令时（DST）时间。该程序于夏季在中欧的布拉迪斯拉发执行。 中欧夏令时间（CEST）比世界标准时间早 2 小时。 该时区是夏令时时区，在欧洲和南极洲使用。 冬季使用的标准时间是中欧时间（CET）。

Unix 纪元

纪元是选择作为特定纪元起源的时间瞬间。 例如，在西方基督教国家，时间从耶稣出生的第 0 天开始。 另一个例子是法国共和党日历，使用了十二年。 这个时期是 1792 年 9 月 22 日宣布的共和纪元的开始，即宣布成立第一共和国并废除君主制的那一天。

电脑也有自己的纪元。 最受欢迎的版本之一是 Unix 纪元。 Unix 纪元是 1970 年 1 月 1 日 UTC 时间 00:00:00（或1970-01-01T00:00:00Z ISO8601）。 计算机中的日期和时间是根据自该计算机或平台的定义时期以来经过的秒数或时钟滴答数确定的。

Unix 时间是自 Unix 纪元以来经过的秒数。

  1. $ date +%s
  2. 1505128973

Unix date命令可用于获取 Unix 时间。 在这个特定时刻，自 Unix 纪元以来已经过去了 1505128973 秒。

unix_time.py

  1. #!/usr/bin/python3
  3. from PyQt5.QtCore import QDateTime, Qt
  5. now = QDateTime.currentDateTime()
  7. unix_time = now.toSecsSinceEpoch() 
  8. print(unix_time)
  10. d = QDateTime.fromSecsSinceEpoch(unix_time)
  11. print(d.toString(Qt.ISODate))

该示例显示 Unix 时间并将其转换回QDateTime。

  1. now = QDateTime.currentDateTime()

首先，我们获取当前日期和时间。

  1. unix_time = now.toSecsSinceEpoch()

toSecsSinceEpoch()返回 Unix 时间。

  1. d = QDateTime.fromSecsSinceEpoch(unix_time)

使用fromSecsSinceEpoch()我们将 Unix 时间转换为QDateTime。

  1. $ ./unix_time.py 
  2. 1505129851
  3. 2017-09-11T13:37:31

这是输出。

朱利安日

朱利安日是指自朱利安纪元开始以来的连续天数。 它主要由天文学家使用。 不应将其与朱利安历法相混淆。 朱利安纪元开始于公元前 4713 年。 朱利安天数 0 被指定为从公元前 4713 年 1 月 1 日正午开始的那一天。

朱利安天数（JDN）是自此时间段开始以来经过的天数。 任意时刻的儒略日期（JD）是前一个正午的儒略日编号加上该时刻以来的那一天的分数。 （Qt 不会计算此分数。）除天文学外，军事和大型机程序经常使用儒略日期。

julian_day.py

  1. #!/usr/bin/python3
  3. from PyQt5.QtCore import QDate, Qt
  5. now = QDate.currentDate()
  7. print("Gregorian date for today: ", now.toString(Qt.ISODate))
  8. print("Julian day for today: ", now.toJulianDay())

在示例中，我们计算了今天的公历日期和儒略日。

  1. print("Julian day for today: ", now.toJulianDay())

使用toJulianDay()方法返回儒略日。

  1. $ ./julianday.py 
  2. Gregorian date for today:  2017-09-11
  3. Julian day for today:  2458008

这是输出。

历史战役

在朱利安纪元，可以进行跨越几个世纪的计算。

battles.py

  1. #!/usr/bin/python3
  3. from PyQt5.QtCore import QDate, Qt
  5. borodino_battle = QDate(1812, 9, 7)
  6. slavkov_battle = QDate(1805, 12, 2)
  8. now = QDate.currentDate()
  10. j_today = now.toJulianDay()
  11. j_borodino = borodino_battle.toJulianDay()
  12. j_slavkov = slavkov_battle.toJulianDay()
  14. d1 = j_today - j_slavkov
  15. d2 = j_today - j_borodino
  17. print("Days since Slavkov battle: {0}".format(d1))
  18. print("Days since Borodino battle: {0}".format(d2))

该示例计算自两次历史事件以来经过的天数。

  1. borodino_battle = QDate(1812, 9, 7)
  2. slavkov_battle = QDate(1805, 12, 2)

我们有拿破仑纪元的两次战斗。

  1. j_today = now.toJulianDay()
  2. j_borodino = borodino_battle.toJulianDay()
  3. j_slavkov = slavkov_battle.toJulianDay()

我们计算了今天以及斯拉夫科夫和波罗底诺战役的儒略日。

  1. d1 = j_today - j_slavkov
  2. d2 = j_today - j_borodino

我们计算了两次战斗以来经过的天数。

  1. $ ./battles.py 
  2. Days since Slavkov battle: 77350
  3. Days since Borodino battle: 74879

运行此脚本时，自从斯拉夫科夫战役以来已经过去了 77350 天，从波罗底诺战役已经过去了 74878 天。

在 PyQt5 教程的这一部分中，我们处理了日期和时间。