python datetime time_基于Python的datetime模块和time模块源码阅读分析

最新推荐文章于 2024-04-28 00:07:35 发布

weixin_39821718

最新推荐文章于 2024-04-28 00:07:35 发布

阅读量259

点赞数

文章标签： python datetime time

1 前言

最近工作需求上对于datetime模块中的方法调用比较多，有时还要返回指定的格式，以及大小比较等情况。发现使用Python自带的datetime模块可以很好地实现相关需求，但是对于其中的具体实现原理以及相关方法的特性不是很了解，所以决定花点时间来看看datetime模块的源码以及time模块的源码，提高自己以后实现此类需求的工作效率。

一般情况下，我们引用datetime模块相关方式，引用有两种方式：

(1)

import datetime #此种引用，即包含了datetime模块所有方法，但是引用具体方法时，需要这样写：datetime.date.today()，表示获取今天的日期，要多写一个datetime

(2)

from datetime import datetime, time, timedelta, tzinfo, date #此种应用，可以看实际需求决定需要应用那个类方法，比如只应用date时，使用date.today()即可获取今天的日期

通过初步阅读datetime模块源码，datetime模块包含五个内部类，分别是：

tzinfo类(表示日期时间的时区)

date类(表示具体日期，精确到天，例如2018-7-22)

time类(表示具体时间，可精确到微秒，例如11:47:23.0001)

timedelta类(可表示具体的时间差，例如一小时时间差为timedelta(hours=1))

datetime类(表示具体日期时间，可理解为date类+time类所有属性和内部方法的结合体，例如：2018-7-22 11:49:30.0001)

注意在看datetime源码时，会发现源码包有一个datetime.pyi文件，通过查找资料得知：每一个模块源码都会有一个对于的.pyi文件，该文件只列出具体的实现方法头部代码和相关参数和返回值说明。例如，给出一篇论文的目录，具体内容可通过目录索引查看具体细节。(PS:资料种说明.pyi表示“存根文件”。)

使用time模块方式，引用方式：

import time

time模块内部只有相关调用方法，源码较少。

2 datetime.pyi源码分步解析

2.1 头部定义源码分析

importsysfrom time import struct_time #关于struct_time的具体源码，可见下文详解

from typing import(

AnyStr, Optional, SupportsAbs, Tuple, Union, overload,

ClassVar,

)#请注意其中有多个类型，可能初次见面，不太明白，下面到具体应用会详细说明

if sys.version_info >= (3,): #此处判断本地Python版本，是否大于3.0.0

_Text= str #表示_Text代表类型str

else:

_Text= Union[str, unicode] #表示_Text可选类型有str和unicode；Union功能是可以结合多个类型，但是如果类型之间有继承关系，只取优先级最高的，即辈份最高的父类

MINYEAR: int#定义默认的最小年数，为1MAXYEAR: int#定义默认的最大年数，为9999

2.2 tzinfo类源码分析

tzinfo：time zone infomation，即时区信息，从该类类名即可知道其作用为限定给定时间的时区参数提供支持。该类的对象实例传递给datetime或者time对象的构造函数，从而输出相应时区的信息，如果不传递则默认输出本地时区的对应时间信息。

classtzinfo:#下面使用的Optional类型，意思是该变量的具体实际类型或者为None，Optional[X]等同于Union[X, None]

#返回指定datetime对象的所在时区名称，返回值类型为字符串

def tzname(self, dt: Optional[datetime]) ->str: ...#返回当地时间与UTC(世界统一时间)的偏移量，返回值类型是timedelta类型

def utcoffset(self, dt: Optional[datetime]) ->Optional[timedelta]: ...#dst(daylight saving time,阳光节约时或称夏至时)，该方法用于获取夏至时调整量，一般不需要调用

def dst(self, dt: Optional[datetime]) ->Optional[timedelta]: ...#调整日期(date)和时间(time)数据，在自己的本地时间返回一个等效的日期时间(datetime)。

def fromutc(self, dt: datetime) ->datetime: ...if sys.version_info >= (3, 2): #当Python版本大于等于3.2.0时，添加类tzinfo的timezone子类实现

classtimezone(tzinfo):

"""以下用到了一个ClassVar变量，这是一个类变量类型，是Python3.6版本新添加的功能；

网上解析：已添加typing.ClassVar类型构造，来标识类变量。如**PEP 526**中所述，封装在ClassVar中的一个变量注释暗示着一个给定的属性打算作为一个类变量使用，并且不应该在那个类的实例上设置它。

"""

utc: ClassVar[timezone]#定义的一个类变量，源码中具体实现：timezone.utc = timezone._create(timedelta(0))

min: ClassVar[timezone]#定义的一个类变量，源码中具体实现：timezone.min = timezone._create(timezone._minoffset)

max: ClassVar[timezone]#定义的一个类变量，源码中具体实现：timezone.max = timezone._create(timezone._maxoffset)

#类timezone的构造函数，用于定义对象时的初始化函数

def __init__(self, offset: timedelta, name: str = ...) ->None: ...#为该类定义的哈希函数，对象调用该方法，可以返回一个hash值，该对象可以用作字典中的key或集合中的一员

def __hash__(self) ->int: ...

_tzinfo= tzinfo #定义类tzinfo的一个别名，前面加一个下划线，表示该别名只能在当前类内部使用

2.3 date类源码分析

classdate:

min: ClassVar[date]#date类变量，具体实现：date.min = date(1, 1, 1)，表示1年1月1日

max: ClassVar[date]#date类变量，具体实现：date.max = date(9999, 12, 31)，表示9999年12月31日

resolution: ClassVar[timedelta]#timedelta类变量，具体实现：date.resolution = timedelta(days=1)，表示时长为1天的timedelta类变量

#构造函数，初始化参数分别为年(year)、月(month)、日(day)，返回值类型为None

def __init__(self, year: int, month: int, day: int) ->None: ...

"""此处先简单说明一下@classmethod装饰器的作用：在类前面加该装饰器，特点就是可以通过类名去调用，但是也必须传递一个参数，一般用cls表示class，表示可以通过类直接调用”””#通过传入一个float类型的时间戳值，返回该时间戳对应的日期(date类型，年月日)@classmethoddef fromtimestamp(cls, t: float) ->date: ...#返回系统今天的日期，类似fromtimestamp(t=time.time())调用结果@classmethoddef today(cls) ->date: ...#参数n为天数，通过给定天数，返回具体的日期(date类型，年月日)，从公元1年1月1日开始，即n=1，表示公元1年1月1日@classmethoddef fromordinal(cls, n: int) ->date: ...

"""先说一下装饰器@property作用：负责把一个方法变成属性调用的。因此，类对象可以直接调用该方法作为属性使用，例如test_date.year直接返回对象test_date的年份数据”””#date对象对应的年份信息，可作为对象的属性直接调用@propertydef year(self) ->int: ...#date对象对应的月份信息，可作为对象的属性直接调用@propertydef month(self) ->int: ...#date对象对应的天信息，可作为对象的属性直接调用@propertydef day(self) ->int: ...#返回当前date对象的ctime()样式字符串，例如今天是2018-07-21 星期六，则返回'Sat Jul 21 00:00:00 2018'

def ctime(self) ->str: ...#fmt(format缩写，代表格式)类型为_Text在头部文件代码有定义，该方法依据提供的格式返回对应date对应对象的字符串格式，例如：fmt="%Y-%m-%dT%H:%M:%SZ",返回示例：'2018-07-21T00:00:00Z'

def strftime(self, fmt: _Text) ->str: ...if sys.version_info >= (3,): #当Python版本大于等于3.0.0

def __format__(self, fmt: str) ->str: ...else:def __format__(self, fmt: AnyStr) -> AnyStr: ... #此处有一个新的类型AnyStr，看源码中具体实现为：AnyStr = TypeVar('AnyStr', bytes, str)，表示该类型为str结构类型或者bytes结构类型，附源码中注释：

"""

Usage::

T= TypeVar('T') #Can be anythingA= TypeVar('A', str, bytes) #Must be str or bytes"""#返回date对象的ISO格式的日期，具体为”yyyy-mm-dd"，例如：'2018-07-21'

def isoformat(self) ->str: ...#返回与time.localtime()兼容的本地时间元组。返回示例：time.struct_time(tm_year=2018, tm_mon=7, tm_mday=21, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=5, tm_yday=202, tm_isdst=-1)

def timetuple(self) ->struct_time: ...#返回指定日期，从公元1年1月1日到现在的总天数，例如date(1,2,1).toordinal()=32

def toordinal(self) ->int: ...#修改初始化date对象中year、month、int属性的值，例如date(2018,7,18).replace(year=2019)，则该日期就变成2019年7月18日

def replace(self, year: int = ..., month: int = ..., day: int = ...) ->date: ...#date对象间的大小比较，le表示 <=

def __le__(self, other: date) ->bool: ...#date对象间的大小比较，lt表示 <

def __lt__(self, other: date) ->bool: ...#date对象间的大小比较，ge表示 >=

def __ge__(self, other: date) ->bool: ...#date对象间的大小比较，gt表示 >

def __gt__(self, other: date) ->bool: ...#date对象的加操作，但是添加的值只能是timedelta对象，而不能是date对象

def __add__(self, other: timedelta) ->date: ...#date对象的减操作，但是减去的值只能是timedelta对象，而不能是date对象@overload#重载功能装饰器，关于重载的概念可自行网上搜索

def __sub__(self, other: timedelta) ->date: ...#date对象的减操作，但是减去的值只能是date对象@overloaddef __sub__(self, other: date) ->timedelta: ...#date对象的哈希化方法，可以返回当前对象的哈希值

def __hash__(self) ->int: ...#返回当前date对象的星期几数目，例如2018年7月21日星期六，当天的date.today().weekday() = 5。注意：Monday == 0 ... Sunday == 6.所以5代表星期六

def weekday(self) ->int: ...#返回当前date对象的星期几数目，注意：Monday == 1 ... Sunday == 7.则星期六，就返回6。

def isoweekday(self) ->int: ...#返回当前date对象的年份、本年份的所在周数、星期几，例如：date(1,2,1).isocalendar()=(1，5，4)表示公元1年2月1日，年份是1，周数是4(公元1年的第4周)，星期四

def isocalendar(self) -> Tuple[int, int, int]: ...

2.4 time类源码分析

下述方法有部分和上面date类实现或者意义类似，就大概简单说明，不作详细介绍啦。

classtime:

min: ClassVar[time]#time类变量，具体实现：time.min = time(0, 0, 0)

max: ClassVar[time]#time类变量，具体实现：time.max = time(23, 59, 59, 999999)

resolution: ClassVar[timedelta]#timedelta类变量，具体实现：time.resolution = timedelta(microseconds=1)

#time类的构造函数，依据参数名即可知道具体参数的实际意义

def __init__(self, hour: int = ..., minute: int = ..., second: int = ..., microsecond: int =...,

tzinfo: Optional[tzinfo]= ...) ->None: ...#time对象的具体hour属性函数@propertydef hour(self) ->int: ...#time对象的具体minute属性函数@propertydef minute(self) ->int: ...#time对象的具体second属性函数@propertydef second(self) ->int: ...#time对象的具体microsecond(微秒)属性函数@propertydef microsecond(self) ->int: ...#time对象所在时区信息，该属性方法表示该time对象的当前所在时区，默认为None@propertydef tzinfo(self) ->Optional[_tzinfo]: ...if sys.version_info >= (3, 6): #当Python版本大于等于3.6.0时

#time类对象的 fold属性方法是3.6版本新添加的特性，主要用于区分本地相同两个时刻的分歧，当未出现此类情况时，fold值默认为0@propertydef fold(self) ->int: ...#time类对象间大小比较，le表示 <=

def __le__(self, other: time) ->bool: ...#time类对象间大小比较，lt表示 <

def __lt__(self, other: time) ->bool: ...#time类对象间大小比较，ge表示 >=

def __ge__(self, other: time) ->bool: ...#time类对象间大小比较，gt表示 >

def __gt__(self, other: time) ->bool: ...#可获取time类对象的hash值函数

def __hash__(self) ->int: ...#返回ISO格式化的时间，例如time(1,1,1,1).isoformat()返回：'01:01:01.000001'

def isoformat(self) ->str: ...#返回给定fmt格式的time对象字符串，例如time(1,1,1,1).strftime("%H:%M:%S")返回：'01:01:01'

def strftime(self, fmt: _Text) ->str: ...if sys.version_info >= (3,): #当Python版本大于等于3.0.0时

def __format__(self, fmt: str) -> str: ... #检测fmt类型是否为str

else:def __format__(self, fmt: AnyStr) -> AnyStr: ... #检测fmt类型是否为AnyStr

#返回当前time类对象UTC以东的分钟时区偏移(西区为负)，默认为空

def utcoffset(self) ->Optional[timedelta]: ...#返回当前time类对象的时区名称，time类对象初始化默认时区为空，所以此处返回值一般也为空

def tzname(self) ->Optional[str]: ...#返回当前time类对象的UTC偏移量，一般tzinfo为空时，此处返回值也为空，如果tzInfo不为空，没有偏移量则返回0

def dst(self) ->Optional[int]: ...if sys.version_info >= (3, 6): #当前Python版本大于等于3.6.0时

#该函数作用为修改time类对象具体属性值，其中有一个fold属性，是3.6版本新添加的属性

def replace(self, hour: int = ..., minute: int = ..., second: int =...,

microsecond: int= ..., tzinfo: Optional[_tzinfo] =...,*, fold: int = ...) ->time: ...else:def replace(self, hour: int = ..., minute: int = ..., second: int =...,

microsecond: int= ..., tzinfo: Optional[_tzinfo] = ...) ->time: ...

_date= date #类date定义的别名，只限本类中使用_time= time #类time定义的别名，只限本类中使用

2.5 timedelta类源码分析

timedelta实际意义表示两个日期时间对象之间的差异，例如可作为date对象的运算成员。

class timedelta(SupportsAbs[timedelta]):

min: ClassVar[timedelta]#timedelta类变量，具体实现：timedelta.min = timedelta(-999999999)

max: ClassVar[timedelta]#timedelta类变量，具体实现：timedelta.max = timedelta(days=999999999, hours=23, minutes=59, seconds=59,microseconds=999999)

resolution: ClassVar[timedelta]#timedelta类变量，具体实现：timedelta.resolution = timedelta(microseconds=1)

#timedelta的构造函数

def __init__(self, days: float = ..., seconds: float = ..., microseconds: float =...,

milliseconds: float= ..., minutes: float = ..., hours: float =...,

weeks: float= ...) ->None: ...#timedelta类对象days(天数)属性方法@propertydef days(self) ->int: ...#timedelta类对象seconds(秒数)属性方法@propertydef seconds(self) ->int: ...#timedelta类对象microseconds(微秒数)属性方法@propertydef microseconds(self) ->int: ...#获取timedelta类对象总秒数，例如timedelta(hours=1).total_seconds()=3600.0

def total_seconds(self) ->float: ...#timedelta类对象间相加操作函数

def __add__(self, other: timedelta) ->timedelta: ...#源码中关于此方法实现：__radd__ = __add__，可看出功能作用和__add__一样

def __radd__(self, other: timedelta) ->timedelta: ...#返回当前timedelta对象 - other对象值

def __sub__(self, other: timedelta) ->timedelta: ...#返回other对象 - 当前timedelta对象值

def __rsub__(self, other: timedelta) ->timedelta: ...#源码中返回:timedelta(-self._days,-self._seconds,-self._microseconds)，具体作用不明

def __neg__(self) ->timedelta: ...#返回当前timedelte对象，例如timedelta(microseconds=1).__pos__()，返回结果：datetime.timedelta(0, 0, 1)

def __pos__(self) ->timedelta: ...#返回当前timedelte对象绝对值，和__neg__作用相反

def __abs__(self) ->timedelta: ...#返回两个timedelta对象self*other的值

def __mul__(self, other: float) ->timedelta: ...#返回两个timedelta对象乘积，源码实现：__rmul__ = __mul__，可知和__mul__功能一样

def __rmul__(self, other: float) ->timedelta: ...#除数是timedelta类型的整除运算，向下取整@overloaddef __floordiv__(self, other: timedelta) ->int: ...#除数是int类型的整除运算，向下取整@overloaddef __floordiv__(self, other: int) ->timedelta: ...if sys.version_info >= (3,): #当python版本大于等于3.0.0时

#除数是timedelta类型的除法运算，结果是浮点数@overloaddef __truediv__(self, other: timedelta) ->float: ...#除数是float类型的除法运算，结果是timedelta类型@overloaddef __truediv__(self, other: float) ->timedelta: ...#取余运算，返回余数

def __mod__(self, other: timedelta) ->timedelta: ...#取整运算和取余运算结合，返回int类型结果是取整结果，返回timedelta类型是取余结果

def __divmod__(self, other: timedelta) ->Tuple[int, timedelta]: ...else:#除法运算，返回结果是float，此处源码未找到具体实现，此处释义是我自己猜的@overloaddef __div__(self, other: timedelta) ->float: ...#除法运算，返回的结果是timedelta，此处源码中也未找到具体实现代码@overloaddef __div__(self, other: float) ->timedelta: ...#比较运算，le表示<=

def __le__(self, other: timedelta) ->bool: ...#比较运算，lt表示<

def __lt__(self, other: timedelta) ->bool: ...#比较运算，ge表示>=

def __ge__(self, other: timedelta) ->bool: ...#比较运算，gt表示>

def __gt__(self, other: timedelta) ->bool: ...#timedelta对象取哈希值函数

def __hash__(self) -> int: ...

2.6 datetime类源码分析

datetime类是date类的子类。

classdatetime:#TODO: Is a subclass of date, but this would make some types incompatible.

min: ClassVar[datetime]#datetime类变量，源码实现：datetime.min = datetime(1, 1, 1)

max: ClassVar[datetime]#datetime类变量，源码实现：datetime(9999, 12, 31, 23, 59, 59, 999999)

resolution: ClassVar[timedelta]#datetime类变量，源码实现：datetime.resolution = timedelta(microseconds=1)

if sys.version_info >= (3, 6): #此处依据Python版本是否大于等于3.6.0，来区分构造函数

#注意，此处多了一个fold参数，这是3.6版本新添加的属性，用于区分时间分歧

def __init__(self, year: int, month: int, day: int, hour: int =...,

minute: int= ..., second: int = ..., microsecond: int =...,

tzinfo: Optional[tzinfo]= ..., *, fold: int = ...) ->None: ...else:def __init__(self, year: int, month: int, day: int, hour: int =...,

minute: int= ..., second: int = ..., microsecond: int =...,

tzinfo: Optional[tzinfo]= ...) ->None: ...#以下包含@property装饰器的属性函数，可依据函数名知道其具体作用，不作详细说明@propertydef year(self) ->int: ...

@propertydef month(self) ->int: ...

@propertydef day(self) ->int: ...

@propertydef hour(self) ->int: ...

@propertydef minute(self) ->int: ...

@propertydef second(self) ->int: ...

@propertydef microsecond(self) ->int: ...#该属性函数，表示datetime类对象的时区信息，默认为空@propertydef tzinfo(self) ->Optional[_tzinfo]: ...#当python版本大于等于3.6时，添加一个fold属性函数

if sys.version_info >= (3, 6):

@propertydef fold(self) ->int: ...#将一个时间戳格式的数字，转换为datetime类型对象，例如 datetime.fromtimestamp(1582982934.11)=datetime.datetime(2020, 2, 29, 21, 28, 54, 110000)@classmethoddef fromtimestamp(cls, t: float, tz: Optional[_tzinfo] = ...) ->datetime: ...#一般情况下和fromtimestamp返回结果一样，如果有UTC时间偏差则会出现结果偏差@classmethoddef utcfromtimestamp(cls, t: float) ->datetime: ...、#返回今天的具体日期时间，例如datetime.today()=datetime.datetime(2018, 7, 22, 9, 59, 6, 907570)@classmethoddef today(cls) ->datetime: ...#传入具体天数，返回当前天数的从公元1年1月1日开始计算后的日期时间@classmethoddef fromordinal(cls, n: int) ->datetime: ...#返回当前系统时间戳对应的日期时间，例如：datetime.now()=datetime.datetime(2018, 7, 22, 10, 3, 21, 38726)@classmethoddef now(cls, tz: Optional[_tzinfo] = ...) ->datetime: ...#返回当前系统UTC时间戳对应的日期时间@classmethoddef utcnow(cls) ->datetime: ...if sys.version_info >= (3, 6): #依据Python版本是否大于等于3.6，定义combine函数@classmethoddef combine(cls, date: date, time: time, tzinfo: Optional[_tzinfo] = ...) ->datetime: ...else:

@classmethoddef combine(cls, date: date, time: time) ->datetime: ...#依据fmt格式，返回指定格式的datetime时间字符串

def strftime(self, fmt: _Text) ->str: ...if sys.version_info >= (3,): #此处依据Python版本是否大于等于3.0来初始化__format__函数

def __format__(self, fmt: str) ->str: ...else:def __format__(self, fmt: AnyStr) ->AnyStr: ...#返回从公元1年1月1日到当前datetime对象所代表日期间的总天数，例如：datetime(2,1,1,1,1,1,1).toordinal() = 366

def toordinal(self) ->int: ...#返回当前日期的time_struct格式的结果

def timetuple(self) ->struct_time: ...if sys.version_info >= (3, 3):#返回当前日期对象所对应的时间戳结果

def timestamp(self) ->float: ...#返回当前日期UTC的time_struct格式的结果

def utctimetuple(self) ->struct_time: ...#返回当前日期时间对象的具体日期，例如datetime.today().date()=datetime.date(2018, 7, 22)

def date(self) ->_date: ...#返回当前日期时间对象的具体时间，例如datetime.today().time()=datetime.time(10, 15, 58, 933266)

def time(self) ->_time: ...#返回当前日期时间对象的具体时间，其中包含了该时间的时区信息，一般为空

def timetz(self) ->_time: ...#依据版本判断，定义不同的replace覆盖函数

if sys.version_info >= (3, 6):def replace(self, year: int = ..., month: int = ..., day: int = ..., hour: int =...,

minute: int= ..., second: int = ..., microsecond: int =..., tzinfo:

Optional[_tzinfo]= ..., *, fold: int = ...) ->datetime: ...else:def replace(self, year: int = ..., month: int = ..., day: int = ..., hour: int =...,

minute: int= ..., second: int = ..., microsecond: int =..., tzinfo:

Optional[_tzinfo]= ...) ->datetime: ...#依据版本判断，返回包含时区信息的datetime类型值，例如：datetime.today().astimezone()=datetime.datetime(2018, 7, 22, 10, 51, 1, 6604, tzinfo=datetime.timezone(datetime.timedelta(0, 28800), 'CST'))

if sys.version_info >= (3, 3):def astimezone(self, tz: Optional[_tzinfo] = ...) ->datetime: ...else:def astimezone(self, tz: _tzinfo) ->datetime: ...#返回ctime格式的datetime类型的字符串值，例如：datetime.today().ctime()='Sun Jul 22 10:53:43 2018'

def ctime(self) ->str: ...#依据Python版本不同，返回isoformat格式的datetime类型的字符串值，例如：datetime.today().isoformat()='2018-07-22T10:55:11.618810'

if sys.version_info >= (3, 6):def isoformat(self, sep: str = ..., timespec: str = ...) ->str: ...else:def isoformat(self, sep: str = ...) ->str: ...#返回指定date_string日期时间的format格式的datetime类型，例如：datetime.strptime("2017-10-13 16:00:00", "%Y-%m-%d %H:%M:%S")=datetime.datetime(2017, 10, 13, 16, 0)@classmethoddef strptime(cls, date_string: _Text, format: _Text) ->datetime: ...#返回datetime对象的时区UTC偏差，一般情况下为空

def utcoffset(self) ->Optional[timedelta]: ...#返回datetime对象的具体时区名称，一般情况下为空

def tzname(self) ->Optional[str]: ...#返回当前datetime对象的DST偏差，一般情况下为空

def dst(self) ->Optional[int]: ...#比较运算，le表示 <=

def __le__(self, other: datetime) ->bool: ...#比较运算，lt表示 <

def __lt__(self, other: datetime) ->bool: ...#比较运算，ge表示 >=

def __ge__(self, other: datetime) ->bool: ...#比较运算，gt表示 >

def __gt__(self, other: datetime) ->bool: ...#加运算

def __add__(self, other: timedelta) ->datetime: ...#减运算，参数类型为datetime，返回值类型为timedelta@overloaddef __sub__(self, other: datetime) ->timedelta: ...#减运算，参数类型为timedelta，返回值类型为datetime@overloaddef __sub__(self, other: timedelta) ->datetime: ...#可返回datetime类对象的哈希值

def __hash__(self) ->int: ...#返回当前datetime类对象的工作日(即为星期几)，注意：Monday == 0 ... Sunday == 6.

def weekday(self) ->int: ...#返回当前datetime类对象的工作日(即为星期几)，注意：Monday == 1 ... Sunday == 7.

def isoweekday(self) ->int: ...#返回当前datetime类对象的年份、本年份的所在周数、星期几

def isocalendar(self) -> Tuple[int, int, int]: ...

2.7 格式化字符串

datetime、date、time 都提供了 strftime() 方法，该方法接收一个格式字符串，输出日期时间的字符串表示。支持的转换格式如下：

字符

含义

例子

英文星期的简写

Sun, Mon, …, Sat

英文星期的全拼

Sunday, Monday, …, Saturday

星期几,星期天为0,星期六为6

0, 1, …, 6

这个月的第几天,以0填充的10进制

01, 02, …, 31

月份英文简写

Jan, Feb, …, Dec

月份英文全拼

January, February, …, December

月份数，以0填充的10进制

01, 02, …, 12

不带世纪的年份

00, 01, …, 99

带有世纪的年份

1970, 1988, 2001, 2013

24小时制的小时数

00, 01, …, 23

12小时制的小时数

01, 02, …, 12

AM或者PM

AM, PM

分钟

00, 01, …, 59

秒数

00, 01, …, 59

微秒

000000, 000001, …, 999999

与utc时间的间隔

(), +0000, -0400, +1030

时区

(), UTC, EST, CST

当年的第几天

001, 002, …, 366

当年的第几周(星期天作为周的第一天)

00, 01, …, 53

当年的第几周(星期一作为周的第一天)

00, 01, …, 53

日期时间的字符串表示

Tue Aug 16 21:30:00 1988

时间字符串表示

21:30:00

日期字符串表示

08/16/88

相当于转意等于一个%

3 time模块time.pyi源码解析

先说一下struct_time结构的返回参数：

struct_time元组。这种结构具有如下属性：

序号

属性

值

tm_year

2008

tm_mon

1 到 12

tm_mday

1 到 31

tm_hour

0 到 23

tm_min

0 到 59

tm_sec

0 到 61 (60或61 是闰秒)

tm_wday

0到6 (0是周一)

tm_yday

1 到 366(儒略历)

tm_isdst

-1, 0, 1, -1是决定是否为夏令时的旗帜

#Stubs for time

#Ron Murawski

#based on: http://docs.python.org/3.3/library/time.html#module-time

#see: http://nullege.com/codes/search?cq=time

importsysfrom typing importAny, NamedTuple, Tuple, Unionfrom types importSimpleNamespace

TimeTuple= Tuple[int, int, int, int, int, int, int, int, int] #定义一个时间元组返回类型，共9个返回值，其中每一个值均为int类型

#----- variables and constants -----

accept2dyear=False

altzone=0

daylight=0

timezone=0

tzname= ... #type: Tuple[str, str]

if sys.version_info >= (3, 3) and sys.platform != 'win32':

CLOCK_HIGHRES= 0 #Solaris only

CLOCK_MONOTONIC= 0 #Unix only

CLOCK_MONOTONIC_RAW= 0 #Linux 2.6.28 or later

CLOCK_PROCESS_CPUTIME_ID= 0 #Unix only

CLOCK_REALTIME= 0 #Unix only

CLOCK_THREAD_CPUTIME_ID= 0 #Unix only

if sys.version_info >= (3, 3):class struct_time( #注意这是struct_time类型的具体相关参数定义，通过参数名即可知道其具体含义

NamedTuple('_struct_time',

[('tm_year', int), ('tm_mon', int), ('tm_mday', int),

('tm_hour', int), ('tm_min', int), ('tm_sec', int),

('tm_wday', int), ('tm_yday', int), ('tm_isdst', int),

('tm_zone', str), ('tm_gmtoff', int)]

)

):def __init__( #构造函数

self,

o: Union[

Tuple[int, int, int, int, int, int, int, int, int],

Tuple[int, int, int, int, int, int, int, int, int, str],

Tuple[int, int, int, int, int, int, int, int, int, str, int]

_arg: Any=...,

)->None: ...def __new__( #调用构造函数之前，需要调用此函数

cls,

o: Union[

Tuple[int, int, int, int, int, int, int, int, int],

Tuple[int, int, int, int, int, int, int, int, int, str],

Tuple[int, int, int, int, int, int, int, int, int, str, int]

_arg: Any=...,

)->struct_time: ...else:class struct_time( #struct_time类型具体定义

NamedTuple('_struct_time',

[('tm_year', int), ('tm_mon', int), ('tm_mday', int),

('tm_hour', int), ('tm_min', int), ('tm_sec', int),

('tm_wday', int), ('tm_yday', int), ('tm_isdst', int)]

)

):def __init__(self, o: TimeTuple, _arg: Any = ...) ->None: ...def __new__(cls, o: TimeTuple, _arg: Any = ...) ->struct_time: ...#----- functions -----

#返回指定格式的系统当前时间，例如：time.asctime()='Sun Jul 22 12:59:50 2018'

def asctime(t: Union[TimeTuple, struct_time, None] = ...) -> str: ... #return current time

#返回自进程开始或之后的CPU时间

def clock() ->float: ...#依据参数secs秒数，返回自1970开始后计算的日期，参数为空时返回当前日期时间

def ctime(secs: Union[float, None] = ...) -> str: ... #return current time

#和ctime()区别在于返回值的格式不同，返回值的格式为struct_time

def gmtime(secs: Union[float, None] = ...) -> struct_time: ... #return current time

#和gmtime()方法功能基本相同，但是gmtime()时转换为标准的UTC时间

def localtime(secs: Union[float, None] = ...) -> struct_time: ... #return current time

#将当地时间的时间元组转换为自纪元以来的秒数，也就是时间戳的值

def mktime(t: Union[TimeTuple, struct_time]) ->float: ...#延迟指定的secs秒数时间，就是让代码在此处休眠指定的秒数时间，然后再执行后续代码

def sleep(secs: Union[int, float]) ->None: ...#返回指定t的格式format的字符串类型时间，例如：time.strftime("%Y-%m-%dT%H:%M:%SZ", a) = '2018-07-22T05:13:58Z'

defstrftime(format: str,

t: Union[TimeTuple, struct_time, None]= ...) -> str: ... #return current time

#给定指定的str类型的字符串时间，返回struct_time类型时间对象，例如：time.strptime("2018-07-18T13:12:11","%Y-%m-%dT%H:%M:%S")= time.struct_time(tm_year=2018, tm_mon=7, tm_mday=18, tm_hour=13, tm_min=12, tm_sec=11, tm_wday=2, tm_yday=199, tm_isdst=-1)

defstrptime(string: str,

format: str= ...) ->struct_time: ...#返回系统当前的时间戳

def time() ->float: ...if sys.platform != 'win32':#将本地时区初始化或重新初始化为存储的值os.environ[ 'TZ']，默认为空

def tzset() -> None: ... #Unix only

if sys.version_info >= (3, 3):def get_clock_info(name: str) ->SimpleNamespace: ...def monotonic() ->float: ...def perf_counter() ->float: ...def process_time() ->float: ...if sys.platform != 'win32':def clock_getres(clk_id: int) -> float: ... #Unix only

def clock_gettime(clk_id: int) -> float: ... #Unix only

def clock_settime(clk_id: int, time: float) -> None: ... #Unix only

if sys.version_info >= (3, 7):def clock_gettime_ns(clock_id: int) ->int: ...def clock_settime_ns(clock_id: int, time: int) ->int: ...def monotonic_ns() ->int: ...def perf_counter_ns() ->int: ...def process_time_ns() ->int: ...def time_ns() ->int: ...

参考资料：

1.python--利用datetime模块计算时间差(https://blog.csdn.net/wo1182929447/article/details/77841529)

2.【python】获取指定日期的后(前)一(n)天(https://blog.csdn.net/evillist/article/details/50522505)

3.Python的datetime模块分析(https://blog.csdn.net/memory_qianxiao/article/details/80953710)

4.python——从datetime模块探索python的数据架构(https://www.cnblogs.com/Simon-xm/p/3935812.html#top)

5.Python标准库笔记(3) — datetime模块(http://www.cnblogs.com/jhao/p/6678921.html#top)

6.Python 日期和时间(http://www.runoob.com/python/python-date-time.html)

7.8.1. datetime — Basic date and time types(https://docs.python.org/3/library/datetime.html#module-datetime)

8.Python 3.6https://juejin.im/entry/5860db8a1b69e6005625eb91)

9.Python3.6新特性官方文档中文版(https://pycntech.github.io/Python3.6%E6%96%B0%E7%89%B9%E6%80%A7%E5%AE%98%E6%96%B9%E6%96%87%E6%A1%A3%E4%B8%AD%E6%96%87%E7%89%88.html)