python中time和datetime模块的使用

一、time模块

time模块中时间表现的格式主要有三种：

时间戳time_stamp：时间戳表示的是时间从1970年1月1日00:00:00开始按秒计算的偏移量；
时间元组struct_time：共有九个元素组;
时间格式化format_time :已格式化的结构使时间更具可读性。包括自定义格式和固定格式

1、时间戳，时间元组和时间格式化三者之间的转换如下图：

获取当前的时间戳--time.time()
当传入默认的参数时，代表的是使用当前时间作为参数，图中带黄色底纹的都是设有默认值的参数（虽然默认值为None），函数2、3不传入该参数时，系统会自动获取当前时间的时间戳作为该参数值。而函数5则是系统会自动获取当前时间的时间元组作为该参数值。
localtime(函数2)和gmtime(函数3)都可以实现将时间戳转化成时间元组,只是localtime转化的是本地时间，gmtime转化的是世界标准时间
asctime（函数7）和ctime（函数8）只能转为为%a %b %d %H:%M:%S %Y格式的字符串时间。不传入参数时，用的也是当前时间。
struct_time时间元组结构：

属性                               值
tm_year（年）                  比如2011 
tm_mon（月）                   1 - 12
tm_mday（日）                  1 - 31
tm_hour（时）                  0 - 23
tm_min（分）                   0 - 59
tm_sec（秒）                   0 - 61
tm_wday（weekday）             0 - 6（0表示周日）
tm_yday（一年中的第几天）        1 - 366
tm_isdst（是否是夏令时）        默认为-1

时间格式化format time结构化表

格式	含义
%a	本地（locale）简化星期名称
%A	本地完整星期名称
%b	本地简化月份名称
%B	本地完整月份名称
%c	本地相应的日期和时间表示
%d	一个月中的第几天（01 - 31）
%H	一天中的第几个小时（24小时制，00 - 23）
%I	第几个小时（12小时制，01 - 12）
%j	一年中的第几天（001 - 366）
%m	月份（01 - 12）
%M	分钟数（00 - 59）
%p	本地am或者pm的相应符
%S	秒（01 - 61）
%U	一年中的星期数。（00 - 53星期天是一个星期的开始。）第一个星期天之前的所有天数都放在第0周。
%w	一个星期中的第几天（0 - 6，0是星期天）
%W	和%U基本相同，不同的是%W以星期一为一个星期的开始。
%x	本地相应日期
%X	本地相应时间
%y	去掉世纪的年份（00 - 99）
%Y	完整的年份
%Z	时区的名字（如果不存在为空字符）
%%	‘%’字符

time.time()

#获取当前时间戳
import time
time_stamp = time.time()
print('时间戳= %s' % time_stamp)
时间戳= 1646791111.73

time.localtime()

#获取时间元组 不传入参数
struct_time = time.localtime()
print(struct_time)
time.struct_time(tm_year=2022, tm_mon=3, tm_mday=9, tm_hour=11, tm_min=10, tm_sec=25, tm_wday=2, tm_yday=68, tm_isdst=0)

#获取时间元组 传入参数

struct_time = time.localtime(time.time())
print(struct_time)
time.struct_time(tm_year=2022, tm_mon=3, tm_mday=9, tm_hour=11, tm_min=10, tm_sec=25, tm_wday=2, tm_yday=68, tm_isdst=0)

#获取时间元组 传入其他时间戳
struct_time = time.localtime(1544200000.1232)
print(struct_time)
time.struct_time(tm_year=2018, tm_mon=12, tm_mday=8, tm_hour=0, tm_min=26, tm_sec=40, tm_wday=5, tm_yday=342, tm_isdst=0)

time.gmtime()

struct_time = time.gmtime()
print(struct_time)
time.struct_time(tm_year=2022, tm_mon=3, tm_mday=9, tm_hour=3, tm_min=24, tm_sec=14, tm_wday=2, tm_yday=68, tm_isdst=0)

print(struct_time.tm_year)
2022

time.mktime(p_tuple)

# 时间元组转化成时间戳
stamp_time = time.mktime(time.localtime())
print(stamp_time)
1646808956.0

time.strftime(fromat,p_tuple)

#元组转化成时间格式化  不传入参数 默认是当前时间
format_time = time.strftime('%Y-%m-%d %H:%M:%S')
print(format_time)
2022-03-09 14:58:51

format_time = time.strftime('%y-%m-%d')
print(format_time)
22-03-09

format_time = time.strftime('%Y-%m-%d')
print(format_time)
2022-03-09

format_time = time.strftime('%H:%M:%S')
print(format_time)
14:58:51

#元组转化成时间格式化  传入参数
format_time = time.strftime('%Y年%m月%d日 %H时%M分%S秒', time.localtime())
print(format_time)
2022年03月09日 14时58分51秒

time.strptime(string, format)

#format的格式必须与string的格式一致
strue_time = time.strptime('2022年03月09日 14时08分09秒',"%Y年%m月%d日 %H时%M分%S秒")
print(strue_time)
time.struct_time(tm_year=2022, tm_mon=3, tm_mday=9, tm_hour=14, tm_min=8, tm_sec=9, tm_wday=2, tm_yday=68, tm_isdst=-1)

time.asctime(p_tuple)

# #生成固定格式的时间表示格式
# #不传入参数
time_asc = time.asctime()
print(time_asc)
Wed Mar  9 15:02:58 2022

# 传入参数
time_asc = time.asctime(time.localtime())
print(time_asc)
Wed Mar  9 15:02:58 2022

time.ctring(seconds=None)

# 生成固定格式的时间表示格式
# 不传入参数
time_c = time.ctime()
print(time_c)
Wed Mar  9 15:04:40 2022

# 传入参数
time_c = time.ctime(1646807357.49)
print(time_c)
Wed Mar  9 14:29:17 2022

2、time加减

# 时间戳的加减是以秒为单位进行加减计算
t1 = time.time()
t2 = t1+10

print(time.ctime(t1))  #Wed Mar  9 15:07:26 2022
print(time.ctime(t2))  #Wed Mar  9 15:07:36 2022

二、datetime模块

　　datetime模块是time模块的进一步封装。datetime模块的功能主要都几种在datetime、date、time、timedelta、tzinfo五个类中。这五个类功能如下表所示：

　　(1)date:表示日期的类，主要属性有year、month和day。

　　(2)time:表示时间的类，主要属性有hour、minute、second、microsecond和tzinfo。

　　(3)datetime：表示日期和时间的组合类，常用的属性有year、month、day、hour、minute、second、microsecond和tzinfo。

　　(4)timedelta：表示时间间隔类，即两个时间点之间的长度。

　　(5)tzinfo：表示时区信息类。

1、date类

　　datetime.date(year,month, day)

静态方法和字段

date.max、date.min：date对象所能表示的最大、最小日期；
date.resolution：date对象表示日期的最小单位。这里是天。
date.today()：返回一个表示当前本地日期的date对象；
date.fromtimestamp(timestamp)：根据给定的时间戮，返回一个date对象；


import datetime
# datetime.date(year,month,day)
print'date.max:', datetime.date.max
print'date.min:', datetime.date.min
print'date.today():', datetime.date.today()
print'date.fromtimestamp():', datetime.date.fromtimestamp(time.time())

#output========
# date.max: 9999-12-31
# date.min: 0001-01-01
# date.today(): 2022-03-09
# date.fromtimestamp(): 2022-03-09

方法和属性

now = date(2022,3,9)#date对象
now.year、date.month、date.day：年、月、日；
now.replace(year, month, day)：生成一个新的日期对象，用参数指定的年，月，日代替原有对象中的属性。（原有对象仍保持不变）
now.timetuple()：返回日期对应的time.struct_time对象；
now.weekday()：返回weekday，如果是星期一，返回0；如果是星期2，返回1，以此类推；
now.isoweekday()：返回weekday，如果是星期一，返回1；如果是星期2，返回2，以此类推；
now.isocalendar()：返回格式如(year，month，day)的元组；
now.isoformat()：返回格式如'YYYY-MM-DD’的字符串；
now.strftime(fmt)：和time模块format相同。

import datetime
now = datetime.date(2022, 3, 9)
tommrow = now.replace(day=10)
print(f'now:{now},tommrow:{tommrow}')
print(f'year:{now.year},month:{now.month},day:{now.day}')
print(f'timetuple():{now.timetuple()}')
print(f'weekday()：{now.weekday()}')
print(f'isoweekday()：{now.isoweekday()}')
print(f'isocalendar()：{now.isocalendar()}')
print(f'isoformat()：{now.isoformat()}')
print(f'strftime()：{now.strftime("%Y-%m-%d")}')

#output===========
    now:2022-03-09,tommrow:2022-03-10
    year:2022,month:3,day:9
    timetuple():time.struct_time(tm_year=2022, tm_mon=3, tm_mday=9, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=68, tm_isdst=-1)
    weekday()：2
    isoweekday()：3
    isocalendar()：(2022, 10, 3)
    isoformat()：2022-03-09
    strftime()：2022-03-09

2、time类

datetime.time(hour, minute, second, microsecond,tzinfo)

静态方法和字段

time.min、time.max：time类所能表示的最小、最大时间。其中，time.min = time(0, 0, 0, 0)， time.max = time(23, 59, 59, 999999)；
time.resolution：时间的最小单位，这里是1微秒；

方法和属性

import datetime
# datetime.time(hour, minute, second, microsecond,tzinfo)
# now = datetime.time(10,23,15)#time对象
# now.hour、now.minute、now.second、now.microsecond：时、分、秒、微秒；
# now.tzinfo：时区信息；
# now.replace([ hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )：创建一个新的时间对象，用参数指定的时、分、秒、微秒代替原有对象中的属性（原有对象仍保持不变）；
# now.isoformat()：返回型如"HH:MM:SS"格式的字符串表示；
# now.strftime(fmt)：同time模块中的format；

now = datetime.time(20, 23,15)
tm1 = now.replace(hour=10)
print(f'now：{now}')
print(f'replace：{tm1}')
print(f'时:{now.hour},分:{now.minute}, 秒：{now.second},微妙：{now.microsecond}')
print(f'tzinfo:{now.tzinfo}')
print(f'isoformat:{now.isoformat()}')
print(f'strftime:{now.strftime("%X")}')

#out============
# now;20:23:15
# replace;10:23:15
# 时:20,分:23, 秒：15,微妙：0
# tzinfo:None
# isoformat:20:23:15
# strftime:20:23:15

3、datetime类

　　datetime相当于date和time结合起来。
　　datetime.datetime (year, month, day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )

静态方法和字段

import time
import datetime
# datetime.today()：返回一个表示当前本地时间的datetime对象；
# datetime.now([tz])：返回一个表示当前本地时间的datetime对象，如果提供了参数tz，则获取tz参数所指时区的本地时间；
# datetime.utcnow()：返回一个当前utc时间的datetime对象；#格林威治时间
# datetime.fromtimestamp(timestamp[, tz])：根据时间戮创建一个datetime对象，参数tz指定时区信息；
# datetime.utcfromtimestamp(timestamp)：根据时间戮创建一个datetime对象；
# datetime.combine(date, time)：根据date和time，创建一个datetime对象；
# datetime.strptime(date_string, format)：将格式字符串转换为datetime对象；

print(f'today:{datetime.datetime.today()}')
print(f'now:{datetime.datetime.now()}')
print(f'utcnow:{datetime.datetime.utcnow()}')
print(f'fromtimestamp:{datetime.datetime.fromtimestamp(time.time())}')
print(f'utcfromtimestamp:{datetime.datetime.utcfromtimestamp(time.time())}')
print(f'strptime:{datetime.datetime.strptime("2022-03-09 13:45:23", "%Y-%m-%d %H:%M:%S")}')


# out======
# today:2022-03-09 21:47:12.422018
# now:2022-03-09 21:47:12.423018
# utcnow:2022-03-09 13:47:12.423018
# fromtimestamp:2022-03-09 21:47:12.423018
# utcfromtimestamp:2022-03-09 13:47:12.423018
# strptime:2022-03-09 13:45:23

方法和属性

dt=datetime.now()#datetime对象
dt.year、month、day、hour、minute、second、microsecond、tzinfo：
dt.date()：获取date对象；
dt.time()：获取time对象；
dt.replace ([ year[ , month[ , day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] ] ] ])：
dt.timetuple ()
dt.utctimetuple ()
dt.toordinal ()
dt.weekday ()
dt.isocalendar ()
dt.isoformat ([ sep] )
dt.ctime ()：返回一个日期时间的C格式字符串，等效于time.ctime(time.mktime(dt.timetuple()))；
dt.strftime (format)

4、timedelta类用于时间之间的加减

　　datetime.timedelta(days, seconds, microseconds,milliseconds, minutes, hours,weeks)

　　使用timedelta可以很方便的在日期上做天days，小时hours，分钟minutes，秒seconds，毫秒，微妙以及星期的时间计算，如果要计算月份则需要另外的办法。

dt = datetime.datetime.now()
#日期减一天
dt1 = dt + datetime.timedelta(days=-1)#昨天
dt2 = dt - datetime.timedelta(days=1)#昨天
dt3 = dt + datetime.timedelta(hours=1)
delta_obj = dt3-dt
print(type(delta_obj),delta_obj) #<type 'datetime.timedelta'> 1 day, 0:00:00
print(delta_obj.days ,delta_obj.total_seconds()) #1 86400.0
print(dt)  #2022-03-09 21:57:19.166722
print(dt1) #2022-03-08 21:57:19.166722
print(dt2) #2022-03-08 21:57:59.201011
print(dt3)  #2022-03-09 22:57:59.201011

5、tzinfo时区类

from datetime import datetime, tzinfo,timedelta

"""
tzinfo是关于时区信息的类
tzinfo是一个抽象类，所以不能直接被实例化
"""
class UTC(tzinfo):
    """UTC"""
    def __init__(self,offset = 0):
        self._offset = offset

    def utcoffset(self, dt):
        return timedelta(hours=self._offset)

    def tzname(self, dt):
        return "UTC +%s" % self._offset

    def dst(self, dt):
        return timedelta(hours=self._offset)

#北京时间
beijing = datetime(2011,11,11,0,0,0,tzinfo = UTC(8))
print "beijing time:",beijing
#曼谷时间
bangkok = datetime(2011,11,11,0,0,0,tzinfo = UTC(7))
print "bangkok time",bangkok
#北京时间转成曼谷时间
print "beijing-time to bangkok-time:",beijing.astimezone(UTC(7))

#计算时间差时也会考虑时区的问题
timespan = beijing - bangkok
print "时差:",timespan

#Output==================
# beijing time: 2011-11-11 00:00:00+08:00
# bangkok time 2011-11-11 00:00:00+07:00
# beijing-time to bangkok-time: 2011-11-10 23:00:00+07:00
# 时差: -1 day, 23:00:00