python常用模块（一）---datetime模块和time模块

-字符串时间戳和字符串datetime转 datetime

def utc_timestamp_to_local_dt(time_stamp, formatter='%Y-%m-%d %H:%M:%S'):
    """
    时间戳转化为北京时间的 datetime 格式 (python默认时utc时间，需转化为本地时间)
    示例如下:
    > a = '2021-11-30 00:00:00'; b='1638007718'
    > c = time.strftime(formatter, time.localtime(int(b)))
    > c, type(c)
        ('2021-11-27 18:08:38', <class 'str'>)
    > d = datetime.datetime.strptime(c, formatter)
    > d, type(d)
        (datetime.datetime(2021, 11, 27, 18, 8, 38), <class 'datetime.datetime'>)
    > dd = datetime.datetime.strptime(a, formatter)
    > dd, type(dd)
        (datetime.datetime(2021, 11, 30, 0, 0), <class 'datetime.datetime'>)
    :param time_stamp: str TimeStamp
    :param formatter:
    :return:
    """
    if isinstance(time_stamp, datetime.datetime):
        return time_stamp.replace(microsecond=0)
    if len(str(time_stamp)) not in (10, 19):
        raise ValueError(
            "time_stamp should be strictly like '1990-01-12 00:00:01' "
            "with length 19 or '1638007718' with length 10")
    if len(str(time_stamp)) == 10:
        time_stamp = int(time_stamp)
        time_stamp = time.strftime(formatter, time.localtime(time_stamp))
    return datetime.datetime.strptime(time_stamp, formatter)

一、相关术语的解释

1. 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进行表示。
2. epoch time 表示时间开始的起点；它是一个特定的时间，不同平台上这个时间点的值不太相同，对于Unix而言，epoch time为 1970-01-01 00:00:00 UTC。
3. timestamp（时间戳） 也称为Unix时间 或 POSIX时间；它是一种时间表示方式，表示从格林尼治时间1970年1月1日0时0分0秒开始到现在所经过的毫秒数，其值为float类型。 但是有些编程语言的相关方法返回的是秒数（Python就是这样），这个需要看方法的文档说明。需要说明的是时间戳是个差值，其值与时区无关。

二、 时间表示形式

4. 时间戳
5. time模块的time.struct_time (多属性均可***.tm_xxx***调用)
6. datetime模块的datetime （属性可通过 ***.year/month/…***调用）
7. 格式化的时间字符串

三、 time模块和datetime模块的时间形式转换

8. 如图：
   
   

另外：
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模块函数列表

方法/属性	描述
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.time类

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.timedelta类
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'