转载

time模块和datetime模块的内置函数

一、time模块

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

  a、timestamp时间戳,时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量

  b、struct_time时间元组,共有九个元素组。

  c、format time 格式化时间,已格式化的结构使时间更具可读性。包括自定义格式和固定格式。

1、时间格式转换图:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#! /usr/bin/env python
# -*- coding:utf-8 -*-
# __author__ = "TKQ"
 
import  time
 
# 生成timestamp
time.time()
# 1477471508.05
#struct_time to timestamp
time.mktime(time.localtime())
#生成struct_time
# timestamp to struct_time 本地时间
time.localtime()
time.localtime(time.time())
# time.struct_time(tm_year=2016, tm_mon=10, tm_mday=26, tm_hour=16, tm_min=45, tm_sec=8, tm_wday=2, tm_yday=300, tm_isdst=0)
 
# timestamp to struct_time 格林威治时间
time.gmtime()
time.gmtime(time.time())
# time.struct_time(tm_year=2016, tm_mon=10, tm_mday=26, tm_hour=8, tm_min=45, tm_sec=8, tm_wday=2, tm_yday=300, tm_isdst=0)
 
#format_time to struct_time
time.strptime( '2011-05-05 16:37:06' '%Y-%m-%d %X' )
# time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6, tm_wday=3, tm_yday=125, tm_isdst=-1)
 
#生成format_time
#struct_time to format_time
time.strftime( "%Y-%m-%d %X" )
time.strftime( "%Y-%m-%d %X" ,time.localtime())
# 2016-10-26 16:48:41
 
 
#生成固定格式的时间表示格式
time.asctime(time.localtime())
time.ctime(time.time())
# Wed Oct 26 16:45:08 2016

  

1
2
3
4
5
6
7
8
9
10
属性                            值
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 时区的名字(如果不存在为空字符)
%% ‘%’字符

常见结构化时间组合:

1
2
print  time.strftime( "%Y-%m-%d %X" )
#2016-10-26 20:50:13

3、time加减

1
2
3
4
5
6
7
#timestamp加减单位以秒为单位
import  time
t1  =  time.time()
t2 = t1 + 10
 
print  time.ctime(t1) #Wed Oct 26 21:15:30 2016
print  time.ctime(t2) #Wed Oct 26 21:15:40 2016

二、datetime模块

datatime模块重新封装了time模块,提供更多接口,提供的类有:date,time,datetime,timedelta,tzinfo。

1、date类

datetime.date(year, month, day)

静态方法和字段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
date. max 、date. min :date对象所能表示的最大、最小日期;
date.resolution:date对象表示日期的最小单位。这里是天。
date.today():返回一个表示当前本地日期的date对象;
date.fromtimestamp(timestamp):根据给定的时间戮,返回一个date对象;
 
from  datetime  import  *
import  time
 
print    'date.max:' , date. max
print    'date.min:' , date. min
print    'date.today():' , date.today()
print    'date.fromtimestamp():' , date.fromtimestamp(time.time())
 
#Output======================
# date.max: 9999-12-31
# date.min: 0001-01-01
# date.today(): 2016-10-26
# date.fromtimestamp(): 2016-10-26
 
output

方法和属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
d1  =  date( 2011 , 06 , 03 ) #date对象
d1.year、date.month、date.day:年、月、日;
d1.replace(year, month, day):生成一个新的日期对象,用参数指定的年,月,日代替原有对象中的属性。(原有对象仍保持不变)
d1.timetuple():返回日期对应的time.struct_time对象;
d1.weekday():返回weekday,如果是星期一,返回 0 ;如果是星期 2 ,返回 1 ,以此类推;
d1.isoweekday():返回weekday,如果是星期一,返回 1 ;如果是星期 2 ,返回 2 ,以此类推;
d1.isocalendar():返回格式如(year,month,day)的元组;
d1.isoformat():返回格式如'YYYY - MM - DD’的字符串;
d1.strftime(fmt):和time模块 format 相同。
 
 
from  datetime  import  *
 
now  =  date( 2016 10 26 )
tomorrow  =  now.replace(day  =  27 )
print  'now:' , now,  ', tomorrow:' , tomorrow
print  'timetuple():' , now.timetuple()
print  'weekday():' , now.weekday()
print  'isoweekday():' , now.isoweekday()
print  'isocalendar():' , now.isocalendar()
print  'isoformat():' , now.isoformat()
print  'strftime():' , now.strftime( "%Y-%m-%d" )
 
#Output========================
# now: 2016-10-26 , tomorrow: 2016-10-27
# timetuple(): time.struct_time(tm_year=2016, tm_mon=10, tm_mday=26, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=300, tm_isdst=-1)
# weekday(): 2
# isoweekday(): 3
# isocalendar(): (2016, 43, 3)
# isoformat(): 2016-10-26
# strftime(): 2016-10-26
 
output

2、time类

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

静态方法和字段

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

  方法和属性

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

  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from   datetime  import  *
 
tm  =  time( 23 46 10 )
print    'tm:' , tm
print    'hour: %d, minute: %d, second: %d, microsecond: %d'  %  (tm.hour, tm.minute, tm.second, tm.microsecond)
tm1  =  tm.replace(hour = 20 )
print    'tm1:' , tm1
print    'isoformat():' , tm.isoformat()
print    'strftime()' , tm.strftime( "%X" )
 
#Output==============================================
# tm: 23:46:10
# hour: 23, minute: 46, second: 10, microsecond: 0
# tm1: 20:46:10
# isoformat(): 23:46:10
# strftime() 23:46:10
 
output

  

3、datetime类

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

静态方法和字段

1
2
3
4
5
6
7
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对象;

  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from   datetime  import  *
import  time
 
print    'datetime.max:' , datetime. max
print    'datetime.min:' , datetime. min
print    'datetime.resolution:' , datetime.resolution
print    'today():' , datetime.today()
print    'now():' , datetime.now()
print    'utcnow():' , datetime.utcnow()
print    'fromtimestamp(tmstmp):' , datetime.fromtimestamp(time.time())
print    'utcfromtimestamp(tmstmp):' , datetime.utcfromtimestamp(time.time())
 
#output======================
# datetime.max: 9999-12-31 23:59:59.999999
# datetime.min: 0001-01-01 00:00:00
# datetime.resolution: 0:00:00.000001
# today(): 2016-10-26 23:12:51.307000
# now(): 2016-10-26 23:12:51.307000
# utcnow(): 2016-10-26 15:12:51.307000
# fromtimestamp(tmstmp): 2016-10-26 23:12:51.307000
# utcfromtimestamp(tmstmp): 2016-10-26 15:12:51.307000
 
output

  方法和属性

1
2
3
4
5
6
7
8
9
10
11
12
13
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类,时间加减

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

1
2
3
4
5
6
7
8
9
10
11
#coding:utf-8
from   datetime  import  *
 
dt  =  datetime.now()
#日期减一天
dt1  =  dt  +  timedelta(days = - 1 ) #昨天
dt2  =  dt  -  timedelta(days = 1 ) #昨天
dt3  =  dt  +  timedelta(days = 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

5、tzinfo时区类

 

 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#! /usr/bin/python
# coding=utf-8
 
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

datetime模块定义了下面这几个类:

datetime.date:表示日期的类。常用的属性有year, month, day;

datetime.time:表示时间的类。常用的属性有hour, minute, second, microsecond;

datetime.datetime:表示日期时间。

datetime.timedelta:表示时间间隔,即两个时间点之间的长度。

datetime.tzinfo:与时区有关的相关信息。(这里不详细充分讨论该类,感兴趣的童鞋可以参考python手册)

:上面这些类型的对象都是不可变(immutable)的。

date类:

表示一个日期。日期由年、月、日组成(地球人都知道~~)。date类的构造函数如下:

class datetime.date(year, month, day):参数的意义就不多作解释了,只是有几点要注意一下:

year的范围是[MINYEAR, MAXYEAR],即[1, 9999];

month的范围是[1, 12]。(月份是从1开始的,不是从0开始的~_~);

day的最大值根据给定的year, month参数来决定。例如闰年2月份有29天;

date类定义了一些常用的类方法与类属性,方便我们操作:

date.max、date.min:date对象所能表示的最大、最小日期;

date.resolution:date对象表示日期的最小单位。这里是天。

date.today():返回一个表示当前本地日期的date对象;

date.fromtimestamp(timestamp):根据给定的时间戮,返回一个date对象;

datetime.fromordinal(ordinal):将Gregorian日历时间转换为date对象;(Gregorian Calendar:一种日历表示方法,类似于我国的农历,西方国家使用比较多,此处不详细展开讨论。)

 
 
 
 

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

date.year、date.month、date.day:年、月、日;

date.replace(year, month, day):生成一个新的日期对象,用参数指定的年,月,日代替原有对象中的属性。(原有对象仍保持不变

date.timetuple():返回日期对应的time.struct_time对象;

date.toordinal():返回日期对应的Gregorian Calendar日期;

date.weekday():返回weekday,如果是星期一,返回0;如果是星期2,返回1,以此类推;

date.isoweekday():返回weekday,如果是星期一,返回1;如果是星期2,返回2,以此类推;

date.isocalendar():返回格式如(year,month,day)的元组;

date.isoformat():返回格式如'YYYY-MM-DD’的字符串;

date.strftime(fmt):自定义格式化字符串。

 
 
 
 

Time类

time类表示时间,由时、分、秒以及微秒组成。(我不是从火星来的~~)time类的构造函数如下:

class datetime.time(hour[, minute[, second[, microsecond[, tzinfo]]]]) :各参数的意义不作解释,这里留意一下参数tzinfo,它表示时区信息。注意一下各参数的取值范围:hour的范围为[0, 24),minute的范围为[0, 60),second的范围为[0, 60),microsecond的范围为[0, 1000000)。

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):返回自定义格式化字符串。在下面详细介绍;

 
 
 
 

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类定义的类属性与方法:

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对象;

 
 
 
 

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)

格式化字符串:

 
 
 
 
 
 

小礼物走一走,来简书关注我



作者:LittlePy
链接:https://www.jianshu.com/p/ce197a6a14ea
来源:简书
简书著作权归作者所有,任何形式的转载都请联系作者获得授权并注明出处。

转载于:https://www.cnblogs.com/kwkk978113/p/11262490.html

正文到此结束
本文目录