table of Contents
1. Classes defined in the datetime module
2. Constants defined in the datetime module
6. Use datetime.datetime class to convert timestamp and time string
- UTC time Coordinated Universal Time, also known as Greenwich astronomical time and universal standard time. Corresponding to UTC time is the local time of each time zone. The time in East N zone is N hours earlier than UTC time, so UTC time + N hours is the local time in East N zone; and West N zone time is N later than UTC time. Hour, namely UTC time-N hours is the local time in West N District; China is in East 8 District, so it is 8 hours earlier than UTC time and can be expressed in UTC+8.
-
Epoch time represents the starting point of the time; it is a specific time, and the value of this time point on different platforms is not the same. For Unix, the epoch time is 1970-01-01 00:00:00 UTC.
-
timestamp (timestamp) is also called Unix time or POSIX time; it is a way of time representation, representing the number of milliseconds that have elapsed since January 1, 1970, 0:0:0, GMT, and its value is float type. But some programming language related methods return the number of seconds (Python is like this), this requires the documentation of the method. It should be noted that the timestamp is a difference, and its value has nothing to do with the time zone
1. The manifestation of time
The common time representation is:
- Timestamp
- Formatted time string
- time.struct_time() of the time module
time.struct_time contains the following attributes:
| Subscript/index | Attribute name | description |
|---|---|---|
| 0 | tm_year | Year, such as 2017 |
| 1 | tm_mon | Month, the value range is [1, 12] |
| 2 | tm_mday | The day of the month, the value range is [1-31] |
| 3 | tm_hour | Hour, the value range is [0-23] |
| 4 | tm_min | Minutes, the value range is [0, 59] |
| 5 | tm_sec | Seconds, the value range is [0, 61] |
| 6 | tm_wday | The day of the week, the value range is [0-6], 0 means Monday |
| 7 | tm_yday | The day of the year, the value range is [1, 366] |
| 8 | tm_isdst | Whether it is daylight saving time, the possible values are: 0, 1 or -1 |
There are two ways to obtain attribute values:
- It can be regarded as a special ordered immutable sequence to obtain the value of each element through the subscript/index , such as t[0]
- You can also get the value of each element by means of the attribute name , such as t.tm_year.
It should be noted that each attribute of the struct_time instance is read-only and cannot be modified.
>>> time.localtime()
time.struct_time(tm_year=2020, tm_mon=9, tm_mday=16, tm_hour=9, tm_min=33, tm_sec=16, tm_wday=2, tm_yday=260, tm_isdst=0)
>>> t=time.localtime()
>>> t[0]
2020
>>> t.tm_year
2020Two, time module
The time module is mainly used for time access and conversion. This module provides various time-related functions.
1. List of functions
| Method/attribute | description |
|---|---|
| time.altzone | Returns the time difference with UTC time, in seconds (the value is positive in the west zone, and the value is negative in the east zone). It represents the offset of the local DST time zone and is used only when daylight is not 0. |
| time.clock() | Returns the number of seconds of processor running time consumed by the current process (not including sleep time), the value is a decimal; the method Python3.3 is changed to time.process_time() |
| time.asctime([t]) | Convert a time in the form of a tuple or struct_time (which can be obtained through the gmtime() and localtime() methods) into a 24-character time string in the format: "Fri Aug 19 11:14:16 2016" . If the parameter t is not provided, the return value of localtime() is taken as the parameter. |
| time.ctime([secs]) | The function is the same as above, it converts the time represented by a second timestamp into a string representing the current local time . If the parameter secs is not provided or the value is None, the return value of the time() method is taken as the default value. ctime(secs) is equivalent to asctime(localtime(secs)) |
| time.time() | Returns the timestamp (the number of seconds that have elapsed since 1970-1-1 0:00:00) |
| time.localtime([secs]) | Return the struct_time object of the local time corresponding to the specified time timestamp (you can use the subscript or the .attribute name to refer to the internal attribute) format |
| time.localtime(time.time() + n*3600) | Return the struct_time object format of the local time after n hours (can be used to achieve a function similar to crontab) |
| time.gmtime([secs]) | Returns the struct_time object format of the UTC time corresponding to the specified timestamp (8 hours difference from the current local time) |
| time.gmtime(time.time() + n*3600) | Return the struct_time object of the utc time after n hours (you can refer to the internal attribute by means of the attribute name) format |
| time.strptime(time_str, time_format_str) | Convert a time string to a struct_time time object , such as: time.strptime('2017-01-13 17:07','%Y-%m-%d %H:%M') |
| time.mktime(struct_time_instance) | Convert struct_time object instance to timestamp |
| time.strftime(time_format_str[, struct_time_instance]) | Convert the struct_time object instance into a string , if struct_time_instance is not specified, take the time_struct object corresponding to the current local time |
Get the time in timestamp format
>>> time.time()
1600223833.5988557
Get the time in string format
>>> time.ctime()
'Sat Feb 04 14:06:42 2017'
>>> time.asctime()
'Sat Feb 04 14:06:47 2017'
>>> time.strftime('%Y-%m-%d')
'2017-02-04'Convert string format to struct_time format time (you can learn the format of time through this part)
>>> time.strptime('Sat Feb 04 14:06:42 2017')
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)
>>> time.strptime('Sat Feb 04 14:06:42 2017', '%a %b %d %H:%M:%S %Y')
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)
>>> time.strptime('2017-02-04 14:12', '%Y-%m-%d %H:%M')
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)
>>> time.strptime('2017/02/04 14:12', '%Y/%m/%d %H:%M')
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)
>>> time.strptime('201702041412', '%Y%m%d%H%M')
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 format to string format time
>>> time.strftime('%Y-%m-%d %H:%M', time.localtime())
'2017-02-04 14:19'2. Time format conversion
Although the time in the timestamp format and the time in the string format can be converted by the ctime([secs]) method, the string format is not suitable for China's national conditions. Therefore, on the whole, they cannot be converted directly, and need to use struct_time as an intermediary. The conversion relationship is as follows:
Note: The above'%H:%M:%S' can be directly replaced by'%X'.
Three, datetime module
The datetime module provides classes for handling dates and times, in both simple and complex ways. Although it supports date and time algorithms, the focus of its implementation is to provide efficient attribute extraction functions for output formatting and operations.
1. Classes defined in the datetime module
The datetime module defines the following classes:
| Class name | description |
|---|---|
| datetime.date | Represents the date, the commonly used attributes are: year, month and day |
| datetime.time | Represents the time. Common attributes are: hour, minute, second, microsecond |
| datetime.datetime | 表示日期时间 |
| datetime.timedelta | 表示两个date、time、datetime实例之间的时间间隔，分辨率（最小单位）可达到微秒 |
| datetime.tzinfo | 时区相关信息对象的抽象基类。它们由datetime和time类使用，以提供自定义时间的而调整。 |
| datetime.timezone | Python 3.2中新增的功能，实现tzinfo抽象基类的类，表示与UTC的固定偏移量 |
需要说明的是：这些类的对象都是不可变的。
类之间的关系：
object
date
datetime
time
timedelta
tzinfo
timezone
2. datetime模块中定义的常量
| 常量名称 | 描述 |
|---|---|
| datetime.MINYEAR | datetime.date或datetime.datetime对象所允许的年份的最小值，值为1 |
| datetime.MAXYEAR | datetime.date或datetime.datetime对象所允许的年份的最大值，只为9999 |
3. datetime.date类
datetime.date类的定义
class datetime.date(year, month, day)
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对象 |
>>> 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(2020, 9, 16)
>>> date.fromtimestamp(time.time())
datetime.date(2020, 9, 16)对象方法和属性
| 对象方法/属性名称 | 描述 |
|---|---|
| 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, weekday, isoweekday) |
| d.isoformat() | 返回‘YYYY-MM-DD’格式的日期字符串 |
| d.strftime(format) | 返回指定格式的日期字符串，与time模块的strftime(format, struct_time)功能相同 |
>>> d = date.today()
>>> d.year
2020
>>> d.month
9
>>> d.day
16
>>> d.replace(2016)
datetime.date(2016, 9, 16)
>>> d.year
2020
>>> d.timetuple()
time.struct_time(tm_year=2020, tm_mon=9, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=260, tm_isdst=-1)
>>> d.toordinal()
737684
>>> d.weekday()
2
>>> d.isoweekday()
3
>>> d.isocalendar()
(2020, 38, 3)
>>> d.isoformat()
'2020-09-16'
>>> d.strftime('%Y/%m/%d')
'2020/09/16'4. datetime.time类
time类的定义
class datetime.time(hour, [minute[, second, [microsecond[, tzinfo]]]])
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微秒 |
对象方法和属性
| 对象方法/属性名称 | 描述 |
|---|---|
| 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)功能相同 |
实例
>>> 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 = time(20, 5, 40, 8888)
>>> t.hour
20
>>> t.minute
5
>>> t.second
40
>>> t.microsecond
8888
>>> t.tzinfo
>>>
>>> t.replace(21)
datetime.time(21, 5, 40, 8888)
>>> t.isoformat()
'20:05:40.008888'
>>> t.strftime('%H%M%S')
'200540'
>>> t.strftime('%H%M%S.%f')
'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子类的实例。
各参数的取值范围为：
| 参数名称 | 取值范围 |
|---|---|
| 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对象 |
对象方法和属性
| 对象方法/属性名称 | 描述 |
|---|---|
| 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.timestamp() | 返回datetime对象对应的时间戳，返回值是一个类似time.time()返回的浮点型值。需要注释的是，该方法是Python 3.3才新增的 |
| dt.toordinal() | 同date对象 |
| dt.weekday() | 同date对象 |
| dt.isocalendar() | 同date对象 |
| dt.isoformat([sep]) | 返回一个‘%Y-%m-%d%H:%M:%S.%f’格式的字符串 |
| dt.ctime() | 等价于time模块的time.ctime(time.mktime(d.timetuple())) |
| dt.strftime(format) | 返回指定格式的时间字符串 |
实例
>>> from datetime import datetime, timezone
>>>
>>> datetime.today()
datetime.datetime(2017, 2, 4, 20, 44, 40, 556318)
>>> datetime.now()
datetime.datetime(2017, 2, 4, 20, 44, 56, 572615)
>>> datetime.now(timezone.utc)
datetime.datetime(2017, 2, 4, 12, 45, 22, 881694, tzinfo=datetime.timezone.utc)
>>> datetime.utcnow()
datetime.datetime(2017, 2, 4, 12, 45, 52, 812508)
>>> import time
>>> datetime.fromtimestamp(time.time())
datetime.datetime(2017, 2, 4, 20, 46, 41, 97578)
>>> datetime.utcfromtimestamp(time.time())
datetime.datetime(2017, 2, 4, 12, 46, 56, 989413)
>>> datetime.combine(date(2017, 2, 4), t)
datetime.datetime(2017, 2, 4, 20, 5, 40, 8888)
>>> datetime.strptime('2017/02/04 20:49', '%Y/%m/%d %H:%M')
datetime.datetime(2017, 2, 4, 20, 49)
>>> dt = datetime.now()
>>> dt
datetime.datetime(2017, 2, 4, 20, 57, 0, 621378)
>>> dt.year
2017
>>> dt.month
2
>>> dt.day
4
>>> dt.hour
20
>>> dt.minute
57
>>> dt.second
0
>>> dt.microsecond
621378
>>> dt.tzinfo
>>> dt.timestamp()
1486213020.621378
>>> dt.date()
datetime.date(2017, 2, 4)
>>> dt.time()
datetime.time(20, 57, 0, 621378)
>>> dt.timetz()
datetime.time(20, 57, 0, 621378)
>>> dt.replace()
datetime.datetime(2017, 2, 4, 20, 57, 0, 621378)
>>> dt.replace(2016)
datetime.datetime(2016, 2, 4, 20, 57, 0, 621378)
>>> dt.timetuple()
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)
>>> dt.utctimetuple()
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)
>>> dt.toordinal()
736364
>>> dt.weekday()
5
>>> dt.isocalendar()
(2017, 5, 6)
>>> dt.isoformat()
'2017-02-04T20:57:00.621378'
>>> dt.isoformat(sep='/')
'2017-02-04/20:57:00.621378'
>>> dt.isoformat(sep=' ')
'2017-02-04 20:57:00.621378'
>>> dt.ctime()
'Sat Feb 4 20:57:00 2017'
>>> dt.strftime('%Y%m%d %H:%M:%S.%f')
'20170204 20:57:00.621378'
6. 使用datetime.datetime类对时间戳与时间字符串进行转换
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]
类属性
| 类属性名称 | 描述 |
|---|---|
| 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) |
实例
>>> import datetime
>>>
>>> datetime.timedelta(365).total_seconds() # 一年包含的总秒数
31536000.0
>>> dt = datetime.datetime.now()
>>> dt + datetime.timedelta(3) # 3天后
datetime.datetime(2017, 2, 8, 9, 39, 40, 102821)
>>> dt + datetime.timedelta(-3) # 3天前
datetime.datetime(2017, 2, 2, 9, 39, 40, 102821)
>>> dt + datetime.timedelta(hours=3) # 3小时后
datetime.datetime(2017, 2, 5, 12, 39, 40, 102821)
>>> dt + datetime.timedelta(hours=-3) # 3小时前
datetime.datetime(2017, 2, 5, 6, 39, 40, 102821)
>>> dt + datetime.timedelta(hours=3, seconds=30) # 3小时30秒后
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实现的平台上都可以工作：
五、总结
那么Python中处理时间时，使用time模块好，还是用datetime模块好呢？我觉得还是看个人习惯吧，没有什么绝对的好坏之分。就我个人而言，datetime模块基本上可以满足需要，且用起来确实比较方便。对于time模块，在以下几种情况下比较实用：
- 取当前时间的时间戳时会用到time.time()方法，当然也可以通过datetime.datetime.now().timestamp()来获取，只是显得复杂一点；
- 同样，如果想获取当前本地时间的字符串格式（如生成一个备份文件或日志文件的名称）直接使用time.strtime(format)会更简洁一点，当然也可以通过datetime.datetime.now().strftime(format)来实现；
- 但是，如果需要把一个时间字符串转换为一个时间戳，且使用的是Python 2时，应该使用time模块，因为datetime.timestamp()方法是在Python 3.3才新增的方法。