一、相关术语的解释
- UTC time Coordinated Universal Time，世界协调时，又称 格林尼治天文时间、世界标准时间。与UTC time对应的是各个时区的local time，东N区的时间比UTC时间早N个小时，因此UTC time + N小时 即为东N区的本地时间；而西N区时间比UTC时间晚N个小时，即 UTC time - N小时 即为西N区的本地时间； 中国在东8区，因此比UTC时间早8小时，可以以UTC+8进行表示。
- epoch time 表示时间开始的起点；它是一个特定的时间，不同平台上这个时间点的值不太相同，对于Unix而言，epoch time为 1970-01-01 00:00:00 UTC。
- timestamp（时间戳） 也称为Unix时间 或 POSIX时间；它是一种时间表示方式，表示从格林尼治时间1970年1月1日0时0分0秒开始到现在所经过的毫秒数，其值为float类型。 但是有些编程语言的相关方法返回的是秒数（Python就是这样），这个需要看方法的文档说明。需要说明的是时间戳是个差值，其值与时区无关。
二、 时间表示形式
- 时间戳
- time模块的time.struct_time (多属性均可.tm_xxx调用)
- datetime模块的datetime （属性可通过 .year/month/…调用）
- 格式化的时间字符串
三、 time模块和datetime模块的时间形式转换
- 如图：
另外：
1）时间戳 –> 格式化的时间字符串（固定格式）
~~ time.ctime([secs])
字符串格式– ‘Mon Jun 25 12:31:42 2018’
2）struct_time –> 格式化的时间字符串（固定格式）
~~ time.asctime([t]) — （留意转换后的固定格式，若自定义格式，需使用图片中的time.strftime(自定义格式，secs))
字符串格式：’Mon Jun 25 13:37:57 2018’
3）datetime.datetime –> 格式化的字符串（固定格式）
~~ dt.ctime()
字符串格式：’Mon Jun 25 16:46:05 2018’
4）时间戳 –> struct_time(utc)
~~ time.gmtime([secs]) 等价于 time.localtime([secs] - n*3600) （仅使用中国，时区差8H）
5）datetime.datetime– > time.struct_time
~~ dt.timetuple() 返回日期对应的time.struct_time对象
notes:
strftime: f == format 格式化
strptime: p = parse 解析
>>> ts # 时间戳
1529901102.1701407
>>> struct_t # struct_time
time.struct_time(tm_year=2018, tm_mon=6, tm_mday=25, tm_hour=13, tm_min=37, tm_sec=57, tm_wday=0, tm_yday=176, tm_isdst=0)
>>> dt # datetime.datetime
datetime.datetime(2018, 6, 25, 12, 31, 42, 170141)
# 时间戳 --> 格式化的时间字符串（固定格式）
>>> time.ctime(ts) # import time
'Mon Jun 25 12:31:42 2018'
# struct_time --> 格式化的时间字符串（固定格式）
>>> time.asctime(struct_t) # import time
'Mon Jun 25 13:37:57 2018'
# datetime.datetime --> 格式化的字符串（固定格式）
>>> dt.ctime()
'Mon Jun 25 12:31:42 2018'
# 时间戳 --> struct_time**(utc)
>>> time.gmtime(t + 8*3600) # == time.localtime(t) import time
time.struct_time(tm_year=2018, tm_mon=6, tm_mday=25, tm_hour=13, tm_min=37, tm_sec=57, tm_wday=0, tm_yday=176, tm_isdst=0)
>>> time.localtime(t) # import time
time.struct_time(tm_year=2018, tm_mon=6, tm_mday=25, tm_hour=13, tm_min=37, tm_sec=57, tm_wday=0, tm_yday=176, tm_isdst=0)
>>> time.gmtime(t+8*3600) == time.localtime(t) # import time
True
# datetime.datetime --> time.struct_time
>>> dt.timetuple() # import datetime
time.struct_time(tm_year=2018, tm_mon=6, tm_mday=25, tm_hour=12, tm_min=31, tm_sec=42, tm_wday=0, tm_yday=176, tm_isdst=-1)
6）object.isoformat() :返回另一种格式化的字符串（固定格式）
NOTE: time模块的对象time.struct_time没有isoformat()方法，只适用datetime.datetime / datetime.date / datetime.time
date_t.isoformat()
Out[114]: '2018-06-25T16:46:05.774752'
date_t.date().isoformat()
Out[112]: '2018-06-25'
datetime.date(2018,6,19).isoformat()
Out[116]: '2018-06-19'
date_t.time().isoformat()
Out[113]: '16:46:05.774752'
四、time模块
1）time模块函数列表
扫描二维码关注公众号，回复：
2357018 查看本文章
| 方法/属性 | 描述 |
|---|---|
| time.altzone | 返回与utc时间的时间差，以秒为单位（西区该值为正，东区该值为负）。其表示的是本地DST 时区的偏移量，只有daylight非0时才使用。 |
| time.clock() | 返回当前进程所消耗的处理器运行时间秒数（不包括sleep时间），值为小数；该方法Python3.3改成了time.process_time() |
| time.asctime([t]) | 将一个tuple或struct_time形式的时间（可以通过gmtime()和localtime()方法获取）转换为一个24个字符的时间字符串，格式为: “Fri Aug 19 11:14:16 2016”。如果参数t未提供，则取localtime()的返回值作为参数。 |
| time.time() | 返回时间戳（自1970-1-1 0:00:00 至今所经历的秒数） |
| time.localtime([secs]) | 返回以指定时间戳对应的本地时间的 struct_time对象（可以通过下标，也可以通过 .属性名 的方式来引用内部属性）格式 |
| time.localtime(time.time() + n*3600) | 返回n个小时后本地时间的 struct_time对象格式（可以用来实现类似crontab的功能） |
| time.gmtime([secs]) | 返回指定时间戳对应的utc时间的 struct_time对象格式（与当前本地时间差8个小时） |
| time.gmtime(time.time() + n*3600) | 返回n个小时后utc时间的 struct_time对象（可以通过 .属性名 的方式来引用内部属性）格式 |
| time.mktime(struct_time_instance) | 将struct_time对象实例转换成时间戳 |
| time.strptime(time_str, time_format_str) | 将时间字符串转换为struct_time时间对象，如：time.strptime(‘2017-01-13 17:07’, ‘%Y-%m-%d %H:%M’) |
| time.strftime(time_format_str, struct_time_instance) | 将struct_time对象实例转换成字符串 |
2）time.struct_time属性列表
| 下标/索引 | 属性 | 描述 |
|---|---|---|
| 0 | tm_year | 年份，如 2017 |
| 1 | tm_mon | 月份，取值范围为[1, 12] |
| 3 | tm_hour | 小时， 取值范围为[0-23] |
| 4 | tm_min | 分钟，取值范围为[0, 59] |
| 5 | tm_sec | 秒，取值范围为[0, 61] |
| 6 | tm_wday | 一个星期中的第几天，取值范围为[0-6]，0表示星期一 |
| 7 | tm_yday | 一年中的第几天，取值范围为[1, 366] |
| 8 | tm_isdst | 是否为夏令时，可取值为：0 , 1 或 -1 |
备注：
属性值的获取方式有两种：
- 可以把它当做一种特殊的有序不可变序列通过 下标/索引 获取各个元素的值，如t[0]
- 也可以通过 .属性名 的方式来获取各个元素的值，如t.tm_year。
需要说明的是struct_time实例的各个属性都是只读的，不可修改。
五、datetime模块
- datetime模块中定义的类
datetime模块定义了以下几个类（类的对象不可变）：
| 类名称 | 描述 |
|---|---|
| datetime.date | 表示日期，常用的属性有：year, month和day |
| datetime.time | 表示时间，常用属性有：hour, minute, second, microsecond |
| datetime.datetime | 表示日期时间 |
| datetime.timedelta | 表示两个date、time、datetime实例之间的时间间隔，分辨率（最小单位）可达到微秒 |
| datetime.tzinfo | 时区相关信息对象的抽象基类。它们由datetime和time类使用，以提供自定义时间的而调整。 |
| datetime.timezone | Python 3.2中新增的功能，实现tzinfo抽象基类的类，表示与UTC的固定偏移量 |
1）datetime.date类
datetime.date(year,month,day)year, month 和 day都是是必须参数
- 类方法和属性：
| 类名称 | 描述 |
|---|---|
| date.max | date对象所能表示的最大日期：9999-12-31 |
| date.min | date对象所能表示的最小日志：00001-01-01 |
| date.resoluation | date对象表示的日期的最小单位：天 |
| date.today() | 返回一个表示当前本地日期的date对象 |
| date.fromtimestamp(timestamp) | 根据跟定的时间戳，返回一个date对象 |
>>> from datetime import date
>>> d = date.today()
>>> d
datetime.date(2018, 6, 25)- 对象方法和属性：
| 对象方法/属性名称 | 描述 |
|---|---|
| d.year | 年 |
| d.month | 月 |
| d.day | 日 |
| d.replace(year[, month[, day]]) | 生成并返回一个新的日期对象，原日期对象不变 |
| d.timetuple() | 返回日期对应的time.struct_time对象 （可datetime.datetime–>time.struct_time） |
| d.toordinal() | 返回日期是是自 0001-01-01 开始的第多少天 (可用于计算两个日期之间的天数) |
| d.weekday() | 返回日期是星期几，[0, 6]，0表示星期一 |
| d.isoweekday() | 返回日期是星期几，[1, 7], 1表示星期一 |
| d.isocalendar() | 返回一个元组，格式为：(year, weekday, isoweekday) |
| d.isoformat() | 返回‘YYYY-MM-DD’格式的日期字符串 |
| d.strftime(format) | 返回指定格式的日期字符串，与time模块的strftime(format, struct_time)功能相同 |
>>> d.replace(2000,6)
datetime.date(2000, 6, 25)
>>> d.replace(2009)
datetime.date(2009, 6, 25)
>>> d
datetime.date(2018, 6, 25)
>>> dt
datetime.datetime(2018, 6, 25, 12, 31, 42, 170141)
>>> dt.timetuple()
time.struct_time(tm_year=2018, tm_mon=6, tm_mday=25, tm_hour=12, tm_min=31, tm_sec=42, tm_wday=0, tm_yday=176, tm_isdst=-1)
# 计算两个日期之间的天数
>>> date.today().toordinal()-date(2017,9,13).toordinal()
285
>>> date.today()-date(2017,9,13)
datetime.timedelta(285)2）datetime.date类
datetime.time(hour, [minute[, second, [microsecond[, tzinfo]]]])hour为必须参数，其他为可选参数。各参数的取值范围为：
| 参数名称 | 取值范围 |
|---|---|
| hour | [0, 23] |
| minute | [0, 59] |
| second | [0, 59] |
| microsecond | [0, 1000000] |
| tzinfo | tzinfo的子类对象，如timezone类的实例 |
类方法和属性
| 类方法/属性名称 | 描述 |
|---|---|
| time.max | time类所能表示的最大时间：time(23, 59, 59, 999999) |
| time.min | time类所能表示的最小时间：time(0, 0, 0, 0) |
| time.resolution | 时间的最小单位，即两个不同时间的最小差值：1微秒 |
对象方法和属性
| 对象方法/属性名称 | 描述 |
|---|---|
| t.hour | 时 |
| t.minute | 分 |
| t.second | 秒 |
| t.microsecond | 微秒 |
| t.tzinfo | 返回传递给time构造方法的tzinfo对象，如果该参数未给出，则返回None |
| t.replace(hour[, minute[, second[, microsecond[, tzinfo]]]]) | 生成并返回一个新的时间对象，原时间对象不变 |
| t.isoformat() | 返回一个‘HH:MM:SS.%f’格式的时间字符串 |
| t.strftime() | 返回指定格式的时间字符串，与time模块的strftime(format, struct_time)功能相同 |
time_t = datetime.datetime.time(date_t)
time_t
Out[35]: datetime.time(16, 46, 5, 774752)
time_t.microsecond
Out[36]: 774752
time_t.replace(22,23)
Out[38]: datetime.time(22, 23, 5, 774752)
time_t.isoformat()
Out[39]: '16:46:05.774752'3）datetime.datetime类
datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None)year, month 和 day是必须要传递的参数， tzinfo可以是None或tzinfo子类的实例。
| 对象方法/属性名称 | 描述 |
|---|---|
| year | [MINYEAR, MAXYEAR] |
| month | [1, 12] |
| day | [1, 指定年份的月份中的天数] |
| hour | [0, 23] |
| minute | [0, 59] |
| second | [0, 59] |
| microsecond | [0, 1000000] |
| tzinfo | tzinfo的子类对象，如timezone类的实例 |
类方法和属性
| 对象方法/属性名称 | 描述 |
|---|---|
| 类方法/属性名称 | 描述 |
| datetime.today() | 返回一个表示当前本期日期时间的datetime对象 |
| datetime.now([tz]) | 返回指定时区日期时间的datetime对象，如果不指定tz参数则结果同上 |
| datetime.utcnow() | 返回当前utc日期时间的datetime对象 |
| datetime.fromtimestamp(timestamp[, tz]) | 根据指定的时间戳创建一个datetime对象 |
| datetime.utcfromtimestamp(timestamp) | 根据指定的时间戳创建一个datetime对象 |
| datetime.combine(date, time) | 把指定的date和time对象整合成一个datetime对象 |
| datetime.strptime(date_str, format) | 将时间字符串转换为datetime对象 |
对象方法和属性
| 对象方法/属性名称 | 描述 |
|---|---|
| dt.year, dt.month, dt.day | 年、月、日 |
| dt.hour, dt.minute, dt.second | 时、分、秒 |
| dt.microsecond, dt.tzinfo | 微秒、时区信息 |
| dt.date() | 获取datetime对象对应的date对象 |
| dt.time() | 获取datetime对象对应的time对象， tzinfo 为None |
| dt.timetz() | 获取datetime对象对应的time对象，tzinfo与datetime对象的tzinfo相同 |
| dt.replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]]) | 生成并返回一个新的datetime对象，如果所有参数都没有指定，则返回一个与原datetime对象相同的对象 |
| dt.timetuple() | 返回datetime对象对应的tuple（不包括tzinfo） |
| dt.utctimetuple() | 返回datetime对象对应的utc时间的tuple（不包括tzinfo） |
| dt.toordinal() | 同date对象 |
| dt.weekday() | 同date对象 |
| dt.isocalendar() | 同date对象 |
| dt.isoformat([sep]) | 返回一个‘%Y-%m-%d |
| dt.ctime() | 等价于time模块的time.ctime(time.mktime(d.timetuple())) |
| dt.strftime(format) | 返回指定格式的时间字符串 |
4）datetime.datetime类
datetime.timedelta对象代表两个时间之间的的时间差，两个date或datetime对象相减时可以返回一个timedelta对象。
构造函数：
datetime.timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]])所有参数可选，且默认都是0，参数的值可以是整数，浮点数，正数或负数。
内部只存储days，seconds，microseconds，其他参数的值会自动按如下规则抓转换：
- 1 millisecond（毫秒） 转换成 1000 microseconds（微秒）
- 1 minute 转换成 60 seconds
- 1 hour 转换成 3600 seconds
- 1 week转换成 7 days
三个参数的取值范围分别为：
- 0 <= microseconds < 1000000
- 0 <= seconds < 3600*24 (the number of seconds in one day)
- -999999999 <= days <= 999999999
如果任意参数是float，且小数点后含有microseconds部分，那么microseconds的值为所有参数的微秒部分的总和（四舍五入）如：
>>> a = dt.datetime.today().date()
>>> a
datetime.date(2018, 6, 27)
>>> b = dt.date(2000,6,27)
>>> b
datetime.date(2000, 6, 27)
>>> a - b
datetime.timedelta(6574)
>>> (a-b).days
6574六、当前时间的表示方法
import datetime
1. datetime.date.today() # Out[72]: datetime.date(2018, 6, 25)
2. datetime.datetime.today() # Out[75]: datetime.datetime(2018, 6, 25, 18, 59, 27, 481401)
3. datetime.datetime.now() # Out[75]: datetime.datetime(2018, 6, 25, 18, 59, 27, 481401)
import time
4. time.time() # Out[78]: 1529924407.0582347
5. time.localtime(time.time()) # Out[79]: time.struct_time(tm_year=2018, tm_mon=6, tm_mday=25, tm_hour=19, tm_min=0, tm_sec=30, tm_wday=0, tm_yday=176, tm_isdst=0)
datetime.datetime.today().date()
Out[95]: datetime.date(2018, 6, 25)
datetime.datetime.today().date().month
Out[101]: 6
datetime.datetime.today().time()
Out[96]: datetime.time(19, 47, 10, 229158)
datetime.datetime.today().time().hour
Out[100]: 19
举例：
import datetime
import time
# 时间戳
t = time.time()
# 时间戳 --> time.struct_time
stc_t = time.localtime(t)
stc_t
Out[7]: time.struct_time(tm_year=2018, tm_mon=6, tm_mday=25, tm_hour=16, tm_min=46, tm_sec=5, tm_wday=0, tm_yday=176, tm_isdst=0)
# 时间戳 --> datetime.datetime
date_t = datetime.datetime.fromtimestamp(t)
date_t
Out[9]: datetime.datetime(2018, 6, 25, 16, 46, 5, 774752)
# datetime.datetime --> str
date_t.strftime('%Y-%m-%d') # == datetime.datetime.strftime(date_t,'%Y-%m-%d')
Out[21]: '2018-06-25'
#\
datetime.datetime.strftime(date_t,'%Y-%m-%d') # # 参数2为自定义格式
Out[24]: '2018-06-25'
# str --> datetime.datetime
datetime.datetime.strptime(data_str,'%Y-%m-%d %H:%M:%S')
Out[29]: datetime.datetime(2018, 6, 25, 16, 46, 5)
# time.struct_time --> str (time模块 import time)
time.strftime('%H:%M:%S',stc_t) # 注意：参数1为自定义格式
Out[55]: '16:50:59'
# str --> time.struct_time
time.strptime(t_str, '%H:%M:%S') # 参数2为自定义格式
Out[62]: time.struct_time(tm_year=1900, tm_mon=1, tm_mday=1, tm_hour=16, tm_min=50, tm_sec=59, tm_wday=0, tm_yday=1, tm_isdst=-1)
# object.isoformat()
# ~~~ 日期/时间 --》 str~~~ 返回‘YYYY-MM-DD’ / ‘HH:MM:SS.%f'格式的日期字符串
# 适用对象：datetime.datetime / datetime.date / datetime.time /
date_t.isoformat() # 返回的格式不完全符合‘YYYY-MM-DD’
Out[10]: '2018-06-25T16:46:05.774752'
#\
datetime.datetime.date(date_t)
Out[15]: datetime.date(2018, 6, 25)
#\
datetime.datetime.date(date_t).isoformat() # d.isoformat() 返回‘YYYY-MM-DD’格式的日期字符串
Out[43]: '2018-06-25'
#\
datetime.datetime.date(date_t).year
Out[17]: 2018
#\
# 返回‘HH:MM:SS.%f’格式的时间字符串
datetime.datetime.time(date_t)
Out[32]: datetime.time(16, 46, 5, 774752)
#\
datetime.datetime.time(date_t).isoformat()
Out[44]: '16:46:05.774752'