Python之日期与时间处理模块（date和datetime）

旧城等待， 2021-09-16 07:26 425阅读 0赞

# [来源][Link 1] #

# #

## 本节内容 ##

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

1.  前言
2.  相关术语的解释
3.  时间的表现形式
4.  time模块
5.  datetime模块
6.  时间格式码
7.  总结

## 前言 ##

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

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

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

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

## 一、相关术语的解释 ##

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

*  ***UTC time*** Coordinated Universal Time，世界协调时，又称 格林尼治天文时间、世界标准时间。与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类***

关于datetime模块的datetime类会在下面做详细讲解，这里简单说下time.struct\_time。

time.struct\_time包含如下属性：

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

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

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

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

## 三、 time模块 ##

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

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

### 1. 函数列表 ###

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

### 2. 练习 ###

获取时间戳格式的时间

1.  `>>> time.time()`
2.  `1486188022.862`

获取struct\_time格式的时间

1.  `>>> time.localtime()`
2.  `time.struct_time(tm_year=2017, tm_mon=2, tm_mday=4, tm_hour=14, tm_min=2, tm_sec=34, tm_wday=5, tm_yday=35, tm_isdst=0)`
3.  `>>> time.gmtime()`
4.  `time.struct_time(tm_year=2017, tm_mon=2, tm_mday=4, tm_hour=6, tm_min=2, tm_sec=56, tm_wday=5, tm_yday=35, tm_isdst=0)`

获取字符串格式的时间

1.  `>>> time.ctime()`
2.  `'Sat Feb 04 14:06:42 2017'`
3.  `>>> time.asctime()`
4.  `'Sat Feb 04 14:06:47 2017'`

时间戳格式转struct\_time格式时间

1.  `>>> t1 = time.time()`
2.  `>>> print(t1)`
3.  `1486188476.9`
4.  `>>> t2 = time.localtime(t1)`
5.  `>>> print(t2)`
6.  `time.struct_time(tm_year=2017, tm_mon=2, tm_mday=4, tm_hour=14, tm_min=7, tm_sec=56, tm_wday=5, tm_yday=35, tm_isdst=0)`
7.  `>>> t3 = time.gmtime(t1)`
8.  `>>> print(t3)`
9.  `time.struct_time(tm_year=2017, tm_mon=2, tm_mday=4, tm_hour=6, tm_min=7, tm_sec=56, tm_wday=5, tm_yday=35, tm_isdst=0)`
10. `>>>`

字符串格式转struct\_time格式时间

1.  `>>> time.strptime('Sat Feb 04 14:06:42 2017')`
2.  `time.struct_time(tm_year=2017, tm_mon=2, tm_mday=4, tm_hour=14, tm_min=6, tm_sec=42, tm_wday=5, tm_yday=35, tm_isdst=-1)`
3.  `>>> time.strptime('Sat Feb 04 14:06:42 2017', '%a %b %d %H:%M:%S %Y')`
4.  `time.struct_time(tm_year=2017, tm_mon=2, tm_mday=4, tm_hour=14, tm_min=6, tm_sec=42, tm_wday=5, tm_yday=35, tm_isdst=-1)`
5.  `>>> time.strptime('2017-02-04 14:12', '%Y-%m-%d %H:%M')`
6.  `time.struct_time(tm_year=2017, tm_mon=2, tm_mday=4, tm_hour=14, tm_min=12, tm_sec=0, tm_wday=5, tm_yday=35, tm_isdst=-1)`
7.  `>>> time.strptime('2017/02/04 14:12', '%Y/%m/%d %H:%M')`
8.  `time.struct_time(tm_year=2017, tm_mon=2, tm_mday=4, tm_hour=14, tm_min=12, tm_sec=0, tm_wday=5, tm_yday=35, tm_isdst=-1)`
9.  `>>> time.strptime('201702041412', '%Y%m%d%H%M')`
10. `time.struct_time(tm_year=2017, tm_mon=2, tm_mday=4, tm_hour=14, tm_min=12, tm_sec=0, tm_wday=5, tm_yday=35, tm_isdst=-1)`

struct\_time格式转字符串格式时间

1.  `>>> time.strftime('%Y-%m-%d %H:%M', time.localtime())`
2.  `'2017-02-04 14:19'`

struct\_time格式转时间戳格式时间

1.  `>>> time.mktime(time.localtime())`
2.  `1486189282.0`

### 3. 时间格式转换 ###

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

![1063221-20170204153018854-1098926175.png][]

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

## 四、 datetime模块 ##

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

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

### 1. datetime模块中定义的类 ###

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

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

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

类之间的关系：

1.  `object`
2.  `date`
3.  `datetime`
4.  `time`
5.  `timedelta`
6.  `tzinfo`
7.  `timezone`

### 2. datetime模块中定义的常量 ###

<table> 
 <thead> 
  <tr> 
   <th>常量名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>datetime.MINYEAR</td> 
   <td>datetime.date或datetime.datetime对象所允许的年份的最小值，值为1</td> 
  </tr> 
  <tr> 
   <td>datetime.MAXYEAR</td> 
   <td>datetime.date或datetime.datetime对象所允许的年份的最大值，只为9999</td> 
  </tr> 
 </tbody> 
</table>

### 3. datetime.date类 ###

datetime.date类的定义

class datetime.date(year, month, day)

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

类方法和属性

<table> 
 <thead> 
  <tr> 
   <th>类方法/属性名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>date.max</td> 
   <td>date对象所能表示的最大日期：9999-12-31</td> 
  </tr> 
  <tr> 
   <td>date.min</td> 
   <td>date对象所能表示的最小日志：00001-01-01</td> 
  </tr> 
  <tr> 
   <td>date.resoluation</td> 
   <td>date对象表示的日期的最小单位：天</td> 
  </tr> 
  <tr> 
   <td>date.today()</td> 
   <td>返回一个表示当前本地日期的date对象</td> 
  </tr> 
  <tr> 
   <td>date.fromtimestamp(timestamp)</td> 
   <td>根据跟定的时间戳，返回一个date对象</td> 
  </tr> 
 </tbody> 
</table>

对象方法和属性

<table> 
 <thead> 
  <tr> 
   <th>对象方法/属性名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>d.year</td> 
   <td>年</td> 
  </tr> 
  <tr> 
   <td>d.month</td> 
   <td>月</td> 
  </tr> 
  <tr> 
   <td>d.day</td> 
   <td>日</td> 
  </tr> 
  <tr> 
   <td>d.replace(year[, month[, day]])</td> 
   <td>生成并返回一个新的日期对象，原日期对象不变</td> 
  </tr> 
  <tr> 
   <td>d.timetuple()</td> 
   <td>返回日期对应的time.struct_time对象</td> 
  </tr> 
  <tr> 
   <td>d.toordinal()</td> 
   <td>返回日期是是自 0001-01-01 开始的第多少天</td> 
  </tr> 
  <tr> 
   <td>d.weekday()</td> 
   <td>返回日期是星期几，[0, 6]，0表示星期一</td> 
  </tr> 
  <tr> 
   <td>d.isoweekday()</td> 
   <td>返回日期是星期几，[1, 7], 1表示星期一</td> 
  </tr> 
  <tr> 
   <td>d.isocalendar()</td> 
   <td>返回一个元组，格式为：(year, weekday, isoweekday)</td> 
  </tr> 
  <tr> 
   <td>d.isoformat()</td> 
   <td>返回‘YYYY-MM-DD’格式的日期字符串</td> 
  </tr> 
  <tr> 
   <td>d.strftime(format)</td> 
   <td>返回指定格式的日期字符串，与time模块的strftime(format, struct_time)功能相同</td> 
  </tr> 
 </tbody> 
</table>

实例

1.  `>>> import time`
2.  `>>> from datetime import date`
3.  `>>>`
4.  `>>> date.max`
5.  `datetime.date(9999, 12, 31)`
6.  `>>> date.min`
7.  `datetime.date(1, 1, 1)`
8.  `>>> date.resolution`
9.  `datetime.timedelta(1)`
10. `>>> date.today()`
11. `datetime.date(2017, 2, 4)`
12. `>>> date.fromtimestamp(time.time())`
13. `datetime.date(2017, 2, 4)`
14. `>>>`
15. `>>> d = date.today()`
16. `>>> d.year`
17. `2017`
18. `>>> d.month`
19. `2`
20. `>>> d.day`
21. `4`
22. `>>> d.replace(2016)`
23. `datetime.date(2016, 2, 4)`
24. `>>> d.replace(2016, 3)`
25. `>>> d.replace(2016, 3, 2)`
26. `datetime.date(2016, 3, 2)`
27. `>>> d.timetuple()`
28. `time.struct_time(tm_year=2017, tm_mon=2, tm_mday=4, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=5, tm_yday=35, tm_isdst=-1)`
29. `>>> d.toordinal()`
30. `736364`
31. `>>> d.weekday()`
32. `5`
33. `>>> d.isoweekday()`
34. `6`
35. `>>> d.isocalendar()`
36. `(2017, 5, 6)`
37. `>>> d.isoformat()`
38. `'2017-02-04'`
39. `>>> d.ctime()`
40. `'Sat Feb 4 00:00:00 2017'`
41. `>>> d.strftime('%Y/%m/%d')`
42. `'2017/02/04'`

### 4. datetime.time类 ###

time类的定义

class datetime.time(hour, [minute[, second, [microsecond[, tzinfo]]]])

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

<table> 
 <thead> 
  <tr> 
   <th>参数名称</th> 
   <th>取值范围</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>hour</td> 
   <td>[0, 23]</td> 
  </tr> 
  <tr> 
   <td>minute</td> 
   <td>[0, 59]</td> 
  </tr> 
  <tr> 
   <td>second</td> 
   <td>[0, 59]</td> 
  </tr> 
  <tr> 
   <td>microsecond</td> 
   <td>[0, 1000000]</td> 
  </tr> 
  <tr> 
   <td>tzinfo</td> 
   <td>tzinfo的子类对象，如timezone类的实例</td> 
  </tr> 
 </tbody> 
</table>

类方法和属性

<table> 
 <thead> 
  <tr> 
   <th>类方法/属性名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>time.max</td> 
   <td>time类所能表示的最大时间：time(23, 59, 59, 999999)</td> 
  </tr> 
  <tr> 
   <td>time.min</td> 
   <td>time类所能表示的最小时间：time(0, 0, 0, 0)</td> 
  </tr> 
  <tr> 
   <td>time.resolution</td> 
   <td>时间的最小单位，即两个不同时间的最小差值：1微秒</td> 
  </tr> 
 </tbody> 
</table>

对象方法和属性

<table> 
 <thead> 
  <tr> 
   <th>对象方法/属性名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>t.hour</td> 
   <td>时</td> 
  </tr> 
  <tr> 
   <td>t.minute</td> 
   <td>分</td> 
  </tr> 
  <tr> 
   <td>t.second</td> 
   <td>秒</td> 
  </tr> 
  <tr> 
   <td>t.microsecond</td> 
   <td>微秒</td> 
  </tr> 
  <tr> 
   <td>t.tzinfo</td> 
   <td>返回传递给time构造方法的tzinfo对象，如果该参数未给出，则返回None</td> 
  </tr> 
  <tr> 
   <td>t.replace(hour[, minute[, second[, microsecond[, tzinfo]]]])</td> 
   <td>生成并返回一个新的时间对象，原时间对象不变</td> 
  </tr> 
  <tr> 
   <td>t.isoformat()</td> 
   <td>返回一个‘HH:MM:SS.%f’格式的时间字符串</td> 
  </tr> 
  <tr> 
   <td>t.strftime()</td> 
   <td>返回指定格式的时间字符串，与time模块的strftime(format, struct_time)功能相同</td> 
  </tr> 
 </tbody> 
</table>

实例

1.  `>>> from datetime import time`
2.  `>>>`
3.  `>>> time.max`
4.  `datetime.time(23, 59, 59, 999999)`
5.  `>>> time.min`
6.  `datetime.time(0, 0)`
7.  `>>> time.resolution`
8.  `datetime.timedelta(0, 0, 1)`
9.  `>>>`
10. `>>> t = time(20, 5, 40, 8888)`
11. `>>> t.hour`
12. `20`
13. `>>> t.minute`
14. `5`
15. `>>> t.second`
16. `40`
17. `>>> t.microsecond`
18. `8888`
19. `>>> t.tzinfo`
20. `>>>`
21. `>>> t.replace(21)`
22. `datetime.time(21, 5, 40, 8888)`
23. `>>> t.isoformat()`
24. `'20:05:40.008888'`
25. `>>> t.strftime('%H%M%S')`
26. `'200540'`
27. `>>> t.strftime('%H%M%S.%f')`
28. `'200540.008888'`

### 5. datetime.datetime类 ###

datetime类的定义

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

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

各参数的取值范围为：

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

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

类方法和属性

<table> 
 <thead> 
  <tr> 
   <th>类方法/属性名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>datetime.today()</td> 
   <td>返回一个表示当前本期日期时间的datetime对象</td> 
  </tr> 
  <tr> 
   <td>datetime.now([tz])</td> 
   <td>返回指定时区日期时间的datetime对象，如果不指定tz参数则结果同上</td> 
  </tr> 
  <tr> 
   <td>datetime.utcnow()</td> 
   <td>返回当前utc日期时间的datetime对象</td> 
  </tr> 
  <tr> 
   <td>datetime.fromtimestamp(timestamp[, tz])</td> 
   <td>根据指定的时间戳创建一个datetime对象</td> 
  </tr> 
  <tr> 
   <td>datetime.utcfromtimestamp(timestamp)</td> 
   <td>根据指定的时间戳创建一个datetime对象</td> 
  </tr> 
  <tr> 
   <td>datetime.combine(date, time)</td> 
   <td>把指定的date和time对象整合成一个datetime对象</td> 
  </tr> 
  <tr> 
   <td>datetime.strptime(date_str, format)</td> 
   <td>将时间字符串转换为datetime对象</td> 
  </tr> 
 </tbody> 
</table>

对象方法和属性

<table> 
 <thead> 
  <tr> 
   <th>对象方法/属性名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>dt.year, dt.month, dt.day</td> 
   <td>年、月、日</td> 
  </tr> 
  <tr> 
   <td>dt.hour, dt.minute, dt.second</td> 
   <td>时、分、秒</td> 
  </tr> 
  <tr> 
   <td>dt.microsecond, dt.tzinfo</td> 
   <td>微秒、时区信息</td> 
  </tr> 
  <tr> 
   <td>dt.date()</td> 
   <td>获取datetime对象对应的date对象</td> 
  </tr> 
  <tr> 
   <td>dt.time()</td> 
   <td>获取datetime对象对应的time对象， tzinfo 为None</td> 
  </tr> 
  <tr> 
   <td>dt.timetz()</td> 
   <td>获取datetime对象对应的time对象，tzinfo与datetime对象的tzinfo相同</td> 
  </tr> 
  <tr> 
   <td>dt.replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]])</td> 
   <td>生成并返回一个新的datetime对象，如果所有参数都没有指定，则返回一个与原datetime对象相同的对象</td> 
  </tr> 
  <tr> 
   <td>dt.timetuple()</td> 
   <td>返回datetime对象对应的tuple（不包括tzinfo）</td> 
  </tr> 
  <tr> 
   <td>dt.utctimetuple()</td> 
   <td>返回datetime对象对应的utc时间的tuple（不包括tzinfo）</td> 
  </tr> 
  <tr> 
   <td>dt.toordinal()</td> 
   <td>同date对象</td> 
  </tr> 
  <tr> 
   <td>dt.weekday()</td> 
   <td>同date对象</td> 
  </tr> 
  <tr> 
   <td>dt.isocalendar()</td> 
   <td>同date独享</td> 
  </tr> 
  <tr> 
   <td>dt.isoformat([sep])</td> 
   <td>返回一个‘%Y-%m-%d</td> 
  </tr> 
  <tr> 
   <td>dt.ctime()</td> 
   <td>等价于time模块的time.ctime(time.mktime(d.timetuple()))</td> 
  </tr> 
  <tr> 
   <td>dt.strftime(format)</td> 
   <td>返回指定格式的时间字符串</td> 
  </tr> 
 </tbody> 
</table>

实例

1.  `>>> from datetime import datetime, timezone`
2.  `>>>`
3.  `>>> datetime.today()`
4.  `datetime.datetime(2017, 2, 4, 20, 44, 40, 556318)`
5.  `>>> datetime.now()`
6.  `datetime.datetime(2017, 2, 4, 20, 44, 56, 572615)`
7.  `>>> datetime.now(timezone.utc)`
8.  `datetime.datetime(2017, 2, 4, 12, 45, 22, 881694, tzinfo=datetime.timezone.utc)`
9.  `>>> datetime.utcnow()`
10. `datetime.datetime(2017, 2, 4, 12, 45, 52, 812508)`
11. `>>> import time`
12. `>>> datetime.fromtimestamp(time.time())`
13. `datetime.datetime(2017, 2, 4, 20, 46, 41, 97578)`
14. `>>> datetime.utcfromtimestamp(time.time())`
15. `datetime.datetime(2017, 2, 4, 12, 46, 56, 989413)`
16. `>>> datetime.combine(date(2017, 2, 4), t)`
17. `datetime.datetime(2017, 2, 4, 20, 5, 40, 8888)`
18. `>>> datetime.strptime('2017/02/04 20:49', '%Y/%m/%d %H:%M')`
19. `datetime.datetime(2017, 2, 4, 20, 49)`
20. `>>> dt = datetime.now()`
21. `>>> dt`
22. `datetime.datetime(2017, 2, 4, 20, 57, 0, 621378)`
23. `>>> dt.year`
24. `2017`
25. `>>> dt.month`
26. `2`
27. `>>> dt.day`
28. `4`
29. `>>> dt.hour`
30. `20`
31. `>>> dt.minute`
32. `57`
33. `>>> dt.second`
34. `0`
35. `>>> dt.microsecond`
36. `621378`
37. `>>> dt.tzinfo`
38. `>>> dt.timestamp()`
39. `1486213020.621378`
40. `>>> dt.date()`
41. `datetime.date(2017, 2, 4)`
42. `>>> dt.time()`
43. `datetime.time(20, 57, 0, 621378)`
44. `>>> dt.timetz()`
45. `datetime.time(20, 57, 0, 621378)`
46. `>>> dt.replace()`
47. `datetime.datetime(2017, 2, 4, 20, 57, 0, 621378)`
48. `>>> dt.replace(2016)`
49. `datetime.datetime(2016, 2, 4, 20, 57, 0, 621378)`
50. `>>> dt.timetuple()`
51. `time.struct_time(tm_year=2017, tm_mon=2, tm_mday=4, tm_hour=20, tm_min=57, tm_sec=0, tm_wday=5, tm_yday=35, tm_isdst=-1)`
52. `>>> dt.utctimetuple()`
53. `time.struct_time(tm_year=2017, tm_mon=2, tm_mday=4, tm_hour=20, tm_min=57, tm_sec=0, tm_wday=5, tm_yday=35, tm_isdst=0)`
54. `>>> dt.toordinal()`
55. `736364`
56. `>>> dt.weekday()`
57. `5`
58. `>>> dt.isocalendar()`
59. `(2017, 5, 6)`
60. `>>> dt.isoformat()`
61. `'2017-02-04T20:57:00.621378'`
62. `>>> dt.isoformat(sep='/')`
63. `'2017-02-04/20:57:00.621378'`
64. `>>> dt.isoformat(sep=' ')`
65. `'2017-02-04 20:57:00.621378'`
66. `>>> dt.ctime()`
67. `'Sat Feb 4 20:57:00 2017'`
68. `>>> dt.strftime('%Y%m%d %H:%M:%S.%f')`
69. `'20170204 20:57:00.621378'`

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

![1063221-20170205083810667-126583354.png][]

### 7. datetime.timedelta类 ###

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

datetime.timedelta类的定义

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\]

类属性

<table> 
 <thead> 
  <tr> 
   <th>类属性名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>timedelta.min</td> 
   <td>timedelta(-999999999)</td> 
  </tr> 
  <tr> 
   <td>timedelta.max</td> 
   <td>timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999)</td> 
  </tr> 
  <tr> 
   <td>timedelta.resolution</td> 
   <td>timedelta(microseconds=1)</td> 
  </tr> 
 </tbody> 
</table>

实例方法和属性

<table> 
 <thead> 
  <tr> 
   <th>实例方法/属性名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>td.days</td> 
   <td>天 [-999999999, 999999999]</td> 
  </tr> 
  <tr> 
   <td>td.seconds</td> 
   <td>秒 [0, 86399]</td> 
  </tr> 
  <tr> 
   <td>td.microseconds</td> 
   <td>微秒 [0, 999999]</td> 
  </tr> 
  <tr> 
   <td>td.total_seconds()</td> 
   <td>时间差中包含的总秒数，等价于: td / timedelta(seconds=1)</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>方法/属性</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>datetime.datetime.now()</td> 
   <td>返回当前本地时间（datetime.datetime对象实例）</td> 
  </tr> 
  <tr> 
   <td>datetime.datetime.fromtimestamp(timestamp)</td> 
   <td>返回指定时间戳对应的时间（datetime.datetime对象实例）</td> 
  </tr> 
  <tr> 
   <td>datetime.timedelta()</td> 
   <td>返回一个时间间隔对象，可以直接与datetime.datetime对象做加减操作</td> 
  </tr> 
 </tbody> 
</table>

实例

1.  `>>> import datetime`
2.  `>>>`
3.  `>>> datetime.timedelta(365).total_seconds() # 一年包含的总秒数`
4.  `31536000.0`
5.  `>>> dt = datetime.datetime.now()`
6.  `>>> dt + datetime.timedelta(3) # 3天后`
7.  `datetime.datetime(2017, 2, 8, 9, 39, 40, 102821)`
8.  `>>> dt + datetime.timedelta(-3) # 3天前`
9.  `datetime.datetime(2017, 2, 2, 9, 39, 40, 102821)`
10. `>>> dt + datetime.timedelta(hours=3) # 3小时后`
11. `datetime.datetime(2017, 2, 5, 12, 39, 40, 102821)`
12. `>>> dt + datetime.timedelta(hours=-3) # 3小时前`
13. `datetime.datetime(2017, 2, 5, 6, 39, 40, 102821)`
14. `>>> dt + datetime.timedelta(hours=3, seconds=30) # 3小时30秒后`
15. `datetime.datetime(2017, 2, 5, 12, 40, 10, 102821)`

## 五、时间格式码 ##

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

time模块的struct\_time以及datetime模块的datetime、date、time类都提供了strftime()方法，该方法可 以输出一个指定格式的时间字符串。具体格式由一系列的格式码（格式字符）组成，Python最终调用的是各个平台C库的strftme()函数，因此各平台对全套格式码的支持会有所不同，具体情况需要参考该平台上的strftime(3)文档。下面列出了C标准（1989版）要求的所有格式码，它们在所有标准C实现的平台上都可以工作：

![1063221-20170205104434573-1343126060.png][]

## 六、总结 ##

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

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

[Link 1]: https://blog.csdn.net/p9bl5bxp/article/details/54945920
[1063221-20170204153018854-1098926175.png]: /images/20210520/77e2a8fd160847b897dccb2e1edd353a.png
[1063221-20170205083810667-126583354.png]: /images/20210520/570975c191154a94ad34e8bf64e13d7d.png
[1063221-20170205104434573-1343126060.png]: /images/20210520/200ec43fad9647de83fd044b06c1e668.png