python常用内建模块之time、date、datetime

Python的time和datetime模块提供了时间日期工具, python中的时间有4种表示方式:

• datetime obj
• time obj/tuple
• posix timestamp
• timestring

time

时间相关的操作，时间有三种表示方式：

• 时间戳 1970年1月1日之后的秒，即：time.time()
• 格式化的字符串 2014-11-11 11:11， 即：time.strftime('%Y-%m-%d')
• 结构化时间 元组包含了：年、日、星期等... time.struct_time 即：time.localtime()

获得当前时间:

>>> 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 对象进行调整

1. datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None)

所有的参数都是可选的；tzinfo 可以是 None 或者 tzinfo 子类的实例对象；其余的参数可以是整数，并且在以下范围内：

• 0 <= hour < 24
• 0 <= minute < 60
• 0 <= second < 60
• 0 <= microsecond < 1000000

注：如果参数超出范围，将引发 ValueError 异常 time 类属性

• time.min - time 对象所能表示的最早时间，time(0, 0, 0, 0)
• time.max - time 对象所能表示的最晚时间，time(23, 59, 59, 999999)
• time.resolution - time 对象表示时间的最小单位，在这里是 1 毫秒，timedelta(microseconds=1)

time 实例属性（只读）：

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 的综合应用：

1. # 学编程，到鱼C
2. >>> from datetime import time, timedelta, tzinfo
3. >>> class GMT1(tzinfo):
4. def utcoffset(self, dt):
5. return timedelta(hours=1)
6. def dst(self, dt):
7. return timedelta(0)
8. def tzname(self, dt):
9. return "欧洲/布拉格"
11. >>> t = time(14, 10, 30, tzinfo=GMT1())
12. >>> t
13. datetime.time(14, 10, 30, tzinfo=<__main__.GMT1 object at 0x02D7FE90>)
14. >>> gmt = GMT1()
15. >>> t.isoformat()
16. '14:10:30+01:00'
17. >>> t.dst()
18. datetime.timedelta(0)
19. >>> t.tzname()
20. '欧洲/布拉格'
21. >>> t.strftime("%H:%M:%S %Z")
22. '14:10:30 欧洲/布拉格'
23. >>> 'The {} is {:%H:%M}.'.format("time", t)
24. 'The time is 14:10.'

转换为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 对象表示两个日期或时间之间的间隔

1. 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 minutes -> 60 seconds
• 1 hours -> 3600 seconds
• 1 weeks -> 7 days

而 days、seconds 和 microseconds 为了不产生时间表示上的歧义，将根据以下范围自动“进位”：

• 0 <= microseconds < 1000000
• 0 <= seconds < 3600 * 24（1小时的秒数 * 24小时）
• -999999999 <= days <= 999999999

timedelta 类属性：

• timedelta.min - timedelta 对象负值的极限，timedelta(-999999999)
• timedelta.max - timedelta 对象正值的极限，timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999)
• timedelta.resolution - 两个 timedelta 不相等的对象之间最小的差值，timedelta(microseconds=1)

请注意，在正常情况下，timedelta.max > -timedelta.min，-timedelta.max 无意义。 timedelta 实例属性（只读）：

timedelta 对象支持的操作：

timedelta 实例方法： timedelta.total_seconds() - 返回 timedelta 对象所包含的总秒数，相当于 td / timedelta(seconds=1) 请注意，对于非常大的时间间隔（在大多数平台上是大于270年），这种方法将失去微秒（microsecond）精度 timedelta 用法示例：

1. # 爱学习，爱鱼C工作室
2. >>> from datetime import timedelta
3. >>> year = timedelta(days=365)
4. >>> another_year = timedelta(weeks=40, days=84, hours=23,
5. ... minutes=50, seconds=600) # adds up to 365 days
6. >>> year.total_seconds()
7. 31536000.0
8. >>> year == another_year
9. True
10. >>> ten_years = 10 * year
11. >>> ten_years, ten_years.days // 365
12. (datetime.timedelta(3650), 10)
13. >>> nine_years = ten_years - year
14. >>> nine_years, nine_years.days // 365
15. (datetime.timedelta(3285), 9)
16. >>> three_years = nine_years // 3;
17. >>> three_years, three_years.days // 365
18. (datetime.timedelta(1095), 3)
19. >>> abs(three_years - ten_years) == 2 * three_years + year
20. True

date 对象 date 对象表示一个日期，在一个理想化的日历里，日期由 year（年）、month（月）、day（日）组成

1. datetime.date(year, month, day)

所有的参数都是必需的，参数可以是整数，并且在以下范围内：

• MINYEAR <= year <= MAXYEAR（也就是 1 ~ 9999）
• 1 <= month <= 12
• 1 <= day <= 根据 year 和 month 来决定（例如 2015年2月 只有 28 天）

date 类方法（classmethod）：

• date.today() - 返回一个表示当前本地日期的 date 对象
• date.fromtimestamp(timestamp) - 根据给定的时间戮，返回一个 date 对象
• date.fromordinal(ordinal) - 将 Gregorian 日历时间转换为 date 对象（Gregorian Calendar：一种日历表示方法，类似于我国的农历，西方国家使用比较多）

date 类属性：

• date.min - date 对象所能表示的最早日期，date(MINYEAR, 1, 1)
• date.max - date 对象所能表示的最晚日期，date(MAXYEAR, 12, 31)
• date.resolution - date 对象表示日期的最小单位，在这里是 1 天，timedelta(days=1)

date 实例属性（只读）：

date 对象支持的操作：

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 对象的字符串 以下是计算天数的例子：

1. # You may say I'm the dreamer. But I'm not the only one!
3. >>> import time
4. >>> from datetime import date
5. >>> today = date.today()
6. >>> today
7. datetime.date(2014, 8, 31)
8. >>> today == date.fromtimestamp(time.time())
9. True
10. >>> my_birthday = date(today.year, 6, 24)
11. >>> if my_birthday < today:
12. my_birthday = my_birthday.replace(year = today.year + 1)
14. >>> my_birthday
15. datetime.date(2015, 6, 24)
16. >>> time_to_birthday = abs(my_birthday - today)
17. >>> time_to_birthday.days
18. 297

关于 date 的综合应用：

1. # Follow FishC. Follow your dream!
3. >>> from datetime import date
4. >>> d = date.fromordinal(735678) # 自日期 1.1.0001 之后的第 735678 天
5. >>> d
6. datetime.date(2015, 3, 21)
7. >>> t = d.timetuple()
8. >>> for i in t:
9. print(i)
11. 2015
12. 3
13. 21
14. 0
15. 0
16. 0
17. 5
18. 80
19. -1
20. >>> ic = d.isocalendar()
21. >>> for i in ic:
22. print(i)
24. 2015
25. 12
26. 6
27. >>> d.isoformat()
28. '2015-03-21'
29. >>> d.strftime("%d/%m/%y")
30. '21/03/15'
31. >>> d.strftime("%A %d. %B %Y")
32. 'Saturday 21. March 2015'
33. >>> 'The {1} is {0:%d}, the {2} is {0:%B}.'.format(d, "day", "month")
34. 'The day is 21, the month is March.'

datetime-- 基本的日期和时间类型

datetime 对象是 date 对象和 time 对象的结合体，并且包含他们的所有信息

1. datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None)

必须的参数是 year（年）、month（月）、day（日）；tzinfo 可以是 None 或者 tzinfo 子类的实例对象；其余的参数可以是整数，并且在以下范围内：

• MINYEAR <= year <= MAXYEAR（也就是 1 ~ 9999）
• 1 <= month <= 12
• 1 <= day <= 根据 year 和 month 来决定（例如 2015年2月 只有 28 天）
• 0 <= hour < 24
• 0 <= minute < 60
• 0 <= second < 60
• 0 <= microsecond < 1000000

注：如果参数超出范围，将引发 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.min - datetime 对象所能表示的最早日期，datetime(MINYEAR, 1, 1, tzinfo=None)
• datetime.max - datetime 对象所能表示的最晚日期，datetime(MAXYEAR, 12, 31, 23, 59, 59, 999999, tzinfo=None)
• datetime.resolution - datetime 对象表示日期的最小单位，在这里是 1 毫秒，timedelta(microseconds=1)

datetime 实例属性（只读）：

datetime 对象支持的操作：

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.MINYEAR - date 和 datetime 对象所能支持的最小年份，object.MINYEAR 的值为 1
• datetime.MAXYEAR - date 和 datetime 对象所能支持的最大年份，object.MAXYEAR 的值为 9999

datetime 模块中定义的类：

• datetime.date - 表示日期的类，常用属性：year, month, day
• datetime.time - 表示时间的类，常用属性：hour, minute, second, microsecond, tzinfo
• datetime.datetime - 表示日期和时间的类，常用属性： year, month, day, hour, minute, second, microsecond, tzinfo
• datetime.timedelta - 表示时间间隔，即两个时间点（date，time，datetime）之间的长度
• datetime.tzinfo - 表示时区的基类，为上方的 time 和 datetime 类提供调整的基准
• datetime.timezone - 表示 UTC 时区的固定偏移，是 tzinfo 基类的实现

从属关系

1. object
2. timedelta
3. tzinfo
4. timezone
5. time
6. date
7. 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 的综合应用：

1. # I love FishC.com!
2. >>> from datetime import datetime, date, time
4. # 使用 datetime.combine()
5. >>> d = date(2015, 8, 1)
6. >>> t = time(12, 30)
7. >>> datetime.combine(d, t)
8. datetime.datetime(2015, 8, 1, 12, 30)
10. # 使用 datetime.now() 或 datetime.utcnow()
11. >>> datetime.now()
12. datetime.datetime(2014, 8, 31, 18, 13, 40, 858954)
13. >>> datetime.utcnow()
14. datetime.datetime(2014, 8, 31, 10, 13, 49, 347984)
16. # 使用 datetime.srptime()
17. >>> dt = datetime.strptime("21/11/14 16:30", "%d/%m/%y %H:%M")
18. >>> dt
19. datetime.datetime(2014, 11, 21, 16, 30)
21. # 使用 datetime.timetuple()
22. >>> tt = dt.timetuple()
23. >>> for it in tt:
24. print(it)
26. 2014
27. 11
28. 21
29. 16
30. 30
31. 0
32. 4
33. 325
34. -1
36. # ISO 格式的日期
37. >>> ic = dt.isocalendar()
38. >>> for it in ic:
39. print(it)
41. 2014
42. 47
43. 5
45. # 格式化 datetime 对象
46. >>> dt.strftime("%A, %d. %B %Y %I:%M%p")
47. 'Friday, 21. November 2014 04:30PM'
48. >>> 'The {1} is {0:%d}, the {2} is {0:%B}, the {3} is {0:%I:%M%p}.'.format(dt, "day", "month", "time")
49. 'The day is 21, the month is November, the time is 04:30PM.'

带有 tzinfo 的 datetime 综合演示：

1. # 嘿，都能看到这里来了，毅力不错哈^_^
2. >>> from datetime import timedelta, datetime, tzinfo
3. >>> class GMT1(tzinfo):
4. def utcoffset(self, dt):
5. return timedelta(hours=1) + self.dst(dt)
6. def dst(self, dt):
7. # DST 开始于三月最后一个星期天
8. # 结束于十月最后一个星期天
9. d = datetime(dt.year, 4, 1)
10. self.dston = d - timedelta(days=d.weekday() + 1)
11. d = datetime(dt.year, 11, 1)
12. self.dstoff = d - timedelta(days=d.weekday() + 1)
13. if self.dston <= dt.replace(tzinfo=None) < self.dstoff:
14. return timedelta(hours=1)
15. else:
16. return timedelta(0)
17. def tzname(self, dt):
18. return "GMT +1"
20. >>> class GMT2(tzinfo):
21. def utcoffset(self, dt):
22. return timedelta(hours=2) + self.dst(dt)
23. def dst(self, dt):
24. d = datetime(dt.year, 4, 1)
25. self.dston = d - timedelta(days=d.weekday() + 1)
26. d = datetime(dt.year, 11, 1)
27. self.dstoff = d - timedelta(days=d.weekday() + 1)
28. if self.dston <= dt.replace(tzinfo=None) < self.dstoff:
29. return timedelta(hours=1)
30. else:
31. return timedelta(0)
32. def tzname(self, dt):
33. return "GMT +2"
35. >>> gmt1 = GMT1()
37. # 夏令时
38. >>> dt1 = datetime(2014, 11, 21, 16, 30, tzinfo=gmt1)
39. >>> dt1.dst()
40. datetime.timedelta(0)
41. >>> dt1.utcoffset()
42. datetime.timedelta(0, 3600)
43. >>> dt2 = datetime(2014, 6, 14, 13, 0, tzinfo=gmt1)
44. >>> dt2.dst()
45. datetime.timedelta(0, 3600)
46. >>> dt2.utcoffset()
47. datetime.timedelta(0, 7200)
49. # 将 datetime 转换到另一个时区
50. >>> dt3 = dt2.astimezone(GMT2())
51. >>> dt3
52. datetime.datetime(2014, 6, 14, 14, 0, tzinfo=<__main__.GMT2 object at 0x036C0F70>)
53. >>> dt2
54. datetime.datetime(2014, 6, 14, 13, 0, tzinfo=<__main__.GMT1 object at 0x036C0B10>)
55. >>> dt2.utctimetuple() == dt3.utctimetuple()
56. True

时间格式化

格式化字符串：strftime() 和 strptime() date, datetime, 和 time 对象均支持使用 strftime(format) 方法，将指定的日期或时间转换为自定义的格式化字符串 相反的，datetime.strptime() 类方法却是把格式化字符串转换为 datetime 对象

格式化字符串综合演示：

1. >>> from datetime import datetime
2. >>> dt = datetime.now()
3. >>> print('(%Y-%m-%d %H:%M:%S %f): ', dt.strftime('%Y-%m-%d %H:%M:%S %f'))
4. (%Y-%m-%d %H:%M:%S %f): 2014-08-31 23:54:58 379804
5. >>> print('(%Y-%m-%d %H:%M:%S %p): ', dt.strftime('%y-%m-%d %I:%M:%S %p'))
6. (%Y-%m-%d %H:%M:%S %p): 14-08-31 11:54:58 PM
7. >>> print('%%a: %s ' % dt.strftime('%a'))
8. %a: Sun
9. >>> print('%%A: %s ' % dt.strftime('%A'))
10. %A: Sunday
11. >>> print('%%b: %s ' % dt.strftime('%b'))
12. %b: Aug
13. >>> print('%%B: %s ' % dt.strftime('%B'))
14. %B: August
15. >>> print('日期时间%%c: %s ' % dt.strftime('%c'))
16. 日期时间%c: 08/31/14 23:54:58
17. >>> print('日期%%x：%s ' % dt.strftime('%x'))
18. 日期%x：08/31/14
19. >>> print('时间%%X：%s ' % dt.strftime('%X'))
20. 时间%X：23:54:58
21. >>> print('今天是这周的第%s天 ' % dt.strftime('%w'))
22. 今天是这周的第0天
23. >>> print('今天是今年的第%s天 ' % dt.strftime('%j'))
24. 今天是今年的第243天
25. >>> print('今周是今年的第%s周 ' % dt.strftime('%U'))
26. 今周是今年的第35周

时间与字符串等间的转换

datetime转换为timestamp

在计算机中，时间实际上是用数字表示的。我们把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

要把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

很多时候，用户输入的日期和时间是字符串，要处理日期和时间，首先必须把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

如果已经有了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往后或往前计算，得到新的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时间

本地时间是指系统设定时区的时间，例如北京时间是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