常见的有三种，日期元祖、time与datetime
调用源码如下：
y=datetime.datetime(int(get_data[7][0:4]),int(get_data[7][4:6]),int(get_data[7][6:8]),int(get_data[8][0:2]),int(get_data[8][2:4]),int(get_data[8][4:6]),000000) y=datetime.datetime.now() + datetime.timedelta(seconds=2*int(get_data[16])-2) #比现在+2s y=datetime.datetime.now() + datetime.timedelta(microseconds=i*1000) #比现在+1ms starttime = "'"+str(y.year)+"-"+str(y.month)+"-"+str(y.day)+" "+str(y.hour)+":"+str(y.minute)+":"+str(y.second)+"."+str(y.microsecond)+"'" #cv.line(src,(i - 3,100),(i + 5,900),(255,0,0),4) insert_lightning(file_name,"I",starttime,starttime,y_list[i],start_longitude,start_latitude,end_longitude,end_latitude,i,0,i,0)
datetime赋值函数如下：
datetime(year,month,day,hour,min,seconds,microseconds)
日期元祖结构体:
日期元祖格式化：
%y 两位数的年份表示（00-99） %Y 四位数的年份表示（000-9999） %m 月份（01-12） %d 月内中的一天（0-31） %H 24小时制小时数（0-23） %I 12小时制小时数（01-12） %M 分钟数（00=59） %S 秒（00-59） %a 本地简化星期名称 %A 本地完整星期名称 %b 本地简化的月份名称 %B 本地完整的月份名称 %c 本地相应的日期表示和时间表示 %j 年内的一天（001-366） %p 本地A.M.或P.M.的等价符 %U 一年中的星期数（00-53）星期天为星期的开始 %w 星期（0-6），星期天为星期的开始 %W 一年中的星期数（00-53）星期一为星期的开始 %x 本地相应的日期表示 %X 本地相应的时间表示 %Z 当前时区的名称 %% %号本身
时间相关操作，时间有三种表示方式：
- 时间戳 1970年1月1日之后的秒，即：time.time()
- 格式化的字符串 2014-11-11 11:11， 即：time.strftime('%Y-%m-%d')
- 结构化时间 元组包含了：年、日、星期等... time.struct_time 即：time.localtime()
time.time()
|
1
2
3
4
5
|
返回当前时间的时间戳（
1970
纪元后经过的浮点秒数）。
时间戳单位最适于做日期运算。但是
1970
年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到
2038
年。
>>>
import
time
>>>
print
(time.time())
1459999336.1963577
|
time.mktime(tupletime)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
接受时间元组并返回时间辍（
1970
纪元后经过的浮点秒数）。
Python time.mktime() 函数执行与gmtime(), localtime()相反的操作，它接收struct_time对象作为参数，返回用秒数来表示时间的浮点数。
如果输入的值不是一个合法的时间，将触发 OverflowError 或 ValueError。
#!/usr/bin/python3
import
time
t
=
(
2016
,
2
,
17
,
17
,
3
,
38
,
1
,
48
,
0
)
secs
=
time.mktime( t )
print
(
"time.mktime(t) : %f"
%
secs)
print
(
"asctime(localtime(secs)): %s"
%
time.asctime(time.localtime(secs)))
以上实例输出结果为：
time.mktime(t) :
1455699818.000000
asctime(localtime(secs)): Wed Feb
17
17
:
03
:
38
2016
|
time.gmtime([secs])
|
1
2
3
4
|
接收时间辍（
1970
纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。注：t.tm_isdst始终为
0
>>>
import
time
>>>
print
(
"gmtime :"
, time.gmtime(
1455508609.34375
))
gmtime : time.struct_time(tm_year
=
2016
, tm_mon
=
2
, tm_mday
=
15
, tm_hour
=
3
, tm_min
=
56
, tm_sec
=
49
, tm_wday
=
0
, tm_yday
=
46
, tm_isdst
=
0
)
|
time.localtime([secs])
|
1
2
3
4
|
接收时间辍（
1970
纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取
0
或
1
，取决于当地当时是不是夏令时）。
>>>
import
time
>>>
print
(
"localtime(): "
, time.localtime(
1455508609.34375
))
localtime(): time.struct_time(tm_year
=
2016
, tm_mon
=
2
, tm_mday
=
15
, tm_hour
=
11
, tm_min
=
56
, tm_sec
=
49
, tm_wday
=
0
, tm_yday
=
46
, tm_isdst
=
0
)
|
time.mktime(tupletime)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
接受时间元组并返回时间辍（
1970
纪元后经过的浮点秒数）。
Python time mktime() 函数执行与gmtime(), localtime()相反的操作，它接收struct_time对象作为参数，返回用秒数来表示时间的浮点数。
如果输入的值不是一个合法的时间，将触发 OverflowError 或 ValueError。
#!/usr/bin/python3
import
time
t
=
(
2016
,
2
,
17
,
17
,
3
,
38
,
1
,
48
,
0
)
secs
=
time.mktime( t )
print
(
"time.mktime(t) : %f"
%
secs)
print
(
"asctime(localtime(secs)): %s"
%
time.asctime(time.localtime(secs)))
以上实例输出结果为：
time.mktime(t) :
1455699818.000000
asctime(localtime(secs)): Wed Feb
17
17
:
03
:
38
2016
|
time.strftime(fmt[,tupletime])
|
1
2
3
4
5
|
接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。
>>>
import
time
>>>
print
(time.strftime(
"%Y-%m-%d %H:%M:%S"
, time.localtime()))
2016
-
04
-
07
11
:
18
:
05
|
time.strptime(str,fmt='%a %b %d %H:%M:%S %Y')
|
1
2
3
4
5
|
根据fmt的格式把一个时间字符串解析为时间元组。
>>>
import
time
>>> struct_time
=
time.strptime(
"30 Nov 00"
,
"%d %b %y"
)
>>>
print
(
"返回元组: "
, struct_time)
返回元组: time.struct_time(tm_year
=
2000
, tm_mon
=
11
, tm_mday
=
30
, tm_hour
=
0
, tm_min
=
0
, tm_sec
=
0
, tm_wday
=
3
, tm_yday
=
335
, tm_isdst
=
-
1
)
|
time.altzone
|
1
2
3
4
|
返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。
>>>
import
time
>>>
print
(
"time.altzone %d "
%
time.altzone)
time.altzone
-
28800
|
time.asctime([tupletime])
|
1
2
3
4
5
|
接受时间元组并返回一个可读的形式为
"Tue Dec 11 18:07:14 2008"
（
2008
年
12
月
11
日 周二
18
时
07
分
14
秒）的
24
个字符的字符串。
>>>
import
time
>>> t
=
time.localtime()
>>>
print
(
"time.asctime(t): %s "
%
time.asctime(t))
time.asctime(t): Thu Apr
7
10
:
36
:
20
2016
|
time.clock()
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。
#!/usr/bin/python3
import
time
def
procedure():
time.sleep(
2.5
)
# time.clock
t0
=
time.clock()
procedure()
print
(time.clock()
-
t0)
# time.time
t0
=
time.time()
procedure()
print
(time.time()
-
t0)
以上实例输出结果为：
5.000000000000143e
-
05
2.5020556449890137
|
time.ctime([secs])
|
1
2
3
4
|
作用相当于asctime(localtime(secs))，未给参数相当于asctime()
>>>
import
time
>>>
print
(
"time.ctime() : %s"
%
time.ctime())
time.ctime() : Thu Apr
7
10
:
51
:
58
2016
|
time.sleep(secs)
|
1
2
3
4
5
6
7
|
推迟调用线程的运行，secs指秒数。
#!/usr/bin/python3
import
time
print
(
"Start : %s"
%
time.ctime())
time.sleep(
5
)
print
(
"End : %s"
%
time.ctime())
|
time.tzset()
|
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
|
根据环境变量TZ重新初始化时间相关设置。
标准TZ环境变量格式：
std offset [dst [offset [,start[
/
time], end[
/
time]]]]
参数：
std 和 dst:三个或者多个时间的缩写字母。传递给 time.tzname.
offset: 距UTC的偏移，格式： [
+
|
-
]hh[:mm[:ss]] {h
=
0
-
23
, m
/
s
=
0
-
59
}。
start[
/
time], end[
/
time]: DST 开始生效时的日期。格式为 m.w.d — 代表日期的月份、周数和日期。w
=
1
指月份中的第一周，而 w
=
5
指月份的最后一周。
'start'
和
'end'
可以是以下格式之一：
Jn: 儒略日 n (
1
<
=
n <
=
365
)。闰年日（
2
月
29
）不计算在内。
n: 儒略日 (
0
<
=
n <
=
365
)。 闰年日（
2
月
29
）计算在内
Mm.n.d: 日期的月份、周数和日期。w
=
1
指月份中的第一周，而 w
=
5
指月份的最后一周。
time:（可选）DST 开始生效时的时间（
24
小时制）。默认值为
02
:
00
（指定时区的本地时间）。
#!/usr/bin/python3
import
time
import
os
os.environ[
'TZ'
]
=
'EST+05EDT,M4.1.0,M10.5.0'
time.tzset()
print
(time.strftime(
'%X %x %Z'
))
os.environ[
'TZ'
]
=
'AEST-10AEDT-11,M10.5.0,M3.5.0'
time.tzset()
print
(time.strftime(
'%X %x %Z'
))
以上实例输出结果为：
23
:
25
:
45
04
/
06
/
16
EDT
13
:
25
:
45
04
/
07
/
16
AEST
|
time.timezone
|
1
|
属性time.timezone是当地时区（未启动夏令时）距离格林威治的偏移秒数（>
0
，美洲;<
=
0
大部分欧洲，亚洲，非洲）。
|
time.tzname
|
1
|
属性time.tzname包含一对根据情况的不同而不同的字符串，分别是带夏令时的本地时区名称，和不带的。
|
时间装换图：
三. datetime模块
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
print
(datetime.now())
# 获取当前时间 2015-03-29 16:23:20.618564
print
(datetime.date.fromtimestamp(time.time()
-
864400
) )
#2016-01-16 将时间戳转成日期格式
current_time
=
datetime.datetime.now()
#
print
(current_time)
#输出2016-01-26 19:04:30.335935
print
(current_time.timetuple())
#返回struct_time格式
#datetime.replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]])
print
(current_time.replace(
2014
,
9
,
12
))
#输出2014-09-12 19:06:24.074900,返回当前时间,但指定的值将被替换
str_to_date
=
datetime.datetime.strptime(
"21/11/06 16:30"
,
"%d/%m/%y %H:%M"
)
#将字符串转换成日期格式
new_date
=
datetime.datetime.now()
+
datetime.timedelta(days
=
10
)
#比现在加10天
new_date
=
datetime.datetime.now()
+
datetime.timedelta(days
=
-
10
)
#比现在减10天
new_date
=
datetime.datetime.now()
+
datetime.timedelta(hours
=
-
10
)
#比现在减10小时
new_date
=
datetime.datetime.now()
+
datetime.timedelta(seconds
=
120
)
#比现在+120s
print
(new_date)
|
datetime转换为timestamp
|
1
2
3
4
|
>>>
from
datetime
import
datetime
>>> dt
=
datetime(
2017
,
3
,
29
,
12
,
20
)
# 用指定日期创建datetime
>>> dt.timestamp()
# 把datetime转换为timestamp
1490761200.0
|
在Python中的时间戳是一个浮点小数，如果有小数位，小数位表示毫秒数。其他如Java和JavaScript中的时间戳使用整数表示毫秒数，这种情况下只需要将时间戳除以1000就可以得到和Python一样的浮点表示法。
timestamp 转换为 datetime
|
1
2
3
4
5
6
|
>>>
from
datetime
import
datetime
>>> t
=
1490761200.0
>>>
print
(datetime.fromtimestamp(t))
# 本地时间转换
2017
-
03
-
29
12
:
20
:
00
>>>
print
(datetime.utcfromtimestamp(t))
# UTC时间转换
2017
-
03
-
29
04
:
20
:
00
|
str转换为datetime
|
1
2
3
4
|
>>>
from
datetime
import
datetime
>>> cday
=
datetime.strptime(
'2016-01-03 16:15:56'
,
'%Y-%m-%d %H:%M:%S'
)
>>>
print
(cday)
2016
-
01
-
03
16
:
|