目录
- 一、常见时间名词
- 二、datetime模块介绍
- 三、datetime模块中的常量以及几个常用类
- 四、常用方法介绍
- 4.1 datetime对象常用方法
- 4.1.1 now()方法——返回指定时区的本地日期时间
- 4.1.2 today()方法——返回当前本地日期时间
- 4.1.3 strftime()方法——返回指定格式的日期时间字符串
- 4.1.4 strptime()方法——获取对应的datetime对象
- 4.1.5 weekday()方法——获取星期对应的数字
- 4.1.6 tzname()方法——返回时区名称
- 4.1.7 toordinal()方法——返回自0001年01月01日开始的第多少天
- 4.1.8 timestamp()方法——返回当前时间的时间戳
- 4.1.9 time()方法——返回时间对象
- 4.1.10 fromtimestamp()方法——根据时间戳创建datetime对象
- 4.1.11 date()方法——返回日期对象
- 4.1.12 ctime()方法——返回一个代表日期和时间的字符串
- 4.1.13 combine()方法——将date和time对象合为datetime对象
- 4.1.14 astimezone()方法——返回一个带有时区信息的datetime对象
- 4.1.15 __format__()方法——返回指定格式的日期字符串
- 4.1.16 __str__()方法——返回“YYYY-MM-DD”格式的日期字符串
- 4.1.17 dst()方法——返回datetime对象的dst偏移量
- 4.1.18 fromisoformat()方法——将日期时间字符串转换为datetime对象
- 4.1.19 fromordinal()方法——根据指定的天数返回对应的date对象
- 4.1.20 isocalendar()方法——返回包含年、周、星期的元组
- 4.1.21 isoformat()方法——返回“YYYY-MM-DD”格式的日期时间字符串
- 4.1.22 utcnow()方法——返回当前日期时间的UTC datetime对象
- 4.1.23 utcfromtimestamp()方法——将时间戳转为UTC datetime对象
- 4.1.24 utcoffset()方法——返回datetime对象的UTC偏移量
- 4.1.25 utctimetuple()方法——返回UTC世界协调时的时间元组
- 4.1.26 timetz()方法——返回时区时间对象
- 4.1.27 timetuple()方法——返回对应的时间元组
- 4.1.28 replace()方法——替换并返回新datetime对象
- 4.1.29 isoweekday()方法——返回指定日期的星期序号
- 4.2 timedelta对象常用方法
- 4.3 date对象与time对象常用方法
- 4.4 timezone对象常用方法
一、常见时间名词
GMT（Greenwich Mean Time）格林尼治标准时间： GMT 是从英国伦敦附近的格林尼治天文台定义的时间标准。它是一种国际标准时间，在全球范围内作为基准时间使用。GMT 不受夏令时影响，因此它一年四季都保持不变。
夏令时（Daylight Saving Time，DST） 是为了更好地利用日光，在夏季将时钟拨快一小时的做法。这样，人们可以在白天拥有更长的自然光时间，从而减少晚上的用电需求。夏令时通常从春季开始，到秋季结束。夏令时的特点：
开始和结束：夏令时通常在春季开始，将时钟拨快一小时，到了秋季结束时再将时钟拨回一小时。具体的日期在不同国家和地区有所不同。
目的：主要目的是为了节省能源。通过延长日光时间，人们可以减少晚间使用电力照明的时间。
影响地区：并非所有国家或地区都实行夏令时。它主要在北美、欧洲和部分亚洲国家使用。比如，美国的夏令时通常从3月的第二个星期天开始，11月的第一个星期天结束。
非适用地区：靠近赤道的国家由于日照时间变化不大，通常不采用夏令时。中国大陆自1991年起也不再实行夏令时。
举个例子：美国东部时间（EST） 是 UTC-5，但在夏令时期间，变成了 EDT（Eastern Daylight Time），即 UTC-4。当夏令时结束时，时钟会回调一小时，恢复到标准时间。
时区： 时区是为了方便全球不同地区的人们协调时间，而将地球按经度划分的区域。每个时区通常以小时为单位相对于 GMT 或 UTC 来表示。地球上共划分了 24 个标准时区。例如，北京位于东八区，因此其时间通常表示为 GMT+8 或 UTC+8。
UTC（Coordinated Universal Time）协调世界时： UTC 是基于原子钟的全球时间标准，常用于航海、航空等需要精确时间的领域。UTC 类似于 GMT，但更加精确。UTC 也不受夏令时影响，因此一年四季的时间都是固定的。
CST：CST 可以有多种含义，具体取决于地区：
- China Standard Time 中国标准时间：指的是中国所使用的时区，即 UTC+8（也称为北京时间）。
- Central Standard Time 中部标准时间：这是北美中部地区的时区，通常指的是 UTC-6（标准时间），但在夏季可能会采用夏令时（CDT，UTC-5）。
二、datetime模块介绍
datetime 模块中提供了多种操作日期和时间的类，还提供了一系列由简单到复杂的日期时间处理方法，可以实现以各种不同方式创建和输出日期与时间信息。另外，本模块中还包含对时区及夏令时信息的处理方法。
三、datetime模块中的常量以及几个常用类
3.1 datetime模块中的常量
datetime 模块提供两个常量 MINYEAR 与 MAXYEAR，分别用于表示 date 或者 datetime 对象所允许的最小年份与最大年份。示例：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
import datetime # 导入datetime模块
# date或datetime对象允许的最小年份为: 1
print('date或datetime对象允许的最小年份为: ', datetime.MINYEAR)
# date或datetime对象允许的最大年份为: 9999
print('date或datetime对象允许的最大年份为: ', datetime.MAXYEAR)
3.2 datetime模块中的几个常用类
3.2.1 date类
datetime.date 类由 year、month 及 day 构成。datetime.date 类的定义如下：
参数说明：
- year：必须参数，年，取值范围：
[1,9999] - month：必须参数，月，取值范围：
[1,12] - day：必须参数，一月中第几天，取值范围：
[1,指定年份的月份中的天数]， 最大值根据给定的 year 和 month 参数来决定 - 返回值：返回 year-month-day 格式的日期对象
【示例】
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
import datetime # 导入datetime模块
# 1.创建指定日期的date对象
# # 打印date对象，返回结果看似是字符串 其实是date对象
print(datetime.date(2024, 10, 12)) # 2024-10-12
# <class 'datetime.date'>
print(type(datetime.date(2024, 10, 12)))
# 2.获取date对象中的年、月、日
date_object = datetime.date(2024, 9, 30) # 创建日期对象
print('日期对象的年为: ', date_object.year)
print('日期对象的月为: ', date_object.month)
print('日期对象的日为: ', date_object.day)
# 3.获取日期的最小单位、最大值与最小值
print(datetime.date.min) # 打印日期最小值 0001-01-01
print(datetime.date.max) # 打印日期最大值 9999-12-31
print(datetime.date.resolution) # 打印日期最小单位 1 day, 0:00:00
3.2.2 time类
time 类由 hour、minute、second、microsecond 和 tzinfo 五部分组成，time 类的定义如下：
参数说明：
- hour：可选参数，表示小时，取值范围：
[0, 23] - minute：可选参数，表示分钟，取值范围：
[0, 59] - second：可选参数，表示秒，取值范围：
[0, 59] - microsecond：可选参数，表示微秒，取值范围：
[0, 999999] - tzinfo：可选参数，表示时区的相关信息，tzinfo 为子类对象（如timezone类）的实例。
- fold：值为0或1，默认为0
【示例1】hour,minute,second以及microsecond(时、分、秒、微秒)属性。代码如下:
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
from datetime import time # 导入datetime模块中的time类
t = time(16, 13, 56, 888) # 创建时间对象
print(type(t)) # <class 'datetime.time'>
print(t) # 16:13:56.000888
# 16 13 56 888
print(t.hour, t.minute, t.second, t.microsecond) # 打印时、分、秒、微秒
【示例2】min,max,resolution(时间对象的最小时间,最大时间与时间的最小单位)属性。代码如下:
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
from datetime import time # 导入datetime模块中的time类
print(time.max) # time类所能表示的最大时间 23:59:59.999999
print(time.min) # time类所能表示的最小时间 00:00:00
print(time.resolution) # 两个不同时间的最小单位 0:00:00.000001
【示例3】 tzinfo——返回时区信息对象。使用time类对象提供的tzinfo属性,获取时间对象的时区信息对象,代码如下:
from datetime import time # 导入datetime模块中的time类
t = time(16, 13, 56, 888) # 创建时间对象
print(t.tzinfo) # 在没有指定时区参数时，返回None
3.2.3 datetime类
datetime 类可以看作是 date 类和 time 类的合体，其大部分的方法和属性都继承于这两个类，其数据构成也是由这两个类的所有属性组成的，datetime.datetime 类的定义如下：
示例代码：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
from datetime import datetime # 导入datetime模块中的datetime类
# 1.获取年、月、日、时、分、秒及微秒信息
dt = datetime.today() # 把获取的当前本地日期时间赋给变量dt
print(type(dt)) # <class 'datetime.datetime'>
print(dt) # 打印当前本地日期时间 2024-10-12 05:42:49.352447
print(dt.year, '年') # 2024 年
print(dt.month, '月') # 10 月
print(dt.day, '日') # 12 日
print(dt.hour, '时') # 5 时
print(dt.minute, '分') # 43 分
print(dt.second, '秒') # 3 秒
print(dt.microsecond, '微秒') # 153388 微秒
print(dt.tzinfo, '时区') # None 时区
# 2.获取日期时间的最小值、最大值与最小单位
print('最大值: ', dt.max) # 最大值: 9999-12-31 23:59:59.999999
print('最小值: ', dt.min) # 最小值: 0001-01-01 00:00:00
print('最小单位: ', dt.resolution) # 最小单位: 0:00:00.000001
3.2.4 timedelta类
timedelta 类表示时间差，即两个日期或时间之间的差值。timedelta 类可以很方便地对 datetime.date、datetime.time 和 datetime.datetime 对象进行算术运算，且两个时间之间的差值单位也更加容易控制。这个差值的单位可以是：天、秒、微秒、毫秒、分钟、小时、周。datetime.timedelta 类的定义如下：
示例代码：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
from datetime import timedelta, datetime # 导入datetime模块中的timedelta与datetime类
# 1.使用timedelta 类对象提供的min、max、resolution 属性获取三种时间差，代码如下:
print(timedelta.max) # 打印正数最大时间差 999999999 days, 23:59:59.999999
print(timedelta.min) # 打印负数最小时间差 -999999999 days, 0:00:00
print(timedelta.resolution) # 打印两个时间的最小差值单位 0:00:00.000001
# 2.days、seconds、microseconds（timedelta类对象的天、秒与微秒）属性
td = timedelta(365, 888, 687411) # 创建timedelta对象
print(type(td)) # <class 'datetime.timedelta'>
print(td.days) # 打印天 365
print(td.seconds) # 打印秒 888
print(td.microseconds) # 打印微秒 687411
# 3.计算两个日期之间的差值（datetime.timedelta可以直接与datetime.datetime对象做加减操作）
print('现在时间:', datetime.now()) # 现在时间
# 2天后: 2024-10-14 05:52:04.090962
print('2天后:', datetime.now() + timedelta(2)) # 打印2天后
# 3天前: 2024-10-09 05:52:04.090962
print('3天前:', datetime.now() + timedelta(-3)) # 打印3天前
# 1小时后: 2024-10-12 06:52:04.090962
print('1小时后:', datetime.now() + timedelta(hours=1)) # 打印1小时后
# 4小时前: 2024-10-12 01:52:04.090962
print('4小时前:', datetime.now() + timedelta(hours=-4)) # 打印4小时前
# 2小时20秒后: 2024-10-12 07:52:24.090962
print('2小时20秒后:', datetime.now() + timedelta(hours=2, seconds=20)) # 打印2小时20秒后
3.2.5 timezone类
timezone 类是 tzinfo 类的一个子类，它的每一个实例代表一个与 UTC 的固定差值所定义的时区。注意，该类的对象不能用于表示某些特殊地点的时区信息。datetime.timezone 类的定义如下：
【示例1】 获取自定义的时区名称。首先使用timezone类创建时区对象,然后通过time类中的tzname()方法获取自定义的时区名称,代码如下:
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
import datetime # 导入datetime模块
# 创建名称为欧洲 马德里时区
timezone_madrid = datetime.timezone(datetime.timedelta(hours=2), name='Europe / Madrid')
# 创建-4时区
timezone_toronto = datetime.timezone(datetime.timedelta(hours=-4))
# 创建+8时区
timezone1 = datetime.timezone(datetime.timedelta(hours=8))
t1 = datetime.time(4, 5, 12, tzinfo=timezone_madrid) # 马德里时区的时间对象
t2 = datetime.time(4, 5, 12, tzinfo=timezone_toronto) # -4时区的时间对象
t3 = datetime.time(4, 5, 12) # 未指定时区
t4 = datetime.time(4, 5, 12, tzinfo=timezone1) # +8时区的时间对象
print(t1.tzname()) # Europe / Madrid
print(t2.tzname()) # UTC-04:00
print(t3.tzname()) # None
print(t4.tzname()) # UTC+08:00
四、常用方法介绍
4.1 datetime对象常用方法
4.1.1 now()方法——返回指定时区的本地日期时间
datetime 类中的 now() 方法用于返回一个表示当前本地时间的 datetime 对象。语法格式如下：
In [5]: from datetime import datetime
In [6]: datetime.now?
Signature: datetime.now(tz=None)
Docstring:
Returns new datetime object representing current time local to tz.
tz
Timezone object.
If no tz is specified, uses local timezone.
Type: builtin_function_or_method
参数说明:
1.tz: 可选参数。如果提供了参数tz，则获取tz所指时区的本地时间
如果不指定参数tz或参数tz为None，则结果和datetime.today()结果相同。
2.返回值: 返回一个表示当前本地日期时间的datetime对象。
示例：
In [8]: datetime.today()
Out[8]: datetime.datetime(2024, 10, 12, 6, 6, 57, 690856)
In [9]: datetime.now()
Out[9]: datetime.datetime(2024, 10, 12, 6, 7, 2, 987768)
4.1.2 today()方法——返回当前本地日期时间
datetime 类中的 today() 方法用于返回一个表示当前本地日期时间的datetime 对象。语法格式如下：
In [11]: datetime.today?
Docstring: Current date or datetime: same as self.__class__.fromtimestamp(time.time()).
Type: builtin_function_or_method
参数说明:
1.返回值: 返回一个表示当前本地日期时间的datetime对象
示例：
In [12]: from datetime import datetime
In [13]: datetime.today()
Out[13]: datetime.datetime(2024, 10, 12, 6, 10, 26, 387741)
4.1.3 strftime()方法——返回指定格式的日期时间字符串
datetime 类中的 strftime() 方法用于返回指定格式的日期时间字符串。语法格式如下：
In [14]: datetime.strftime?
Docstring: format -> strftime() style string.
Type: method_descriptor
参数说明:
1.format: 表示指定的显示格式
2.返回值: 返回format指定格式的日期时间字符串
3.strftime: Convert object to a string according to a given format----
Instance method----date; datetime; time
示例代码：
In [15]: from datetime import datetime
In [16]: dt = datetime.today() # 获取当前日期时间
In [17]: dt.strftime("%d-%m-%y %H:%M")
Out[17]: '12-10-24 06:13'
In [18]: dt.strftime("%d/%m/%y %H:%M")
Out[18]: '12/10/24 06:13'
In [19]: dt.strftime("%d %m %y %H:%M")
Out[19]: '12 10 24 06:13'
In [20]: dt.strftime("%d %m %y %H:%M:%S")
Out[20]: '12 10 24 06:13:40'
4.1.4 strptime()方法——获取对应的datetime对象
datetime 类中的 strptime() 方法用于根据指定的日期时间字符串与格式，获取对应的 datetime 对象。语法格式如下：
In [21]: strptime(date_string, format)
Docstring: string, format -> new datetime parsed from a string (like time.strptime()).
Type: builtin_function_or_method
参数说明:
1.Parse a string into a datetime object given a corresponding format--Class method--datetime
2.string: 表示指定的日期时间字符串
3.format: 表示指定日期时间字符串的格式
4.返回值: 返回指定格式的日期时间字符串对应的datetime对象
示例代码：
In [23]: from datetime import datetime
In [24]: datetime.strptime('24/10/12 6:25', '%d/%m/%y %H:%M')
Out[24]: datetime.datetime(2012, 10, 24, 6, 25)
In [25]: datetime.strptime('14/08/20 14:25:50', '%d/%m/%y %H:%M:%S')
Out[25]: datetime.datetime(2020, 8, 14, 14, 25, 50)
4.1.5 weekday()方法——获取星期对应的数字
datetime 类中的 weekday() 方法用于返回指定日期在一周内的序号，其中周一表示为0，周日表示为6。语法格式如下：
In [26]: datetime.weekday?
Docstring:
Return the day of the week represented by the date.
Monday == 0 ... Sunday == 6
Type: method_descriptor
参数说明:
1.返回值: 返回指定日期在一周内的序号，其中周一表示为0，周日表示为6
示例代码：
In [27]: from datetime import datetime
In [28]: dt = datetime.today()
In [29]: dt.weekday()
Out[29]: 5
In [31]: dt = datetime(2024, 9, 2)
In [32]: dt.weekday()
Out[32]: 0
4.1.6 tzname()方法——返回时区名称
datetime 类中的 tzname() 方法用于获取时区名称。语法格式如下：
In [34]: datetime.tzname?
Docstring: Return self.tzinfo.tzname(self).
Type: method_descriptor
参数说明:
1.返回值: 如果datetime实例对象中指定了tz参数，将返回对应的时区名称。
如果datetime实例对象未设置tz参数，则返回None。
返回的时区名称可以是"GMT","UTC","500","-5:00"以及"美国东部时间"等有效名称。
示例代码：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
import datetime # 导入datetime模块
from dateutil.tz import gettz # 导入获取指定时区的方法
dt1 = datetime.datetime.now(tz=gettz('China Standard Time')) # 获取中国标准时间时区
dt2 = datetime.datetime.now(tz=gettz('Pacific/Kiritimati')) # 获取太平洋 圣诞岛时区
dt3 = datetime.datetime.now(tz=gettz('Australia/Sydney')) # 澳大利亚 悉尼时区
dt4 = datetime.datetime.now(tz=gettz('Europe/Madrid')) # 获取欧洲 马德里时区
dt5 = datetime.datetime.now(tz=gettz('America/Toronto')) # 获取美国 多伦多时区
dt6 = datetime.datetime.now() # 未指定时区
print('中国标准时间时区名称:', dt1.tzname()) # 中国标准时间时区名称: 中国标准时间
print('太平洋 圣诞岛时区名称:', dt2.tzname()) # 太平洋 圣诞岛时区名称: +14
print('澳大利亚 悉尼时区名称:', dt3.tzname()) # 澳大利亚 悉尼时区名称: AEDT
print('欧洲 马德里时区名称：', dt4.tzname()) # 欧洲 马德里时区名称： CEST
print('美国 多伦多时区名称', dt5.tzname()) # 美国 多伦多时区名称 EDT
print('未指定时区：', dt6.tzname()) # 未指定时区： None
4.1.7 toordinal()方法——返回自0001年01月01日开始的第多少天
datetime 类中的 toordinal() 方法用于获取自 0001年01月01日 开始至当前日期时间对象的天数。语法格式如下：
In [35]: datetime.toordinal?
Docstring: Return proleptic Gregorian ordinal. January 1 of year 1 is day 1.
Type: method_descriptor
示例代码：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
from datetime import datetime # 导入datetime模块中的datetime类
dt = datetime.today() # 获取当前日期时间
# 739171
print(dt.toordinal()) # 打印自0001年01月01日开始至当前日期时间的天数
4.1.8 timestamp()方法——返回当前时间的时间戳
datetime 类中的 timestamp() 方法用于获取当前日期时间对象所对应的时间戳。语法格式如下：
In [36]: datetime.timestamp?
Docstring: Return POSIX timestamp as float.
Type: method_descriptor
参数说明:
1.返回值: 返回当前日期时间对象所对应的时间戳
示例代码：
In [37]: from datetime import datetime
In [38]: dt = datetime.now()
In [39]: dt.timstamp()
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
Cell In[39], line 1
----> 1 dt.timstamp()
AttributeError: 'datetime.datetime' object has no attribute 'timstamp'
In [40]: dt.timestamp()
Out[40]: 1728686695.231874
4.1.9 time()方法——返回时间对象
datetime 类中的 time() 方法获取时间对象。语法格式如下：
In [41]: datetime.time?
Docstring: Return time object with same time but with tzinfo=None.
Type: method_descriptor
参数说明:
1.返回值: 返回时间对象
示例代码：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
from datetime import datetime # 导入datetime模块中的datetime类
dt = datetime.today() # 获取当前日期时间
print(dt) # 打印日期时间 2024-10-12 06:47:00.812759
print(dt.time()) # 打印日期时间对象中的时间部分 06:47:00.812759
print(type(dt)) # 打印日期时间的类型 <class 'datetime.datetime'>
print(type(dt.time())) # 打印时间部分的类型 <class 'datetime.time'>
4.1.10 fromtimestamp()方法——根据时间戳创建datetime对象
datetime 类中的 fromtimestamp() 方法用于根据指定的时间戳创建一个 datetime 对象。语法格式如下：
In [42]: datetime.fromtimestamp?
Docstring: timestamp[, tz] -> tz's local time from POSIX timestamp.
Type: builtin_function_or_method
参数说明:
1.timestamp: 指定的时间戳
2.tz: 指定时区信息
3.返回值: 返回一个datetime对象
【示例1】根据指定的时间戳创建一个datetime对象并输出,代码如下:
In [44]: from datetime import datetime
In [45]: import time
In [46]: datetime.fromtimestamp(time.time())
Out[46]: datetime.datetime(2024, 10, 12, 7, 51, 7, 779602)
4.1.11 date()方法——返回日期对象
datetime 类中的 date() 方法用于获取日期时间对象中日期部分的 date 对象。语法格式如下：
In [47]: datetime.date?
Docstring: Return date object with same year, month and day.
Type: method_descriptor
参数说明:
1.返回值: 返回日期时间对象中日期部分的date对象
示例代码：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
from datetime import datetime # 导入datetime模块中的datetime类
dt = datetime.today() # 获取当前日期时间
print(dt) # 打印日期时间 2024-10-12 07:54:32.351977
print(dt.date()) # 打印日期时间对象中的日期部分 2024-10-12
print(type(dt)) # 打印日期时间的类型 <class 'datetime.datetime'>
print(type(dt.date())) # 打印日期部分的类型 <class 'datetime.date'>
4.1.12 ctime()方法——返回一个代表日期和时间的字符串
datetime 类中的 ctime() 方法用于返回一个代表日期和时间的字符串。语法格式如下：
In [48]: datetime.ctime?
Docstring: Return ctime() style string.
Type: method_descriptor
参数说明:
1.返回值: 返回一个代表日期和时间的字符串
示例代码：
In [49]: from datetime import datetime
In [50]: dt = datetime.today()
In [51]: print(dt)
2024-10-12 07:57:20.601738
In [52]: print(dt.ctime())
Sat Oct 12 07:57:20 2024
4.1.13 combine()方法——将date和time对象合为datetime对象
datetime 类中的 combine() 方法用于将 date 对象和 time 对象合为一个 datetime 对象。语法格式如下：
In [53]: datetime.combine?
Docstring: date, time -> datetime with same date and time fields
Type: builtin_function_or_method
参数说明:
1.date: 表示需要指定的date对象
2.time: 表示需要指定的time对象
3.tzinfo: 表示时区信息对象
4.返回值: 返回将date对象与time对象组合后的新对象
示例代码：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
from datetime import datetime # 导入datetime模块中的datetime类
from datetime import date # 导入datetime模块中的date类
from datetime import time # 导入datetime模块中的time类
d = date(2024, 10, 12) # 创建日期对象
t = time(8, 1) # 创建时间对象
print(datetime.combine(d, t)) # 打印合并后的datetime对象 2024-10-12 08:01:00
4.1.14 astimezone()方法——返回一个带有时区信息的datetime对象
datetime 类中的 astimezone() 方法用于获取一个带有时区信息的 datetime 对象，或者将 datetime 对象从一个时区转换到另一个时区。语法格式如下：
In [54]: datetime.astimezone?
Docstring: tz -> convert to local time in new timezone tz
Type: method_descriptor
参数说明:
1.tz: 表示需要更换的时区，默认值为None
2.返回值: 返回一个带有时区信息的datetime对象
示例代码：
In [55]: from datetime import datetime
In [56]: dt = datetime.today()
In [57]: dt.astimezone()
Out[57]: datetime.datetime(2024, 10, 12, 8, 3, 45, 912449,
tzinfo=datetime.timezone(datetime.timedelta(seconds=28800), '中国标准时间'))
In [58]: print(dt.astimezone())
2024-10-12 08:03:45.912449+08:00
In [59]: import datetime
In [60]: reduce_four = datetime.timezone(datetime.timedelta(hours=-4))
In [61]: plus_four = datetime.timezone(datetime.timedelta(hours=4))
In [62]: dt = datetime.datetime.today()
In [63]: print(dt.astimezone(reduce_four))
2024-10-11 20:04:49.580592-04:00
In [64]: print(dt.astimezone(plus_four))
2024-10-12 04:04:49.580592+04:00
4.1.15 format()方法——返回指定格式的日期字符串
datetime 类中的 __format__() 方法与 strftime() 方法相似，用于返回指定格式的日期时间字符串。语法格式如下：
In [67]: datetime.__format__?
Docstring: Formats self with strftime.
Type: method_descriptor
参数说明:
1.format: 表示指定的显示格式
2.返回值: 返回以指定格式表示的日期时间字符串
示例：
In [65]: from datetime import datetime
In [68]: dt = datetime.today()
In [69]: dt.__format__('%Y-%m-%d')
Out[69]: '2024-10-12'
4.1.16 str()方法——返回“YYYY-MM-DD”格式的日期字符串
datetime 类中的 __str__() 方法与 isoformat() 方法相似，用于返回 "YYYY-MM-DD" 格式的日期字符串。语法格式如下：
In [71]: datetime.__str__?
Signature: datetime.__str__(self, /)
Call signature: datetime.__str__(*args, **kwargs)
Type: wrapper_descriptor
String form: <slot wrapper '__str__' of 'datetime.datetime' objects>
Docstring: Return str(self).
参数说明:
1.返回值: 返回 "YYYY-MM-DD" 格式的日期字符串
示例代码：
In [72]: from datetime import datetime
In [73]: dt = datetime.today()
In [74]: print(dt.__str__())
2024-10-12 08:13:52.689625
In [75]: dt.__str__()
Out[75]: '2024-10-12 08:13:52.689625'
In [76]: dt.isoformat()
Out[76]: '2024-10-12T08:13:52.689625'
4.1.17 dst()方法——返回datetime对象的dst偏移量
datetime 类中的 dst() 方法用于获取 datetime 实例对象中的 dst(夏令时) 偏移量。语法格式如下：
In [95]: datetime.dst?
Docstring: Return self.tzinfo.dst(self).
Type: method_descriptor
参数说明:
返回值: 如果datetime实例对象中指定了tz参数，并且该参数的时区为夏令时，将返回dst（夏令时）偏移量对应的timedelta对象
如果tz参数所设置的时区不是夏令时则返回0:00:00;如果datetime实例对象未设置tz参数，则返回None。
示例代码：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
import datetime # 导入datetime模块
from dateutil.tz import gettz # 导入获取指定时区的方法
dt1 = datetime.datetime.now(tz=gettz('China Standard Time')) # 获取中国标准时间时区
dt2 = datetime.datetime.now(tz=gettz('Pacific/Kiritimati')) # 获取太平洋 圣诞岛时区
dt3 = datetime.datetime.now(tz=gettz('Australia/Sydney')) # 澳大利亚 悉尼时区
dt4 = datetime.datetime.now(tz=gettz('Europe/Madrid')) # 获取欧洲 马德里时区
dt5 = datetime.datetime.now(tz=gettz('America/Toronto')) # 获取美国 多伦多时区
print('中国标准时间时区:', dt1) # 中国标准时间时区: 2024-10-12 22:54:34.037921+08:00
print('夏令时偏移量：', dt1.dst()) # 夏令时偏移量： 0:00:00
print('太平洋 圣诞岛时区:', dt2) # 太平洋 圣诞岛时区: 2024-10-13 04:54:34.169143+14:00
print('夏令时偏移量：', dt2.dst()) # 夏令时偏移量： 0:00:00
print('澳大利亚 悉尼时区:', dt3) # 澳大利亚 悉尼时区: 2024-10-13 01:54:34.169143+11:00
print('夏令时偏移量：', dt3.dst()) # 夏令时偏移量： 1:00:00
print('欧洲 马德里时区', dt4) # 欧洲 马德里时区 2024-10-12 16:54:34.169143+02:00
print('夏令时偏移量：', dt4.dst()) # 夏令时偏移量： 1:00:00
print('美国 多伦多时区', dt5) # 美国 多伦多时区 2024-10-12 10:54:34.169143-04:00
print('夏令时偏移量：', dt5.dst()) # 夏令时偏移量： 1:00:00
4.1.18 fromisoformat()方法——将日期时间字符串转换为datetime对象
datetime 类中的 fromisoformat() 方法用于返回指定的日期时间字符串对应的 datetime 对象。语法格式如下：
In [96]: datetime.fromisoformat?
Docstring: string -> datetime from datetime.isoformat() output
Type: builtin_function_or_method
参数说明:
1.date_string: 表示指定的日期时间字符串
2.返回值: 返回对应的datetime对象。
示例代码：
In [94]: from datetime import datetime
In [97]: dt = datetime.now()
In [98]: str_dt = dt.isoformat()
In [99]: # 打印指定的日期时间字符串对应的datetime对象
...:
...: print(datetime.fromisoformat(str_dt))
2024-10-12 23:02:24.464948
4.1.19 fromordinal()方法——根据指定的天数返回对应的date对象
datetime 类中的 fromordinal() 方法用于返回给定的公历序数对应的 datetime 对象实例，其中0001年的1月1日的序数为1。语法格式如下：
In [100]: datetime.fromordinal?
Docstring: int -> date corresponding to a proleptic Gregorian ordinal.
Type: builtin_function_or_method
参数说明:
1.ordinal: 表示日期公历序数，即自0001年01月01日开始的第多少天
2.返回值: 返回给定的公历序数对应的datetime对象
示例代码：
In [101]: from datetime import datetime
In [102]: from datetime import date
In [103]: od = date.today().toordinal()
In [104]: od
Out[104]: 739171
In [105]: print(datetime.fromordinal(od))
2024-10-12 00:00:00
4.1.20 isocalendar()方法——返回包含年、周、星期的元组
datetime 类中的 isocalendar() 方法用于返回一个包含给定日期时间对象的 ISO year、ISO weeknumber 和 ISO weekday 的元组。语法格式如下：
In [106]: datetime.isocalendar?
Docstring: Return a named tuple containing ISO year, week number, and weekday.
Type: method_descriptor
参数说明:
返回值: 返回一个包含给定日期时间对象的ISO year、ISO week number和ISO weekday的元组。
示例代码：
In [107]: from datetime import datetime
In [108]: dt = datetime.today()
In [109]: dt.isocalendar()
Out[109]: datetime.IsoCalendarDate(year=2024, week=41, weekday=6)
4.1.21 isoformat()方法——返回“YYYY-MM-DD”格式的日期时间字符串
datetime 类中的 isoformat() 方法用于返回一个 "YYYY-MM-DD" 格式的日期时间字符串。语法格式如下：
In [111]: dt.isoformat?
Docstring:
[sep] -> string in ISO 8601 format, YYYY-MM-DDT[HH[:MM[:SS[.mmm[uuu]]]]][+HH:MM].
sep is used to separate the year from the time, and defaults to 'T'.
The optional argument timespec specifies the number of additional terms
of the time to include. Valid options are 'auto', 'hours', 'minutes',
'seconds', 'milliseconds' and 'microseconds'.
Type: builtin_function_or_method
参数说明:
1.sep: 可选参数，默认值为T，是一个单字符分隔符，用来分隔结果中的日期和时间部分
2.timespec: 可选参数，默认值为auto。还可设置为以下参数:
auto: 如果microseconds为0，则与seconds相同，否则与microseconds相同
hours: 两位数的hour，采用HH格式
minutes: 包含hour、minute，采用HH:MM格式
seconds: 包含hour、minute 和second，采用HH:MM:SS格式
milliseconds: 包含全时，但将小数秒部分截断为毫秒，采用HH:MM :SS.sss格式。
microseconds: 采用HH:MM:SS.ffffff格式的全时。
3.返回值: 返回一个使用 ISO 8601 格式表示的datetime实例的日期和时间字符串
示例代码：
In [112]: from datetime import datetime
In [113]: dt = datetime.today()
In [114]: print(dt.isoformat())
2024-10-12T23:16:27.501773
4.1.22 utcnow()方法——返回当前日期时间的UTC datetime对象
datetime 类中的 utcnow() 方法用于返回一个当前 UTC 时间的 datetime 对象。语法格式如下：
In [125]: from datetime import datetime
In [126]: datetime.utcnow?
Docstring: Return a new datetime representing UTC day and time.
Type: builtin_function_or_method
参数说明:
1.返回值: 返回一个当前UTC时间的datetime对象
示例代码：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
from datetime import datetime # 导入datetime模块中的datetime类
# 2024-10-17 01:13:16.290159
print(datetime.utcnow()) # 获取UTC时间
4.1.23 utcfromtimestamp()方法——将时间戳转为UTC datetime对象
datetime 类中的 utcfromtimestamp() 方法可以根据指定的时间戳创建一个 UTC 时间的 datetime 对象。语法格式如下：
In [127]: datetime.utcfromtimestamp?
Docstring: Construct a naive UTC datetime from a POSIX timestamp.
Type: builtin_function_or_method
参数说明:
1.timestamp: 表示指定的时间戳
2.返回值: 返回一个UTC时间的datetime对象
示例代码：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
from datetime import datetime # 导入datetime模块中的datetime类
import time # 导入时间模块
# 以time.time()方法获取的时间戳为参数创建一个UTC时间的datetime对象
# 2024-10-17 01:15:37.751965
print(datetime.utcfromtimestamp(time.time()))
4.1.24 utcoffset()方法——返回datetime对象的UTC偏移量
datetime 类中的 utcoffset() 方法用于返回 datetime 对象的 UTC 偏移量。语法格式如下：
In [128]: datetime.utcoffset?
Docstring: Return self.tzinfo.utcoffset(self).
Type: method_descriptor
参数说明:
1.返回值: 如果datetime实例对象中指定了tz参数，将返回UTC偏移量对应的timedelta对象
如果datetime实例对象未设置tz参数，则返回None
示例代码：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
import datetime # 导入datetime模块
reduce_four = datetime.timezone(datetime.timedelta(hours=-4)) # 创建-4时区对象
plus_four = datetime.timezone(datetime.timedelta(hours=4)) # 创建+4时区对象
dt = datetime.datetime.now(reduce_four) # 获取-4时区本地日期时间对象
dt1 = datetime.datetime.now(plus_four) # 获取+4时区本地日期时间对象
dt2 = datetime.datetime.now() # 获取未设置时区本地日期时间对象
print(dt) # 打印-4时区本地日期时间 2024-10-16 21:18:08.614984-04:00
print(dt1) # 打印+4时区本地日期时间 2024-10-17 05:18:08.614984+04:00
print(dt2) # 打印未设置时区本地日期时间 2024-10-17 09:18:08.614984
print(dt.utcoffset()) # 打印dt对象utc偏移量 -1 day, 20:00:00
print(dt1.utcoffset()) # 打印dt1对象utc偏移量 4:00:00
print(dt2.utcoffset()) # 打印dt2对象utc偏移量 None
4.1.25 utctimetuple()方法——返回UTC世界协调时的时间元组
datetime 类中的 utctimetuple() 方法与 timetuple() 类似，都可以用于获取时间元组信息。不同的是 utctimetuple() 方法可以获取 datetime 对象 UTC 世界协调时的时间元组，在 datetime 对象中无论设置什么时区，都将被强制设为0。语法格式如下：
In [129]: datetime.utctimetuple?
Docstring: Return UTC time tuple, compatible with time.localtime().
Type: method_descriptor
参数说明:
1.返回值: 返回datetime对象UTC世界协调时的时间元组
示例代码：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
import datetime # 导入datetime模块
reduce_four = datetime.timezone(datetime.timedelta(hours=-4)) # 创建-4时区对象
plus_four = datetime.timezone(datetime.timedelta(hours=4)) # 创建+4时区对象
dt1 = datetime.datetime.now() # 获取未设置时区本地日期时间对象
dt2 = datetime.datetime.now(reduce_four) # 获取-4时区本地日期时间对象
dt3 = datetime.datetime.now(plus_four) # 获取+4时区本地日期时间对象
print(dt1.timetuple()) # 打印未设置时区的时间元组，默认北京时区+8
print(dt1.utctimetuple()) # 打印未设置时区UTC世界协调时的时间元组,默认北京时区+8
print(dt2.timetuple()) # 打印-4时区的时间元组，tm_hour=当前小时-8-4
print(dt2.utctimetuple()) # 打印-4时区UTC世界协调时的时间元组，tm_hour=当前小时-8
print(dt3.timetuple()) # 打印+4时区的时间元组，tm_hour=当前小时-4
print(dt3.utctimetuple()) # 打印+4时区UTC世界协调时的时间元组，tm_hour=当前小时-8
4.1.26 timetz()方法——返回时区时间对象
datetime 类中的 timetz() 方法用于获取日期时间对象所对应的时区时间。语法格式如下：
In [130]: datetime.timetz?
Docstring: Return time object with same time and tzinfo.
Type: method_descriptor
参数说明:
1.返回值: 返回时区对应的时间对象
示例代码：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
from datetime import datetime # 导入datetime模块中的datetime类
dt = datetime.today() # 把获取的当前本地日期时间赋给变量dt
print(dt.timetz()) # 打印日期时间对象对应的时区时间 09:24:14.068019
4.1.27 timetuple()方法——返回对应的时间元组
datetime 类中的 timetuple() 方法用于获取日期时间对象所对应的时间元组。语法格式如下：
In [131]: datetime.timetuple?
Docstring: Return time tuple, compatible with time.localtime().
Type: method_descriptor
参数说明:
1.返回值: 返回对应的时间元组
示例代码：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
from datetime import datetime # 导入datetime模块中的datetime类
dt = datetime.today() # 获取当前日期时间
# time.struct_time(tm_year=2024, tm_mon=10, tm_mday=17, tm_hour=9,
# tm_min=26, tm_sec=58, tm_wday=3, tm_yday=291, tm_isdst=-1)
print(dt.timetuple()) # 打印对应的时间元组
4.1.28 replace()方法——替换并返回新datetime对象
datetime 类中的 replace() 方法用于在不改变原日期时间对象的情况下替换并返回新的 datetime 对象。语法格式如下：
示例代码：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
from datetime import datetime # 导入datetime模块中的datetime类
dt = datetime.today() # 获取当前日期时间
new_dt = dt.replace(2019, 12, 25, 22, 15, 38,
888) # 替换原对象获取新对象
print('原对象：', dt) # 原对象： 2024-10-17 09:32:07.180068
print('新对象：', new_dt) # 新对象： 2019-12-25 22:15:38.000888
print('原对象id为：', id(dt)) # 原对象id为： 1374577045696
print('新对象id为：', id(new_dt)) # 新对象id为： 1374576738144
4.1.29 isoweekday()方法——返回指定日期的星期序号
datetime 类中的 isoweekday() 方法用于返回指定日期在一周内的序号，其中周一表示为1，周日表示为7。语法格式如下：
In [133]: datetime.isoweekday?
Docstring:
Return the day of the week represented by the date.
Monday == 1 ... Sunday == 7
Type: method_descriptor
参数说明:
1.返回值: 返回对象名指定日期在一周内的序号，其中周一表示为1，周日表示为7
示例代码：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
from datetime import datetime # 导入datetime模块中的datetime类
dt = datetime.today() # 获取当前日期时间
print(dt.isoweekday()) # 打印当前日期对应的星期序号 4
4.2 timedelta对象常用方法
4.2.1 total_seconds()方法——获取时间差中包含的总秒数
timedelta 类中的 total_seconds() 方法用于获取时间差中包含的总秒数，等价于 timedelta(seconds=1)。语法格式如下：
示例代码：
In [80]: from datetime import timedelta
In [81]: year = timedelta(days=365)
In [82]: another_year = timedelta(weeks=40, days=84, hours=23,
...: ... minutes=50, seconds=600)
...:
In [83]: year == another_year
Out[83]: True
In [84]: year.total_seconds()
Out[84]: 31536000.0
In [85]: year = timedelta(days=365)
In [86]: ten_years = 10 * year
In [87]: ten_years
Out[87]: datetime.timedelta(days=3650)
In [88]: ten_years.days // 365
Out[88]: 10
In [89]: nine_years = ten_years - year
In [90]: nine_years
Out[90]: datetime.timedelta(days=3285)
In [91]: three_years = nine_years // 3
In [92]: three_years, three_years.days // 365
Out[92]: (datetime.timedelta(days=1095), 3)
4.3 date对象与time对象常用方法
大部分 date 对象与 time 对象的方法与 datetime 大差不差，datetime 对象中支持的方法，date 对象与 time 对象在某些方法上也是支持的，毕竟 datetime 类是 date 类与 time 类的结合体。如果需要使用 date 对象与 time 对象的方法，查询 Python 帮助文档即可，按理说 datetime 的常用方法已经够用了。
4.4 timezone对象常用方法
4.4.1 utc属性——获取UTC时区
timezone 类中的 utc 属性用于获取 UTC 时区，即 timezone(timedelta(0))。语法格式如下：
In [115]: from datetime import timezone
In [116]: timezone.utc?
Type: timezone
String form: UTC
File: f:\dev_tools\python\python310\lib\datetime.py
Docstring: Fixed offset from UTC implementation of tzinfo.
参数说明:
1.返回值: 返回UTC时区，即timezone(timedelta(0))
示例代码：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
import datetime # 导入datetime模块
# 1.获取timezone 实例对象的UTC时区
# 创建名称为欧洲 马德里时区
timezone_madrid = datetime.timezone(datetime.timedelta(hours=2), name='Europe/Madrid')
# 创建-4时区
timezone_toronto = datetime.timezone(datetime.timedelta(hours=-4))
print(timezone_madrid.utc) # 打印名称为欧洲 马德里时区的UTC时区 UTC
print(timezone_toronto.utc) # 打印名-4时区的UTC时区 UTC
# 2.获取timezone 实例对象中UTC时区的值
# 创建名称为欧洲 马德里时区
timezone_madrid = datetime.timezone(datetime.timedelta(hours=2), name='Europe/Madrid')
t_madrid = datetime.time(4, 5, 12, tzinfo=timezone_madrid) # 为time对象设置自定义的马德里时区
# 为time对象设置自定义的马德里时区所对应的utc
t_utc = datetime.time(4, 5, 12, tzinfo=timezone_madrid.utc)
print(t_madrid) # 打印马德里时区的time对象 04:05:12+02:00
print(t_utc) # 打印马德里时区对应的UTC的time对象 04:05:12+00:00
4.4.2 dst()方法——总是返回None
timezone 类中的 dst() 方法总是返回 None。语法格式如下：
In [117]: timezone.dst?
Docstring: Return None.
Type: method_descriptor
参数说明:
1.dt: 表示datetime实例对象
2.返回值: dst()方法正常是用于获取夏令时的偏移量，而调用timezone类中的dst()方法则总是返回None
示例代码：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
import datetime # 导入datetime模块
# 创建名称为马德里时区
timezone_madrid = datetime.timezone(datetime.timedelta(hours=2), name='Europe/Madrid')
reduce_four = datetime.timezone(datetime.timedelta(hours=-4)) # 创建-4时区对象
dt = datetime.datetime.now(reduce_four) # 创建一个使用-4时区的datetime对象
dt1 = datetime.datetime.now() # 未指定时区的datetime对象
print(timezone_madrid.dst(dt)) # 打印自定义欧洲 马德里时区对象的dst None
print(timezone_madrid.dst(dt1)) # 打印自定义欧洲 马德里时区对象的dst None
4.4.3 fromutc()方法——返回一个datetime对象
timezone 类中的 fromutc() 方法用于获取一个包含 datetime+offset 信息的 datetime 对象。语法格式如下：
In [118]: timezone.fromutc?
Docstring: datetime in UTC -> datetime in local time.
Type: method_descriptor
参数说明:
1.dt: 表示具有时区或夏令时的datetime实例对象，其tzinfo值设为self(timezone对象自身)
2.返回值: 返回一个包含datetime+offset信息的datetime对象。
示例代码：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
import datetime # 导入datetime模块
# 创建名称为欧洲 马德里时区
timezone_madrid = datetime.timezone(datetime.timedelta(hours=2), name='Europe/Madrid')
dt = datetime.datetime.now(tz=timezone_madrid) # 指定马德里时区的datetime对象
print(dt) # 打印马德里当前时间 2024-10-12 17:33:56.004699+02:00
# 2024-10-12 19:33:56.004699+02:00
print(timezone_madrid.fromutc(dt)) # 打印包含datetime+offset信息的datetime对象
4.4.4 tzname()方法——返回指定的name值
timezone 类中的 tzname() 方法用于获取在构造 timezone 实例时指定的 name 值。语法格式如下：
In [119]: timezone.tzname?
Docstring: If name is specified when timezone is created, returns the name.
Otherwise returns offset as 'UTC(+|-)HH:MM'.
Type: method_descriptor
参数说明:
1.dt: 表示datetime实例对象
2.返回值: 返回在构造timezone实例时指定的name值。
2.1 如果没有为构造器提供name参数，则tzname(dt)所返回的名称将根据offset值按UTC+00:00 规则生成
2.2 如果offset为timedelta(0)，则名称为"UTC"，否则为字符串'UTC±HH:MM'，
其中±为offset值的正负，HH和MM分别表示offset.hours和offset.minutes。
示例代码：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
import datetime # 导入datetime模块
# 创建名称为欧洲 马德里时区
timezone_madrid = datetime.timezone(datetime.timedelta(hours=2), name='Europe/Madrid')
reduce_four = datetime.timezone(datetime.timedelta(hours=-4)) # 创建-4时区对象
plus_four = datetime.timezone(datetime.timedelta(hours=4)) # 创建+4时区对象
utc_time = datetime.timezone(datetime.timedelta(hours=0)) # 创建UTC时区对象，协调世界时为0
dt = datetime.datetime.now() # datetime对象
print(timezone_madrid.tzname(dt)) # 打印时区名称 Europe/Madrid
print(reduce_four.tzname(dt)) # 打印-4时区 UTC-04:00
print(plus_four.tzname(dt)) # 打印+4时区 UTC+04:00
print(utc_time.tzname(dt)) # 打印UTC时区 UTC
4.4.5 utcoffset()方法——返回指定的UTC偏移量
timezone 类中的 utcoffset() 方法用于获取在构造 timezone 实例时指定的 UTC 偏移量。语法格式如下：
In [121]: timezone.utcoffset(dt)
Docstring: Return fixed offset.
Type: method_descriptor
参数说明:
1.dt: 表示datetime实例对象
2.返回值: 返回在构造timezone实例时指定的UTC偏移量
示例代码：
# -*- coding: utf-8 -*-
# @Time : 2024-10-12 5:09
# @Author : AmoXiang
# @File: datetime_demo.py
# @Software: PyCharm
# @Blog: https://blog.csdn.net/xw1680
import datetime # 导入datetime模块
# 创建名称为欧洲 马德里时区
timezone_madrid = datetime.timezone(datetime.timedelta(hours=2), name='Europe/Madrid')
reduce_four = datetime.timezone(datetime.timedelta(hours=-4)) # 创建-4时区对象
plus_four = datetime.timezone(datetime.timedelta(hours=4)) # 创建+4时区对象
utc_time = datetime.timezone(datetime.timedelta(hours=0)) # 创建UTC时区对象，协调世界时为0
dt = datetime.datetime.now() # datetime对象
print(timezone_madrid.utcoffset(dt)) # 打印时区名称 2:00:00
print(reduce_four.utcoffset(dt)) # 打印-4时区 -1 day, 20:00:00
print(plus_four.utcoffset(dt)) # 打印+4时区 4:00:00
print(utc_time.utcoffset(dt)) # 打印UTC时区 0:00:00