Python标准库datetime库datetime类详解（3/6）

datetime对象

datetime 对象是包含来自 date 对象和 time 对象的所有信息的单一对象。

与 date 对象一样，datetime 假定当前的公历向前后两个方向无限延伸；与 time 对象一样，datetime 假定每一天恰好有 3600*24 秒。

常用方法：

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

datetime.datetime()构造器方法。

功能：用于创建一个包含日期和时间的对象。

year, month 和 day 参数是必须的。 tzinfo 可以是 None 或者是一个 tzinfo 子类的实例。 其余的参数必须是在下面范围内的整数：

MINYEAR <= year <= MAXYEAR,

1 <= month <= 12,

1 <= day <= 指定年月的天数,

0 <= hour < 24,

0 <= minute < 60,

0 <= second < 60,

0 <= microsecond < 1000000,

fold in [0, 1]. # 默认为0，用于处理夏令时等情况下可能出现的时间重复问题。正常可以忽略。

如果参数不在这些范围内，则抛出 ValueError 异常。

3.6 新版功能: 增加了 fold 参数。

例：

import datetime

date = datetime.datetime(2022,12,23)

print(date) # 输出：2022-12-23 00:00:00

其它构造器，所有的类方法：

2、datetime.today()

功能：用于获取当前时区的日期和时间（datetime对象），其中 tzinfo 为 None。

等价于:

datetime.fromtimestamp(time.time())

此方法的功能等价于 now()，但是不带 tz 形参。

例：

import datetime

print(datetime.datetime.today())

输出：2023-12-25 16:56:06.856274

3、datetime.now(tz=None)

功能：返回表示当前时区的日期和时间（date 和 time 对象）。

如果可选参数 tz 为 None 或未指定，这就类似于 today()，但该方法会在可能的情况下提供比通过 time.time() 时间戳所获时间值更高的精度（例如，在提供了 C gettimeofday() 函数的平台上就可以做到这一点）。

如果 tz 不为 None，它必须是 tzinfo 子类的一个实例，并且当前日期和时间将被转换到 tz 时区。

此函数可以替代 today() 和 utcnow()。

例：

import datetime

print(datetime.datetime.now())

输出：2023-12-25 16:56:06.856274

4、datetime.utcnow()

功能：返回表示当前 UTC 时间的 date 和 time，其中 tzinfo 为 None。

这类似于 now()，但返回的是当前 UTC 日期和时间，类型为简单型 datetime 对象。 感知型的当前 UTC 日期时间可通过调用 datetime.now(timezone.utc) 来获得。 另请参阅 now()。

警告

 由于简单型 datetime 对象会被许多 datetime 方法当作本地时间来处理，最好是使用感知型日期时间对象来表示 UTC 时间。 因此，创建表示当前 UTC 时间的对象的推荐方式是通过调用 datetime.now(timezone.utc)。

3.12 版后已移除: 请用带 UTC 的 datetime.now() 代替。

5、datetime.fromtimestamp(timestamp, tz=None)

功能：用于根据给定时间戳创建一个datetime.datetime对象。

返回 POSIX（可移植操作系统接口）时间戳对应的本地日期和时间，如 time.time() 返回的。 如果可选参数 tz 指定为 None 或未指定，时间戳将转换为平台的本地日期和时间，并且返回的 datetime 对象将为简单型。

如果 tz 不为 None，它必须是 tzinfo 子类的一个实例，并且时间戳将被转换到 tz 指定的时区。

在 3.3 版更改: 引发 OverflowError 而不是 ValueError，如果时间戳数值超出所在平台 C localtime() 或 gmtime() 函数的支持范围的话。 并会在 localtime() 或 gmtime() 出错时引发 OSError 而不是 ValueError。

在 3.6 版更改: fromtimestamp() 可能返回 fold 值设为 1 的实例。

示例：

import datetime

  

# 创建一个基于UTC时间的时间戳  

timestamp = 1625585137.0  # 2021-06-23 13:18:57 UTC  

dt = datetime.datetime.fromtimestamp(timestamp)  

print(dt)  # 输出：2021-06-23 13:18:57+00:00  

  

# 创建一个基于特定时区的时间戳  

tz = datetime.timezone(datetime.timedelta(hours=8))  # 时区：UTC+8  

dt_with_tz = datetime.datetime.fromtimestamp(timestamp, tz)  

print(dt_with_tz)  # 输出：2021-06-23 13:18:57+08:00

6、datetime.utcfromtimestamp(timestamp)

返回对应于 POSIX 时间戳的 UTC datetime，其中 tzinfo 值为 None。 （结果为简单型对象。）

这可能引发 OverflowError，如果时间戳数值超出所在平台 C gmtime() 函数的支持范围的话，并会在 gmtime() 报错时引发 OSError。

要得到一个感知型 datetime 对象，应调用 fromtimestamp():

datetime.fromtimestamp(timestamp, timezone.utc)

在 POSIX 兼容的平台上，它等价于以下表达式:

datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(seconds=timestamp)

不同之处在于后一种形式总是支持完整年份范围：从 MINYEAR 到 MAXYEAR 的开区间。

在 3.3 版更改: 引发 OverflowError 而不是 ValueError，如果时间戳数值超出所在平台 C gmtime() 函数的支持范围的话。 并会在 gmtime() 出错时引发 OSError 而不是 ValueError。

3.12 版后已移除: 请用带 UTC 的 datetime.fromtimestamp() 代替。

7、datetime.fromordinal(ordinal)

返回对应于预期公历序号的 datetime对象，其中公元 1 年 1 月 1 日的序号为 1。

除非 1 <= ordinal <= datetime.max.toordinal() 否则会引发 ValueError。 结果的 hour, minute, second 和 microsecond 值均为 0，并且 tzinfo 值为 None。

例：

import datetime

  

date = datetime.datetime.fromordinal(603333)

print(date) # 输出：1652-11-13 00:00:00

8、datetime.combine(date, time, tzinfo=time.tzinfo)

用于将日期（date）和时间（time）对象合并为一个datetime对象。

返回一个新的 datetime 对象，其日期部分等于给定的 date 对象的值，而其时间部分等于给定的 time 对象的值。

如果提供了 tzinfo 参数，其值会被用来设置结果的 tzinfo 属性，否则将使用 time 参数的 tzinfo 属性。

如果 date 参数是一个 datetime 对象，则其时间部分和 tzinfo 属性将被忽略。

对于任意 datetime 对象 d，d == datetime.combine(d.date(), d.time(), d.tzinfo)。

在 3.6 版更改: 增加了 tzinfo 参数。

示例：

from datetime import datetime, date, time, timezone,timedelta

  

# 创建一个日期对象和一个时间对象  

d = date(2023, 9, 15)  

t = time(10, 30, 0)  

  

# 使用 combine 方法将它们合并为一个 datetime 对象  

dt = datetime.combine(d, t)  

print(dt)  # 输出：2023-09-15 10:30:00  

  

# 如果有一个时区对象，也可以合并进去  

tz = timezone(timedelta(hours=1))  # UTC+1 时区  

dt_with_tz = datetime.combine(d, t, tzinfo=tz)  

print(dt_with_tz)  # 输出：2023-09-15 10:30:00+01:00

9、datetime.fromisoformat(date_string)

用于从ISO 8601格式的日期字符串创建一个datetime.datetime对象，例如“2023-09-15”。

下列格式除外:

时区时差可能会有带小数的秒值。

T 分隔符可以用任何单个 unicode 字符来替换。

目前不支持序数日期。

带小数的时和分是不受支持的。

例：

from datetime import datetime  

  

# 从ISO 8601格式的日期字符串创建一个 datetime 对象  

dt = datetime.fromisoformat("2023-09-15")  

print(dt)  # 输出：2023-09-15 00:00:00

dt = datetime.fromisoformat('2011-11-04T00:05:23Z')

print(dt)  # 输出：2011-11-04 00:05:23+00:00

dt = datetime.fromisoformat('2011-W01-2T00:05:23.283')

print(dt)  # 输出：2011-01-04 00:05:23.283000

dt = datetime.fromisoformat('2011-11-04 00:05:23.283+00:00')

print(dt)  # 输出：2011-11-04 00:05:23.283000+00:00

dt = datetime.fromisoformat('2011-11-04T00:05:23+04:00')

print(dt)  # 输出：2011-11-04 00:05:23+04:00

dt = datetime.fromisoformat('20111104') # Python3.12支持此格式

print(dt)  # 输出：2011-11-04 00:00:00

dt = datetime.fromisoformat('20111104T000523') # Python3.12支持此格式

print(dt)  # 输出：2011-11-04 00:05:23+00:00

10、datetime.fromisocalendar(year, week, day)

3.8 新版功能.

用于根据 ISO 8601 日历的指定年、周和日来创建一个 datetime 对象。

返回以 year, week 和 day 值指明的 ISO 历法日期所对应的 datetime。 该datetime 对象的非日期部分将使用其标准默认值来填充。 这是函数 datetime.isocalendar() 的逆操作。

注意：这个方法不会解析时间部分。

参数说明：

year：ISO 8601 日历的年份。

week：ISO 8601 日历的周数，范围是 1 到 53。

day：ISO 8601 日历的星期几，范围是 1（周一）到 7（周日）。

例：

from datetime import datetime  

  

# 从ISO 8601日历的年、周和日创建一个 datetime 对象  

year = 2023  

week = 37  

day = 5  

dt = datetime.fromisocalendar(year, week, day)  

print(dt)  # 输出：2023-09-15 00:00:00

11、datetime.strptime(date_string, format)

功能：用于将字符串日期或时间转换为指定格式的datetime对象。

如果 format 不包含微秒或时区信息，这将等价于:

datetime(*(time.strptime(date_string, format)[0:6]))

如果 date_string 和 format 无法被 time.strptime() 解析或它返回一个不是时间元组的值则将引发 ValueError。 另请参阅 strftime() 和 strptime() 的行为 和 datetime.fromisoformat()。

例：

from datetime import datetime  

  

# 将字符串 "2023-09-15" 转换为 datetime 对象  

date_string = "2023-09-15"  

format = "%Y-%m-%d"  

dt = datetime.strptime(date_string, format)  

print(dt)  # 输出：2023-09-15 00:00:00

类属性

1、datetime.min：值为0001-01-01 00:00:00

最早的可表示 datetime，datetime(MINYEAR, 1, 1, tzinfo=None)。

2、datetime.max：值为9999-12-31 23:59:59.999999

最晚的可表示 datetime，datetime(MAXYEAR, 12, 31, 23, 59, 59, 999999, tzinfo=None)。

3、datetime.resolution：值为0:00:00.000001

两个不相等的 datetime 对象之间可能的最小间隔，timedelta(microseconds=1)。

实例属性（只读）

1、datetime.year：返回1~9999（ MINYEAR 和 MAXYEAR ）

2、datetime.month：返回1~12

3、datetime.day：返回1到指定年月的天数间的数字

4、datetime.hour：返回1~24

5、datetime.minute返回0~59

6、datetime.second返回0~59

7、datetime.microsecond：返回range(1000000)

8、datetime.tzinfo：作为tzinfo参数被传给datetime构造器的对象，如果没有传入值则为 None。

9、datetime.fold：返回0或1。

3.6 新版功能.

用于在重复的时间段中消除边界时间歧义。

（当夏令时结束时回拨时钟或由于政治原因导致当明时区的 UTC 时差减少就会出现重复的时间段。） 取值 0 (1) 表示两个时刻早于（晚于）所代表的同一边界时间。

支持的运算

运算	结果：
datetime2 = datetime1 + timedelta	(1)
datetime2 = datetime1 - timedelta	(2)
timedelta = datetime1 - datetime2	(3)
datetime1 < datetime2	比较 datetime 与 datetime。 (4)

1、datetime2 是从 datetime1 去掉了一段 timedelta 的结果，如果 timedelta.days > 0 则是在时间线上前进，如果 timedelta.days < 0 则是在时间线上后退。 该结果具有与输入的 datetime 相同的 tzinfo 属性，并且操作完成后 datetime2 - datetime1 == timedelta。 如果 datetime2.year 将要小于 MINYEAR 或大于 MAXYEAR 则会引发 OverflowError。 请注意即使输入的是一个感知型对象，该方法也不会进行时区调整。

2、计算 datetime2 使得 datetime2 + timedelta == datetime1。 与相加操作一样，结果具有与输入的 datetime 相同的 tzinfo 属性，即使输入的是一个感知型对象，该方法也不会进行时区调整。

3、从一个 datetime 减去一个 datetime 仅对两个操作数均为简单型或均为感知型时有定义。 如果一个是感知型而另一个是简单型，则会引发 TypeError。

如果两个操作数都是简单型，或都是感知型并且具有相同的 tzinfo 属性，则 tzinfo 属性会被忽略，并且结果会是一个使得 datetime2 + t == datetime1 的 timedelta 对象 t。 在此情况下不会进行时区调整。

如果两个操作数都是感知型且具有不同的 tzinfo 属性，a-b 操作的效果就如同 a 和 b 首先被转换为简单型 UTC 日期时间。 结果将是 (a.replace(tzinfo=None) - a.utcoffset()) - (b.replace(tzinfo=None) - b.utcoffset())，除非具体实现绝对不溢出。

4、当 datetime1 的时间在 datetime2 之前则认为 datetime1 小于 datetime2。

如果比较的一方是简单型而另一方是感知型，则如果尝试进行顺序比较将引发 TypeError。 对于相等比较，简单型实例将永远不等于感知型实例。

如果两个比较方都是感知型，且具有相同的 tzinfo 属性，则相同的 tzinfo 属性会被忽略并对基本日期时间值进行比较。 如果两个比较方都是感知型且具有不同的 tzinfo 属性，则两个比较方将首先通过减去它们的 UTC 差值（使用 self.utcoffset() 获取）来进行调整。

在 3.3 版更改: 感知型和简单型 datetime 实例之间的相等比较不会引发 TypeError。

备注

 为了防止比较操作回退为默认的对象地址比较方式，datetime 比较通常会引发 TypeError，如果比较目标不同样为 datetime 对象的话。 不过也可能会返回 NotImplemented，如果比较目标具有 timetuple() 属性的话。 这个钩子给予其他种类的日期对象实现混合类型比较的机会。 如果未实现，则当 datetime 对象与不同类型比较时将会引发 TypeError，除非是 == 或 != 比较。 后两种情况将分别返回 False 或 True。

实例方法

1、datetime.date()

返回具有同样 year, month 和 day 值的 date 对象。

示例：

from datetime import datetime

d1 = datetime(2022,12,12, 13, 30, 0)

print(d1.date()) # 输出：2022-12-12

2、datetime.time()

返回具有同样 hour, minute, second, microsecond 和 fold 值的 time 对象。 tzinfo 值为 None。 另请参见 timetz() 方法。

在 3.6 版更改: fold 值会被复制给返回的 time 对象。

示例：

from datetime import datetime

d1 = datetime(2022,12,12, 13, 30, 0)

print(d1.time()) # 输出：13:30:00

3、datetime.timetz()

返回具有同样 hour, minute, second, microsecond, fold 和 tzinfo 属性性的 time 对象。 另请参见 time() 方法。

在 3.6 版更改: fold 值会被复制给返回的 time 对象。

示例：

from datetime import datetime

d1 = datetime(2022,12,12, 13, 30, 0)

print(d1.timetz()) # 输出：13:30:00

4、datetime.replace(year=self.year, month=self.month, day=self.day, hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, tzinfo=self.tzinfo, *, fold=0)

功能：将原始datetime对象中指定值替换为新值。

返回一个具有同样属性值的 datetime，除非通过任何关键字参数为某些属性指定了新值。 请注意可以通过指定 tzinfo=None 来从一个感知型 datetime 创建一个简单型 datetime 而不必转换日期和时间数据。

3.6 新版功能: 增加了 fold 参数。

示例：

from datetime import datetime

d1 = datetime(2022,12,12, 13, 30, 0)

print(d1.replace(year=1992)) # 输出：1992-12-12 13:30:00

5、datetime.astimezone(tz=None)

返回一个具有新的 tzinfo 属性 tz 的 datetime 对象，并会调整日期和时间数据使得结果对应的 UTC 时间与 self 相同，但为 tz 时区的本地时间。

如果给出了 tz，则它必须是一个 tzinfo 子类的实例，并且其 utcoffset() 和 dst() 方法不可返回 None。 如果 self 为简单型，它会被假定为基于系统时区表示的时间。

如果调用时不传入参数 (或传入 tz=None) 则将假定目标时区为系统的本地时区。 转换后 datetime 实例的 .tzinfo 属性将被设为一个 timezone 实例，时区名称和时差值将从 OS 获取。

如果 self.tzinfo 为 tz，self.astimezone(tz) 等于 self: 不会对日期或时间数据进行调整。 否则结果为 tz 时区的本地时间，代表的 UTC 时间与 self 相同：在 astz = dt.astimezone(tz) 之后，astz - astz.utcoffset() 将具有与 dt - dt.utcoffset() 相同的日期和时间数据。

如果你只是想要附加一个时区对象 tz 到一个 datetime 对象 dt 而不调整日期和时间数据，请使用 dt.replace(tzinfo=tz)。 如果你只想从一个感知型 datetime 对象 dt 移除时区对象，请使用 dt.replace(tzinfo=None)。

请注意默认的 tzinfo.fromutc() 方法在 tzinfo 的子类中可以被重载，从而影响 astimezone() 的返回结果。 如果忽略出错的情况，astimezone() 的行为就类似于:

def astimezone(self, tz):

    if self.tzinfo is tz:

        return self

    # Convert self to UTC, and attach the new time zone object.

    utc = (self - self.utcoffset()).replace(tzinfo=tz)

    # Convert from UTC to tz's local time.

    return tz.fromutc(utc)

在 3.3 版更改: tz 现在可以被省略。

在 3.6 版更改: astimezone() 方法可以由简单型实例调用，这将假定其表示本地时间。

示例：

from datetime import datetime

d1 = datetime(2022,12,12, 13, 30, 0)

print(d1.astimezone()) # 输出：2022-12-12 13:30:00+08:00

6、datetime.__format__(format)

与 datetime.strftime() 相同。

此方法使得在 格式化字符串字面值 中以及使用 str.format() 时为 datetime 对象指定格式字符串成为可能。 另请参阅 strftime() 和 strptime() 的行为 和 datetime.isoformat()。

7、datetime.utcoffset()

功能：用于计算一个datetime对象相对于UTC（协调世界时）的偏移量。

该方法返回一个表示时间偏移量的 timedelta 对象。timedelta 表示一个时间跨度，通常用于表示时间差，例如：两个日期之间的天数差。

如果 tzinfo 为 None，则返回 None，否则返回 self.tzinfo.utcoffset(self)，并且在后者不返回 None 或者一个幅度小于一天的 timedelta 对象时将引发异常。

在 3.7 版更改: UTC 时差不再限制为一个整数分钟值。

例：

from datetime import datetime, timedelta  

  

# 创建一个 datetime 对象  

dt = datetime.now()  

print(f"当前 datetime 对象: {dt}")  

  

# 计算并打印偏移量  

offset = dt.utcoffset()  

print(f"UTC 偏移量: {offset}")

输出：

当前 datetime 对象: 2023-12-26 11:33:32.433954

UTC 偏移量: None

8、datetime.dst()

用于获取夏令时（Daylight Saving Time）的偏移量

作用：用于获取夏令时（Daylight Saving Time）的偏移量。

返回：这个方法返回一个表示夏令时偏移量的timedelta对象。

如果 tzinfo 为 None，则返回 None，否则返回 self.tzinfo.dst(self)，并且在后者不返回 None 或者一个幅度小于一天的 timedelta 对象时将引发异常。

在 3.7 版更改: DST 差值不再限制为一个整数分钟值。

示例：

from datetime import datetime, timedelta  

  

# 创建一个 datetime 对象  

dt = datetime.now()  

print(f"当前 datetime 对象: {dt}")  

  

# 计算并打印夏令时偏移量  

dst = dt.dst()  

print(f"夏令时偏移量: {dst}")

输出：

当前 datetime 对象: 2023-12-26 11:41:05.065828

夏令时偏移量: None

9、datetime.tzname()

功能：用于获取当前时区的名称

如果 tzinfo 为 None，则返回 None，否则返回 self.tzinfo.tzname(self)，如果后者不返回 None 或者一个字符串对象则将引发异常。

例：

from datetime import datetime  

  

# 获取当前时区名称  

tzname = datetime.now().tzname()  

print(f"当前时区名称: {tzname}") # 输出：当前时区名称: None

10、datetime.timetuple()

功能：用于将datetime对象转换为时间元组。

返回一个 time.struct_time，即 time.localtime() 所返回的类型。

d.timetuple() 等价于:

time.struct_time((d.year, d.month, d.day,

                  d.hour, d.minute, d.second,

                  d.weekday(), yday, dst))

其中 yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1 是日期在当前年份中的序号，起始序号 1 表示 1 月 1 日。 结果的 tm_isdst 旗标的设定会依据 dst() 方法：如果 tzinfo 为 None 或 dst() 返回 None，则 tm_isdst 将设为 -1；否则如果 dst() 返回一个非零值，则 tm_isdst 将设为 1；在其他情况下 tm_isdst 将设为 0。

例：

from datetime import datetime  

  

tzname = datetime.now()

print(tzname.timetuple())

输出：

time.struct_time(tm_year=2023, tm_mon=12, tm_mday=26, tm_hour=14, tm_min=52, tm_sec=48, tm_wday=1, tm_yday=360, tm_isdst=-1)

11、datetime.utctimetuple()

功能：用于将一个本地时间转换为UTC时间对应的元组。

如果 datetime 实例 d 为简单型，这类似于 d.timetuple()，不同之处在于 tm_isdst 会强制设为 0，无论 d.dst() 返回什么结果。 DST 对于 UTC 时间永远无效。

如果 d 为感知型， d 会通过减去 d.utcoffset() 来标准化为 UTC 时间，并返回该标准化时间所对应的 time.struct_time。 tm_isdst 会强制设为 0。 请注意如果 d.year 为 MINYEAR 或 MAXYEAR 并且 UTC

调整超出一年的边界则可能引发 OverflowError。

例：

from datetime import datetime, timedelta  

import time  

  

# 创建一个本地时间对象  

local_dt = datetime.now()  

print(f"本地时间对象: {local_dt}")  

  

# 获取本地时间对应的 UTC 时间元组  

utc_tuple = local_dt.utctimetuple()  

print(f"UTC 时间元组: {utc_tuple}")

输出：

本地时间对象: 2023-12-26 14:55:56.733209

UTC 时间元组: time.struct_time(tm_year=2023, tm_mon=12, tm_mday=26, tm_hour=14, tm_min=55, tm_sec=56, tm_wday=1, tm_yday=360, tm_isdst=0)

12、datetime.toordinal()

用于将一个datetime对象转换为其对应的年度天数序号。

返回日期的预期格列高利历序号。 与 self.date().toordinal() 相同。

例：

from datetime import datetime  

  

# 创建一个 datetime 对象  

dt = datetime(2023, 7, 19)  

print(f"datetime 对象: {dt}")  

  

# 获取日期对应的年度天数序号  

ordinal = dt.toordinal()  

print(f"年度天数序号: {ordinal}")

输出：

datetime 对象: 2023-07-19 00:00:00

年度天数序号: 738720

13、datetime.timestamp()

用于将一个datetime对象转换为时间戳（以秒为单位）。

时间戳是从1970年1月1日00:00:00（UTC）开始计算的秒数。

返回对应于 datetime 实例的 POSIX 时间戳。 此返回值是与 time.time() 返回值类似的 float 对象。

简单型 datetime 实例会被假定为代表本地时间并且此方法依赖于平台的 C mktime() 函数来执行转换。 由于在许多平台上 datetime 支持的取值范围比 mktime() 更广，对于极其遥远的过去或未来此方法可能会引发 OverflowError 或 OSError。

对于感知型 datetime 实例，返回值的计算方式为:

(dt - datetime(1970, 1, 1, tzinfo=timezone.utc)).total_seconds()

3.3 新版功能.

在 3.6 版更改: timestamp() 方法使用 fold 属性来消除重复间隔中的时间歧义。

例：

from datetime import datetime  

  

# 创建一个 datetime 对象  

dt = datetime(2023, 7, 19, 10, 30, 0)  

print(f"datetime 对象: {dt}")  

  

# 获取日期时间的时间戳  

timestamp = dt.timestamp()  

print(f"时间戳: {timestamp}")

输出：

datetime 对象: 2023-07-19 10:30:00

时间戳: 1689733800.0

14、datetime.weekday()

用于获取一个datetime对象表示的日期是星期几。星期一为 0，星期天为 6。

相当于 self.date().weekday()。 另请参阅 isoweekday()。

例：

from datetime import datetime  

  

# 创建一个 datetime 对象  

dt = datetime.today()

print(f"datetime 对象: {dt}")  

  

# 获取日期是星期几  

weekday = dt.weekday()  

print(f"今天是星期: {weekday+1}")

输出：

datetime 对象: 2023-12-26 15:03:44.568316

今天是星期: 2

15、datetime.isoweekday()

返回一个整数代表星期几，星期一为 1，星期天为 7。 相当于 self.date().isoweekday()。 另请参阅 weekday(), isocalendar()。

例：

from datetime import datetime  

  

# 创建一个 datetime 对象  

dt = datetime.today()

print(f"今天是{dt.date()},星期：",dt.isoweekday())

输出：今天是2023-12-26,星期： 2

16、datetime.isocalendar()

用于将给定日期表示为ISO（国际标准化组织）日历格式的（年，周数，星期几）元组。

返回一个由三部分组成的 named tuple: year, week 和 weekday。

等同于 self.date().isocalendar()。

例：

from datetime import datetime  

  

# 创建一个 datetime 对象  

dt = datetime(2023, 7, 19)  

print(f"今天是: {dt.date()}")  

  

# 获取 ISO 日历格式的日期信息  

isocalendar = dt.isocalendar()  

print(f"ISO 日历格式: {isocalendar}")

输出：

今天是: 2023-07-19

ISO 日历格式: datetime.IsoCalendarDate(year=2023, week=29, weekday=3)

17、datetime.isoformat(sep='T', timespec='auto')

用于将datetime对象转换为ISO 8601格式的字符串。ISO 8601是国际标准日期和时间表示方法。

返回一个以 ISO 8601 格式表示的日期和时间字符串：

YYYY-MM-DDTHH:MM:SS.ffffff，如果 microsecond 不为 0

YYYY-MM-DDTHH:MM:SS，如果 microsecond 为 0

如果 utcoffset() 返回值不为 None，则添加一个字符串来给出 UTC 时差：

YYYY-MM-DDTHH:MM:SS.ffffff+HH:MM[:SS[.ffffff]]，如果 microsecond 不为 0

YYYY-MM-DDTHH:MM:SS+HH:MM[:SS[.ffffff]]，如果 microsecond 为 0

可选参数 sep (默认为 'T') 为单个分隔字符，会被放在结果的日期和时间两部分之间。

例：

from datetime import datetime  

  

# 创建一个 datetime 对象  

dt = datetime(2023, 7, 19, 10, 30, 0)  

print(f"datetime 对象: {dt}")  

  

# 将 datetime 对象转换为 ISO 8601 格式的字符串  

iso_str = dt.isoformat()  

print(f"ISO 8601 格式: {iso_str}")

输出：

datetime 对象: 2023-07-19 10:30:00

ISO 8601 格式: 2023-07-19T10:30:00

可选参数 timespec 要包含的额外时间组件值 (默认为 'auto')。它可以是以下值之一：

'auto': 如果 microsecond 为 0 则与 'seconds' 相同，否则与 'microseconds' 相同。

'hours': 以两个数码的 HH 格式 包含 hour。

'minutes': 以 HH:MM 格式包含 hour 和 minute。

'seconds': 以 HH:MM:SS 格式包含 hour, minute 和 second。

'milliseconds': 包含完整时间，但将秒值的小数部分截断至毫秒。 格式为 HH:MM:SS.sss。

'microseconds': 以 HH:MM:SS.ffffff 格式包含完整时间。

备注

 排除掉的时间部分将被截断，而不是被舍入。

3.6 新版功能: 增加了 timespec 参数。

18、datetime.__str__()

用于返回datetime对象的字符串表示形式。

当你尝试打印一个datetime对象或者将其转换为字符串时，实际上调用的就是这个方法。

对于 datetime 实例 d，str(d) 等价于 d.isoformat(' ')。

例：

from datetime import datetime  

  

# 创建一个 datetime 对象  

dt = datetime(2023, 7, 19, 10, 30, 0)  

  

# 打印 datetime 对象  

print(dt.__str__())

print(type(dt.__str__()))

输出：

2023-07-19 10:30:00

<class 'str'>

19、datetime.ctime()

返回一个表示日期和时间的字符串:

例：

from datetime import datetime

>>> datetime(2002, 12, 4, 20, 30, 40).ctime()

输出：'Wed Dec  4 20:30:40 2002'

输出字符串将 并不 包括时区信息，无论输入的是感知型还是简单型。

d.ctime() 等效于:

time.ctime(time.mktime(d.timetuple()))

在原生 C ctime() 函数 (time.ctime() 会发起调用该函数，但 datetime.ctime() 则不会) 遵循 C 标准的平台上。

20、datetime.strftime(format)

返回一个由显式格式字符串所控制的，代表日期和时间的字符串。

datetime用法示例

1、获取当前日期和时间

from datetime import datetime  

  

# 创建一个 datetime 对象  

dt = datetime.now()

print(dt) # 输出：2023-12-26 16:08:29.104972

2、创建特定日期时间

from datetime import datetime  

  

# 创建一个 datetime 对象  

dt = datetime(1992,3,20,6,0,30)

print(dt) # 输出：1992-03-20 06:00:30

3、日期时间格式化

from datetime import datetime  

  

# 创建一个 datetime 对象  

dt = datetime(1992,3,20,6,0,30)

format_dt = dt.__format__("%Y/%m/%d")

print(format_dt) # 输出：1992/03/20

4、计算两个日期之间的差异

from datetime import datetime  

  

# 创建一个 datetime 对象  

dt1 = datetime(1992,3,20,6,0,30)

dt2 = datetime(2023,12,26,16,12)

diff = dt1-dt2

print(diff) # 输出：-11604 days, 13:48:30

5、将字符串转化为datetime对象

from datetime import datetime  

  

str = "20080512T1427"

dt = datetime.fromisoformat(str)

print(dt) # 输出：2008-05-12 14:27:00