datetime（基本日期和时间类型）

datetime（基本日期和时间类型）

datetime 模块提供了用于处理日期和时间的类。

虽然支持日期和时间算术运算，但实现的重点在于高效的属性提取，以便进行输出格式化和操作。

另请参见：

• calendar 模块：与日历相关的一般函数。
• time 模块：时间访问和转换。
• zoneinfo 模块：表示 IANA 时区数据库的具体时区。
• dateutil 包：第三方库，提供扩展的时区和解析支持。

---

1. 导入 datetime 库

要使用 datetime 库，需要先导入它。可以通过以下方式导入整个库或者部分模块：

1.1 导入整个 datetime 库

import datetime as dt

1.2 从 datetime 库中导入特定的类

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

1.3 *导入 pytz 库用于时区处理（需要安装第三方库）

import pytz

1.4 检查当前的日期和时间

print(dt.datetime.now())

2024-05-18 01:09:57.192076

---

2. 有时区信息和无时区信息的对象

根据是否包含时区信息，日期和时间对象可以分为“有时区信息（aware）”和“无时区信息（naive）”。

通过充分了解适用的算法和政治时间调整（如时区和夏令时信息），有时区信息的对象可以相对于其他有时区信息的对象定位。有时区信息的对象代表一个特定的时刻，不存在解释的余地。

无时区信息的对象不包含足够的信息，无法明确地相对于其他日期/时间对象定位。无时区信息的对象是否表示协调世界时（UTC）、本地时间或其他时区的时间完全取决于程序，就像一个特定的数字表示米、英里或质量取决于程序一样。无时区信息的对象易于理解和使用，但忽略了现实中的一些方面。

对于需要有时区信息对象的应用程序，datetime 和 time 对象有一个可选的时区信息属性，可以设置为 tzinfo 类的子类的实例。这些 tzinfo 对象捕获有关与 UTC 时间的偏移量、时区名称以及是否处于夏令时的信息。

datetime 模块只提供一个具体的 tzinfo 类，即 timezone 类。timezone 类可以表示具有固定 UTC 偏移量的简单时区，如 UTC 本身或北美的东部标准时间（EST）和东部夏令时间（EDT）。支持更详细时区的责任在于应用程序。世界各地的时间调整规则更多是政治性的而非理性的，经常变化，除了 UTC 之外，没有适用于所有应用程序的标准。

---

3. 常量

该模块导出了以下常量：

• datetime.MINYEAR
  • data 或 datetime 对象中允许的最小年份。MINYEAR is 1。
• datetime.MAXYEAR
  • data 或 datetime 对象中允许的最大年份。MAXYEAR is 9999。

---

4. 可用类型

• class datetime.date

  • 一个理想化的无时区日期，假设当前的公历始终有效。

  • 属性：

    year	month	day
    年份	月份	日期

• class datetime.time

  • 一个理想化的时间，独立于任何特定的日期，假设每天都恰好有 $24\ast 60\ast 60=86400$ 秒。（这里没有“闰秒”的概念。）

  • 属性：

    hour	minute	second	microsecond	tzinfo
    小时	分钟	秒	微秒	时区信息

• class datetime.datetime

  • 日期和时间的结合体。

  • 属性：

    year	month	day	hour	minute	hour	minute	second
    年份	月份	日期	小时	分钟	秒	微秒	时区信息

• class datetime.timedelta

  • 表达两个日期、时间或 datetime 实例之间的差异的持续时间，以微秒为分辨率。

• class datetime.tzinfo

  • 一个用于时区信息对象的抽象基类。这些被 datetime 和 time 类使用，提供一个可自定义的时间调整概念（例如，考虑时区和/或夏令时）。

• class datetime.timezone

  • 一个实现了 tzinfo 抽象基类的类，作为相对于 UTC 的固定偏移量。

    在 3.2 版本中新增。

这些类型的对象是不可变的。

4.1 常见属性

date、datetime、time 和 timezone 类型具有以下共同特性：

• 这些类型的对象是不可变的。
• 这些类型的对象是可哈希的，这意味着它们可以用作字典键。
• 这些类型的对象支持通过 pickle 模块进行高效的序列化。

4.2 确定对象是有时区信息还是无时区信息

date 类型的对象总是无时区信息的。

time 或 datetime 类型的对象可能是有时区信息的，也可能是无时区信息的。

如果同时满足以下两个条件，datetime 对象 d 是有时区信息的：

1. d.tzinfo 不是 None
2. d.tzinfo.utcoffset(d) 返回的不是 None

​ 否则，d 是无时区信息的。

如果同时满足以下两个条件，time 对象 t 是有时区信息的：

1. t.tzinfo 不是 None
2. t.tzinfo.utcoffset(None) 返回的不是 None

​ 否则，t 是无时区信息的。

有时区信息和无时区信息的区分不适用于 timedelta 对象。

---

5. 日期和时间对象的创建

在 datetime 库中，有三个主要的类用于创建和处理日期和时间对象：date、time 和 datetime。此外，还有 timedelta 类用于表示时间间隔。以下是如何创建这些对象的详细说明。

5.1 创建日期对象 - datetime.date

日期对象只包含日期部分（年、月、日）。

5.1.1 dt.date 函数

1. date.today()：获取当前日期

   此方法返回一个表示当前日期的 date 对象。

   dt.date.today()
   

   datetime.date(2024, 5, 18)

2. date.fromtimestamp(timestamp)：从时间戳创建日期对象

   此方法接受一个时间戳作为参数，并返回一个对应于该时间戳的 date 对象。

   timestamp = 1716004800  # 2024-05-18 12:00:00 的时间戳
   dt.date.fromtimestamp(timestamp)
   

   datetime.date(2024, 5, 18)

3. date.fromisoformat(date_string)：从ISO格式的日期字符串创建日期对象

   这个方法接受一个 ISO 格式的日期字符串作为参数，并返回一个对应的 date 对象。

   date_string = "2023-05-17"
   dt.date.fromisoformat(date_string)
   

   datetime.date(2023, 5, 17)

4. date(year, month, day)：创建特定日期的对象

   这个方法接受年、月、日作为参数，并返回一个对应的 date 对象。

   dt.date(2024, 5, 17)
   

   datetime.date(2024, 5, 17)

5. date.replace(year, month, day)：返回一个新的日期对象，替换指定的年、月、日

   这个方法接受年、月、日作为参数，并返回一个新的 date 对象，其中指定的年、月、日被替换为新值。

   # 创建一个日期对象
   specific_date = dt.date(2024, 5, 18)
   # 对该日期对象的值进行替换
   specific_date.replace(year=2025, month=9)
   

   datetime.date(2025, 9, 18)

5.1.2 dt.date 属性

1. date.weekday()：返回一个 [0, 6] 内的整数代表星期几

   这个方法返回一个整数，代表日期对象所对应的星期几，其中 0 代表星期一，6 代表星期日。

   specific_date = dt.date(2024, 5, 18)
   print("星期几(0-6，0代表星期一):", \
         specific_date.weekday())
   

   星期几(0-6，0代表星期一): 5

2. date.isoweekday()：返回一个 [1, 7] 内的整数代表星期几

   这个方法返回一个整数，代表日期对象所对应的星期几，其中 1 代表星期一，7 代表星期日。

   specific_date = dt.date(2024, 5, 18)
   print("星期几(1-7，1代表星期一):", \
         specific_date.weekday())
   

   星期几(1-7，1代表星期一): 6

3. date.isoformat()：返回日期的 ISO 8601 格式字符串（如 “YYYY-MM-DD”）

   这个方法返回日期对象的 ISO 8601 格式的字符串。

   specific_date = dt.date(2024, 5, 18)
   print("ISO 格式日期:", \
         specific_date.isoformat())
   

   ISO 格式日期: 2024-05-18

4. date.strftime(format)：返回日期的指定格式字符串（类似于 strftime 函数）

   这个方法返回日期对象的自定义格式字符串，格式由参数 format 指定。

   specific_date = dt.date(2024, 5, 18)
   print("自定义格式日期:", \
         specific_date.strftime("%Y/%m/%d"))
   

   自定义格式日期: 2024/05/18

5.1.3 创建时间对象 - datetime.time

时间对象只包含时间部分（时、分、秒、微秒）。

5.1.4 dt.time 函数

1. time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None, fold=0)：创建特定时间的对象

   这个方法创建一个特定时间的 time 对象。默认情况下，所有参数都为 0。

   dt.time(12, 30, 15, 123456)
   

   datetime.time(12, 30, 15, 123456)

2. time.replace(hour, minute, second, microsecond, tzinfo, fold)：返回一个新的时间对象，替换指定的时、分、秒、微秒等属性

   这个方法返回一个新的 time 对象，其中指定的时、分、秒、微秒等属性被替换为新值。

   # 创建一个特定时间的对象
   specific_time = dt.time(12, 30, 15, 123456)
   # 替换时间对象的小时和分钟
   specific_time.replace(hour=10, minute=45)
   

   datetime.time(10, 45, 15, 123456)

5.1.5 dt.time 属性

1. time.isoformat()：返回时间的 ISO 8601 格式字符串（如 “HH:MM:SS.mmmmmm”）

   这个方法返回时间对象的 ISO 8601 格式字符串。

   # 创建一个特定时间的对象
   specific_time = dt.time(12, 30, 15, 123456)
   print("ISO 格式时间:", \
         specific_time.isoformat())
   

   ISO 格式时间: 12:30:15.123456

2. time.strftime(format)：返回时间的指定格式字符串（类似于 strftime 函数）

   这个方法返回时间对象的自定义格式字符串，格式由参数 format 指定。

   # 创建一个特定时间的对象
   specific_time = dt.time(12, 30, 15, 123456)
   print("自定义格式时间:", \
         specific_time.strftime("%H:%M:%S.%f"))
   

   自定义格式时间: 12:30:15.123456

5.2 创建日期时间对象 - datetime.datetime

5.2.1 dt.datetime 函数

日期时间对象包含日期和时间部分。

1. datetime.now(tz=None)：获取当前日期和时间

   这个方法返回一个表示当前日期和时间的 datetime 对象，可以接受一个可选的时区参数 tz。

   now = dt.datetime.now()
   print("当前日期时间:", now)
   

   当前日期时间: 2024-05-18 13:23:02.344240

2. datetime.today()：获取当前日期和时间（不带时区信息）

   这个方法返回一个表示当前日期和时间的 datetime 对象，不包含时区信息。

   today = dt.datetime.today()
   print("当前日期时间(无时区):", today)
   

   当前日期时间(无时区): 2024-05-18 13:23:19.992831

3. datetime.utcnow()：获取当前的 UTC 日期和时间

   这个方法返回一个表示当前 UTC 日期和时间的 datetime 对象。

   utc_now = dt.datetime.utcnow()
   print("当前 UTC 日期时间:", utc_now)
   

   当前 UTC 日期时间: 2024-05-18 05:23:35.657310

4. datetime.fromtimestamp(timestamp, tz=None)：从时间戳创建日期时间对象

   这个方法接受一个时间戳作为参数，并返回一个对应于该时间戳的 datetime 对象，可以接受一个可选的时区参数 tz。

   timestamp = 1674031200
   dt_from_ts = dt.datetime.fromtimestamp(timestamp)
   print("从时间戳创建的日期时间:", dt_from_ts)
   

   从时间戳创建的日期时间: 2023-01-18 16:40:00

5. datetime.utcfromtimestamp(timestamp)：从 UTC 时间戳创建日期时间对象

   这个方法接受一个 UTC 时间戳作为参数，并返回一个对应于该时间戳的 datetime 对象。

   timestamp = 1674031200
   dt_from_utc_ts = dt.datetime.utcfromtimestamp(timestamp)
   print("从 UTC 时间戳创建的日期时间:", dt_from_utc_ts)
   

   从 UTC 时间戳创建的日期时间: 2023-01-18 08:40:00

6. datetime.fromisoformat(date_string)：从 ISO 格式的日期时间字符串创建日期时间对象

   这个方法接受一个 ISO 格式的日期时间字符串作为参数，并返回一个对应的 datetime 对象。

   iso_date_string = "2023-05-17T12:30:00"
   dt_from_iso = dt.datetime.fromisoformat(iso_date_string)
   print("从 ISO 格式字符串创建的日期时间:", dt_from_iso)
   

   从 ISO 格式字符串创建的日期时间: 2023-05-17 12:30:00

7. datetime.combine(date, time)：将日期对象和时间对象合并成日期时间对象

   这个方法接受一个 date 对象和一个 time 对象，并返回一个对应的 datetime 对象。

   date_obj = dt.date(2023, 5, 17)
   time_obj = dt.time(12, 30)
   combined_dt = dt.datetime.combine(date_obj, time_obj)
   print("合并后的日期时间:", combined_dt)
   

   合并后的日期时间: 2023-05-17 12:30:00

8. datetime.strptime(date_string, format)：根据格式化字符串解析日期时间字符串

   这个方法接受一个日期时间字符串和一个格式化字符串，并返回一个对应的 datetime 对象。

   date_string = "17-05-2023 12:30"
   dt_from_str = dt.datetime.strptime(date_string, "%d-%m-%Y %H:%M")
   print("解析后的日期时间:", dt_from_str)
   

   解析后的日期时间: 2023-05-17 12:30:00

9. datetime.replace(year, month, day, hour, minute, second, microsecond, tzinfo, fold)：返回一个新的日期时间对象，替换指定的年、月、日、时、分、秒、微秒等属性

   这个方法返回一个新的 datetime 对象，其中指定的年、月、日、时、分、秒、微秒等属性被替换为新值。

   dt_obj = dt.datetime(2023, 5, 17, 12, 30)
   new_dt = dt_obj.replace(year=2025, hour=15)
   print("替换后的日期时间:", new_dt)
   

   替换后的日期时间: 2025-05-17 15:30:00

10. datetime.date()：返回日期部分的日期对象

    这个方法返回 datetime 对象中的日期部分。

    dt_obj = dt.datetime(2023, 5, 17, 12, 30)
    date_part = dt_obj.date()
    print("日期部分:", date_part)
    

    日期部分: 2023-05-17

11. datetime.time()：返回时间部分的时间对象

    这个方法返回 datetime 对象中的时间部分。

    dt_obj = dt.datetime(2023, 5, 17, 12, 30)
    time_part = dt_obj.time()
    print("时间部分:", time_part)
    

    时间部分: 12:30:00

5.2.2 dt.datetime 属性

1. datetime.utcoffset()：返回时区偏移量

   这个方法返回 datetime 对象的时区偏移量。如果没有时区信息，则返回 None。

   # 创建一个带时区的 datetime 对象
   dt_obj = dt.datetime(2023, 5, 17, 12, 30, tzinfo=dt.timezone(dt.timedelta(hours=8)))
   offset = dt_obj.utcoffset()
   print("时区偏移量:", offset)
   

   时区偏移量: 8:00:00

2. datetime.dst()：返回夏令时偏移量

   这个方法返回夏令时（DST）偏移量。

   # 创建一个带时区的 datetime 对象，假设时区支持夏令时
   class TZ(dt.tzinfo):
       def utcoffset(self, dt):
           # 返回标准时间的时区偏移量
           return dt.timedelta(hours=1)
       
       def dst(self, dt):
           # 返回夏令时的时区偏移量
           return dt.timedelta(hours=1)
       
       def tzname(self, dt):
           # 返回时区的名字
           return "DST"
   
   # 创建一个 datetime 对象，使用自定义的时区信息
   dt_obj = dt.datetime(2023, 5, 17, 12, 30, tzinfo=TZ())
   # 获取夏令时偏移量
   dst_offset = dt_obj.dst()
   print("夏令时偏移量:", dst_offset)
   

   夏令时偏移量: 1:00:00

3. datetime.timetuple()：返回时间元组

   这个方法返回一个时间元组，类似于 time.struct_time。

   dt_obj = dt.datetime(2023, 5, 17, 12, 30)
   time_tuple = dt_obj.timetuple()
   print("时间元组:", time_tuple)
   

   时间元组: time.struct_time(tm_year=2023, tm_mon=5, tm_mday=17, tm_hour=12, tm_min=30, tm_sec=0, tm_wday=2, tm_yday=137, tm_isdst=-1)

4. datetime.utctimetuple()：返回 UTC 时间元组

   这个方法返回一个 UTC 时间元组。

   dt_obj = dt.datetime(2023, 5, 17, 12, 30)
   utc_time_tuple = dt_obj.utctimetuple()
   print("UTC 时间元组:", utc_time_tuple)
   

   UTC 时间元组: time.struct_time(tm_year=2023, tm_mon=5, tm_mday=17, tm_hour=12, tm_min=30, tm_sec=0, tm_wday=2, tm_yday=137, tm_isdst=0)

5. datetime.toordinal()：返回自 1 年 1 月 1 日以来的天数

   这个方法返回自公元 1 年 1 月 1 日以来的天数。

   dt_obj = dt.datetime(2023, 5, 17)
   ordinal = dt_obj.toordinal()
   print("自 1 年 1 月 1 日以来的天数:", ordinal)
   

   自 1 年 1 月 1 日以来的天数: 738657

6. 返回星期几

   • datetime.weekday()：返回一个 [0, 6] 内的整数代表星期几
   • datetime.isoweekday()：返回一个 [1, 7] 内的整数代表星期几

   具体描述参见 dt.date

7. datetime.isoformat(sep='T')：返回日期时间的 ISO 8601 格式字符串

   这个方法返回日期时间的 ISO 8601 格式字符串。

   dt_obj = dt.datetime(2023, 5, 17, 12, 30)
   iso_format = dt_obj.isoformat()
   print("ISO 8601 格式字符串:", iso_format)
   

   ISO 8601 格式字符串: 2023-05-17T12:30:00

8. datetime.ctime()：返回日期时间的字符串表示形式（类似于 ctime 函数）

   这个方法返回日期时间的字符串表示形式，类似于 ctime 函数。

   dt_obj = dt.datetime(2023, 5, 17, 12, 30)
   ctime_str = dt_obj.ctime()
   print("ctime 字符串表示形式:", ctime_str)
   

   ctime 字符串表示形式: Wed May 17 12:30:00 2023

9. datetime.strftime(format)：返回日期时间的指定格式字符串（类似于 strftime 函数）

   这个方法返回日期时间的指定格式字符串，格式字符串与 strftime 函数类似。

   dt_obj = dt.datetime(2023, 5, 17, 12, 30)
   formatted_str = dt_obj.strftime("%Y-%m-%d %H:%M:%S")
   print("指定格式字符串:", formatted_str)
   

   指定格式字符串: 2023-05-17 12:30:00

5.3 创建时间间隔对象 - datetime.timedelta

时间间隔对象表示两个日期时间之间的差异。

1. timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)：创建时间间隔对象

   timedelta 对象表示两个日期或时间之间的时间间隔。可以使用不同的参数来定义这个间隔，包括天数、秒、微秒、毫秒、分钟、小时和星期。

   # 创建一个时间间隔对象，表示2天3小时30分钟
   time_delta = dt.timedelta(days=2, hours=3, minutes=30)
   print("时间间隔对象:", time_delta)
   

   时间间隔对象: 2 days, 3:30:00

2. timedelta.total_seconds()：返回时间间隔的总秒数

   这个方法返回 timedelta 对象表示的时间间隔的总秒数。这个总秒数包含了天数、小时、分钟、秒和微秒的总和。

   # 创建一个时间间隔对象，表示2天3小时30分钟
   time_delta = dt.timedelta(days=2, hours=3, minutes=30)
   # 获取时间间隔的总秒数
   total_seconds = time_delta.total_seconds()
   print("时间间隔的总秒数:", total_seconds)
   

   时间间隔的总秒数: 183000.0

---

6. 日期时间的格式化和解析

日期时间的格式化和解析是将日期时间对象转换为字符串或将字符串解析为日期时间对象的过程。

在 Python 中，可以使用 strftime() 方法将日期时间对象格式化为字符串，使用 strptime() 函数将字符串解析为日期时间对象。

在此示例中，"%Y-%m-%d %H:%M:%S" 是格式化字符串，它定义了日期时间的输出格式。这个格式化字符串包含了特定的格式占位符，每个占位符代表了日期时间的不同部分，例如年、月、日、小时、分钟、秒等。

常用的占位符有：

• %Y: 年份（四位数）
• %m: 月份（两位数，01-12）
• %d: 日期（两位数，01-31）
• %H: 小时（24小时制，00-23）
• %M: 分钟（00-59）
• %S: 秒（00-59）

此外，也可以使用其他格式化字符串，根据需求定义日期时间的输出格式。

6.1 格式化日期时间对象 - datetime.strftime

可以使用 strftime() 方法将日期时间对象格式化为字符串。strftime() 方法接受一个格式化字符串作为参数，用于指定日期时间的输出格式。

# 创建一个日期时间对象
dt_obj = dt.datetime(2023, 5, 17, 12, 30)

# 将日期时间对象格式化为字符串
formatted_str = dt_obj.strftime("%Y-%m-%d %H:%M:%S")
print("格式化后的日期时间字符串:", formatted_str)

格式化后的日期时间字符串: 2023-05-17 12:30:00

6.2 解析字符串为日期时间对象 - datetime.strptime

要将字符串解析为日期时间对象，可以使用 strptime() 函数。这个函数接受两个参数：一个表示日期时间的字符串，另一个表示日期时间的格式化字符串。以下是 strptime() 函数的用法：

# 定义一个日期时间字符串
date_string = "2023-05-17 12:30:00"

# 解析日期时间字符串为日期时间对象
parsed_dt_obj = dt.datetime.strptime(date_string, "%Y-%m-%d %H:%M:%S")
print("解析后的日期时间对象:", parsed_dt_obj)

解析后的日期时间对象: 2023-05-17 12:30:00

---

7. 日期时间的算术运算

datetime 模块提供了多种方法和功能，可以方便地进行日期和时间的算术运算，例如加减日期、时间间隔的计算等。主要用到的类是 datetime、date 和 timedelta。

7.1 日期时间的加减运算

7.1.1 date（日期）加减时间间隔

# 创建一个日期对象
date_obj = dt.date(2023, 5, 17)

# 创建一个时间间隔对象，表示10天
time_delta = dt.timedelta(days=10)

# 计算10天后的日期
new_date = date_obj + time_delta
print("10天后的日期:", new_date)

10天后的日期: 2023-05-27

7.1.2 datetime（日期时间）加减时间间隔

# 创建一个日期时间对象
datetime_obj = dt.datetime(2023, 5, 17, 12, 30)

# 创建一个时间间隔对象，表示10天
time_delta = dt.timedelta(days=10)

# 计算10天前的日期时间
previous_datetime = datetime_obj - time_delta
print("10天前的日期时间:", previous_datetime)

10天前的日期时间: 2023-05-07 12:30:00

7.2 计算两个日期之间的差异

可以计算两个 datetime 或 date 对象之间的差值，结果是一个 timedelta 对象。

7.2.1 计算两个 date（日期）之间的差异

# 创建两个日期对象
date_obj1 = dt.date(2023, 5, 17)
date_obj2 = dt.date(2023, 6, 1)

# 计算日期差值
date_diff = date_obj2 - date_obj1
print("日期差值:", date_diff)
print("相差的天数:", date_diff.days)

日期差值: 15 days, 0:00:00
相差的天数: 15

7.2.2 计算两个 datetime（日期时间）之间的差异

# 创建两个日期时间对象
datetime_obj1 = dt.datetime(2023, 5, 17, 12, 30)
datetime_obj2 = dt.datetime(2023, 6, 1, 15, 45)

# 计算日期时间差值
datetime_diff = datetime_obj2 - datetime_obj1
print("日期时间差值:", datetime_diff)
print("相差的天数:", datetime_diff.days)
print("相差的总秒数:", datetime_diff.total_seconds())

日期时间差值: 15 days, 3:15:00
相差的天数: 15
相差的总秒数: 1305000.0

---

8. 时区处理

8.1 创建时区感知的日期时间对象 - datetime.timezone

# 创建一个表示 UTC+8 时区的时区对象
tz_utc8 = dt.timezone(dt.timedelta(hours=8))

# 创建一个带有时区信息的日期时间对象
datetime_with_tz = dt.datetime(2023, 5, 17, 12, 30, tzinfo=tz_utc8)
print("带有时区信息的日期时间对象:", datetime_with_tz)

带有时区信息的日期时间对象: 2023-05-17 12:30:00+08:00

8.2 使用第三方库 pytz

pytz 是 Python 中处理时区的强大工具，它支持几乎所有的时区信息，并且提供了更多的时区处理功能。

import pytz

# 获取一个表示亚洲/上海时区的时区对象
tz_shanghai = pytz.timezone('Asia/Shanghai')

# 创建一个带有时区信息的日期时间对象
datetime_with_tz = dt.datetime(2023, 5, 17, 12, 30, tzinfo=tz_shanghai)
print("带有时区信息的日期时间对象:", datetime_with_tz)

带有时区信息的日期时间对象: 2023-05-17 12:30:00+08:06

8.3 时区转换 - datetime.tzinfo

import pytz

# 获取表示 UTC 时区的时区对象
utc_tz = pytz.utc

# 创建一个带有时区信息的日期时间对象（UTC时间）
datetime_utc = dt.datetime(2023, 5, 17, 12, 30, tzinfo=utc_tz)
print("带有时区信息的日期时间对象（UTC时间）:", datetime_utc)

# 将UTC时间转换为上海时间
datetime_shanghai = datetime_utc.astimezone(pytz.timezone('Asia/Shanghai'))
print("上海时间:", datetime_shanghai)

带有时区信息的日期时间对象（UTC时间）: 2023-05-17 12:30:00+00:00
上海时间: 2023-05-17 20:30:00+08:00

---

9. 日期时间的比较和排序

在 Python 中，可以直接使用比较运算符（如 <, <=, ==, !=, >=, >）来比较日期时间对象，以进行日期时间的比较和排序。

9.1 比较运算符

Python 中的日期时间对象支持直接使用比较运算符进行比较。当比较两个日期时间对象时，会按照日期时间的先后顺序进行比较。

# 创建两个日期时间对象
datetime_obj1 = dt.datetime(2023, 5, 17, 12, 30)
datetime_obj2 = dt.datetime(2023, 6, 1, 15, 45)

# 比较日期时间对象
print("datetime_obj1 < datetime_obj2:", datetime_obj1 < datetime_obj2)
print("datetime_obj1 == datetime_obj2:", datetime_obj1 == datetime_obj2)
print("datetime_obj1 > datetime_obj2:", datetime_obj1 > datetime_obj2)

datetime_obj1 < datetime_obj2: True
datetime_obj1 == datetime_obj2: False
datetime_obj1 > datetime_obj2: False

9.2 列表排序

可以直接使用列表的 sort() 方法来对包含日期时间对象的列表进行排序。

# 创建日期时间对象列表
datetime_list = [
    dt.datetime(2023, 5, 17, 12, 30),
    dt.datetime(2023, 6, 1, 15, 45),
    dt.datetime(2023, 4, 20, 8, 0)
]

# 对日期时间对象列表进行排序
datetime_list.sort()

# 打印排序后的列表
print("排序后的日期时间对象列表:")
for dt_obj in datetime_list:
    print(dt_obj)

排序后的日期时间对象列表:
2023-04-20 08:00:00
2023-05-17 12:30:00
2023-06-01 15:45:00

---

10. 其他常用功能

除了基本的日期和时间处理，Python 的 datetime 模块还提供了一些其他常用功能，可以帮助你处理更复杂的日期和时间操作。

10.1 datetime 对象的 timestamp() 方法

获取自 Unix 纪元（1970 年 1 月 1 日）以来的秒数。

# 创建一个日期时间对象
datetime_obj = dt.datetime(2023, 5, 17, 12, 30)

# 获取 Unix 时间戳
timestamp = datetime_obj.timestamp()
print("Unix 时间戳:", timestamp)

Unix 时间戳: 1684297800.0

10.2 使用 datetime 对象进行日期迭代

# 起始日期
start_date = dt.date(2023, 5, 1)
# 结束日期
end_date = dt.date(2023, 5, 10)

# 生成日期范围
current_date = start_date
while current_date <= end_date:
    print(current_date)
    current_date += dt.timedelta(days=1)

2023-05-01
2023-05-02
2023-05-03
2023-05-04
2023-05-05
2023-05-06
2023-05-07
2023-05-08
2023-05-09
2023-05-10