python time datetime timedelta

python 项目中很多时候需要将时间在 datetime 格式和 timestamp 格式之间转化，本文将对 python 中多个时间储存方式、时间模块(如time、datetime、timeit)以及他们之间的转换关系进行详细的梳理和总结。

1. 概述

1.1. 时间类型

在 python 中，通常有这三种方式来表示时间：时间戳、元组(struct_time)、格式化的时间字符串：

• 时间戳(timestamp) ：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型
• 格式化的时间字符串(Format String)：“1999-12-06”

%y 两位数的年份表示(00-99)
%Y 四位数的年份表示(000-9999)
%m 月份(01-12)
%d 月内中的一天(0-31)
%H 24小时制小时数(0-23)
%I 12小时制小时数(01-12)
%M 分钟数(00=59)
%S 秒(00-59)
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天(001-366)
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数(00-53)星期天为星期的开始
%w 星期(0-6)，星期天为星期的开始
%W 一年中的星期数(00-53)星期一为星期的开始
%x 本地相应的日期表示%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身

• 元组(struct_time) ：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等)
  时间元组可通过 time.localtime() 获取

print(time.localtime())    #获取当前结构化时间
 
time.struct_time(tm_year=2023, tm_mon=4, tm_mday=23, tm_hour=16, tm_min=14, tm_sec=52, tm_wday=6, tm_yday=113, tm_isdst=0)

1.2. 类型转换

import time
import datetime

def get_time():
    # 获取当前 datetime 类型时间
    now_time = datetime.datetime.now()
    # 当前时间减去一天，获得昨天当前时间
    yes_time = now_time + datetime.timedelta(days=-1)

    # 格式化输出
    yes_time_str = yes_time.strftime('%Y-%m-%d %H:%M:%S')
    print(yes_time_str)
    # 2024-07-23 17:47:10

def dif_time():
    # 使用 datetime 类型计算两个时间之间差值
    d1 = datetime.datetime.strptime('2017-10-16 19:21:22', '%Y-%m-%d %H:%M:%S')
    now_time = datetime.datetime.now()
    now_time = now_time.strftime('%Y-%m-%d %H:%M:%S')
    d2 = datetime.datetime.strptime(now_time, '%Y-%m-%d %H:%M:%S')
    # 间隔天数
    day = (d2 - d1).days
    # 间隔秒数
    second = (d2 - d1).seconds
    print(day)
    # 2472
    print(second)
    # 80748 注意这样计算出的秒数只有小时之后的计算额 也就是不包含天之间差数

def unix_time():
    # 将 python 的 datetime 转换为 unix 时间戳
    dtime = datetime.datetime.now()
    un_time = time.mktime(dtime.timetuple())
    print(un_time)
    # 1721814430.0

    # 将 unix 时间戳转换为 python 的 datetime
    unix_ts = 1509636585.0
    times = datetime.datetime.fromtimestamp(unix_ts)
    print(times)
    # 2017-11-02 23:29:45

if __name__ == "__main__":
	# datetime 格式化
    get_time()
    # datetime.timedelta
    dif_time()
    # datetime 与 时间戳之间的类型转换
    unix_time()

2. time

2.1. time.time()

创建时间戳，返回当前时间的时间戳（1970纪元后经过的浮点秒数）。

import time
# 返回当前时间的时间戳（1970纪元后经过的浮点秒数）。

temp = time.time()
print(type(temp), temp)
#  1721811399.5623212

2.2. time.localtime([sec])

格式化时间戳为结构体时间。
将一个时间戳转换为 struct_time，可选的参数 sec 表示从1970-01-01以来的秒数（即时间戳），默认值为当前时间戳 time.time()，函数返回 time.struct_time 类型的对象。

import time

# 1，localtime中加入时间戳参数
timestamp = time.time()
# localtime 输入时间戳参数，将时间戳转化为本地时间
locaoltime = time.localtime(timestamp)
print(type(locaoltime), locaoltime)
#  time.struct_time(tm_year=2024, tm_mon=7, tm_mday=24, tm_hour=16, tm_min=59, tm_sec=18, tm_wday=2, tm_yday=206, tm_isdst=0)

time.sleep(3)
# 2，localtime未输入参数时,默认为当时时间
print(type(time.localtime()), time.localtime())
#  time.struct_time(tm_year=2024, tm_mon=7, tm_mday=24, tm_hour=16, tm_min=59, tm_sec=21, tm_wday=2, tm_yday=206, tm_isdst=0)

2.3. time.gmtime([sec])

将时间戳转换为结构体时间（0时区）
将一个时间戳转换为 UTC 时区（0时区）的 struct_time，可选的参数 sec 表示从1970-01-01 以来的秒数，默认值为当前时间戳 time.time()，函数返回 time.struct_time 类型的对象。

import time

timestamp = time.time()

# localtime输入时间戳参数，将时间戳转化为本地时间
print(type(time.localtime(timestamp)), time.localtime(timestamp))
#  time.struct_time(tm_year=2024, tm_mon=7, tm_mday=24, tm_hour=17, tm_min=5, tm_sec=24, tm_wday=2, tm_yday=206, tm_isdst=0)

# gmtimee输入时间戳参数，将时间戳转换为UTC时区
print(type(time.gmtime(timestamp)), time.gmtime(timestamp))
#  time.struct_time(tm_year=2024, tm_mon=7, tm_mday=24, tm_hour=9, tm_min=5, tm_sec=24, tm_wday=2, tm_yday=206, tm_isdst=0)

2.4. time.strftime(format[, t])

将结构体时间转换为字符串。
输入结构体时间，输出为按照输入的格式的字符串。

import time

local_time = time.localtime()
print(type(local_time), local_time)
#  time.struct_time(tm_year=2024, tm_mon=7, tm_mday=24, tm_hour=17, tm_min=12, tm_sec=27, tm_wday=2, tm_yday=206, tm_isdst=0)

# 输入结构体时间，输出为按照输入的格式的字符串
time_str = time.strftime("%Y-%m-%d %H:%M:%S", local_time)
print(type(time_str), time_str)
#  2024-07-24 17:12:27

time_str = time.strftime("%Y-%m-%d %H:%M:%S")
print(type(time_str), time_str)
#  2024-07-24 17:12:27

2.5. time.strptime(string[, format])

将字符串转换为结构体时间。
根据指定的格式把一个时间字符串解析为结构体时间。

import time

time_str = "2024-07-24 17:13:53"

# 输入字符串，按照参数指定格式，输出结构体时间
localtime = time.strptime(time_str, "%Y-%m-%d %H:%M:%S")
print(type(localtime), localtime)
#  time.struct_time(tm_year=2024, tm_mon=7, tm_mday=24, tm_hour=17, tm_min=13, tm_sec=53, tm_wday=2, tm_yday=206, tm_isdst=-1)

2.6. time.mktime(struct_time: t)

将结构体时间转换为时间戳，接收struct_time对象作为参数，返回用秒数来表示时间的浮点数。
如果输入的值不是一个合法的时间，将触发 OverflowError 或 ValueError。

import time

# 输入结构体时间，返回时间戳
localtime = time.localtime()
print(type(localtime), localtime)
#  time.struct_time(tm_year=2024, tm_mon=7, tm_mday=24, tm_hour=17, tm_min=19, tm_sec=49, tm_wday=2, tm_yday=206, tm_isdst=0)

timestamp = time.mktime(localtime)
print(type(timestamp), timestamp)
#  1721812789.0

2.7. time.sleep(nums)

推迟执行的秒数，没有任何输出

import time

# 推迟执行的秒数，没有任何输出
temp = time.sleep(3)
print(type(temp), temp)
#  None

2.8. timeit.Timer([number])

用来计算一个函数平均执行了多少时间。

import timeit

def T1():
    '''表内置属性'''
    li = []

    for i in range(1000):
        li.append(i)

def T2():
    '''列表拼接'''
    li = []

    for i in range(1000):
        li = li + [i]

def T3():
    '''列表推导式'''
    li = [i for i in range(1000)]

def T4():
    '''属性转换'''
    li = list(range(1000))

if __name__ == "__main__":
    test_list = ['T1()','T2()','T3()','T4()']
    for i in test_list:
        timer = timeit.Timer(i, "from __main__ import T1,T2,T3,T4")
        print("%s: %f seconds" % (i, timer.timeit(number=1000)))
		# T1(): 0.103853 seconds
		# T2(): 1.678137 seconds
		# T3(): 0.046770 seconds
		# T4(): 0.018923 seconds

3. datetime

参考：https://blog.csdn.net/lovedingd/article/details/134929553

3.1. datetime.date 类

表示日期的类，常用的属性有 year、month、day。参数都为整数。

import datetime
import time

# 1，以下为两种生成日期的方式，效果一致,返回datetime类型
someday = datetime.date(year=2024, month=1, day=1)
someday = datetime.date(2024, 1, 1)
print(type(someday), someday)
#  2024-01-01

# 2，以规定的格式返回日期，返回字符串类型
someday_str = someday.strftime('/%Y/%m/%d')
print(type(someday_str), someday_str)
#  /2024/01/01

# 3，以默认的格式返回日期
print(someday.isoformat())
# 2024-01-01

# 4，获得今天日期，返回 datetime 类型
today = datetime.date.today()
print(type(today), today)
#  2024-07-24

# 5，根据给定的时间戮，返回一个date对象
temp = datetime.date.fromtimestamp(time.time())
print(type(temp), temp)
#  2024-07-24

3.2. datetime.time 类

表示时间的类，参数包括 hour、minute、second、microsecond。 time 类的方法同 datetime 类。

import datetime
import time

# 1，以下为两种生成时间的方式，效果一致,返回datetime类型
someday = datetime.time(hour=12,minute=50,second=12,microsecond=10)
someday = datetime.time(12, 50, 12, 10)
print(type(someday), someday)
#  12:50:12.000010

# 2，以规定的格式返回时间，返回字符串类型
temp = someday.strftime('%H::%M::%S')
print(type(temp), temp)
#  12::50::12

# 3，以默认的格式返回时间
print(type(someday), someday.isoformat())
#  12:50:12.000010

3.3. datetime.datetime 类

日期实践类，常用的参数包含 year、month、day、hour、minute、second、microsecond。但是至少要包含 year、month、day 三个参数。

3.3.1. datetime.now()

import datetime
import time

now_time = datetime.datetime.now()
print(type(now_time), now_time)
#  2024-07-24 18:23:26.110395

3.3.2. datetime.datetime()

以下为两种生成日期时间的方式，效果一致，返回 datetime 类型

import datetime
import time

someday = datetime.datetime(year=2018,month=1,day=1,hour=12,minute=50,second=12,microsecond=10)
someday = datetime.datetime(2018, 1, 1, 12, 50, 12, 10)
print(type(someday), someday)
#  2018-01-01 12:50:12.000010

3.3.3. datetime.isoformat()

以默认的格式返回日期时间

import datetime
import time
someday = datetime.datetime(2018, 1, 1, 12, 50, 12, 10)

print(type(someday), someday.isoformat())
#  2018-01-01T12:50:12.000010

3.3.4. datetime.timetuple()

将 datetime 转化为结构体时间；再通过 time.mktime() 装换为时间戳

import datetime
import time

dtime = datetime.datetime.now()
print(type(dtime.timetuple()), dtime.timetuple())
#  time.struct_time(tm_year=2024, tm_mon=7, tm_mday=24, tm_hour=17, tm_min=37, tm_sec=12, tm_wday=2, tm_yday=206, tm_isdst=-1)

un_time = time.mktime(dtime.timetuple())
print(type(un_time), un_time)
#  1721813832.0

3.3.5. datetime.fromtimestamp(sec)

时间戳转换为 python 的 datetime

import datetime
import time

un_time = 1721813832
times = datetime.datetime.fromtimestamp(un_time)
print(type(times), times)
#  2024-07-24 17:37:12

3.3.6. datetime.strftime(format)

将 datetime 类转换为格式化时间，format=‘%Y-%m-%d %H:%M:%S’

import datetime
import time

now_time = datetime.datetime.now()
now_time = now_time.strftime('%Y-%m-%d %H:%M:%S')
print(type(now_time), now_time)
#  2024-07-24 17:37:12

3.3.7. datetime.strptime(string, format)

将格式化时间转换为 datetime 类，string= ‘2024-07-24 17:37:12’，format=‘%Y-%m-%d %H:%M:%S’

import datetime
import time

now_time = datetime.datetime.now()
# now_time = '2024-07-24 17:37:12'
now_time = now_time.strftime('%Y-%m-%d %H:%M:%S')
d2 = datetime.datetime.strptime(now_time, '%Y-%m-%d %H:%M:%S')
print(type(d2), d2)
#  2024-07-24 17:37:12

3.4. datetime.timedelta 类

单独说明，参考 4. timedelta

4. datetime.timedelta

参考：https://geek-docs.com/python/python-ask-answer/981_python_formatting_timedelta_objects.html
timedelta 是 Python 中的一个类，用于表示两个日期或时间之间的差异。它可以表示年、月、日、小时、分钟和秒等单位的时间差。timedelta 对象非常有用，可以用于日期和时间的计算，也可以格式化为字符串以显示给用户。

4.1. timedelta 对象的创建

from datetime import datetime, timedelta

# 创建一个以秒为单位的时间差为 3600 秒的 timedelta 对象
td1 = timedelta(seconds=3600)
print(td1)					# 输出 1:00:00

# 创建一个以分钟为单位的时间差为 120 分钟的 timedelta 对象
td2 = timedelta(minutes=120)
print(td2)					# 输出 2:00:00

# 创建一个以天为单位的时间差为 5 天的 timedelta 对象
td3 = timedelta(days=5)
print(td3)					# 输出 5 days, 0:00:00

4.2. timedelta 对象的属性和方法

timedelta 对象具有多个属性和方法，用于获取和操作时间间隔的不同部分。下面是一些常用的属性和方法：

days：获取 timedelta 对象的天数部分。返回一个整数值。
seconds：获取 timedelta 对象的秒数部分。返回一个整数值。
total_seconds()：获取 timedelta 对象的总秒数。
total_seconds()：获取 timedelta 对象的总秒数。

以下是使用这些属性和方法的示例：

# 创建一个时间差为 2 小时 30 分钟的 timedelta 对象
td = timedelta(hours=2, minutes=30)

# 获取 timedelta 对象的天数和秒数
print(td.days)      		# 输出 0，因为仅包含小时和分钟
print(td.seconds)   		# 输出 9000，表示 2 小时 30 分钟共有 9000 秒

# 获取 timedelta 对象的总秒数
print(td.total_seconds()) 	# 输出 9000.0

# 将 timedelta 对象的秒数转换为分钟
print(td.seconds / 60)  	# 输出 150.0

4.3. timedelta 对象的格式化

timedelta 对象默认以 [days,] [hh:mm:ss] 的格式进行输出。但我们也可以根据需要使用不同的格式进行定制。以下是一些常见的格式化选项：

%d：天数的两位数表示（01-31）。
%H：小时的两位数表示（00-23）。
%M：分钟的两位数表示（00-59）。
%S：秒数的两位数表示（00-59）。

下面是一个使用上述格式化选项的示例：

# 创建一个时间差为 1 天 2 小时 30 分钟的 timedelta 对象
td = timedelta(days=1, hours=2, minutes=30, seconds=1)
print(td)						# 输出: 1 day, 2:30:01
print(td.seconds // 3600)		# 输出: 2
print(td.seconds % 3600 // 60)	# 输出: 30
print(td.seconds % 60)  		# 输出: 1

# 格式化 timedelta 对象为字符串
def timedelta_to_str(delta: timedelta):
    if delta.days == 0:
        return "{:02d}:{:02d}:{:02d}".format(delta.days, delta.seconds//3600, (delta.seconds%3600)//60, delta.seconds%60)
    elif delta.days == 1:
        return "{:d} day, {:02d}:{:02d}:{:02d}".format(delta.days, delta.seconds//3600, (delta.seconds%3600)//60, delta.seconds%60)
    else:
        return "{:d} days, {:02d}:{:02d}:{:02d}".format(delta.days, delta.seconds//3600, (delta.seconds%3600)//60, delta.seconds%60)

# 格式化字符串对象为 timedelta 
def str_to_timedelta(delta: str):
    days, hours, minutes, seconds = 0, 0, 0, 0
    if ' ' in delta:
        days_str, format_str, time_str = delta.split(' ')
        days = int(days_str)
        hours, minutes, seconds = [int(i) for i in time_str.split(':')]
    else:
        hours, minutes, seconds = [int(i) for i in delta.split(':')]
    return timedelta(days=days, hours=hours, minutes=minutes, seconds=seconds)

formatted_td = timedelta_to_str(td)
print("format", formatted_td)			# 输出: 1 day, 02:30:01
print(str_to_timedelta(formatted_td))	# 输出: 1 day, 2:30:01