python-标准库-time&datetime

time库
datetime

time库

python有三种表示时间的类型

时间戳: 从1997-01-01 00:00:00秒开始到现在经过的秒数, float类型
结构化时间对象: 将时间以实例对象的形式表示, time-object类型
格式化时间字符串: 将时间以字符串的形式表示, string类型

三种类型之间可以转换, 其中结构化时间对象是时间戳与格式化时间字符串的桥梁, 转换图如下

In [1]: import time

时间戳

# 生成时间戳
In [2]: timestamp = time.time()
# 打印时间戳
In [3]: timestamp
Out[3]: 1604840007.8823948

结构化时间对象

创建结构化时间对象

# 生成本地当前时间对象, 与当前操作系统有关
In [3]: t = time.localtime()
# 打印时间对象, 对应属性分别是: 年 月 日 时 分 秒 星期7(6+1)(0表示星期一) 今年的第313天 夏令时时间
In [4]: t
Out[4]: time.struct_time(tm_year=2020, tm_mon=11, tm_mday=8, tm_hour=20, tm_min=54, tm_sec=6, tm_wday=6, tm_yday=313, tm_isdst=0)

# UTC时间和GMT(格林威治时间)一致, 我们中国为东8区, 本地时间比UTC时间早8小时
In [12]: time.gmtime()
Out[12]: time.struct_time(tm_year=2020, tm_mon=11, tm_mday=8, tm_hour=13, tm_min=0, tm_sec=36, tm_wday=6, tm_yday=313, tm_isdst=0)
    
# localtime()接受一个时间戳(秒数)参数, 可以将时间戳转为时间对象
In [15]: a = time.localtime(timestamp)  # timestamp为上面生成的时间戳
In [16]: a
Out[16]: time.struct_time(tm_year=2020, tm_mon=11, tm_mday=8, tm_hour=20, tm_min=53, tm_sec=27, tm_wday=6, tm_yday=313, tm_isdst=0)

结构化时间的属性和方法

# 单独获取年/月/日/时/分/秒
In [22]: "{}年{}月{}日 {}时{}分{}秒".format(t.tm_year, t.tm_mon, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec)
Out[22]: '2020年11月8日 20时54分6秒'
# 获取星期几, 这里0表示星期一, 6则表示星期日
In [23]: t.tm_wday
Out[23]: 6
# 获取日期是当年的第几天
In [27]: t.tm_yday
Out[27]: 313

结构化时间==>时间字符串

# 默认格式, '星期 月 日 时:分:秒 年'
In [28]: time.ctime()
Out[28]: 'Sun Nov  8 21:38:31 2020'

# 自定义格式 time.strftime(format, 结构化时间对象)
# t = time.localtime()
In [32]: time.strftime('%Y-%m-%d %H:%M:%S', t)
Out[32]: '2020-11-08 20:54:06'

格式化符号及含义

# t = time.localtime()
# %a/%A 星期的缩写/全写
In [36]: time.strftime('%a %A', t)
Out[36]: 'Sun Sunday'
# %b/%B 月份的缩写/全写
In [37]: time.strftime('%b %B', t)
Out[37]: 'Nov November'
# %c 默认的时间格式
In [38]: time.strftime('%c', t)
Out[38]: 'Sun Nov  8 20:54:06 2020'
# %I 12小时制的时 %p AM或PM
In [46]: time.strftime('%Y-%m-%d %I:%M:%S %p', t)
Out[46]: '2020-11-08 08:54:06 PM'  # 下午8点54分
# %w 星期几[0（Sunday），6](0表示星期天)  %W 本周是当年的第几周
In [47]: time.strftime('%Y-%m-%d %H:%M:%S %w %W', t)
Out[47]: '2020-11-08 20:54:06 0 44'

计算时间差多少秒

# 可以使用时间戳相减, 得到相差的秒数
In [48]: start = time.time()
# time.sleep(8)
In [49]: end = time.time()
In [51]: diff = end - start
In [52]: type(diff), diff
Out[52]: (float, 8.107917070388794)

三种类型的转化

时间戳 => 结构化时间对象

结构化时间对象 = time.localtime(时间戳)

# 生成时间戳
In [54]: timestamp = time.time()
# 时间戳转为Local时间
In [56]: time.localtime(timestamp)
Out[56]: time.struct_time(tm_year=2020, tm_mon=11, tm_mday=8, tm_hour=22, tm_min=6, tm_sec=17, tm_wday=6, tm_yday=313, tm_isdst=0)
# 时间戳转为UTC/GMT时间
In [55]: time.gmtime(timestamp)
Out[55]: time.struct_time(tm_year=2020, tm_mon=11, tm_mday=8, tm_hour=14, tm_min=6, tm_sec=17, tm_wday=6, tm_yday=313, tm_isdst=0)

结构化时间对象 => 时间戳

时间戳 = time.mktime(结构化对象)

# 生成结构化时间对象
In [57]: t = time.localtime()
# 转为时间戳
In [59]: time.mktime(t)
Out[59]: 1604844553.0
# 注意: 由于结构化对象精确到秒, 不包含毫秒/微秒, 所以最终生成的时间戳小数位是0

结构化时间对象 => 时间字符串

时间字符串 = time.strftime(format, 结构化时间对象)

In [60]: time.strftime('%Y-%m-%d %H:%M:%S', t)
Out[60]: '2020-11-08 22:09:13'

时间字符串 => 结构化时间对象

结构化对象 = time.strptime(时间字符串, format)

# 创建时间字符串
In [61]: s = '2020-11-08 22:09:13'
# 转为结构化时间对象
In [62]: time.strptime(s, '%Y-%m-%d %H:%M:%S')
Out[62]: time.struct_time(tm_year=2020, tm_mon=11, tm_mday=8, tm_hour=22, tm_min=9, tm_sec=13, tm_wday=6, tm_yday=313, tm_isdst=-1)

datetime

datetime中四个常用的标准结构化时间对象的类

datetime.date , 只有年月日: year, month, 和 day
datetime.time, 只有时分秒微秒: hour , minute, second, microsecond 和tzinfo
datetime.datetime, 同时有年月日和时分秒
datetime.timedelta, 同date/time/datetime类型的时间差

datetime.date类型

生成datetime.date

# 获取当前时间 date.today()
In [72]: today = datetime.date.today()
In [73]: today
Out[73]: datetime.date(2020, 11, 8)
# 创建指定时间 date(1995, 4, 17)
In [74]: birthday = datetime.date(1995, 4, 17)
In [75]: birthday
Out[75]: datetime.date(1995, 4, 17)
# 通过时间戳创建时间 date.fromtimestamp(时间戳)
In [77]: import time
In [78]: datetime.date.fromtimestamp(time.time())
Out[78]: datetime.date(2020, 11, 8)

类属性

In [84]: datetime.date.max
Out[84]: datetime.date(9999, 12, 31)
In [85]: datetime.date.min
Out[85]: datetime.date(1, 1, 1)
In [86]: datetime.date.resolution
Out[86]: datetime.timedelta(days=1)

实例属性

# 获取年月日
In [81]: today.year, today.month, today.day
Out[81]: (2020, 11, 8)

实例方法

# datetime对象 转为 time模块的结构化时间对象
In [89]: today.timetuple()
Out[89]: time.struct_time(tm_year=2020, tm_mon=11, tm_mday=8, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=313, tm_isdst=-1)
# repalce 替换年月日, 可以通过关键字参数随意替换年月日
In [93]: today.replace(year=2014, month=3, day=12)
Out[93]: datetime.date(2014, 3, 12)
# 获取星期几
In [94]: today.weekday()
Out[94]: 6  # 0代表周一, 6代表周日
In [95]: today.isoweekday()
Out[95]: 7  # 1代表周一, 7代表周日
# 转为字符串格式 .strftime(format)
In [96]: today.strftime('%Y-%m-%d %H:%M:%S')
Out[96]: '2020-11-08 00:00:00'  # 由于没有时分秒, 所以都为0

datetime.time类型

生成datetime.time

# 生成指定时间
In [106]: t = datetime.time(18, 35, 24, 888888)
In [107]: t
Out[107]: datetime.time(18, 35, 24, 888888)

类属性

In [108]: datetime.time.min
Out[108]: datetime.time(0, 0)
In [109]: datetime.time.max
Out[109]: datetime.time(23, 59, 59, 999999)
In [110]: datetime.time.resolution
Out[110]: datetime.timedelta(microseconds=1)

实例属性

# 获取 时 分 秒 毫秒
In [112]: t.hour, t.minute, t.second, t.microsecond
Out[112]: (18, 35, 24, 888888)

常用方法

# repalce 替换时分秒, 可以通过关键字参数随意替换年月日
In [115]: t.replace(hour=20, minute=12, second=40, microsecond=123456)
Out[115]: datetime.time(20, 12, 40, 123456)
# 转为字符串格式 .strftime(format)
In [116]: t.strftime('%Y-%m-%d %H:%M:%S')
Out[116]: '1900-01-01 18:35:24'  # 由于没有年月日, 所以返回的是UTC的第一天

datetime.datetime类型

生成datetime.datetime

# 生成当前时间
In [117]: now = datetime.datetime.now()
In [118]: now
Out[118]: datetime.datetime(2020, 11, 8, 23, 28, 19, 977933)
# 生成当前UTC时间
In [124]: datetime.datetime.utcnow()
Out[124]: datetime.datetime(2020, 11, 8, 15, 30, 54, 871666)
# 生成指定时间
In [122]: t = datetime.datetime(2018, 10, 4, 21, 12, 24, 977933)
In [123]: t
Out[123]: datetime.datetime(2018, 10, 4, 21, 12, 24, 977933)
# 通过时间戳创建时间 datetime.datetime.fromtimestamp(时间戳)
In [125]: datetime.datetime.fromtimestamp(time.time())
Out[125]: datetime.datetime(2020, 11, 8, 23, 32, 11, 575181)
# 通过字符串创建时间 datetime.datetime.strptime(时间字符串, format)
In [129]: datetime.datetime.strptime('2018-10-04 21:12:24', '%Y-%m-%d %H:%M:%S')
Out[129]: datetime.datetime(2018, 10, 4, 21, 12, 24)

属性

同上

实例方法

# replace
In [8]: t.replace(hour=10)
Out[8]: datetime.datetime(2020, 11, 15, 10, 33, 28, 175214)
# datetime对象 => time模块的结构化时间对象
In [130]: t.timetuple()
Out[130]: time.struct_time(tm_year=2018, tm_mon=10, tm_mday=4, tm_hour=21, tm_min=12, tm_sec=24, tm_wday=3, tm_yday=277, tm_isdst=-1)
# datetime对象 => 时间戳
In [131]: t.timestamp()
Out[131]: 1538658744.977933
# datetime对象 => 时间字符串
In [127]: t.strftime('%Y-%m-%d %H:%M:%S')
Out[127]: '2018-10-04 21:12:24'

四种类型的转化

datetime.timedelta类型

创建timedelta

datetime.timedelta(days=0, hours=0, seconds=0, microseconds=0, milliseconds=0, weeks=0)
# 例1 向后5天2小时
In [21]: datetime.timedelta(days=5, hours=2)
Out[22]: datetime.timedelta(days=5, seconds=7200)
# 例2 向前3天又8小时 等价于 向前4天16小时
In [23]: datetime.timedelta(days=-3, hours=-8)
Out[23]: datetime.timedelta(days=-4, seconds=57600)

应用1. 计算目标日期

In [25]: today = datetime.datetime.now()
In [31]: today
Out[31]: datetime.datetime(2020, 11, 15, 10, 35, 45, 151476)
In [28]: delta = datetime.timedelta(hours=10)
In [29]: target = today + delta
In [30]: target
Out[30]: datetime.datetime(2020, 11, 15, 20, 35, 45, 151476

应用2. 计算时间差

In [32]: today = datetime.datetime.now()
In [33]: utc = datetime.datetime.utcnow()
In [34]: td = today - utc
In [35]: print(td.seconds/3600)  # timedelta没有小时, 需要用秒进行换算
7.996666666666667