Python 日期和时间

Python程序可以以几种方式处理日期和时间。在计算机中，转换日期格式是一种常见的任务。以下是Python标准库中处理日期和时间相关处理的模块：

• DateTime模块

• Time模块

• Calendar模块

什么是Tick间隔

时间间隔是以秒为单位的浮点数。特定的时间瞬间以自1970年1月1日午夜12:00以来的秒数表示（时代）。

在Python中有一个流行的 time 模块，它提供了处理时间和转换表示之间的函数。函数 time.time() 返回自1970年1月1日午夜12:00以来的当前系统时间的tick数。

示例

import time # This is required to include time module.
ticks = time.time()
print ("Number of ticks since 12:00am, January 1, 1970:", ticks)

这将会产生如下结果 –

Number of ticks since 12:00am, January 1, 1970: 1681928297.5316436

日期计算使用ticks非常容易。然而，这种形式无法表示纪元之前的日期。未来的日期也无法以这种方式表示——UNIX和Windows的截止点在2038年左右。

TimeTuple是什么

Python中的许多时间函数将时间处理为一个由9个数字组成的元组，如下所示：-

例如，

>>>import time
>>> print (time.localtime())

这将产生以下输出-

time.struct_time(tm_year=2023, tm_mon=4, tm_mday=19, tm_hour=23, tm_min=49, tm_sec=8, tm_wday=2, tm_yday=109, tm_isdst=0)

上述元组等同于struct_time结构。该结构具有以下属性：

获取当前时间

要将一个时间点从以浮点数表示的秒数（自纪元以来）转换为时间元组，将浮点数传递给一个函数（例如，localtime），该函数将返回一个带有所有有效九个项的时间元组。

import time
localtime = time.localtime(time.time())
print ("Local current time :", localtime)

这将产生以下结果，可以以任何其他可呈现的形式进行格式化−

Local current time : time.struct_time(tm_year=2023, tm_mon=4, tm_mday=19, tm_hour=23, tm_min=42, tm_sec=41, tm_wday=2, tm_yday=109, tm_isdst=0)

获取格式化的时间

可以根据需要对任何时间进行格式化，但是获取可读格式的时间的一种简单方法是 asctime() 方法。

import time

localtime = time.asctime( time.localtime(time.time()) )
print ("Local current time :", localtime)

这将产生以下 输出 –

Local current time : Wed Apr 19 23:45:27 2023

获取一个月的日历

日历模块提供了许多方法来操作年历和月历。在这里，我们打印出给定月份（2008年1月）的日历。

import calendar
cal = calendar.month(2023, 4)
print ("Here is the calendar:")
print (cal)

这将产生以下结果 输出 –

Here is the calendar:
     April 2023
Mo Tu We Th Fr Sa Su
                1  2
 3  4  5  6  7  8  9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30

时间模块

Python中有一个流行的 time 模块，它提供了处理时间和转换表示之间的函数。这是所有可用方法的列表。

让我们简要介绍一下这些函数。

time模块提供了两个重要的属性，它们是：

日历模块

日历模块提供与日历相关的函数，包括打印给定月份或年份的文本日历的函数。

默认情况下，日历将星期一作为一周的第一天，星期天作为最后一天。要更改这个设置，请调用 calendar.setfirstweekday() 函数。

下面是 calendar 模块提供的函数列表：

日期时间模块

Python的日期时间模块包含在标准库中。它包含用于操作日期时间数据和执行日期时间运算的类。

日期时间类的对象可以是有意识的（aware）或者天真的（naïve）。如果对象包含时区信息，则为有意识的；否则为天真的。日期类的对象是天真的，而时间和日期时间对象是有意识的。

日期

日期对象表示带有年、月和日的日期。当前的公历可以无限期地向两个方向延伸。

语法

datetime.date(year, month, day)

参数必须是整数，在以下范围内−

• year − MINYEAR ≤ 年份 ≤ MAXYEAR

• month − 1 ≤ 月份 ≤ 12

• day − 1 ≤ day≤ 给定的月份和年份的天数

如果给定的任何参数值超出这些范围，将引发ValueError。

示例

from datetime import date
date1 = date(2023, 4, 19)
print("Date:", date1)
date2 = date(2023, 4, 31)

它将产生以下 输出 −

Date: 2023-04-19
Traceback (most recent call last):
 File "C:\Python311\hello.py", line 8, in <module>
  date2 = date(2023, 4, 31)
ValueError: day is out of range for month

日期类属性

• date.min − 最早可表示的日期，date（MINYEAR, 1, 1）。

• date.max − 最晚可表示的日期，date（MAXYEAR, 12, 31）。

• date.resolution − 非相等日期对象之间的最小可能差异。

• date.year − 在MINYEAR和MAXYEAR之间（包括边界）。

• date.month − 在1和12之间（包括边界）。

• date.day − 在给定年份的给定月份中的天数范围内（从1到该月份的天数）。

示例

from datetime import date

# Getting min date
mindate = date.min
print("Minimum Date:", mindate)

# Getting max date
maxdate = date.max
print("Maximum Date:", maxdate)

Date1 = date(2023, 4, 20)
print("Year:", Date1.year)
print("Month:", Date1.month)
print("Day:", Date1.day)

它将产生以下输出

Minimum Date: 0001-01-01
Maximum Date: 9999-12-31
Year: 2023
Month: 4
Day: 20

日期类中的类方法

• today() − 返回当前本地日期。

• fromtimestamp(timestamp) − 返回对应于POSIX时间戳的本地日期，例如time.time()返回的时间戳。

• fromordinal(ordinal) − 返回对应于普遍公历纪元的日期，其中公元1年的1月1日具有序数1。

• fromisoformat(date_string) − 返回对应于以任何有效的ISO 8601格式给出的date_string的日期，但不包括序数日期。

示例

from datetime import date

print (date.today())
d1=date.fromisoformat('2023-04-20')
print (d1)
d2=date.fromisoformat('20230420')
print (d2)
d3=date.fromisoformat('2023-W16-4')
print (d3)

这将产生以下 输出 −

2023-04-20
2023-04-20
2023-04-20
2023-04-20

日期类中的实例方法

• replace() - 使用关键字参数指定的新值替换指定的属性，返回一个日期对象。

• timetuple() - 返回一个time.struct_time对象，类似于time.localtime()返回的对象。

• toordinal() - 返回日期的公元格里高斯序数，其中公元1年1月1日的序数为1。对于任何日期对象d，date.fromordinal(d.toordinal()) d。

• weekday() - 返回星期几的整数表示，星期一为0，星期日为6。

• isoweekday() - 返回星期几的整数表示，星期一为1，星期日为7。

• isocalendar() - 返回一个带有三个组件的命名元组对象：年、周和工作日。

• isoformat() - 返回表示日期的字符串，格式为ISO 8601，即YYYY-MM-DD。

• __str__() - 对于一个日期d，str(d)等同于d.isoformat()。

• ctime() - 返回表示日期的字符串。

• strftime(format) - 返回一个表示日期的字符串，由显示格式字符串控制。

• __format__(format) - 等同于date.strftime()。

示例

from datetime import date
d = date.fromordinal(738630) # 738630th day after 1. 1. 0001
print (d)
print (d.timetuple())
# Methods related to formatting string output
print (d.isoformat())
print (d.strftime("%d/%m/%y"))
print (d.strftime("%A %d. %B %Y"))
print (d.ctime())

print ('The {1} is {0:%d}, the {2} is {0:%B}.'.format(d, "day", "month"))

# Methods for to extracting 'components' under different calendars
t = d.timetuple()
for i in t:
   print(i)

ic = d.isocalendar()
for i in ic:
   print(i)

# A date object is immutable; all operations produce a new object
print (d.replace(month=5))

它将产生以下输出 输出 −

2023-04-20
time.struct_time(tm_year=2023, tm_mon=4, tm_mday=20, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=110, tm_isdst=-1)
2023-04-20
20/04/23
Thursday 20. April 2023
Thu Apr 20 00:00:00 2023
The day is 20, the month is April.
2023
4
20
0
0
0
3
110
-1
2023
16
4
2023-05-20

时间

一个时间对象代表一天中的本地时间。它不依赖于任何特定的日期。如果对象包含tzinfo详细信息，则它是有意识的对象。如果为None，则时间对象是无意识的对象。

语法

datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None)

所有的参数都是可选的。tzinfo可以是None，也可以是一个tzinfo子类的实例。其余的参数必须是以下范围内的整数 −

• hour − 0 <= hour < 24,

• minute − 0 <= minute < 60,

• second − 0 <= second < 60,

• microsecond − 0 <= microsecond < 1000000

如果给出的参数超出这些范围，将抛出ValueError异常。

示例

from datetime import time

time1 = time(8, 14, 36)
print("Time:", time1)

time2 = time(minute = 12)
print("time", time2)

time3 = time()
print("time", time3)

time4 = time(hour = 26)

它将产生以下的 输出 −

Time: 08:14:36
time 00:12:00
time 00:00:00
Traceback (most recent call last):
  File "/home/cg/root/64b912f27faef/main.py", line 12, in 
    time4 = time(hour = 26)
ValueError: hour must be in 0..23

类属性

• time.min - 表示的最早时间，time(0, 0, 0, 0)。

• time.max - 表示的最晚时间，time(23, 59, 59, 999999)。

• time.resolution - 非相等时间对象之间可能的最小差异。

示例

from datetime import time
print(time.min)
print(time.max)
print (time.resolution)

会产生以下输出 output −

00:00:00
23:59:59.999999
0:00:00.000001

实例属性

• time.hour − 在范围(24)内

• time.minute − 在范围(60)内

• time.second − 在范围(60)内

• time.microsecond − 在范围(1000000)内

• time.tzinfo − time构造函数的tzinfo参数，或者为None

示例

from datetime import time
t = time(8,23,45,5000)
print(t.hour)
print(t.minute)
print (t.second)
print (t.microsecond)

它将产生以下 输出 ：

8
23
455000

实例方法

• replace() − 返回一个具有相同值的时间，除非被指定的关键字参数给定了新值。

• isoformat() − 以ISO 8601格式返回时间的字符串表示

• __str__() − 对于时间t，str(t)等于t.isoformat()。

• strftime(format) − 返回一个由显式格式字符串控制的时间的字符串表示。

• __format__(format) − 同time.strftime()。

• utcoffset() − 如果tzinfo为None，则返回None，否则返回self.tzinfo.utcoffset(None)。

• dst() − 如果tzinfo为None，则返回None，否则返回self.tzinfo.dst(None)。

• tzname() − 如果tzinfo为None，则返回None，否则返回self.tzinfo.tzname(None)，或者引发异常。

日期时间

datetime类的一个对象包含日期和时间的信息。它假设当前的公历在两个方向上延伸；就像一个时间对象一样，每天有确切的3600*24秒。

语法

datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)

年、月和日参数是必需的。

• year： MINYEAR <= 年 <= MAXYEAR，

• month： 1 <= 月 <= 12，

• day： 1 <= 日 <= 给定月份和年份的天数，

• hour： 0 <= 小时 < 24，

• minute： 0 <= 分钟 < 60，

• second： 0 <= 秒 < 60，

• microsecond： 0 <= 微秒 < 1000000，

• fold： 取值范围为[0, 1]。

如果给定了超出范围的任何参数，则引发ValueError。

示例

from datetime import datetime
dt = datetime(2023, 4, 20)
print(dt)

dt = datetime(2023, 4, 20, 11, 6, 32, 5000)
print(dt)

将会产生以下输出

2023-04-20 00:00:00
2023-04-20 11:06:32.005000

类属性

• datetime.min - 可表示的最早时间，datetime（MINYEAR, 1, 1, tzinfo = None）。

• datetime.max - 可表示的最晚时间，datetime（MAXYEAR, 12, 31, 23, 59, 59, 999999, tzinfo = None）。

• datetime.resolution - 非等datetime对象之间的最小可能差异，timedelta（microseconds = 1）。

示例

from datetime import datetime
min = datetime.min
print("Min DateTime ", min)

max = datetime.max
print("Max DateTime ", max)

它将产生以下 输出 -

Min DateTime 0001-01-01 00:00:00
Max DateTime 9999-12-31 23:59:59.999999

实例属性

• datetime.year - 在MINYEAR和MAXYEAR之间（包括边界）。

• datetime.month - 在1到12之间（包括边界）。

• datetime.day - 在给定年份给定月份的天数范围内（1到该月份的天数）。

• datetime.hour - 在范围(24)内。

• datetime.minute - 在范围(60)内。

• datetime.second - 在范围(60)内。

• datetime.microsecond - 在范围(1000000)内。

• datetime.tzinfo - 传递给datetime构造器的tzinfo参数的对象，如果未传递则为None。

• datetime.fold - 在[0, 1]范围内。用于在重复间隔期间消除墙时的歧义。

示例

from datetime import datetime
dt = datetime.now()

print("Day: ", dt.day)
print("Month: ", dt.month)
print("Year: ", dt.year)
print("Hour: ", dt.hour)
print("Minute: ", dt.minute)
print("Second: ", dt.second)

这将产生以下 输出 −

Day: 20
Month: 4
Year: 2023
Hour: 15
Minute: 5
Second: 52

类方法

• today() - 返回当前本地日期和时间，时区信息为None。

• now(tz=None) - 返回当前本地日期和时间。

• utcnow() - 返回当前UTC日期和时间，时区信息为None。

• utcfromtimestamp(timestamp) - 返回与POSIX时间戳相对应的UTC日期和时间，时区信息为None。

• fromtimestamp(timestamp, timezone.utc) - 在符合POSIX标准的平台上，它等同于datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(seconds=timestamp)。

• fromordinal(ordinal) - 返回与普通格里高利历序数相对应的日期时间，其中公元1年1月1日的序数为1。

• fromisoformat(date_string) - 返回与任何有效的ISO 8601格式的date_string相对应的日期时间。

实例方法

• date() − 返回具有相同年、月和日的日期对象。

• time() − 返回具有相同小时、分钟、秒、毫秒和fold的时间对象。

• timetz() − 返回具有相同小时、分钟、秒、毫秒、fold和tzinfo属性的时间对象。另请参见方法time()。

• replace() − 返回具有相同属性的日期时间，除了通过指定的关键字参数给出新值的那些属性。

• astimezone(tz=None) − 返回具有新的tzinfo属性tz的日期时间对象。

• utcoffset() − 如果tzinfo为None，则返回None；否则返回self.tzinfo.utcoffset(self)。

• dst() − 如果tzinfo为None，则返回None；否则返回self.tzinfo.dst(self)。

• tzname() − 如果tzinfo为None，则返回None；否则返回self.tzinfo.tzname(self)。

• timetuple() − 返回类似于time.localtime()的time.struct_time。

• atetime.toordinal() − 返回日期的普利普特·格里高利历序数。

• timestamp() − 返回与日期时间实例相对应的POSIX时间戳。

• isoweekday() − 返回一个整数，表示一周的第几天，其中星期一为1，星期日为7。

• isocalendar() − 返回一个命名元组，包含三个组件：年、周和工作日。

• isoformat(sep=’T’, timespec=’auto’) − 返回一个字符串，表示日期和时间的ISO 8601格式。

• __str__() − 对于一个日期时间实例d，str(d)等同于d.isoformat(‘ ‘)。

• ctime() − 返回表示日期和时间的字符串：

• strftime(format) − 返回一个字符串，表示日期和时间，由显式格式字符串控制。

• __format__(format) − 与strftime()相同。

示例

from datetime import datetime, date, time, timezone

# Using datetime.combine()
d = date(2022, 4, 20)
t = time(12, 30)
datetime.combine(d, t)

# Using datetime.now()
d = datetime.now()
print (d)

# Using datetime.strptime()
dt = datetime.strptime("23/04/20 16:30", "%d/%m/%y %H:%M")

# Using datetime.timetuple() to get tuple of all attributes
tt = dt.timetuple()
for it in tt:
   print(it)

# Date in ISO format
ic = dt.isocalendar()
for it in ic:
   print(it)

它将产生以下输出： 输出 −

2023-04-20 15:12:49.816343
2020
4
23
16
30
0
3
114
-1
2020
17
4

时间差

timedelta对象表示两个日期或两个时间对象之间的持续时间。

语法

datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)

在内部，属性以天、秒和微秒的形式存储。其他参数被转换为这些单位 –

• 毫秒被转换为1000微秒。

• 分钟被转换为60秒。

• 小时被转换为3600秒。

• 周被转换为7天。

而天、秒和微秒会被规范化，以确保表示方式是唯一的。

示例

下面的例子展示了Python内部只存储天、秒和微秒。

from datetime import timedelta
delta = timedelta(
   days=100,
   seconds=27,
   microseconds=10,
   milliseconds=29000,
   minutes=5,
   hours=12,
   weeks=2
)
# Only days, seconds, and microseconds remain
print (delta)

以下是其输出结果

114 days, 12:05:56.000010

示例

以下示例显示了如何将timedelta对象添加到datetime对象中。

from datetime import datetime, timedelta

date1 = datetime.now()

date2= date1+timedelta(days = 4)
print("Date after 4 days:", date2)

date3 = date1-timedelta(15)
print("Date before 15 days:", date3)

它将产生以下输出−

Date after 4 days: 2023-04-24 18:05:39.509905
Date before 15 days: 2023-04-05 18:05:39.509905

类属性

• timedelta.min - 最负的timedelta对象，timedelta(-999999999)。

• timedelta.max - 最正的timedelta对象，timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999)。

• timedelta.resolution - 非等timedelta对象之间可能的最小差异，timedelta(microseconds=1)。

示例

from datetime import timedelta

# Getting minimum value
min = timedelta.min
print("Minimum value:", min)

max = timedelta.max
print("Maximum value", max)

它将生成以下 输出 −

Minimum value: -999999999 days, 0:00:00
Maximum value 999999999 days, 23:59:59.999999

实例属性

由于只有天、秒和微秒是内部存储的，因此这些是timedelta对象的唯一实例属性。

• days − 范围在-999999999至999999999之间（包括）

• seconds − 范围在0至86399之间（包括）

• microseconds − 范围在0至999999之间（包括）

实例方法

timedelta.total_seconds() − 返回时间间隔中包含的总秒数。

示例

from datetime import timedelta
year = timedelta(days=365)
years = 5 * year
print (years)
print (years.days // 365)
646
year_1 = years // 5
print(year_1.days)

它将产生以下 输出 −

1825 days, 0:00:00
5
365