Table of Contents

• 一.Python datetime模块介绍
• 1.1 有效的类型
• 1.2 timedelta 类对象
• 1.2.1 timedelta.total_seconds()方法
• 1.3 date对象
• 1.4 datetime对象
• 1.5 time 对象
• 1.6 tzinfo 对象
• 1.7 timezone 对象
• 二.datetime模块实操
• 2.1 datetime模块常用方法案例
• 2.2 格式日期时间
• 2.2.1 使用strftime()格式化日期
• 2.2.2 Python strptime()-日期时间的字符串
• 2.3 python 时间戳
• 三.time模块简介
• 参考:

一.Python datetime模块介绍

datetime 模块提供了可以通过多种方式操作日期和时间的类。在支持日期时间数学运算的同时，实现的关注点更着重于如何能够更有效地解析其属性用于格式化输出和数据操作。

1.1 有效的类型

datetime.time 一个理想化的时间，它独立于任何特定的日期，假设每天一共有 24 60 60 秒（这里没有”闰秒”的概念）属性： hour, minute, second, microsecond, 和 tzinfo。 datetime.datetime 日期和时间的结合。属性：year, month, day, hour, minute, second, microsecond, and tzinfo. datetime.timedelta 表示两个 date 对象或者 time 对象,或者 datetime 对象之间的时间间隔，精确到微秒。 datetime.tzinfo 一个描述时区信息的抽象基类。用于给 datetime 类和 time 类提供自定义的时间调整概念（例如，负责时区或者夏令时）。 datetime.timezone 一个实现了 tzinfo 抽象基类的子类，用于表示相对于 世界标准时间（UTC）的偏移量。

子类关系:

object
    timedelta
    tzinfo
        timezone
        datetime
1.2 timedelta 类对象

timedelta 对象表示两个 date 或者 time 的时间间隔。
*class *datetime.``timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)
所有的参数都是可选的并且默认为 0。这些参数可以是整数或者浮点数，也可以是正数或者负数。
只有 days,seconds 和 microseconds 会存储在内部，即python内部以 days,seconds 和 microseconds 三个单位作为存储的基本单位。参数单位转换规则如下：
1毫秒会转换成1000微秒。
1分钟会转换成60秒。
1小时会转换成3600秒。
1星期会转换成7天。
days, seconds, microseconds 本身也是标准化的，以保证表达方式的唯一性，例：
0 <= microseconds < 1000000
0 <= seconds < 3600*24 (一天的秒数)
-999999999 <= days <= 999999999
在有任何浮点型参数或者微秒为小数的情况下，所有小数均会按照前面的换算规则叠加到下一级，并使用round-half-to-even的方法对微秒进行取舍。没有浮点型参数情况下，转换的过程就是精确的（没有信息丢失）。
如果标准化后的 days 数值超过了指定范围，将会抛出 OverflowError异常。
需要注意的是，负数被标准化后的结果会让你大吃一惊。例如:
E:\>python
Python 3.6.3 (v3.6.3:2c5fed8, Oct  3 2017, 18:11:49) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> from datetime import timedelta
>>> d = timedelta(microseconds=-1)
>>> (d.days, d.seconds, d.microseconds)
(-1, 86399, 999999)
timedelta.min

最大的负数 ,timedelta(-999999999)

timedelta.max

最大的整数, timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999)
timedelta.resolution

两个相等的timedelta类对象最小的间隔为 timedelta(microseconds=1)
需要注意的是，因为标准化的缘故，timedelta.max > -timedelta.min，-timedelta.max 不可以表示一个 timedelta 类对象。
q, r = divmod(t1, t2)
通过 : q = t1 // t2 (3) and r = t1 % t2 计算出商和余数。q是一个整数，r是一个 timedelta 对象。
返回一个相同数值的 timedelta 对象。
等价于 timedelta(-t1.days, -t1.seconds, -t1.microseconds), 和 t1* -1.
abs(t)
当 t.days >= 0时等于 +\ *t*, 当 t.days < 0 时 -t 。
str(t)
返回一个形如 [D day[s], ][H]H:MM:SS[.UUUUUU] 的字符串，当 t 为负数的时候， D 也为负数。
repr(t)
Returns a string in the form datetime.timedelta(D[, S[, U]]), where D is negative for negative t.
1.2.1 timedelta.total_seconds()方法

需要注意的是，时间间隔较大时，这个方法的结果中的微秒将会失真（大多数平台上大于270年视为一个较大的时间间隔）。
>>> from datetime import timedelta
>>> year = timedelta(days=365)
>>> another_year = timedelta(weeks=40, days=84, hours=23, minutes=50, seconds=600);
>>> year.total_seconds()
31536000.0
>>> year == another_year
>>> ten_years = 10 * year
>>> ten_years, ten_years.days
(datetime.timedelta(3650), 3650)
>>> nini_years = ten_years - year
>>> nine_years, nine_years.days
(datetime.timedelta(3285), 3285)
>>> three_years = nine_years // 3
>>> three_years, three_years.days
(datetime.timedelta(1095), 1095)
>>> abs(three_years - ten_years) == 2 * three_years + year
1.3 date对象

date 对象代表一个理想化历法中的日期（年、月和日），即当今的格列高利历向前后两个方向无限延伸。公元 1 年 1 月 1 日是第 1 日，公元 1 年 1 月 2 日是第 2 日， 依此类推。 这与 Dershowitz 与 Reingold 所著 Calendrical Calculations 中“预期格列高利”历法的定义一致，它是适用于该书中所有运算的基础历法。 请参阅该书了解在预期格列高利历序列与许多其他历法系统之间进行转换的算法。
class datetime.date(year, month, day)

All arguments are required. Arguments may be integers, in the following ranges:
MINYEAR <= year <= MAXYEAR

1 <= month <= 12

1 <= 日期 <= 给定年月对应的天数

如果参数不在这些范围内，则抛出 ValueError 异常。
支持的运算:
date.replace(year=self.year, month=self.month, day=self.day)
返回一个具有同样值的日期，除非通过任何关键字参数给出了某些形参的新值。 例如，如果 d == date(2002, 12, 31)，则 d.replace(day=26) == date(2002, 12, 26)。
date.timetuple()
返回一个 time.struct_time，即与 time.localtime() 的返回类型相同。
hours, minutes 和 seconds 值为 0, 且 DST 标志值为 -1。
d.timetuple() 等价于 time.struct_time((d.year, d.month, d.day, 0, 0, 0, d.weekday(), yday, -1))，其中 yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1 是日期在当前年份中的序号，起始序号 1 表示 1 月 1 日。
date.toordinal()
返回日期的预期格列高利历序号，其中公元 1 年 1 月 1 日的序号为 1。 对于任意 date 对象 d，date.fromordinal(d.toordinal()) == d。
date.weekday()
返回一个整数代表星期几，星期一为0，星期天为6。例如， date(2002, 12, 4).weekday() == 2，表示的是星期三。
date.isoweekday()
返回一个整数代表星期几，星期一为1，星期天为7。例如：date(2002, 12, 4).isoweekday() == 3,表示星期三。
date.isocalendar()
返回一个三元元组，(ISO year, ISO week number, ISO weekday) 。
 例如，2004 年的第一天是一个星期四，因此 ISO 2004 年的第一个星期开始于 2003 年 12 月 29 日星期一，结束于 2004 年 1 月 4 日星期日，因此 date(2003, 12, 29).isocalendar() == (2004, 1, 1) and date(2004, 1, 4).isocalendar() == (2004, 1, 7)。
date.isoformat()
返回一个 ISO 8601 格式的字符串， ‘YYYY-MM-DD’。例如 date(2002, 12, 4).isoformat() == ‘2002-12-04’。
date.str()
对于日期对象 d, str(d) 等价于 d.isoformat()
date.ctime()
返回一个代表日期的字符串，例如 date(2002, 12, 4).ctime() == ‘Wed Dec 4 00:00:00 2002’。
 在原生 C ctime() 函数 (time.ctime() 会发起调用该函数，但 date.ctime() 则不会) 遵循 C 标准的平台上，d.ctime() 等价于 time.ctime(time.mktime(d.timetuple()))。
date.strftime(format)
返回一个由显式格式字符串所指明的代表日期的字符串。 表示时、分或秒的格式代码值将为 0。
date.format(format)
与 date.strftime() 相同。 此方法使得为 date 对象指定以 格式化字符串字面值 表示的格式化字符串以及使用 str.format() 进行格式化成为可能。 要获取格式指令的完整列表，请参阅 strftime() 和 strptime() 的行为。
计算距离特定事件天数的例子:
>>> import time
>>> from datetime import date
>>> today = date.today()
>>> today
datetime.date(2021, 3, 10)
>>> today == date.fromtimestamp(time.time())
>>> my_birthday = date(today.year, 6, 24)
>>> if my_birthday < today:
...     my_birthday = my_birthday.replace(year=today.year + 1)
>>> my_birthday
datetime.date(2021, 6, 24)
>>> time_to_birthday = abs(my_birthday - today)
>>> time_to_birthday.days
使用date例子:
>>> from datetime import date
>>> d = date.fromordinal(730920) # 730920th day after 1. 1. 0001
datetime.date(2002, 3, 11)
>>> t = d.timetuple()
>>> for i in t:
...     print(i)
2002      -- 年
3         -- 月
11        -- 日
0         -- weekday (0 = Monday)
70        -- 70th dya in the year
>>> ic = d.isocalendar()
>>> for i in ic:
...     print(i)
2002       -- ISO year
11         -- ISO week number
1          -- ISO day number (1 = Monday)
>>> d.isoformat()
'2002-03-11'
>>> d.strftime("%y%m%d")
'020311'
>>> d.strftime("%y-%m-%d")
'02-03-11'
>>> d.strftime("%Y-%m-%d")
'2002-03-11'
1.4   datetime对象

datetime 对象是一个包含了来自 date 对象和 time 对象所有信息的单一对象。 与 date 对象一样，datetime 假定当今的格列高利历向前后两个方向无限延伸；与 time 对象一样，datetime 假定每一天恰好有 3600*24 秒。
class datetime.datetime
datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)
classmethod datetime.today()
返回当前的本地 datetime，tzinfo 值为 None。 这等价于 datetime.fromtimestamp(time.time())。
classmethod datetime.now(tz=None)
返回当前的本地 date 和 time。 如果可选参数 tz 为 None 或未指定，这就类似于 today()，但该方法会在可能的情况下提供比通过 time.time() 时间戳所获时间值更高的精度（例如，在提供了 C gettimeofday() 函数的平台上就可能做到）。
classmethod datetime.utcnow()
返回当前 UTC 日期和时间，其中 tzinfo 为 None。 这类似于 now()，但返回的当前 UTC 日期和时间是一个本机 datetime 对象。 自动感知的当前 UTC 日期时间可通过调用 datetime.now(timezone.utc) 来获得。
classmethod datetime.fromtimestamp(timestamp, tz=None)
返回对应于 POSIX 时间戳例如 time.time() 的返回值的本地日期和时间。 如果可选参数 tz 为 None 或未指定，时间戳会被转换为所在平台的本地日期和时间，返回的 datetime 对象将为天真型。
classmethod datetime.utcfromtimestamp(timestamp)
返回对应于 POSIX 时间戳的 UTC datetime，其中 tzinfo 为 None。 这可能引发 OverflowError，如果时间戳数值超出所在平台 C gmtime() 函数的支持范围的话，并会在 gmtime() 出错时引发 OSError。 通常该数值并会限制在 1970 年至 2038 年之间。
classmethod datetime.fromordinal(ordinal)
返回对应于预期格列高利历序号的 datetime，其中公元 1 年 1 月 1 日的序号为 1。 除非 1 <= ordinal <= datetime.max.toordinal() 否则会引发 ValueError。 结果的hour, minute, second 和 microsecond 值均为 0，并且 tzinfo 值为 None。
classmethod datetime.combine(date, time, tzinfo=self.tzinfo)
返回一个新的 datetime 对象，对象的日期数值等于给定的 date 对象的数值，时间数值等于给定的 time 对象的数值。 如果提供 tzinfo 参数，其值会被用来设置结果的 tzinfo 属性，否则将会使用 time 参数的 tzinfo 属性。
classmethod datetime.strptime(date_string, format)
返回根据 format 解析与 date_string 相对应的 datetime，这等价于 datetime(*(time.strptime(date_string, format)[0:6]))，如果 date_string 和 format 无法被 time.strptime() 解析或它返回一个不是时间元组的值，则将引发 ValueError。
实例属性（只读）：

如果参数不在这些范围内，则抛出 ValueError 异常。
datetime2 = datetime1 + timedelta
datetime2 是从中去掉的一段 timedelta 的结果，如果 timedelta.days > 0 则是在时间线上前进，如果 timedelta.days < 0 则后退。
datetime2 = datetime1 - timedelta
计算 datetime2 使得 datetime2 + timedelta == datetime1。
timedelta = datetime1 - datetime2
从一个 datetime 减去一个 datetime 仅对两个操作数均为简单型或均为感知型时有定义。 如果一个是感知型而另一个是简单型，则会引发 TypeError。
datetime1 < datetime2
当 datetime1 的时间在 datetime2 之前则认为 datetime1 小于 datetime2
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，除非通过任何关键字参数指定了某些属性值。 请注意可以通过指定 tzinfo=None 从一个感知型 datetime 创建一个简单型 datetime 而不必转换日期和时间值。
datetime.astimezone(tz=None)
返回一个具有新的 tzinfo 属性 tz 的 datetime 对象，并会调整日期和时间数据使得结果对应的 UTC 时间与 self 相同，但为 tz 时区的本地时间。
datetime.utcoffset()
If tzinfo is None, returns None, else returns self.tzinfo.utcoffset(self), and raises an exception if the latter doesn’t return None, or a timedelta object representing a whole number of minutes with magnitude less than one day.
datetime.dst()
If tzinfo is None, returns None, else returns self.tzinfo.dst(self), and raises an exception if the latter doesn’t return None, or a timedelta object representing a whole number of minutes with magnitude less than one day.
datetime.tzname()
如果 tzinfo 为 None，则返回 None，否则返回 self.tzinfo.tzname(self)，如果后者不返回 None 或者一个字符串对象则将引发异常。
datetime.timetuple()
返回一个 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。
datetime.utctimetuple()
如果 datetime 实例 d 为简单型，这类似于 d.timetuple()，不同之处为 tm_isdst 会强设为 0，无论 d.dst() 返回什么结果。 DST 对于 UTC 时间永远无效。
datetime.toordinal()
返回日期的预期格列高利历序号。 与 self.date().toordinal() 相同。
datetime.timestamp()
返回对应于 datetime 实例的 POSIX 时间戳。 返回值是与 time.time() 类似的 float。
datetime.weekday()
返回一个整数代表星期几，星期一为 0，星期天为 6。 相当于 self.date().weekday()。 另请参阅 isoweekday()。
datetime.isoweekday()
返回一个整数代表星期几，星期一为 1，星期天为 7。 相当于 self.date().isoweekday()。 另请参阅 weekday(), isocalendar()。
datetime.isocalendar()
返回一个 3 元组 (ISO 年份, ISO 周序号, ISO 周日期)。 相当于 self.date().isocalendar()。
datetime.ctime()
返回一个代表日期和时间的字符串，例如 datetime(2002, 12, 4, 20, 30, 40).ctime() == ‘Wed Dec  4 20:30:40 2002’。 在原生 C ctime() 函数 (time.ctime() 会发起调用该函数，但 datetime.ctime() 则不会) 遵循 C 标准的平台上，d.ctime() 等价于 time.ctime(time.mktime(d.timetuple()))。
datetime.strftime(format)
返回一个由显式格式字符串所指明的代表日期和时间的字符串， 要获取格式指令的完整列表请参阅 strftime() 和 strptime() 的行为。
datetime.format(format)
与 datetime.strftime() 相同。 此方法使得为 datetime 对象指定以 格式化字符串字面值 表示的格式化字符串以及使用 str.format() 进行格式化成为可能。 要获取格式指令的完整列表，请参阅 strftime() 和 strptime() 的行为。
使用 datetime 对象的例子:




    

>>> from datetime import datetime, date, time
>>> d = date(2005, 7, 14)
>>> t = time(12, 30)
>>> datetime.combine(d, t)
datetime.datetime(2005, 7, 14, 12, 30)
>>> datetime.now()
datetime.datetime(2021, 3, 10, 16, 10, 53, 787000)
>>> datetime.utcnow()
datetime.datetime(2021, 3, 10, 8, 11, 6, 212000)
>>> dt = datetime.strptime("2021-03-10 16:13:00", "%Y-%m-%d %H:%M:%S")
datetime.datetime(2021, 3, 10, 16, 13)
>>> dt = datetime.strptime("2021-03-10 16:13:10", "%Y-%m-%d %H:%M:%S")
datetime.datetime(2021, 3, 10, 16, 13, 10)
>>> tt = dt.timetuple()
>>> for it in tt:
...     print(it)
2021     -- 年
3        -- 月
10       -- 日
16       -- 小时
13       -- 分
10       -- 秒
2        -- weekday (2 = 周三)
69       -- 今年的第多少天
-1       -- 时区相关
>>> ic = dt.isocalendar()
>>> for it in ic:
...     print(it)
>>> dt.strftime("%Y-%m-%d %H:%M:%S")
'2021-03-10 16:13:10'
1.5 time 对象

一个 time 对象代表某个日期内的（本地）时间，它独立于任何特定日期，并可通过 tzinfo 对象来调整。
比较 time 和另一个 time，当 a 的时间在 b 之前时，则认为 a 小于 b。 如果比较的一方是简单型而另一方是感知型，则如果尝试进行顺序比较将引发 TypeError。 对于相等比较，简单型实例将永远不等于感知型实例。
如果两个比较方都是感知型，且具有相同的 tzinfo 属性，相同的 tzinfo 属性会被忽略并对基本时间值进行比较。 如果两个比较方都是感知型且具有不同的 tzinfo 属性，两个比较方将首先通过减去它们的 UTC 差值（使用 self.utcoffset() 获取）来进行调整。 为了防止将混合类型比较回退为基于对象地址的默认比较，当 time 对象与不同类型的对象比较时，将会引发 TypeError，除非比较运算符是 == 或 !=。 在后一种情况下将分别返回 False 或 True。
哈希，以便用作字典的键
高效的封存
在布尔运算时，time 对象总是被视为真值。
time.replace(hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, tzinfo=self.tzinfo, * fold=0)
返回一个具有同样属性值的 time，除非通过任何关键字参数指定了某些属性值。
time.isoformat(timespec=‘auto’)
Return a string representing the time in ISO 8601 format, HH:MM:SS.mmmmmm or, if microsecond is 0, HH:MM:SS If utcoffset() does not return None, a 6-character string is appended, giving the UTC offset in (signed) hours and minutes: HH:MM:SS.mmmmmm+HH:MM or, if self.microsecond is 0, HH:MM:SS+HH:MM
time.str()
对于时间对象 t, str(t) 等价于 t.isoformat()。
time.strftime(format)
返回一个由显式格式字符串所指明的代表时间的字符串。 要获取格式指令的完整列表请参阅 strftime() 和 strptime() 的行为。
time.format(format)
与 time.strftime() 相同。 此方法使得为 time 对象指定以 格式化字符串字面值 表示的格式化字符串以及使用 str.format() 进行格式化成为可能。 要获取格式指令的完整列表，请参阅 strftime() 和 strptime() 的行为。
time.utcoffset()
If tzinfo is None, returns None, else returns self.tzinfo.utcoffset(None), and raises an exception if the latter doesn’t return None or a timedelta object representing a whole number of minutes with magnitude less than one day.
time.dst()
If tzinfo is None, returns None, else returns self.tzinfo.dst(None), and raises an exception if the latter doesn’t return None, or a timedelta object representing a whole number of minutes with magnitude less than one day.
time.tzname()
如果 tzinfo 为 None，则返回 None，否则返回 self.tzinfo.tzname(None)，如果后者不返回 None 或者一个字符串对象则将引发异常。
>>> from datetime import time, tzinfo, timedelta
>>> class GMT1(tzinfo):
...     def utcoffset(self, dt):
...         return timedelta(hours=1)
...     def dst(self, dt):
...         return timedelta(0)
...     def tzname(self, dt):
...         return "Europe/Prague"
>>> t = time(12, 10, 30, tzinfo=GMT1())
datetime.time(12, 10, 30, tzinfo=<__main__.GMT1 object at 0x0000000002882978>)
>>> gmt = gmt1()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'gmt1' is not defined
>>> gmt = GMT1()
>>> t.isoformat()
'12:10:30+01:00'
>>> t.dst()
datetime.timedelta(0)
>>> t.tzname()
'Europe/Prague'
>>> t.strftime("%H:%M:%S %Z")
'12:10:30 Europe/Prague'
1.6 tzinfo 对象

一个描述时区信息的抽象基类。用于给 datetime 类和 time 类提供自定义的时间调整概念（例如，负责时区或者夏令时）。
与时区相关，此处省略。
1.7 timezone 对象

一个实现了 tzinfo 抽象基类的子类，用于表示相对于 世界标准时间（UTC）的偏移量。
与时区相关，此处省略。
二.datetime模块实操

2.1 datetime模块常用方法案例

from datetime import datetime, date, time, timedelta
# 获取当前日期及时间
datetime_object = datetime.now()
print(datetime_object)
# 获取当前日期
datetime_object = date.today()
print(datetime_object)
# 打印今天的年，月和日
today = date.today()
print("当前年:",today.year)
print("当前月:",today.month)
print("当前日:",today.day)
# 打印 时分秒及微妙
t = time(17, 8, 21,1)
print("小时=", t.hour)
print("分钟=", t.minute)
print("秒=", t.second)
print("微秒=", t.microsecond)
# datetime类使用实例,并打印 年，月，时，分，秒及时间戳
a = datetime(2021, 3, 10)
print(a)
b = datetime(2021, 3, 10, 17, 12, 23, 22222)
print(b)
print("年 =", b.year)
print("月 =", b.month)
print("日 =", b.day)
print("时 =", b.hour)
print("分 =", b.minute)
print("秒 =", b.second)
print("微妙 =", b.microsecond)
print("时间戳 =", a.timestamp())
# timedelta 对象表示两个日期或时间之间的时差
t1 = date(2021, 3, 10)
t2 = date(2001, 1, 1)
t3 = t1 - t2
print("t3 = ", t3)
t4 = datetime(2021, 3, 10, 17, 12, 23, 22222)
t5 = datetime(2000, 1, 1, 0, 0, 0, 0)
t6 = t4 - t5
print("t6 = ",t6)
print("type of t3 =",type(t3))
print("type of t6 =",type(t6))
# 两个timedelta对象之间的时间差
t1 = timedelta(weeks = 2, days = 5, hours = 1, seconds = 33)
t2 = timedelta(days = 4, hours = 11, minutes = 4, seconds = 54)
t3 = t1 - t2
print("t3 =", t3)
测试记录:
E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/datetime_test1.py
2021-03-10 17:23:49.158000
2021-03-10
当前年: 2021
当前月: 3
当前日: 10
小时= 17
分钟= 8
秒= 21
微秒= 1
2021-03-10 00:00:00
2021-03-10 17:12:23.022222
年 = 2021
月 = 3
日 = 10
时 = 17
分 = 12
秒 = 23
微妙 = 22222
时间戳 = 1615305600.0
t3 =  7373 days, 0:00:00
t6 =  7739 days, 17:12:23.022222
type of t3 = <class 'datetime.timedelta'>
type of t6 = <class 'datetime.timedelta'>
t3 = 14 days, 13:55:39
Process finished with exit code 0
2.2 格式日期时间

日期和时间的表示方式在不同的地方，组织等中可能有所不同。在美国，使用mm / dd / yyyy更为常见，而在英国使用dd / mm / yyyy更为常见。
Python有strftime()和strptime()方法来处理这个问题。
Python strftime()-字符串的日期时间对象

strftime()方法是在date、datetime和time类下面定义的。该方法根据给定的日期、日期时间或时间对象创建格式化的字符串。

本文以datetime举例说明，time里也是一样的
2.2.1 使用strftime()格式化日期

UTC offset in the form +HHMM or -HHMM (empty string if the object is naive).
(empty), +0000, -0400, +1030
时区名称（如果对象为简单型则为空字符串）。
(空), UTC, EST, CST
以补零后的十进制数表示的一年中的日序号。
001, 002, …, 366
以补零后的十进制数表示的一年中的周序号（星期日作为每周的第一天）。 在新的一年中第一个星期日之前的所有日子都被视为是在第 0 周。
00, 01, …, 53
以十进制数表示的一年中的周序号（星期一作为每周的第一天）。 在新的一年中第一个第期一之前的所有日子都被视为是在第 0 周。
00, 01, …, 53
本地化的适当日期和时间表示。
Tue Aug 16 21:30:00 1988 (美国);Di 16 Aug 21:30:00 1988 (德国)
本地化的适当日期表示。
08/16/88 (None);08/16/1988 (en_US);16.08.1988 (de_DE)
本地化的适当时间表示。
21:30:00 (en_US);21:30:00 (de_DE)
字面的 ‘%’ 字符。
from datetime import datetime
now = datetime.now()
t = now.strftime("%Y-%m-%d %H:%M:%S")
print(t)
测试记录:
E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/dattime_test2.py
2021-03-10 17:28:15
Process finished with exit code 0
2.2.2 Python strptime()-日期时间的字符串

from datetime import datetime
date_string = "1 October, 2020"
print("date_string =", date_string)
date_object = datetime.strptime(date_string, "%d %B, %Y")
print("date_object =", date_object)
测试记录:
E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/datetime_test3.py
date_string = 1 October, 2020
date_object = 2020-10-01 00:00:00
Process finished with exit code 0
2.3 python 时间戳

from datetime import datetime
# 时间戳转为时间
timestamp = 1545730073
dt_object = datetime.fromtimestamp(timestamp)
print("dt_object =", dt_object)
print("type(dt_object) =", type(dt_object))
# 时间转为时间戳
dt = '2018-12-25 17:27:53'
dt2 = datetime.strptime(dt, "%Y-%m-%d %H:%M:%S")
dt_timestamp =  datetime.timestamp(dt2)
print("dt_timestamp =", dt_timestamp)
print("type(dt_timestamp) =", type(dt_timestamp))
测试记录:
E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/datetime_test4.py
dt_object = 2018-12-25 17:27:53
type(dt_object) = <class 'datetime.datetime'>
dt_timestamp = 1545730073.0
type(dt_timestamp) = <class 'float'>
Process finished with exit code 0
三.time模块简介

Python time.time()

time()函数返回自纪元以来经过的秒数。
这个地方用得比较多的是Python time.sleep()

sleep()函数在给定的秒数内暂停（延迟）当前线程的执行。
import time
import datetime
print("这是立即打印输出。",datetime.datetime.now())
time.sleep(4)
print("这是4秒后打印的。",datetime.datetime.now())
测试记录:
E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/time_test1.py
这是立即打印输出。 2021-03-10 18:16:38.225000
这是4秒后打印的。 2021-03-10 18:16:42.225000
Process finished with exit code 0