Python 内置模块之 时间模块 datetime

概述

datatime模块重新封装了time模块，提供更多接口，datetime库定义了2个常量和5个类。

2个常量分别是：

1. MINYEAR=1
2. MAXYEAR=9999

5个类分别是：

1. date类：表示日期的类
2. time类：表示时间的类
3. datetime类：表示时间日期的类
4. timedelta类：表示两个datetime对象的差值；
5. tzinfo类：表示时区的相关信息

1、date类

构造函数

__new__(year,month,day)：默认的构造函数，创建date类的对象时直接传入year，month，day三个参数即可返回对应的日期。

fromtimestamp(t)：使用时间戳构造对象，使用方法为：datetime.date.fromtimestamp(t)，传入参数t为一个时间戳，返回时间戳t对应的日期。

today()：使用今天的日期构造对象，使用方法为：datetime.date.today()，无参数，返回今天的日期。

fromordinal(n)：使用日期序数构造对象，使用方法为：datetime.date.fromordinal(n)，传入参数为一个整数序数，代表从公元1年1月1日开始的序数，序数每增加1代表增加1天，返回最终计算出的日期。

方法

1. timetuple()：返回日期对应的time.struct_time对象，格式为time.struct_time(tm_year=1, tm_mon=1, tm_mday=2, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=2, tm_isdst=-1) 。
2. toordinal()：相当于fromordinal(n)的逆过程，返回值即为fromordinal(n)中的日期序数n。
3. weekday()：返回该日期对应星期几，用[0,6]代表星期一到星期日。
4. isoweekday()：作用同weekday()，用[1,7]代表星期一到星期日。
5. isocalendar()：返回一个三元组，格式为(year,week_number,weekday)，分别代表年，第几周，星期几。
6. isoformat()：返回标准日期格式：YYYY-MM-DD。
7. ctime()：返回格式为：Sat Sep 8 00:00:00 2018
8. strftime(format)：把日期按照format指定的格式进行格式化，具体的格式化符号如下。
9. replace(year,month,day)：传入参数为year，month，day，返回对应的新日期。

%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）
%f 小数秒(000000-999999)
%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 当前时区的名称
%% %号本身

eg：
%Y-%m-%d %H:%M:%S.%f    2021-11-11 10:52:16.000001

示例

from datetime import *
import time


print('date.max:', date.max)             # date.max: 9999-12-31
print('date.min:', date.min)             # date.min: 0001-01-01
print('date.today():', date.today())     # date.today(): 2016-10-26
print('date.fromtimestamp():', date.fromtimestamp(time.time()))   # date.fromtimestamp(): 2016-10-26

now = date(2016, 10, 26)
tomorrow = now.replace(day = 27)
print('now:', now, ', tomorrow:', tomorrow)   # now: 2016-10-26 , tomorrow: 2016-10-27
print('timetuple():', now.timetuple())        # timetuple(): time.struct_time(tm_year=2016, tm_mon=10, tm_mday=26, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=300, tm_isdst=-1) 
print('weekday():', now.weekday())            # weekday(): 2 
print('isoweekday():', now.isoweekday())      # isoweekday(): 3
print('isocalendar():', now.isocalendar())    # isocalendar(): (2016, 43, 3)
print('isoformat():', now.isoformat())        # isoformat(): 2016-10-26
print('strftime():', now.strftime("%Y-%m-%d"))# strftime(): 2016-10-26

2、time类

构造函数

__new__(hour=0, minute=0, second=0, microsecond=0, tzinfo=None, fold=0)：默认的构造函数，创建time类的对象时直接传入相应参数即可返回对应的时间。

方法

1. isoformat()：返回标准时间格式：HH:MM:SS.mmmmmm+zz:zz。
2. strftime(format)：把时间按照format指定的格式进行格式化，具体的格式化符号与date类中介绍的相同。
3. utcoffset()：返回timezone的偏移量。
4. tzname()：返回timezone的名称。
5. replace()：传入对应的参数，返回新的时间。

示例

from  datetime import *


tm = time(23, 46, 10)
print('tm:', tm)
print('hour: %d, minute: %d, second: %d, microsecond: %d' % (tm.hour, tm.minute, tm.second, tm.microsecond))
tm1 = tm.replace(hour=20)
print('tm1:', tm1)
print('isoformat():', tm.isoformat())
print('strftime()', tm.strftime("%X"))


# tm: 23:46:10
# hour: 23, minute: 46, second: 10, microsecond: 0
# tm1: 20:46:10
# isoformat(): 23:46:10
# strftime() 23:46:10

3、datetime类

datetime类是date类和time类的合体，包含前两个类的全部参数。

构造函数

__new__(year, month, day, hour=0, minute=0, second=0,microsecond=0, tzinfo=None, fold=0)：默认的构造函数，创建datetime类的对象时直接传入相应参数即可返回对应的时间日期。

fromtimestamp(t)：使用时间戳构造对象，传入参数t为一个时间戳，返回时间戳t对应的日期和时间。

utcfromtimestamp(t)：使用时间戳构造对象，传入参数t为一个时间戳，返回时间戳t对应的UTC（时间标准时间）日期和时间。

now()：使用当前日期和时间构造对象，无参数，返回当前的日期和时间。

utcnow()：使用当前日期和时间构造对象，无参数，返回当前的UTC（时间标准时间）日期和时间。

combine(date,time)：使用date和time构造对象，传入参数为1个date对象和1个time对象，返回计算出的日期。

方法

1. timetuple()：返回日期时间对应的time.struct_time对象，格式为time.struct_time(tm_year=1973, tm_mon=11, tm_mday=29, tm_hour=21, tm_min=33, tm_sec=9, tm_wday=3, tm_yday=333, tm_isdst=-1) 。
2. utctimetuple()：与timetuple()相似，返回日期时间对应的UTC（时间标准时间）time.struct_time对象。
3. astimezone()：返回的格式中加入时区信息，格式为：1973-11-29 21:33:09+08:00。
4. date()：返回date部分
5. time()：返回time部分，tzinfo设置为None。（另有timetz()方法返回有相同tzinfo的time()）
6. isoformat(sep)：返回标准日期时间格式，传入参数sep可设置日期和时间的分隔符，默认为'T'：1973-11-29T21:33:09。
7. ctime()：返回格式为：Sat Sep 8 00:00:00 2018
8. strftime(format)：把日期按照format指定的格式进行格式化，具体的格式化符号与date类中介绍的相同。
9. strptime(date_string,format)：将字符串格式转换为日期格式，具体的格式化符号与date类中介绍的相同。
10. replace()：传入对应的参数，返回新的日期时间。

示例

from  datetime import *
import time


print('datetime.max:', datetime.max)
print('datetime.min:', datetime.min)
print('datetime.resolution:', datetime.resolution)
print('today():', datetime.today())
print('now():', datetime.now())
print('utcnow():', datetime.utcnow())
print('fromtimestamp(tmstmp):', datetime.fromtimestamp(time.time()))
print('utcfromtimestamp(tmstmp):', datetime.utcfromtimestamp(time.time()))

# datetime.max: 9999-12-31 23:59:59.999999
# datetime.min: 0001-01-01 00:00:00
# datetime.resolution: 0:00:00.000001
# today(): 2016-10-26 23:12:51.307000
# now(): 2016-10-26 23:12:51.307000
# utcnow(): 2016-10-26 15:12:51.307000
# fromtimestamp(tmstmp): 2016-10-26 23:12:51.307000
# utcfromtimestamp(tmstmp): 2016-10-26 15:12:51.307000

4、timedelta类

timedelta类代表两个datetime对象之间的时间差。

构造函数

__new__(days=0, seconds=0, microseconds=0,milliseconds=0, minutes=0, hours=0, weeks=0)：默认的构造函数，创建timedelta类的对象时直接传入相应参数即可返回对应单位的时间差。

方法

1. 支持两个timedelta对象之间的加、减操作。
2. 支持对一个timedelta进行取正、取负、取绝对值等操作。
3. 支持两个timedelta对象之间的比较。
4. 支持一个timedelta对象乘以、除以一个整数的操作

示例

# coding:utf-8
from  datetime import *

dt = datetime.now()
dt1 = dt + timedelta(days=-1) # 昨天
dt2 = dt - timedelta(days=1)  # 昨天
dt3 = dt + timedelta(days=1)  # 明天
delta_obj = dt3-dt
print(type(delta_obj),delta_obj)                  # <type 'datetime.timedelta'> 1 day, 0:00:00
print(delta_obj.days ,delta_obj.total_seconds())  # 1 86400.0

5、tzinfo类

tzinfo类是一个虚拟基类，代表时区（time zone），创建子类时必须重写name()，utcoffset()，dst()这三个方法。

#! /usr/bin/python
# coding=utf-8

from datetime import datetime, tzinfo,timedelta

"""
tzinfo是关于时区信息的类
tzinfo是一个抽象类，所以不能直接被实例化
"""
class UTC(tzinfo):
    """UTC"""
    def __init__(self,offset = 0):
        self._offset = offset

    def utcoffset(self, dt):
        return timedelta(hours=self._offset)

    def tzname(self, dt):
        return "UTC +%s" % self._offset

    def dst(self, dt):
        return timedelta(hours=self._offset)

#北京时间
beijing = datetime(2011,11,11,0,0,0,tzinfo = UTC(8))
print "beijing time:",beijing
#曼谷时间
bangkok = datetime(2011,11,11,0,0,0,tzinfo = UTC(7))
print "bangkok time",bangkok
#北京时间转成曼谷时间
print "beijing-time to bangkok-time:",beijing.astimezone(UTC(7))

#计算时间差时也会考虑时区的问题
timespan = beijing - bangkok
print "时差:",timespan

#Output==================
# beijing time: 2011-11-11 00:00:00+08:00
# bangkok time 2011-11-11 00:00:00+07:00
# beijing-time to bangkok-time: 2011-11-10 23:00:00+07:00
# 时差: -1 day, 23:00:00

6、一些关于时间的计算

获取两个日期间所有月份

def get_month_range(start_day,end_day):
  months = (end_day.year - start_day.year)*12 + end_day.month - start_day.month
  month_range = ['%s-%s'%(start_day.year + mon//12,mon%12+1) 
                    for mon in range(start_day.month-1,start_day.month + months)]
  return month_range

print(get_month_range(datetime.date(2016, 1, 31),datetime.date(2017,3,26))) 
# 输出:['2016-1','2016-2','2016-3','2016-4','2016-5','2016-6','2016-7','2016-8','2016-9','2016-10','2016-11','2016-12','2017-1','2017-2','2017-3']

计算两个日期相差多少个月

import datetime
from dateutil import rrule


d1 = datetime.date(2016, 2, 29)
d2 = datetime.date(2019, 3, 31)
months = rrule.rrule(rrule.MONTHLY, dtstart=d1, until=d2).count()
print(f"months={months}")