python 日期时间

time 模块

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

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

import time

#当前时间戳
t1 = time.time()
print(t1)

#将时间戳转化为struct_time
t2 = time.localtime(t1)
print (t2)
print (time.localtime())
t22 = time.gmtime(t1)
print (t22)
print (time.gmtime())


#将time.struct_time转化为时间戳
t3 = time.mktime(t2)
print('t3 = ',t3,'\n')

#当前时间的自定义格式，str时间
t4 = time.strftime('%Y-%m-%d')
t44 = time.strftime('%Y-%m-%d %X')
print(type(t4))
print('t4 =',t4,'\n',t44)

#将str时间转化为time.struct_time，前后格式形式要对应
t5 = time.strptime(t4,'%Y-%m-%d')
print(type(t5))
print('t5 = ',t5,'\n')

#将time.struct_time转化为asctime形式
t6 = time.asctime(t2)
print(type(t6))
print('t6 = ',t6,'\n')

#将时间戳转化为str--%a %b %d %H %M %S %Y,形式为time.asctime()形式
t7 = time.ctime(t1) 
print('t7 = ',t7,'\n')
t77 = time.strftime('%c')
print('t77 =',t77,'\n')

import time

#当前时间戳
t1 = time.time()
print(t1)

#将时间戳转化为struct_time
t2 = time.localtime(t1)
print (t2)
print (time.localtime())
t22 = time.gmtime(t1)
print (t22)
print (time.gmtime())


#将time.struct_time转化为时间戳
t3 = time.mktime(t2)
print('t3 = ',t3,'\n')

#当前时间的自定义格式，str时间
t4 = time.strftime('%Y-%m-%d')
t44 = time.strftime('%Y-%m-%d %X')
print(type(t4))
print('t4 =',t4,'\n',t44)

#将str时间转化为time.struct_time，前后格式形式要对应
t5 = time.strptime(t4,'%Y-%m-%d')
print(type(t5))
print('t5 = ',t5,'\n')
或
f=time.strftime('%Y-%m-%d %H:%M:%S')
print(time.strptime(f,'%Y-%m-%d %H:%M:%S'))

#将time.struct_time转化为asctime形式
t6 = time.asctime(t2)
print(type(t6))
print('t6 = ',t6,'\n')

#将时间戳转化为str--%a %b %d %H %M %S %Y,形式为time.asctime()形式
t7 = time.ctime(t1) 
print('t7 = ',t7,'\n')
t77 = time.strftime('%c')
print('t77 =',t77,'\n')

1553556035.8537471
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=26, tm_hour=7, tm_min=20, tm_sec=35, tm_wday=1, tm_yday=85, tm_isdst=0)
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=26, tm_hour=7, tm_min=20, tm_sec=35, tm_wday=1, tm_yday=85, tm_isdst=0)
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=25, tm_hour=23, tm_min=20, tm_sec=35, tm_wday=0, tm_yday=84, tm_isdst=0)
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=25, tm_hour=23, tm_min=20, tm_sec=35, tm_wday=0, tm_yday=84, tm_isdst=0)
t3 =  1553556035.0 

<class 'str'>
t4 = 2019-03-26 
 2019-03-26 07:20:35
<class 'time.struct_time'>
t5 =  time.struct_time(tm_year=2019, tm_mon=3, tm_mday=26, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=85, tm_isdst=-1) 

<class 'str'>
t6 =  Tue Mar 26 07:20:35 2019 

t7 =  Tue Mar 26 07:20:35 2019 

t77 = Tue Mar 26 07:20:35 2019 

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    和%U基本相同，不同的是%W以星期一为一个星期的开始
%w    一个星期中的第几天（0 - 6，0是星期天）
%x    本地相应日期
%X    本地相应时间
%y    去掉世纪的年份（00 - 99）
%Y    完整的年份
%Z    时区的名字（如果不存在为空字符）
%%    ‘%’字符

print (time.strftime('%Y-%m-%d %X'))
print (time.strftime('%a %A %b %B'))
print (time.strftime('%c'))
print (time.strftime('%d'))
print (time.strftime('%j'))
print (time.strftime('%U'))
print (time.strftime('%W'))
print (time.strftime('%z'))

2019-03-26 07:20:36
Tue Tuesday Mar March
Tue Mar 26 07:20:36 2019
26
085
12
12
+0800

time.clock( )

用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用

time.sleep()

函数推迟调用线程的运行，可通过参数secs指秒数，表示进程挂起的时间
sleep()方法语法：
time.sleep(t) #t – 推迟执行的秒数

当前时间

d1 = datetime.datetime.today()
print(d1)

d2 = datetime.datetime.now()
print(d2)

两者一样的效果

now是本地时间，可以认为是你电脑现在的时间

utcnow是世界时间（时区不同，所以这两个是不一样的）

选择日期或时间

import datetime
#日期
da1 = datetime.datetime.date(datetime.datetime.today())
print(da1)
#时间
da2 = datetime.datetime.time(datetime.datetime.today())
print(da2)

时间转字符串

 日期输出格式化 datetime => string

import datetime
da = datetime.datetime.now().strftime('%Y-%m-%d %H:%M')
print(da)

字符串转时间

日期输出格式化 string => datetime

st = '2024-10-02 10:01'
print(datetime.datetime.strptime(st,'%Y-%m-%d %H:%M'))

日期比较操作

在datetime模块中有timedelta类，这个类的对象用于表示一个时间间隔，比如两个日期或者时间的差别。

#模板
import datetime
datetime.timedelta(day=0,hours=0,seconds=0,microseconds=0)

实例

d2 = datetime.datetime.now()
#说明：正数表示时间还没有到,负数表示时间已过去
dt1 = datetime.timedelta(days=1,hours=1,seconds=1,microseconds=1)
print(d2+dt1)
#负数,如用的着参数days,hours,seconds,microsecond就写上,不要则可不写
dt2 = datetime.timedelta(days=-1,hours=-1,seconds=-1,microseconds=-1)
print(d2+dt2)

时间戳(datetime与time)

timestamp()内部会根据时区设置得到时间戳，当时区为utc时间时timestamp()函数直接减去EPOCH得到的秒数

#datetime时间戳
from datetime import datetime

dt=datetime.now()

print(dt.timestamp())

结果：1718184963.568089


#time时间戳
import time

print(time.time())

结果：1718184963.5681033

时间戳转当前时间

timestamp转datetime

获得本地时间

from datetime import datetime
timestamp=datetime.now().timestamp()
print(datetime.fromtimestamp(timestamp))
#类型naive datetime object

timestamp转utc datetime

两种方式获得utc时间，但datetime object类型不一样。

方式一：

from datetime import datetime
timestamp=datetime.now().timestamp()
print(datetime.utcfromtimestamp(timestamp))
#类型naive datetime object

方式二：

总结：
timestamp没有时区之分，不要认为不同时区有不同的时间戳。
datetime object有两种类型，naive是不含时区的类型，而aware是有时区类型，就算显示的值一样，不同类型的object也不能直接进行数学运算。

datetime模块

datetime.date：表示日期的类。常用的属性有year, month, day
datetime.time：表示时间的类。常用的属性有hour, minute, second, microsecond
datetime.datetime：表示日期时间
datetime.timedelta：表示时间间隔，即两个时间点之间的长度
datetime.tzinfo：与时区有关的相关信息

from datetime import *
import time

date类

date类表示一个日期。日期由年、月、日组成。

date类的构造函数如：class datetime.date(year, month, day)

date类定义了一些常用的类方法与类属性：

date.max、date.min：date对象所能表示的最大、最小日期； 
date.resolution：date对象表示日期的最小单位。这里是天。 
date.today()：返回一个表示当前本地日期的date对象； 
date.fromtimestamp(timestamp)：根据给定的时间戮，返回一个date对象； 
date.fromordinal(ordinal)：将Gregorian日历时间转换为date对象；（Gregorian Calendar ：一种日历表示方法，类似于我国的农历，西方国家使用比较多，此处不详细展开讨论。） 

print (date.max)
print (date.min)
print (date.resolution)
print (date.today())

t0 = time.time()
print (t0)
print (date.fromtimestamp(t0))
t1 = date.toordinal(date.today())
print (t1)
print (date.fromordinal(t1))

9999-12-31
0001-01-01
1 day, 0:00:00
2019-03-26
1553556036.3595684
2019-03-26
737144
2019-03-26

date提供的实例方法和属性:

t2 = date.today()
print (t2)
print (t2.year,t2.month,t2.day)
或
t2 = date.today().date()
print (t2)
print (t2.year,t2.month,t2.day)


# 生成新的日期，对原来的日期没有做改动
t3 = t2.replace(2019,2,28)
print (t2,id(t2))
print (t3,id(t3))

# date转化为time.struct_time对象
t4 = t2.timetuple()
print (t4)

# 查看星期几
w1 = t2.weekday()
print (w1)
w2 = t2.isoweekday()
print (w2)

t5 = t2.isocalendar()
print (t5,t5[0])

t6 = t2.isoformat()
print (t6)

# date转化为指定格式time
t7 = t2.strftime('%Y-%m-%d')
print (t7)
t77 = t2.strftime('%Y-%m-%d %X')
print (t77)

2019-03-26
2019 3 26
2019-03-26 2255488638032
2019-02-28 2255488637616
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=26, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=85, tm_isdst=-1)
1
2
(2019, 13, 2) 2019
2019-03-26
2019-03-26
2019-03-26 00:00:00

date还对某些操作进行了重载，它允许我们对日期进行如下一些操作：

date2 = date1 + timedelta # 日期加上一个间隔，返回一个新的日期对象（timedelta将在下面介绍，表示时间间隔）
date2 = date1 - timedelta # 日期隔去间隔，返回一个新的日期对象
timedelta = date1 - date2 # 两个日期相减，返回一个时间间隔对象
date1 < date2             # 两个日期进行比较

timedelta = t2 - t3
print (timedelta)
t8 = t3 + timedelta
print (t8)
t9 = t2 - timedelta
print (t9)
print (t3 < t2)

26 days, 0:00:00
2019-03-26
2019-02-28
True

time类

time类表示时间，由时、分、秒以及微秒组成。

time类的构造函数如下：class datetime.time(hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] )

time类定义的类属性：

time.min、time.max：time类所能表示的最小、最大时间。其中，time.min = time(0, 0, 0, 0)，time.max = time(23, 59, 59, 999999)；
time.resolution：时间的最小单位，这里是1微秒；
time类提供的实例方法和属性：
time.hour、time.minute、time.second、time.microsecond：时、分、秒、微秒；
time.tzinfo：时区信息；
time.replace([ hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ]] ] )：创建一个新的时间对象，用参数指定的时、分、秒、微秒代替原有对象中的属性（原有对象仍保持不变）；
time.isoformat()：返回型如”HH:MM:SS”格式的字符串表示；
time.strftime(fmt)：返回自定义格式化字符串

from datetime import time as dtime

print (dtime.min)
print (dtime.max)
print (dtime.resolution)

t0 = datetime.now()
print (t0)

t1 = t0.time()
print (t1)
print (t1.hour,t1.minute,t1.second,t1.microsecond)

t2 = t1.replace(18,0,0,0)
print (t1)
print (t2)

print (t1.isoformat())
print (t0.strftime('%X'))

00:00:00
23:59:59.999999
0:00:00.000001
2019-03-26 07:20:37.066138
07:20:37.066138
7 20 37 66138
07:20:37.066138
18:00:00
07:20:37.066138
07:20:37

time类不能进行相加减操作，如果只是简单的时间相加减没有意义，必须带上日期相比较才行

datetime类
datetime是date与time的结合体，包括date与time的所有信息。

它的构造函数如下：datetime.datetime (year, month, day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )，各参数的含义与date、time的构造函数中的一样，要注意参数值的范围。

datetime类定义的类属性与方法：

datetime.min、datetime.max：datetime所能表示的最小值与最大值；
datetime.resolution：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对象,format与date_string格式要一致；

print (datetime.min)
print (datetime.max)

# 创建指定日期
tt = datetime(2018,5,20)
print (tt)

t0 = datetime.today()
t00 = datetime.now()
t01 = datetime.utcnow()
print (t0)
print (t00)
print (t01)

t1 = t0.timestamp()
print (t1)
t2 = datetime.fromtimestamp(t1)
print (t2)

date0 = t0.date()
print (date0)
time0 = t0.time()
print (time0)
t3 = datetime.combine(date0,time0)
print (t3)

t4 = t3.strftime('%Y-%m-%d %X')
print (t4,type(t4))
t5 = datetime.strptime(t4,'%Y-%m-%d %X')
print (t5)

0001-01-01 00:00:00
9999-12-31 23:59:59.999999
2018-05-20 00:00:00
2019-03-26 07:20:37.190235
2019-03-26 07:20:37.190235
2019-03-25 23:20:37.191235
1553556037.190235
2019-03-26 07:20:37.190235
2019-03-26
07:20:37.190235
2019-03-26 07:20:37.190235
2019-03-26 07:20:37 <class 'str'>
2019-03-26 07:20:37

datetime类是date类与time类的结合，其实例属性与方法也在前面date类与time类中出现，其中有：

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

datetime、date、time都提供了strftime()方法，格式字符串

timedelta 对象

timedelta 对象表示两个日期或时间之间的间隔。

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

以上所有的参数都是可选的（默认为 0），参数的可以是整数或浮点数，正数或负数。

内部的存储单位只有 days（天）、seconds（秒）、microseconds（毫秒），其他单位均先转换后再存储

1 millisecond = 1000 microseconds
1 minute = 60 seconds
1 hour = 3600 seconds
1 week = 7 days

timedelta 实例方法：

timedelta.total_seconds() 返回 timedelta 对象所包含的总秒数，相当于timedelta(seconds=1)

from datetime import timedelta
t1 = datetime.now()
print (t1)

# 加一秒
t3 = t1 + timedelta(seconds = 1)
print (t3)

# 加一分钟
t4 = t1 + timedelta(minutes = 1)
print (t4)

#加一小时
t5 = t1 + timedelta(hours = 1)
print (t5)

# 加一天
t6 = t1 + timedelta(days = 1)
print (t6)

# 加一个星期
t7 = t1 + timedelta(weeks = 1)
print (t7)

# timedelta转化为其对应的秒数
dt1 = t6 - t1
print (dt1)
dt11 = dt1.total_seconds()
print (dt11)

2019-03-26 07:20:37.385598
2019-03-26 07:20:38.385598
2019-03-26 07:21:37.385598
2019-03-26 08:20:37.385598
2019-03-27 07:20:37.385598
2019-04-02 07:20:37.385598
1 day, 0:00:00
86400.0