Python的time和datetime模块提供了时间日期工具, python中的时间有4种表示方式:
时间相关的操作,时间有三种表示方式:
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 | print time.time() print time.mktime(time.localtime()) print time.gmtime() #可加时间戳参数 print time.localtime() #可加时间戳参数 print time.strptime('2014-11-11', '%Y-%m-%d') print time.strftime('%Y-%m-%d') #默认当前时间 print time.strftime('%Y-%m-%d',time.localtime()) #默认当前时间 print time.asctime() print time.asctime(time.localtime()) print time.ctime(time.time()) import datetime ''' datetime.date:表示日期的类。常用的属性有year, month, day datetime.time:表示时间的类。常用的属性有hour, minute, second, microsecond datetime.datetime:表示日期时间 datetime.timedelta:表示时间间隔,即两个时间点之间的长度 timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]]) strftime("%Y-%m-%d") ''' import datetime print datetime.datetime.now() print datetime.datetime.now() - datetime.timedelta(days=5) |
---|
获得当前时间:
>>> import time
>>> time.localtime()
time.struct_time(tm_year=2016, tm_mon=8, tm_mday=21, tm_hour=16, tm_min=48, tm_sec=24, tm_wday=6, tm_yday=234, tm_isdst=0)
time 对象 time 对象表示一天中的一个时间,并且可以通过 tzinfo 对象进行调整
所有的参数都是可选的;tzinfo 可以是 None 或者 tzinfo 子类的实例对象;其余的参数可以是整数,并且在以下范围内:
注:如果参数超出范围,将引发 ValueError 异常 time 类属性
time 实例属性(只读):
属性 | 取值范围 |
---|---|
time.hour | 0 ~ 23 |
time.minute | 0 ~ 59 |
time.second | 0 ~ 59 |
time.microsecond | 0 ~ 999999 |
time.tzinfo | 通过构造函数的 tzinfo 参数赋值 |
time 实例方法: time.replace([hour[, minute[, second[, microsecond[, tzinfo]]]]]) - 生成一个新的时间对象,用参数指定时间代替原有对象中的属性 time.isoformat() - 返回一个 ISO 8601 格式的日期字符串,如 "HH:MM:SS.mmmmmm" 的字符串 time.__str__() - 对于 time 对象 t 来说,str(t) 相当于 t.isoformat() time.strftime(format) - 返回自定义格式化字符串表示时间,下面有详解 time.__format__(format) - 跟 time.strftime(format) 一样,这使得调用 str.format() 时可以指定 time 对象的字符串 time.utcoffset() - 如果 tzinfo 属性是 None,则返回 None;否则返回 self.tzinfo.utcoffset(self) time.dst() - 如果 tzinfo 属性是 None,则返回 None;否则返回 self.tzinfo.dst(self) time.tzname() - 如果 tzinfo 属性是 None,则返回 None;否则返回 self.tzinfo.tzname(self) 关于 time 的综合应用:
转换为datetime:
>>> datetime.datetime(*time.localtime()[0:6])
datetime.datetime(2016, 8, 21, 16, 56, 16)
格式化为时间字符串:
>>> time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
'2016-08-21 16:55:01'
转换为时间戳:
>>> time.mktime(time.localtime())
1471770256.0
UNIX时间戳定义为1970-1-1 00:00:00开始的秒数, 获得当前时间戳:
>>> import time
>>> time.time()
1471777412.3293073
转换为datetime:
>>> datetime.datetime.fromtimestamp(time.time())
datetime.datetime(2016, 8, 21, 19, 8, 22, 719951)
转换为timetuple:
>>> time.localtime(time.time())
time.struct_time(tm_year=2016, tm_mon=8, tm_mday=21, tm_hour=19, tm_min=13, tm_sec=41, tm_wday=6, tm_yday=234, tm_isdst=0)
timedelta 对象
timedelta 对象表示两个日期或时间之间的间隔
以上所有的参数都是可选的(默认为 0),参数的可以是整数或浮点数,正数或负数。 内部的存储单位只有 days(天)、seconds(秒)、microseconds(毫秒),其他单位均先转换后再存储:
而 days、seconds 和 microseconds 为了不产生时间表示上的歧义,将根据以下范围自动“进位”:
timedelta 类属性:
请注意,在正常情况下,timedelta.max > -timedelta.min,-timedelta.max 无意义。 timedelta 实例属性(只读):
属性 | 取值范围 |
---|---|
timedelta.days | -999999999 ~ 999999999 |
timedelta.seconds | 0 ~ 86399 |
timedelta.microseconds | 0 ~ 999999 |
timedelta 对象支持的操作:
操作 | 结果 |
---|---|
t1 = t2 + t3 | t2 和 t3 的和,随后:t1 - t2 == t3 and t1 - t3 == t2 为 True(注1) |
t1 = t2 - t3 | t2 和 t3 的差,随后:t1 == t2 - t3 and t2 == t1 + t3 为 True(注1) |
t1 = t2 * i 或 t1 = i * t2 | 对象乘以一个整数,随后:t1 // i == t2 为 true;且 i != 0 |
t1 = t2 * f 或 t1 = f * t2 | 对象乘以一个浮点数,结果四舍五入到精度 timedelta.resolution(注1) |
f = t2 / t3 | t2 和 t3 的商(注3),返回一个 float 对象 |
t1 = t2 / f 或 t1 = t2 / i | 对象除以一个整数或浮点数,结果四舍五入到精度 timedelta.resolution |
t1 = t2 // i 或 t1 = t2 // t3 | 对象地板除一个整数或浮点数,结果舍去小数,返回一个整数(注3) |
t1 = t2 % t3 | t2 和 t3 的余数,返回一个 timedelta 对象(注3) |
q, r = divmod(t1, t2) | 计算 t1 和 t2 的商和余数,q = t1 // t2(注3),r = t1 % t2,q 是一个整数,r 是一个 timedelta 对象 |
+t1 | 返回一个 timedelta 对象,且值相同(注2) |
-t1 | 等同于 timedelta(-t1.days, -t1.seconds, -t1.microseconds),并且相当于 t1 * -1(注1、4) |
abs(t) | 当 t.days >= 0 时,等同于 +t;当 t.days < = 时,等同于 -t(注2) |
str(t) | 返回一个字符串,按照此格式:[D day[ s ], ][H]H:MM:SS[.UUUUUU] |
repr(t) | 返回一个字符串,按照此格式:datetime.timedelta(D[, S[, U]]) |
timedelta 实例方法: timedelta.total_seconds() - 返回 timedelta 对象所包含的总秒数,相当于 td / timedelta(seconds=1) 请注意,对于非常大的时间间隔(在大多数平台上是大于270年),这种方法将失去微秒(microsecond)精度 timedelta 用法示例:
date 对象 date 对象表示一个日期,在一个理想化的日历里,日期由 year(年)、month(月)、day(日)组成
所有的参数都是必需的,参数可以是整数,并且在以下范围内:
date 类方法(classmethod):
date 类属性:
date 实例属性(只读):
属性 | 取值范围 |
---|---|
date.year | MINYEAR ~ MAXYEAR(1 ~ 9999) |
date.month | 1 ~ 12 |
date.day | 1 ~ 根据 year 和 month 来决定(例如 2015年2月 只有 28 天) |
date 对象支持的操作:
操作 | 结果 |
---|---|
date2 = date1 + timedelta | 日期加上一个时间间隔,返回一个新的日期对象(注1) |
date2 = date1 - timedelta | 日期减去一个时间间隔,相当于 date2 + timedelta == date1(注2) |
timedelta = date1 - date2 | (注3) |
date1 < date2 | 当 date1 的日期在 date2 之前时,我们认为 date1 < date2(注4) |
date 实例方法: date.replace(year, month, day) - 生成一个新的日期对象,用参数指定的年、月、日代替原有对象中的属性 date.timetuple() - 返回日期对应的 time.struct_time 对象(类似于 time 模块的 time.localtime()) date.toordinal() - 返回日期对应的 Gregorian Calendar 日期 date.weekday() - 返回 0 ~ 6 表示星期几(星期一是 0,依此类推) date.isoweekday() - 返回 1 ~ 7 表示星期几(星期一是1, 依此类推) date.isocalendar() - 返回一个三元组格式 (year, month, day) date.isoformat() - 返回一个 ISO 8601 格式的日期字符串,如 "YYYY-MM-DD" 的字符串 date.__str__() - 对于 date 对象 d 来说,str(d) 相当于 d.isoformat() date.ctime() - 返回一个表示日期的字符串,相当于 time 模块的 time.ctime(time.mktime(d.timetuple())) date.strftime(format) - 返回自定义格式化字符串表示日期,下面有详解 date.__format__(format) - 跟 date.strftime(format) 一样,这使得调用 str.format() 时可以指定 data 对象的字符串 以下是计算天数的例子:
关于 date 的综合应用:
datetime 对象是 date 对象和 time 对象的结合体,并且包含他们的所有信息
必须的参数是 year(年)、month(月)、day(日);tzinfo 可以是 None 或者 tzinfo 子类的实例对象;其余的参数可以是整数,并且在以下范围内:
注:如果参数超出范围,将引发 ValueError 异常 datetime 类方法(classmethod): datetime.today() - 返回一个表示当前本地时间的 datetime 对象,等同于 datetime.fromtimestamp(time.time()) datetime.now(tz=None) - 返回一个表示当前本地时间的 datetime 对象;如果提供了参数 tz,则获取 tz 参数所指时区的本地时间 datetime.utcnow() - 返回一个当前 UTC 时间的 datetime 对象 datetime.fromtimestamp(timestamp, tz=None) - 根据时间戮创建一个 datetime 对象,参数 tz 指定时区信息 datetime.utcfromtimestamp(timestamp) - 根据时间戮创建一个 UTC 时间的 datetime 对象 datetime.fromordinal(ordinal) - 返回对应 Gregorian 日历时间对应的 datetime 对象 datetime.combine(date, time) - 根据参数 date 和 time,创建一个 datetime 对象 datetime.strptime(date_string, format) - 将格式化字符串转换为 datetime 对象 datetime 类属性:
datetime 实例属性(只读):
属性 | 取值范围 |
---|---|
datetime.year | MINYEAR ~ MAXYEAR(1 ~ 9999) |
datetime.month | 1 ~ 12 |
datetime.day | 1 ~ 根据 year 和 month 来决定(例如 2015年2月 只有 28 天) |
datetime.hour | 0 ~ 23 |
datetime.minute | 0 ~ 59 |
datetime.second | 0 ~ 59 |
datetime.microsecond | 0 ~ 999999 |
datetime.tzinfo | 通过构造函数的 tzinfo 参数赋值 |
datetime 对象支持的操作:
操作 | 结果 |
---|---|
datetime2 = datetime1 + timedelta | 日期加上一个时间间隔,返回一个新的日期对象(注1) |
datetime2 = datetime1 - timedelta | 日期减去一个时间间隔,相当于 datetime2 + timedelta == datetime1(注2) |
timedelta = datetime1 - datetime2 | 两个日期相减得到一个时间间隔(注3) |
datetime1 < datetime2 | 当 datetime1 的日期在 datetime2 之前时,我们认为 datetime1 < datetime2 |
datetime 实例方法: datetime.date() - 返回一个 date 对象datetime.time() - 返回一个 time 对象(tzinfo 属性为 None) datetime.timetz() - 返回一个 time() 对象(带有 tzinfo 属性) datetime.replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]]) - 生成一个新的日期对象,用参数指定日期和时间代替原有对象中的属性 datetime.astimezone(tz=None) - 传入一个新的 tzinfo 属性,返回根据新时区调整好的 datetime 对象 datetime.utcoffset() - 如果 tzinfo 属性是 None,则返回 None;否则返回 self.tzinfo.utcoffset(self) datetime.dst() - 如果 tzinfo 属性是 None,则返回 None;否则返回 self.tzinfo.dst(self) datetime.tzname() - 如果 tzinfo 属性是 None,则返回 None;否则返回 self.tzinfo.tzname(self) datetime.timetuple() - 返回日期对应的 time.struct_time 对象(类似于 time 模块的 time.localtime()) datetime.utctimetuple() - 返回 UTC 日期对应的 time.struct_time 对象 datetime.toordinal() - 返回日期对应的 Gregorian Calendar 日期(类似于 self.date().toordinal()) datetime.timestamp() - 返回当前时间的时间戳(类似于 time 模块的 time.time()) datetime.weekday() - 返回 0 ~ 6 表示星期几(星期一是 0,依此类推) datetime.isoweekday() - 返回 1 ~ 7 表示星期几(星期一是1, 依此类推) datetime.isocalendar() - 返回一个三元组格式 (year, month, day) datetime.isoformat(sep='T') - 返回一个 ISO 8601 格式的日期字符串,如 "YYYY-MM-DD" 的字符串 datetime.__str__() - 对于 date 对象 d 来说,str(d) 相当于 d.isoformat() datetime.ctime() - 返回一个表示日期的字符串,相当于 time 模块的 time.ctime(time.mktime(d.timetuple())) datetime.strftime(format) - 返回自定义格式化字符串表示日期,下面有详解 datetime.__format__(format) - 跟 datetime.strftime(format) 一样,这使得调用 str.format() 时可以指定 data 对象的字符串
datetime 模块提供了各种类用于操作日期和时间,该模块侧重于高效率的格式化输出 datetime 模块定义了两个常量:
datetime 模块中定义的类:
从属关系
获得当前时间:
>>> import datetime
>>> datetime.datetime.now()
datetime.datetime(2016, 8, 21, 16, 21, 51, 631199)
注意到datetime
是模块,datetime
模块还包含一个datetime
类,通过from datetime import datetime
导入的才是datetime
这个类。如果仅导入import datetime
,则必须引用全名datetime.datetime
。
datetime.now()
返回当前日期和时间,其类型是datetime
。
创建datetime对象:
>>> d = datetime.datetime(year=2016, month=1, day=1, hour=12, minute=0, second=0)
>>> d
datetime.datetime(2016, 1, 1, 12, 0)
>>> d.year
2016
datetime是不可变对象, 若要修改时间需要建立新的datetime对象.
关于 datetime 的综合应用:
带有 tzinfo 的 datetime 综合演示:
格式化字符串:strftime() 和 strptime() date, datetime, 和 time 对象均支持使用 strftime(format) 方法,将指定的日期或时间转换为自定义的格式化字符串 相反的,datetime.strptime() 类方法却是把格式化字符串转换为 datetime 对象
格式化指令 | 含义 |
---|---|
%a | 星期的简写(星期一 ~ 天:Mon, Tue, Wed, Thu, Fri, Sat, Sun) |
%A | 星期的全写(星期一 ~ 天:Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday) |
%w | 在一个星期中的第几天( 0 表示星期天 ... 6 表示星期六) |
%d | 在一个月中的第几天(01, 02, ..., 31) |
%b | 月份的简写(一月 ~ 十二月:Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec) |
%B | 月份的全写(一月 ~ 十二月:January, February, March, April, May, June, July, August, September, October, November, December) |
%m | 月份(01, 02, ..., 12) |
%y | 用两个数字表示年份(例如 2014年 == 14) |
%Y | 用四个数字表示年份 |
%H | 二十四小时制(00, 01, ..., 23) |
%I | 十二小时制(01, 02, ..., 11) |
%p | AM 或者 PM |
%M | 分钟(00, 01, ..., 59) |
%S | 秒(00, 01, ..., 59) |
%f | 微秒(000000, 000001, ..., 999999) |
%z | 与 UTC 时间的间隔 ;如果是本地时间,返回空字符串((empty), +0000, -0400, +1030) |
%Z | 时区名称;如果是本地时间,返回空字符串((empty), UTC, EST, CST) |
%j | 在一年中的第几天(001, 002, ..., 366) |
%U | 在一年中的第几周,星期天作为第一天(00, 01, ..., 53) |
%W | 在一年中的第几周,星期一作为第一天(00, 01, ..., 53) |
%c | 用字符串表示日期和时间(Tue Aug 16 21:30:00 2014) |
%x | 用字符串表示日期(08/16/14) |
%X | 用字符串表示时间(21:30:00) |
%% | 表示百分号 |
格式化字符串综合演示:
在计算机中,时间实际上是用数字表示的。我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0
(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp。
你可以认为:
timestamp = 0 = 1970-1-1 00:00:00 UTC+0:00
对应的北京时间是:
timestamp = 0 = 1970-1-1 08:00:00 UTC+8:00
可见timestamp的值与时区毫无关系,因为timestamp一旦确定,其UTC时间就确定了,转换到任意时区的时间也是完全确定的,这就是为什么计算机存储的当前时间是以timestamp表示的,因为全球各地的计算机在任意时刻的timestamp都是完全相同的(假定时间已校准)。
把一个datetime
类型转换为timestamp只需要简单调用timestamp()
方法:
>>> from datetime import datetime
>>> dt = datetime(2015, 4, 19, 12, 20) # 用指定日期时间创建datetime
>>> dt.timestamp() # 把datetime转换为timestamp
1429417200.0
注意Python的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。
某些编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的浮点表示方法。
要把timestamp转换为datetime
,使用datetime
提供的fromtimestamp()
方法:
>>> from datetime import datetime
>>> t = 1429417200.0
>>> print(datetime.fromtimestamp(t))
2015-04-19 12:20:00
注意到timestamp是一个浮点数,它没有时区的概念,而datetime是有时区的。上述转换是在timestamp和本地时间做转换。
本地时间是指当前操作系统设定的时区。例如北京时区是东8区,则本地时间:
2015-04-19 12:20:00
实际上就是UTC+8:00时区的时间:
2015-04-19 12:20:00 UTC+8:00
而此刻的格林威治标准时间与北京时间差了8小时,也就是UTC+0:00时区的时间应该是:
2015-04-19 04:20:00 UTC+0:00
timestamp也可以直接被转换到UTC标准时区的时间:
>>> from datetime import datetime
>>> t = 1429417200.0
>>> print(datetime.fromtimestamp(t)) # 本地时间
2015-04-19 12:20:00
>>> print(datetime.utcfromtimestamp(t)) # UTC时间
2015-04-19 04:20:00
很多时候,用户输入的日期和时间是字符串,要处理日期和时间,首先必须把str转换为datetime。转换方法是通过datetime.strptime()
实现,需要一个日期和时间的格式化字符串:
>>> from datetime import datetime
>>> cday = datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S')
>>> print(cday)
2015-06-01 18:19:59
字符串'%Y-%m-%d %H:%M:%S'
规定了日期和时间部分的格式。详细的说明请参考Python文档。
注意转换后的datetime是没有时区信息的。
如果已经有了datetime对象,要把它格式化为字符串显示给用户,就需要转换为str,转换方法是通过strftime()
实现的,同样需要一个日期和时间的格式化字符串:
>>> from datetime import datetime
>>> now = datetime.now()
>>> print(now.strftime('%a, %b %d %H:%M'))
Mon, May 05 16:28
对日期和时间进行加减实际上就是把datetime往后或往前计算,得到新的datetime。加减可以直接用+
和-
运算符,不过需要导入timedelta
这个类:
>>> from datetime import datetime, timedelta
>>> now = datetime.now()
>>> now
datetime.datetime(2015, 5, 18, 16, 57, 3, 540997)
>>> now + timedelta(hours=10)
datetime.datetime(2015, 5, 19, 2, 57, 3, 540997)
>>> now - timedelta(days=1)
datetime.datetime(2015, 5, 17, 16, 57, 3, 540997)
>>> now + timedelta(days=2, hours=12)
datetime.datetime(2015, 5, 21, 4, 57, 3, 540997)
可见,使用timedelta
你可以很容易地算出前几天和后几天的时刻。
本地时间是指系统设定时区的时间,例如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。
一个datetime
类型有一个时区属性tzinfo
,但是默认为None
,所以无法区分这个datetime
到底是哪个时区,除非强行给datetime
设置一个时区:
>>> from datetime import datetime, timedelta, timezone
>>> tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
>>> now = datetime.now()
>>> now
datetime.datetime(2015, 5, 18, 17, 2, 10, 871012)
>>> dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
>>> dt
datetime.datetime(2015, 5, 18, 17, 2, 10, 871012, tzinfo=datetime.timezone(datetime.timedelta(0, 28800)))
如果系统时区恰好是UTC+8:00,那么上述代码就是正确的,否则,不能强制设置为UTC+8:00时区。
我们可以先通过utcnow()
拿到当前的UTC时间,再转换为任意时区的时间:
# 拿到UTC时间,并强制设置时区为UTC+0:00:
>>> utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
>>> print(utc_dt)
2015-05-18 09:05:12.377316+00:00
# astimezone()将转换时区为北京时间:
>>> bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
>>> print(bj_dt)
2015-05-18 17:05:12.377316+08:00
# astimezone()将转换时区为东京时间:
>>> tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
>>> print(tokyo_dt)
2015-05-18 18:05:12.377316+09:00
# astimezone()将bj_dt转换时区为东京时间:
>>> tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
>>> print(tokyo_dt2)
2015-05-18 18:05:12.377316+09:00
时区转换的关键在于,拿到一个datetime
时,要获知其正确的时区,然后强制设置时区,作为基准时间。
利用带时区的datetime
,通过astimezone()
方法,可以转换到任意时区。
注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime
都可以正确转换,例如上述bj_dt
到tokyo_dt
的转换。
datetime
表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。
如果要存储datetime
,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。
业务代码中总离不开时间的处理逻辑,来简单总结下Python中的时间用法。
输出时间戳
import time print time.time()
输出的结果是:
1487500731.109869
但是这样是一连串的数字不是我们想要的结果,我们可以利用time模块的格式化时间的方法来处理:
time.localtime(time.time())
用time.localtime()方法,作用是格式化时间戳为本地的时间。
输出的结果是:
time.struct_time(tm_year=2017, tm_mon=2, tm_mday=19, tm_hour=18, tm_min=38, tm_sec=51, tm_wday=6, tm_yday=50, tm_isdst=0)
现在看起来更有希望格式成我们想要的时间了。
time.strftime('%Y-%m-%d',time.localtime(time.time()))
最后用time.strftime()方法,把刚才的一大串信息格式化成我们想要的东西,现在的结果是:
2017-02-19
time.strftime里面有很多参数,可以让你能够更随意的输出自己想要的东西:
下面是time.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 当前时区的名称
%% %号本身
datetime,date,time模块:
datetime.date.today() 本地日期对象,(用str函数可得到它的字面表示(2014-03-24)) datetime.date.isoformat(obj) 当前[年-月-日]字符串表示(2014-03-24) datetime.date.fromtimestamp() 返回一个日期对象,参数是时间戳,返回 [年-月-日] datetime.date.weekday(obj) 返回一个日期对象的星期数,周一是0 datetime.date.isoweekday(obj) 返回一个日期对象的星期数,周一是1 datetime.date.isocalendar(obj) 把日期对象返回一个带有年月日的元组 datetime对象: datetime.datetime.today() 返回一个包含本地时间(含微秒数)的datetime对象 2014-03-24 23:31:50.419000 datetime.datetime.now([tz]) 返回指定时区的datetime对象 2014-03-24 23:31:50.419000 datetime.datetime.utcnow() 返回一个零时区的datetime对象 datetime.fromtimestamp(timestamp[,tz]) 按时间戳返回一个datetime对象,可指定时区,可用于strftime转换为日期表示 datetime.utcfromtimestamp(timestamp) 按时间戳返回一个UTC-datetime对象 datetime.datetime.strptime(‘2014-03-16 12:21:21‘,”%Y-%m-%d %H:%M:%S”) 将字符串转为datetime对象 datetime.datetime.strftime(datetime.datetime.now(), ‘%Y%m%d %H%M%S‘) 将datetime对象转换为str表示形式 datetime.date.today().timetuple() 转换为时间戳datetime元组对象,可用于转换时间戳 datetime.datetime.now().timetuple() time.mktime(timetupleobj) 将datetime元组对象转为时间戳 time.time() 当前时间戳 time.localtime time.gmtime