python 字符串和时间转换

'''
* datestr转换成secs
* 将时间字符串转化为秒("2012-07-20 00:00:00"->1342713600.0)
* @param datestr;
* @return secs;
*
'''
def datestr2secs(datestr):
    tmlist = []
    array = datestr.split(' ')
    array1 = array[0].split('-')
    array2 = array[1].split(':')
    for v in array1:
        tmlist.append(int(v))
    for v in array2:
        tmlist.append(int(v))
    tmlist.append(0)
    tmlist.append(0)
    tmlist.append(0)
    if len(tmlist) != 9:
        return 0
    return int(time.mktime(tmlist))


'''
* secs转换成datestr
* 将秒转化为时间字符串(1342713600.0->"2012-07-20 00:00:00")
* @param secs;
* @return datestr;
*
'''
def secs2datestr(secs):
    if int(secs) < 0:
        return ""
    return str(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(secs)))


'''
* datestr转换成datestr
* 将时间字符串转化为时间字符串("2012-07-20"->"2012-07-20 00:00:00")
* @param datestr;
* @return datestr;
*
'''
def datestr2datestr(datestr):
    # 字符串->time
    datestr = time.strptime(datestr, "%Y-%m-%d")
    # time->字符串
    datestr = time.strftime("%Y-%m-%d %H:%M:%S", datestr)
    # 字符串->time
#    datestr = time.strptime(datestr, "%Y-%m-%d %X")
    # time->datetime
#    datestr=datetime.datetime(datestr[0],datestr[1],datestr[2],datestr[3],datestr[4],datestr[5])
    return datestr


'''
* 获得当前时间：time.time()返回的值是表示时间的秒数
* 秒数转换为time类型:time.localtime(time.time())返回'time.struct_time'类型
* time转换成datetime：datetime.datetime(*(time.localtime(time.time()))[:6])返回'datetime.datetime'类型
* @return datetime_value;
*
'''
def get_current_datetime():
    datetime_value = datetime.datetime(*(time.localtime(time.time()))[:6])
    return datetime_value

 

python获取当前系统时间:

nowTime=time.localtime()

获取当前系统日期:

nowDate=datetime.datetime(nowTime[0],nowTime[1],nowTime[2])

 

字符串转换成时间 string -> time 和 time  -> string  和 time ->  datetime:

date="2012-04-05"

print  type(date)                  #查看date的类型

 

date=time.strptime(date,"%Y-%m-%d")                           #字符串转换成time类型

print  type(date)                 #查看date的类型

date=time.strftime("%Y-%m-%d",date)                             #time类型转换成字符串类型

print type(date) #查看date的类型

 

date="2012-04-05"

date=time.strptime(date,"%Y-%m-%d")                            #字符串转换成time类型

print type(date) #查看date的类型

date=datetime.datetime(date[0],date[1],date[2])               #time类型转换成datetime类型

print type(date) #查看date的类型

 

 

计算两个日志之间的时间查:

d1 = datetime.datetime(2005, 2, 16)
d2 = datetime.datetime(2004, 12, 31)

# 结果:47
print (d1 - d2).days

#上例演示了计算两个日期相差天数的计算。

starttime = datetime.datetime.now()

endtime = datetime.datetime.now()
print (endtime - starttime).seconds

#上例演示了计算运行时间的例子，以秒进行显示。

d1 = datetime.datetime.now()
d3 = d1 + datetime.timedelta(days =10)

print str(d3)
print d3.ctime()

# 上例演示了计算当前时间向后10天的时间。
# 如果是小时 days 换成 hours

 

 

 

1.替换字符串--replace(old,new[,max]):替换字符串中找到的old为new,如果字符串中找到了多个old字串,则可使用max指定替换多少个old(默认是替换所有),再有的就是.如果在字符串没有找到old字串.则返回原字符串

>>> str ='AAAAABBBBBDDDDD'

>>>str.replace('D','C')#把字符串中所有的D替换为C

'AAAAABBBBBCCCCC'

>>>str.replace('A','a',3)#替换字符串中的3个A为a

'aaaAABBBBCCCCC'#replace()函数的操作不会影响原字符串.只是拷贝原字符串然后进行操作而已

2.字符串与时间格式的转换

首先看看格式化日期的时候常用到的标记

%a 星期几的简写 Weekday name, abbr.
　　%A 星期几的全称 Weekday name, full
　　%b 月分的简写 Month name, abbr.
　　%B 月份的全称 Month name, full
　　%c 标准的日期的时间串 Complete date and time representation
　　%d 十进制表示的每月的第几天 Day of the month
　　%H 24小时制的小时 Hour (24-hour clock)
　　%I 12小时制的小时 Hour (12-hour clock)
　　%j 十进制表示的每年的第几天 Day of the year
　　%m 十进制表示的月份 Month number
　　%M 十时制表示的分钟数 Minute number
　　%S 十进制的秒数 Second number
　　%U 第年的第几周，把星期日做为第一天（值从0到53）Week number (Sunday first weekday)
　　%w 十进制表示的星期几（值从0到6，星期天为0）weekday number
　　%W 每年的第几周，把星期一做为第一天（值从0到53） Week number (Monday first weekday)
　　%x 标准的日期串 Complete date representation (e.g. 13/01/08)
　　%X 标准的时间串 Complete time representation (e.g. 17:02:10)
　　%y 不带世纪的十进制年份（值从0到99）Year number within century
　　%Y 带世纪部分的十制年份 Year number
　　%z，%Z 时区名称，如果不能得到时区名称则返回空字符。Name of time zone
　　%% 百分号

①时间转为字符串--strftime(format[,tuple]),其中format为转换格式类型tuple为一个时间元组

>>> importtime#由于获取时间和使用转换函数需用到time模块.所以必须导入

>>> str =time.strftime('%Y-%m-%d %X',time.localtime())#time,localtime()返回以本地时间的所有参数为元素的元组

>>> print str

2009-12-09 21:36:35

②字符串转为时间--需要用到time模块strptime()函数和datetime模块datetime()函数

strptime(string,format)--把字符串string以format的格式返回一个时间的元组(元组内有齐全的时间元素,但是如果字符串中只有几个有用的时间信息,其他的元素默认或取本地时间的一些信息)

>>> str ='2009/12/09'

>>> str =time.strptime(str,'%Y/%m/%d')#注意后面的获取字符串中的时间的格式.对应原字符串中年月日之间的间隔符号

>>> print str

time.struct_time(tm_year=2009, tm_mon=12, tm_mday=9, tm_hour=0,tm_min=0, tm_sec

=0, tm_wday=2, tm_yday=343,tm_isdst=-1)#可以注意到元组中前三个元素都是刚才字符串中得到的值,后面的信息都没没获取到

datetime(year,month,day[,hour[,minute[,second[,microsecend[,tzinfo]]]]]) 函数返回一个datetime类型的变量,这是一种特殊的变量,也就是说,时间型的

>>> str =datetime.datetime(2009,12,9)#定义一个datetime变量,注意后面参数中的月或日,只能单写也就是说,9月或9日不能写成09月或09日,必须单写

>>> print str

2009-12-09 00:00:00#但显示却会显示完整的,比如其中的9日显示为了09日,还有,默认时分秒为0

>>> type(str)

#这里可以看到刚才定义的str为这种类型的变量最后再把上面这两个函数结合起来完整的完成字符串到时间的转换:

>>> importtime,datetime#首先导入两个使用到的模块

>>> string ='2009-12-09'

>>> string =time.strptime(string,'%Y-%m-%d')#首先把字符串使用strptime()返回一个时间元素构成的元组

>>> y, m, d =string[0:3]#把得到的时间元组前三个元素赋值给三个变量(也就是年月日)

>>> string =datetime.datetime(y, m, d)#最后使用datetime把刚才得到的时间变量转为正式的时间格式变量

>>> printstring

2009-12-09 00:00:00#至此,可以说完成了字符串到时间的转换(注意是变量类型转换的过程)

 

1）秒数 ==》字符串

1234567 from time import *  def secs2str(secs):         return strftime("%Y-%m-%d %H:%M:%S",localtime(secs))   >>> secs2str(1227628280.0) '2008-11-25 23:51:20'

2)字符串 ==》 秒数

123456 from time import *#先将时间字符串解析为9元组，例如： #2008-11-25 23:51:20,解析为9元组：[2008,11,25,23,51,20,0,0,0]。 >>> tmlist = [2008,11,25,23,51,20,0,0,0] >>> mktime(tmlist) 1227628280.0

完整的函数:

12345678910 def secs2str(secs):     """ 将秒转化为字符串 """    if int(secs) < 0:         return ""     return str(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(secs))) def str2secs(tmlist=[]):     """ 将字符串的时间转化为秒 """    if len(tmlist) != 9:         return 0    return int(time.mktime(tmlist))

Python的time模块的部分翻译:
一、简介

time模块提供各种操作时间的函数
说明：一般有两种表示时间的方式:
第一种是时间戳的方式(相对于1970.1.1 00:00:00以秒计算的偏移量),时间戳是惟一的
第二种以数组的形式表示即(struct_time),共有九个元素，分别表示，同一个时间戳的struct_time会因为时区不同而不同

year (four digits, e.g. 1998)
month (1-12)
day (1-31)
hours (0-23)
minutes (0-59)
seconds (0-59)
weekday (0-6, Monday is 0)
Julian day (day in the year, 1-366)
DST (Daylight Savings Time) flag (-1, 0 or 1) 是否是夏令时
If the DST flag is 0, the time is given in the regular time zone;
if it is 1, the time is given in the DST time zone;
if it is -1, mktime() should guess based on the date and time.

二、函数介绍
1.asctime()
asctime([tuple]) -> string
将一个struct_time(默认为当时时间)，转换成字符串
Convert a time tuple to a string, e.g. ‘Sat Jun 06 16:26:11 1998′.
When the time tuple is not present, current time as returned by localtime()
is used.

2.clock()
clock() -> floating point number
该函数有两个功能，
在第一次调用的时候，返回的是程序运行的实际时间；
以第二次之后的调用，返回的是自第一次调用后,到这次调用的时间间隔

示例：

view plaincopy to clipboardprint?
import time
if __name__ == '__main__':
    time.sleep(1)
    print "clock1:%s" % time.clock()
    time.sleep(1)
    print "clock2:%s" % time.clock()
    time.sleep(1)
    print "clock3:%s" % time.clock()输出：
clock1:3.35238137808e-006
clock2:1.00004944763
clock3:2.00012040636
其中第一个clock输出的是程序运行时间
第二、三个clock输出的都是与第一个clock的时间间隔

3.sleep(…)
sleep(seconds)
线程推迟指定的时间运行，经过测试，单位为秒，但是在帮助文档中有以下这样一句话，这关是看不懂
“The argument may be a floating point number for subsecond precision.”

4.ctime(…)
ctime(seconds) -> string
将一个时间戳(默认为当前时间)转换成一个时间字符串
例如：

  time.ctime()输出为：’Sat Mar 28 22:24:24 2009′

5.gmtime(…)
gmtime([seconds]) -> (tm_year, tm_mon, tm_day, tm_hour, tm_min,tm_sec, tm_wday, tm_yday, tm_isdst)
将一个时间戳转换成一个UTC时区(0时区)的struct_time，如果seconds参数未输入，则以当前时间为转换标准

6.localtime(…)
localtime([seconds]) -> (tm_year,tm_mon,tm_day,tm_hour,tm_min,tm_sec,tm_wday,tm_yday,tm_isdst)
将一个时间戳转换成一个当前时区的struct_time，如果seconds参数未输入，则以当前时间为转换标准

7.mktime(…)
mktime(tuple) -> floating point number
将一个以struct_time转换为时间戳

8.strftime(…)
strftime(format[, tuple]) -> string
将指定的struct_time(默认为当前时间)，根据指定的格式化字符串输出
python中时间日期格式化符号：
%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 当前时区的名称
%% %号本身

9.strptime(…)
strptime(string, format) -> struct_time
将时间字符串根据指定的格式化符转换成数组形式的时间
例如：
2009-03-20 11:45:39 对应的格式化字符串为：%Y-%m-%d %H:%M:%S
Sat Mar 28 22:24:24 2009 对应的格式化字符串为：%a %b %d %H:%M:%S %Y

10.time(…)
time() -> floating point number
返回当前时间的时间戳

三、疑点
1.夏令时
在struct_time中，夏令时好像没有用，例如
a = (2009, 6, 28, 23, 8, 34, 5, 87, 1)
b = (2009, 6, 28, 23, 8, 34, 5, 87, 0)
a和b分别表示的是夏令时和标准时间，它们之间转换为时间戳应该相关3600，但是转换后输出都为646585714.0

四、小应用
1.python获取当前时间
time.time() 获取当前时间戳
time.localtime() 当前时间的struct_time形式
time.ctime() 当前时间的字符串形式

2.python格式化字符串
格式化成2009-03-20 11:45:39形式

  time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())格式化成Sat Mar 28 22:24:24 2009形式

  time.strftime("%a %b %d %H:%M:%S %Y", time.localtime())3.将格式字符串转换为时间戳

  a = "Sat Mar 28 22:24:24 2009"
  b = time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y"))

python time datetime模块详解
Time模块：
－－－－－－－－－－－－－－－－－－－－－－－－－－
time() #以浮点形式返回自Linux新世纪以来经过的秒数。在linux中，00:00:00 UTC,

January 1, 1970是新**49**的开始。
>>> time.time()
1150269086.6630149
>>> time.ctime(1150269086.6630149)
>>> 'Wed Jun 14 15:11:26 2006'

time.ctime([sec])#把秒数转换成日期格式，如果不带参数，则显示当前的时间。

>>> import time
>>> time.ctime()
>>> 'Wed Jun 14 15:02:50 2006'
>>> time.ctime(1138068452427683)
'Sat Dec 14 04:51:44 1901'
>>> time.ctime(os.path.getmtime('E:\\untitleds.bmp'))
'Fri Sep 19 16:35:37 2008'

>>> time.gmtime(os.path.getmtime('E:\\untitleds.bmp'))
time.struct_time(tm_year=2008, tm_mon=9, tm_mday=19, tm_hour=8, tm_min=35,

tm_sec=37, tm_wday=4, tm_yday=263, tm_isdst=0)

将一个文件的修改时间转换为日期格式（秒 转 日期）
>>> time.strftime('%Y-%m-%d %X',time.localtime(os.path.getmtime('E:\\untitleds.bmp')))
'2008-09-19 16:35:37'

#定时3秒。
>>> time.sleep(3)

TIME模块参考：
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
#取一个文件的修改时间
>>> os.path.getmtime('E:\\untitleds.bmp')
1221813337.7626641

变量
timezone 通用协调时间和本地标准时间的差值，以秒为单位。
altzone 通用协调时间和本地夏令时的差值
daylight 标志，本地时间是否反映夏令时。
tzname (标准时区名，夏令时时区名)
函数
time() 以浮点数返回纪元至今以来的秒数。
clock() 以浮点数返回CPU开始这个process的时间，(或者至上次调用这个函数的时间)
sleep() 延迟一段以浮点数表示的秒数。
gmtime() 把以秒表示的时间转换为通用协调时序列
localtime() 把秒时转换为本地时序列
asctime() 将时间序列转换成文本描述
ctime() 将秒时转换成文本描述
mktime() 将本地时序列转换成秒时
strftime() 以指定格式将序列时转为文本描述
strptime() 以指定格式从文本描述中解析出时间序列
tzset() 改变当地时区值

DateTime模块
－－－－－－－－－－－－－－－－－－－－－－－－－－－－
datetime 将日期转化为秒
-------------------------------------
>>> import datetime,time
>>> time.mktime(datetime.datetime(2009,1,1).timetuple())
1230739200.0

>>> cc=[2000,11,3,12,43,33] #Attributes: year, month, day, hour, minute,

second
>>> time.mktime(datetime.datetime(cc[0],cc[1],cc[2],cc[3],cc[4],cc[5]).timetuple())
973226613.0

将秒转换为日期格式
>>> cc = time.localtime(os.path.getmtime('E:\\untitleds.bmp'))
>>> print cc[0:3]
(2008, 9, 19)

DateTime示例
－－－－－－－－－－－－－－－－－
演示计算两个日期相差天数的计算
>>> import datetime
>>> d1 = datetime.datetime(2005, 2, 16)
>>> d2 = datetime.datetime(2004, 12, 31)
>>> (d1 - d2).days
47

演示计算运行时间的例子，以秒进行显示
import datetime
starttime = datetime.datetime.now()
#long running
endtime = datetime.datetime.now()
print (endtime - starttime).seconds

演示计算当前时间向后10小时的时间。
>>> d1 = datetime.datetime.now()
>>> d3 = d1 + datetime.timedelta(hours=10)
>>> d3.ctime()

其本上常用的类有：datetime和timedelta两个。它们之间可以相互加减。每个类都有一些方法和属性可以查看具体的值

3)glob
可以使用简单的方法匹配某个目录下的所有子目录或文件，用法也很简单。
3.1 glob.glob(regression) 返回一个列表
3.2 glob.iglob(regression) 返回一个遍历器
这个模块简单好用，强力推荐。

---------------------------------------------------------

使用datetime模块计算两个时间的差：

>>> import datetime
>>> d1=datetime.datetime(2010,9,8)
>>> d2=datetime.datetime(2005,8,12)
>>>(d1-d2).days
1853

That means  我这个blog开博至今已经5年28天啦！

计算运行时间的例子，以秒进行显示：

import datetime
starttime = datetime.datetime.now()
#long running
endtime = datetime.datetime.now()
print (endtime - starttime).seconds

计算当前时间向后10小时的时间：

>>> d1 = datetime.datetime.now()
>>> d3 = d1 + datetime.timedelta(hours=10)
>>> d3.ctime()

其本上常用的类有：datetime和timedelta两个。它们之间可以相互加减。每个类都有一些方法和属性可以查看具体的值，如datetime可以查看：天数(day)，小时数(hour)，星期几(weekday())等;timedelta可以查看：天数(days)，秒数(seconds) 等。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

日期的操作必须使用time或datetime库

import time
>>> s="2006-1-2"
>>> time.strptime(s,"%Y-%m-%d)
这是将字符串格式的日期及时间转成日期对象
转义符对应意义如下
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%j 年内的一天（001-366）
%m 月份（01-12）
%M 分钟数（00=59）
%p 本地A.M.或P.M.的等价符
%S 秒（00-59）
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%Z 当前时区的名称
%% %号本身

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝举例的分隔线＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

#-*- coding:utf-8 -*-

import time
import datetime

# time , datetime , string 类型互相转换
#
# string -> time
# time.strptime(publishDate,"%Y-%m-%d %H:%M:%S")
#
# time -> string
# time.strftime("%y-%m-%d",t)

date = '2007-01-01'

print type(date)

date = time.strptime(date,"%Y-%m-%d")

print type(date)

print date[0]

d4 = datetime.datetime(date[0], date[1],date[2])

print d4
print type(d4)

#将日期时间对象转成字符串则要用

date = time.strftime("%y-%m-%d",date)
print type(date)

#其中date为日期时间对象

＝＝＝＝＝＝＝＝＝＝＝＝＝＝我编辑的一个通用的时间计算小程序 ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

# -*- coding:GBK -*-
# 计算两个时间的间隔天数
# 注意：输入月份和天时，不能输入08,09等，会被识别为 8 进制而出错！（8进制是不超过07的）
# 解决办法：要把月份和天前面的0去掉。

from datetime import datetime

(y1,m1,d1) = input("请输入时间1(格式为2009,8,9):")
(y2,m2,d2) = input("请输入时间2:")

date1 = datetime(y1,m1,d1)
date2 = datetime(y2,m2,d2)

days = (date2-date1).days

if (days<0):  # 如果时间相差为负数，取为正数
    days = -days

if (days>365):
    print '两个时间相隔',days/365,'年',days65,'天'
else:
    print '两个时间相隔',days,'天！'