date类和datetime类

发表于 | 分类于 |

整理：QT

边学习边整理，内容来源于互联网，如有疑问请QQ 604615850联系，侵删。

前言

在开发工作中，我们经常需要用到日期与时间，如：

  • 作为日志信息的内容输出
  • 计算某个功能的执行时间
  • 用日期命名一个日志文件的名称
  • 记录或展示某文章的发布或修改时间
  • 其他

Python中提供了多个用于对日期和时间进行操作的内置模块：time模块、datetime模块和calendar模块。其中time模块是通过调用C库实现的，所以有些方法在某些平台上可能无法调用，但是其提供的大部分接口与C标准库time.h基本一致。time模块相比，datetime模块提供的接口更直观、易用，功能也更加强大。

一、相关术语的解释

  • UTC time Coordinated Universal Time，世界协调时，又称 格林尼治天文时间（GMT）、世界标准时间。与UTC time对应的是各个时区的local time，东N区的时间比UTC时间早N个小时，因此UTC time + N小时 即为东N区的本地时间；而西N区时间比UTC时间晚N个小时，即 UTC time - N小时 即为西N区的本地时间； 中国在东8区，因此比UTC时间早8小时，可以以UTC+8进行表示。
  • epoch time 表示时间开始的起点；它是一个特定的时间，不同平台上这个时间点的值不太相同，对于Unix而言，epoch time为 1970-01-01 00:00:00 UTC。
  • timestamp（时间戳） 也称为Unix时间 或 POSIX时间；它是一种时间表示方式，表示从格林尼治时间1970年1月1日0时0分0秒开始到现在所经过的毫秒数，其值为float类型。 但是有些编程语言的相关方法返回的是秒数（Python就是这样），这个需要看方法的文档说明。需要说明的是时间戳是个差值，其值与时区无关。

二、时间的表现形式

常见的时间表示形式为：

  • 时间戳
  • 格式化的时间字符串

Python中还有其它的时间表示形式：

  • time模块的time.struct_time
  • datetime模块的datetime类

这里简单说下time.struct_time，包含如下属性：

下标/索引 属性名称 描述
0 tm_year 年份，如 2017
1 tm_mon 月份，取值范围为[1, 12]
2 tm_mday 一个月中的第几天，取值范围为[1-31]
3 tm_hour 小时， 取值范围为[0-23]
4 tm_min 分钟，取值范围为[0, 59]
5 tm_sec 秒，取值范围为[0, 61]
6 tm_wday 一个星期中的第几天，取值范围为[0-6]，0表示星期一
7 tm_yday 一年中的第几天，取值范围为[1, 366]
8 tm_isdst 是否为夏令时，可取值为：0 , 1 或 -1

属性值的获取方式有两种：

  • 可以把它当做一种特殊的有序不可变序列通过 下标/索引 获取各个元素的值，如t[0]
  • 也可以通过 .属性名 的方式来获取各个元素的值，如t.tm_year。

需要说明的是struct_time实例的各个属性都是只读的，不可修改。

三、time模块

time模块主要用于时间访问和转换，这个模块提供了各种与时间相关的函数。

1. 函数列表

方法/属性 描述
time.altzone 返回与utc时间的时间差，以秒为单位（西区该值为正，东区该值为负）。其表示的是本地DST 时区的偏移量，只有daylight非0时才使用。
time.clock() 返回当前进程所消耗的处理器运行时间秒数（不包括sleep时间），值为小数；该方法Python3.3改成了time.process_time()
time.asctime([t]) 将一个tuple或struct_time形式的时间（可以通过gmtime()和localtime()方法获取）转换为一个24个字符的时间字符串，格式为: “Fri Aug 19 11:14:16 2016”。如果参数t未提供，则取localtime()的返回值作为参数。
time.ctime([secs]) 功能同上，将一个秒数时间戳表示的时间转换为一个表示当前本地时间的字符串。如果参数secs没有提供或值为None，则取time()方法的返回值作为默认值。ctime(secs)等价于asctime(localtime(secs))
time.time() 返回时间戳（自1970-1-1 0:00:00 至今所经历的秒数）
time.localtime([secs]) 返回以指定时间戳对应的本地时间的 struct_time对象格式（可以通过下标，也可以通过 .属性名 的方式来引用内部属性）
time.localtime(time.time() + n*3600) 返回n个小时后本地时间的 struct_time对象格式（可以用来实现类似crontab的功能）
time.gmtime([secs]) 返回指定时间戳对应的utc时间的 struct_time对象格式
time.gmtime(time.time() + n*3600) 返回n个小时后utc时间的 struct_time对象（可以通过 .属性名 的方式来引用内部属性）格式
time.strptime(time_str, time_format_str) 将时间字符串转换为struct_time时间对象，如：time.strptime('2017-01-13 17:07', '%Y-%m-%d %H:%M')
time.mktime(struct_time_instance) 将struct_time对象实例转换成时间戳
time.strftime(time_format_str, struct_time_instance) 将struct_time对象实例转换成字符串

获取时间戳格式的时间

1
2
>>> time.time()
1486188022.862

获取struct_time格式的时间

1
2
3
4
>>> time.localtime()
time.struct_time(tm_year=2018, tm_mon=4, tm_mday=29, tm_hour=16, tm_min=7, tm_sec=36, tm_wday=6, tm_yday=119, tm_isdst=0)
>>> time.gmtime()#返回指定时间戳对应的utc时间的 struct_time对象格式
time.struct_time(tm_year=2018, tm_mon=4, tm_mday=29, tm_hour=8, tm_min=8, tm_sec=37, tm_wday=6, tm_yday=119, tm_isdst=0)

获取字符串格式的时间

1
2
3
4
>>> time.ctime()
'Sun Apr 29 16:10:07 2018'
>>> time.asctime()
'Sun Apr 29 16:10:13 2018'

时间戳格式转struct_time格式时间

1
2
3
4
5
6
7
8
9
>>> t1 = time.time()
>>> print(t1)
1524989702.20803
>>> t2 = time.localtime(t1)
>>> print(t2)
time.struct_time(tm_year=2018, tm_mon=4, tm_mday=29, tm_hour=16, tm_min=15, tm_sec=2, tm_wday=6, tm_yday=119, tm_isdst=0)
>>> t3 = time.gmtime(t1)#返回指定时间戳对应的utc时间的 struct_time对象格式
>>> print(t3)
time.struct_time(tm_year=2018, tm_mon=4, tm_mday=29, tm_hour=8, tm_min=15, tm_sec=2, tm_wday=6, tm_yday=119, tm_isdst=0)

2. 时间格式转换

时间戳格式的时间 与 字符串格式的时间 虽然可以通过ctime([secs])方法进行转换，但是字符串格式不太适应中国国情。因此，整体而言，它们 不能直接进行转换，需要通过struct_time作为中介，转换关系如下：

2017021616254730

说明：上面的 ‘%H:%M:%S’ 可以直接用 ‘%X’ 代替。

四、 datetime模块

datetime模块提供了处理日期和时间的类，既有简单的方式，又有复杂的方式。它虽然支持日期和时间算法，但其实现的重点是为输出格式化和操作提供高效的属性提取功能。

1. datetime模块中定义的类

datetime模块定义了以下几个类：

类名称 描述
datetime.date 表示日期，常用的属性有：year, month和day
datetime.time 表示时间，常用属性有：hour, minute, second, microsecond
datetime.datetime 表示日期时间
datetime.timedelta 表示两个date、time、datetime实例之间的时间间隔，分辨率（最小单位）可达到微秒
datetime.tzinfo 时区相关信息对象的抽象基类。它们由datetime和time类使用，以提供自定义时间的而调整。
datetime.timezone Python 3.2中新增的功能，实现tzinfo抽象基类的类，表示与UTC的固定偏移量

需要说明的是：这些类的对象都是不可变的。

类之间的关系：

1
2
3
4
5
6
7
object
timedelte
tzinfo
timezone
time
date
datetime

2. datetime模块中定义的常量

常量名称 描述
datetime.MINYEAR datetime.date或datetime.datetime对象所允许的年份的最小值，值为1
datetime.MAXYEAR datetime.date或datetime.datetime对象所允许的年份的最大值，只为9999

3. datetime.date类

datetime.date类的定义：

1
date(year, month, day) --> date object

year, month 和 day都是是必须参数，各参数的取值范围为：

参数名称 取值范围
year [MINYEAR, MAXYEAR]
month [1, 12]
day [1, 指定年份的月份中的天数]

类方法和属性

类方法/属性名称 描述
date.max date对象所能表示的最大日期：9999-12-31
date.min date对象所能表示的最小日志：00001-01-01
date.resoluation date对象表示的日期的最小单位：天
date.today() 返回一个表示当前本地日期的date对象
date.fromtimestamp(timestamp) 根据跟定的时间戳，返回一个date对象 
1
2
3
4
5
6
7
8
9
10
11
12
13
>>> import time
>>> from datetime import date
>>> 
>>> date.max
datetime.date(9999, 12, 31)
>>> date.min
datetime.date(1, 1, 1)
>>> date.resolution
datetime.timedelta(1)
>>> date.today()
datetime.date(2018, 4, 29)
>>> date.fromtimestamp(time.time())
datetime.date(2018, 4, 29)

对象方法和属性

对象方法/属性名称 描述
d.year 年
d.month 月
d.day 日
d.replace(year[, month[, day]]) 生成并返回一个新的日期对象，原日期对象不变
d.timetuple() 返回日期对应的time.struct_time对象
d.toordinal() 返回日期是是自 0001-01-01 开始的第多少天
d.weekday() 返回日期是星期几，[0, 6]，0表示星期一
d.isoweekday() 返回日期是星期几，[1, 7], 1表示星期一
d.isocalendar() 返回一个元组，格式为：(year, week_number, isoweekday)
d.isoformat() 返回‘YYYY-MM-DD'格式的日期字符串
d.strftime(format) 返回指定格式的日期字符串，与time模块的strftime(format, struct_time)功能相同 
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
>>> d = date.today()
>>> d.year
2018
>>> d.month
4
>>> d.day
29
>>> d.replace(2015)
datetime.date(2015, 4, 29)
>>> d.replace(2015,3,3)
datetime.date(2015, 3, 3)
>>> d.timetuple()
time.struct_time(tm_year=2018, tm_mon=4, tm_mday=29, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=119, tm_isdst=-1)
>>> d.toordinal()
736813
>>> d.weekday()
6
>>> d.isoweekday()
7
>>> d.isocalendar()
(2018, 17, 7)
>>> d
datetime.date(2018, 4, 29)
>>> d.isoformat()
'2018-04-29'
>>> d.ctime()
'Sun Apr 29 00:00:00 2018'
>>> d.strftime('%Y/%m/%d')
'2018/04/29'

4. datetime.time类

time类的定义:

1
time([hour[, minute[, second[, microsecond[, tzinfo]]]]]) --> a time object

hour为必须参数，其他为可选参数。各参数的取值范围为：

参数名称 取值范围
hour [0, 23]
minute [0, 59]
second [0, 59]
microsecond [0, 1000000]
tzinfo tzinfo的子类对象，如timezone类的实例

类方法和属性

类方法/属性名称 描述
time.max time类所能表示的最大时间：time(23, 59, 59, 999999)
time.min time类所能表示的最小时间：time(0, 0, 0, 0)
time.resolution 时间的最小单位，即两个不同时间的最小差值：1微秒 
1
2
3
4
5
6
7
>>> from datetime import time
>>> time.max
datetime.time(23, 59, 59, 999999)
>>> time.min
datetime.time(0, 0)
>>> time.resolution
datetime.timedelta(0, 0, 1)

对象方法和属性

对象方法/属性名称 描述
t.hour 时
t.minute 分
t.second 秒
t.microsecond 微秒
t.tzinfo 返回传递给time构造方法的tzinfo对象，如果该参数未给出，则返回None
t.replace(hour[, minute[, second[, microsecond[, tzinfo]]]]) 生成并返回一个新的时间对象，原时间对象不变
t.isoformat() 返回一个‘HH:MM:SS.%f'格式的时间字符串
t.strftime() 返回指定格式的时间字符串，与time模块的strftime(format, struct_time)功能相同 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
>>> t=time(20,3,55,6789)
>>> t.hour
20
>>> t.minute
3
>>> t.second
55
>>> t.microsecond
6789
>>> print(t.tzinfo)
None
>>> t.replace(03)
datetime.time(3, 3, 55, 6789)
>>> t.isoformat()
'20:03:55.006789'
>>> t.strftime('%H%M%S')
'200355'
>>> t.strftime('%H%M%S.%f')
'200355.006789'

5. datetime.datetime类

datetime类的定义

1
datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])

year, month和day是必须要传递的参数，tzinfo可以是None或tzinfo子类的实例。

各参数的取值范围为：

参数名称 取值范围
year [MINYEAR, MAXYEAR]
month [1, 12]
day [1, 指定年份的月份中的天数]
hour [0, 23]
minute [0, 59]
second [0, 59]
microsecond [0, 1000000]
tzinfo tzinfo的子类对象，如timezone类的实例

如果一个参数超出了这些范围，会引起ValueError异常。

类方法和属性

类方法/属性名称 描述
datetime.today() 返回一个表示当前本期日期时间的datetime对象
datetime.now([tz]) 返回指定时区日期时间的datetime对象，如果不指定tz参数则结果同上
datetime.utcnow() 返回当前utc日期时间的datetime对象
datetime.fromtimestamp(timestamp[, tz]) 根据指定的时间戳创建一个datetime对象
datetime.utcfromtimestamp(timestamp) 根据指定的时间戳创建一个datetime对象
datetime.combine(date, time) 把指定的date和time对象整合成一个datetime对象
datetime.strptime(date_str, format) 将时间字符串转换为datetime对象 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> from datetime import datetime, timezone, date
>>> datetime.today()
datetime.datetime(2018, 4, 29, 17, 13, 40, 956245)
>>> datetime.now()
datetime.datetime(2018, 4, 29, 17, 14, 16, 872156)
>>> datetime.utcnow()
datetime.datetime(2018, 4, 29, 9, 14, 34, 280177)
>>> import time
>>> datetime.fromtimestamp(time.time())
datetime.datetime(2018, 4, 29, 17, 15, 27, 266250)
>>> datetime.utcfromtimestamp(time.time())
datetime.datetime(2018, 4, 29, 9, 16, 11, 24812)
>>> datetime.combine(datetime.date(2018,2,3),t)

>>> datetime.strptime('2017/02/04 20:49', '%Y/%m/%d %H:%M')
datetime.datetime(2017, 2, 4, 20, 49)

对象方法和属性

对象方法/属性名称 描述
dt.year, dt.month, dt.day 年、月、日
dt.hour, dt.minute, dt.second 时、分、秒
dt.microsecond, dt.tzinfo 微秒、时区信息
dt.date() 获取datetime对象对应的date对象
dt.time() 获取datetime对象对应的time对象， tzinfo 为None
dt.timetz() 获取datetime对象对应的time对象，tzinfo与datetime对象的tzinfo相同
dt.replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]]) 生成并返回一个新的datetime对象，如果所有参数都没有指定，则返回一个与原datetime对象相同的对象
dt.timetuple() 返回datetime对象对应的tuple（不包括tzinfo）
dt.utctimetuple() 返回datetime对象对应的utc时间的tuple（不包括tzinfo）
dt.toordinal() 同date对象
dt.weekday() 同date对象
dt.isocalendar() 同date独享
dt.isoformat([sep]) 返回一个‘%Y-%m-%d'
dt.ctime() 等价于time模块的time.ctime(time.mktime(d.timetuple()))
dt.strftime(format) 返回指定格式的时间字符串 
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
>>> from datetime import datetime, timezone
>>> dt=datetime.now()
>>> dt
datetime.datetime(2018, 4, 29, 17, 33, 26, 541752)
>>> dt.year
2018
>>> dt.timestamp()
1524994406.541752
>>> dt.date()
datetime.date(2018, 4, 29)
>>> dt.time()
datetime.time(17, 33, 26, 541752)
>>> dt.timetz()
datetime.time(17, 33, 26, 541752)
>>> dt.replace(2017)
datetime.datetime(2017, 4, 29, 17, 33, 26, 541752)
>>> dt.timetuple()
time.struct_time(tm_year=2018, tm_mon=4, tm_mday=29, tm_hour=17, tm_min=33, tm_sec=26, tm_wday=6, tm_yday=119, tm_isdst=-1)
>>> dt.utctimetuple()
time.struct_time(tm_year=2018, tm_mon=4, tm_mday=29, tm_hour=17, tm_min=33, tm_sec=26, tm_wday=6, tm_yday=119, tm_isdst=0)
>>> dt.toordinal()
736813
>>> dt.weekday()
6
>>> dt.isoweekday()
7
>>> dt.isocalendar()
(2018, 17, 7)
>>> dt.isoformat()
'2018-04-29T17:33:26.541752'
>>> dt.isoformat('/')
'2018-04-29/17:33:26.541752'
>>> dt.isoformat(' ')
'2018-04-29 17:33:26.541752'
>>> dt.ctime()
'Sun Apr 29 17:33:26 2018'
>>> dt.strftime('%Y%m%d %H:%M:%S.%f')
'20180429 17:33:26.541752'

6. 使用datetime.datetime类对时间戳与时间字符串进行转换

2017021616254731

7.datetime.timedelta类

timedelta对象表示连个不同时间之间的差值。如果使用time模块对时间进行算术运行，只能将字符串格式的时间 和 struct_time格式的时间对象 先转换为时间戳格式，然后对该时间戳加上或减去n秒，最后再转换回struct_time格式或字符串格式，这显然很不方便。而datetime模块提供的timedelta类可以让我们很方面的对datetime.date, datetime.time和datetime.datetime对象做算术运算，且两个时间之间的差值单位也更加容易控制。
这个差值的单位可以是：天、秒、微秒、毫秒、分钟、小时、周。

datetime.timedelta类的定义:

1
class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, hours=0, weeks=0)

所有参数都是默认参数，因此都是可选参数。参数的值可以是整数或浮点数，也可以是正数或负数。内部值存储days、seconds 和 microseconds，其他所有参数都将被转换成这3个单位：

  • 1毫秒转换为1000微秒
  • 1分钟转换为60秒
  • 1小时转换为3600秒
  • 1周转换为7天

然后对这3个值进行标准化，使得它们的表示是唯一的：

  • microseconds : [0, 999999]
  • seconds : [0, 86399]
  • days : [-999999999, 999999999]

类属性

类属性名称 描述
timedelta.min timedelta(-999999999)
timedelta.max timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999)
timedelta.resolution timedelta(microseconds=1)

实例方法和属性

实例方法/属性名称 描述
td.days 天 [-999999999, 999999999]
td.seconds 秒 [0, 86399]
td.microseconds 微秒 [0, 999999]
td.total_seconds() 时间差中包含的总秒数，等价于: td / timedelta(seconds=1) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> import datetime
>>> datetime.timedelta(365).total_seconds()
31536000.0
>>> dt=datetime.datetime.now()
>>> dt
datetime.datetime(2018, 4, 29, 17, 47, 57, 449792)
>>> dt+datetime.timedelta(3)#三天后
datetime.datetime(2018, 5, 2, 17, 47, 57, 449792)
>>> dt+datetime.timedelta(-3)
datetime.datetime(2018, 4, 26, 17, 47, 57, 449792)
>>> dt+datetime.timedelta(hours=3)
datetime.datetime(2018, 4, 29, 20, 47, 57, 449792)
>>> dt+datetime.timedelta(hours=-3)
datetime.datetime(2018, 4, 29, 14, 47, 57, 449792)
>>> dt+datetime.timedelta(hours=3,seconds=30)
datetime.datetime(2018, 4, 29, 20, 48, 27, 449792)

五、时间格式码

time模块的struct_time以及datetime模块的datetime、date、time类都提供了strftime()方法，该方法是用来格式化一个日期、日期时间和时间，可以输出一个指定格式的时间字符串。相反strptime()函数就是从字符串表示的日期时间按格式化字符串要求转换为相应的日期时间。

对于time对象来说，格式化字符串不要使用年、月、日相关的字符，因为time对象没有相应的值。如果不幸使用了，只能默认输出为0值。

对于date对象来说，格式化字符串不要使用时、分、秒和微秒相关的字符，因为date对象没有相应的值。如果使用了，只能默认输出为0值。

由于strftime()函数是调用C语言lib库来实现的，所以在不同平台都支持，具体特定平台支持的细节，需要在平台上查看strftime文档说明。

下面列表符合C89和C99标准的格式化字符：

格式字符 意义 例子 注意事项
%a 星期几的英语缩写 Sun, Mon, …, Sat(en_US); So, Mo, …, Sa(de_DE)
%A 星期几的英语全称 Sunday, Monday, …, Saturday(en_US)
%w 星期几采用数字表示，0表示星期日，6表示星期六。 0，1，…，6
%d 用0补充的两位日期数字。 01，02，…，31
%b 月份采用缩写字符表示。 Jan, Feb,…, Dec(en_US)
%B 月份采用全名称表示。 January, February, …,December(en_US)
%m 月份采用0补充的两位数表示。 01，02，…，12
%y 年份采用0补充的两位数表示。 00，01，…，99
%Y 采用四位数表示的年份。 0001，0002，…，2013，2014，2015，…，9998，9999
%H 以0补充的24小时表示的小时。 00，01，…，23
%I 以0补充的12小时表示的小时。 00，01，…，12
%p 本地时间是上午还是下午。 AM，PM(en_US)
%M 以0补充的分钟表示。 00，01，…，59
%S 以0补充的秒表示。 00，01，…，59
%f 以0补充的微秒表示。 000000，000001，…，999999
%z UTC偏移表示为+HHMM或-HHMM。 (empty)，+0000,-0400,+1030，…
%Z 时区名称。 (empty)，UTC，EST，CST，…
%j 以0补充的年的天数。 001，002，…，366
%U 一年里第几周，星期日作为一周开始。 00，01，…，53
%W 一年里第几周，星期一作为一周开始。 00，01，…，53
%c 采用本地合适日期和时间表示。 Tue Aug 16 21:30:00 1988(en_US)
%x 采用本地合适日期表示。 08/16/88(None);08/16/1988(en_US)
%% 输出百分号%。 %

六、pytz模块与tzlocal模块

  • pytz模块将时区信息数据库引入python，此信息库又称TZ database、Zoneinfo database，是一个主要应用于电脑程序以及操作系统的，可协作编辑世界时区信息的数据库。由于该数据库由David Olson创立，因而有些地方也将其称作Olson数据库。
  • tzlocal返回一个 包含当地的时区信息的tzinfo 对象（需要使用pytz）。
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
>>> import pytz
>>> from datetime import datetime, timedelta
>>> import time
>>> print(pytz.country_timezones("cn"))
['Asia/Shanghai', 'Asia/Urumqi']
>>> nytz=pytz.timezone('America/New_York')
>>> shtz=pytz.timezone('Asia/Shanghai')
>>> fmt = '%Y-%m-%d %H:%M:%S %Z%z'
>>> datetime.datetime.now(nytz).strftime(fmt)
'2018-04-29 20:48:07 EDT-0400'
>>> sh_time=datetime.datetime.now(shtz).strftime(fmt)
'2018-04-30 08:48:08 CST+0800'
#获取当前时区信息
>>> from tzlocal import get_localzone
>>> local_tz=get_localzone()
>>> local_tz
<DstTzInfo 'Asia/Shanghai' LMT+8:06:00 STD>
>>> local_date = datetime.datetime.now(pytz.timezone(str(get_localzone())))
>>> local_date
datetime.datetime(2018, 4, 30, 9, 42, 29, 234674, tzinfo=<DstTzInfo 'Asia/Shanghai' CST+8:00:00 STD>)
>>> local_date = datetime.datetime.now()
>>> local_date
datetime.datetime(2018, 4, 30, 9, 42, 53, 241570)
##
>>> eastern = pytz.timezone('US/Eastern')
>>> amsterdam = pytz.timezone('Europe/Amsterdam')
>>> type(eastern)
<class 'pytz.tzfile.US/Eastern'>
>>> loc_dt = eastern.localize(datetime(2002, 10, 27, 6, 0, 0))
>>> type(loc_dt)
<class 'datetime.datetime'>
>>> print(loc_dt.strftime(fmt))
2002-10-27 06:00:00 EST-0500
>>> ams_dt = loc_dt.astimezone(amsterdam)
>>> ams_dt.strftime(fmt)
'2002-10-27 12:00:00 CET+0100'

七、总结

那么Python中处理时间时，使用time模块好，还是用datetime模块好呢？就我个人而言，datetime模块基本上可以满足需要，且用起来确实比较方便。对于time模块，我只是在取当前时间的时间戳时会用到time.time()方法，当然也可以通过datetime.datetime.now().timestamp()来获取，只是显得复杂一点。我觉得还是看个人习惯吧，没有什么绝对的好坏之分。