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

目录

1 前言 

2 datetime.pyi源码分步解析

2.1 头部定义源码分析

2.2 tzinfo类源码分析

2.3 date类源码分析

2.4 time类源码分析

2.5 timedelta类源码分析

2.6 datetime类源码分析

2.7 格式化字符串

3 time模块time.pyi源码解析

 

 


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 头部定义源码分析

import sys

from 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     # 定义默认的最小年数,为1
MAXYEAR: int     # 定义默认的最大年数,为9999

 


2.2 tzinfo类源码分析

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

class tzinfo:

# 下面使用的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子类实现

class timezone(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类源码分析

class date:

    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类型,年月日) @classmethod def fromtimestamp(cls, t: float) -> date: ... # 返回系统今天的日期,类似fromtimestamp(t=time.time())调用结果 @classmethod def today(cls) -> date: ... # 参数n为天数,通过给定天数,返回具体的日期(date类型,年月日),从公元1年1月1日开始,即n=1,表示公元1年1月1日 @classmethod def fromordinal(cls, n: int) -> date: ... """先说一下装饰器@property作用:负责把一个方法变成属性调用的。因此,类对象可以直接调用该方法作为属性使用,例如test_date.year直接返回对象test_date的年份数据””” # date对象对应的年份信息,可作为对象的属性直接调用 @property def year(self) -> int: ... # date对象对应的月份信息,可作为对象的属性直接调用 @property def month(self) -> int: ... # date对象对应的天信息,可作为对象的属性直接调用 @property def 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 anything A = 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对象 @overload def __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类实现或者意义类似,就大概简单说明,不作详细介绍啦。

class time:

    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属性函数
@property
def hour(self) -> int: ...

#time对象的具体minute属性函数
@property
def minute(self) -> int: ...

# time对象的具体second属性函数
@property
def second(self) -> int: ...

#time对象的具体microsecond(微秒)属性函数
@property
def microsecond(self) -> int: ...

#time对象所在时区信息,该属性方法表示该time对象的当前所在时区,默认为None
@property
def tzinfo(self) -> Optional[_tzinfo]: ...

if sys.version_info >= (3, 6):  # 当Python版本大于等于3.6.0时
#time类对象的 fold属性方法是3.6版本新添加的特性,主要用于区分本地相同两个时刻的分歧,当未出现此类情况时,fold值默认为0
        @property
        def 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(天数)属性方法 @property def days(self) -> int: ... # timedelta类对象seconds(秒数)属性方法 @property def seconds(self) -> int: ... # timedelta类对象microseconds(微秒数)属性方法 @property def 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类型的整除运算,向下取整 @overload def __floordiv__(self, other: timedelta) -> int: ... # 除数是int类型的整除运算,向下取整 @overload def __floordiv__(self, other: int) -> timedelta: ... if sys.version_info >= (3,): # 当python版本大于等于3.0.0时 # 除数是timedelta类型的除法运算,结果是浮点数 @overload def __truediv__(self, other: timedelta) -> float: ... # 除数是float类型的除法运算,结果是timedelta类型 @overload def __truediv__(self, other: float) -> timedelta: ... # 取余运算,返回余数 def __mod__(self, other: timedelta) -> timedelta: ...
# 取整运算和取余运算结合,返回int类型结果是取整结果,返回timedelta类型是取余结果 def __divmod__(self, other: timedelta) -> Tuple[int, timedelta]: ... else: # 除法运算,返回结果是float,此处源码未找到具体实现,此处释义是我自己猜的 @overload def __div__(self, other: timedelta) -> float: ... # 除法运算,返回的结果是timedelta,此处源码中也未找到具体实现代码 @overload def __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类的子类。
class datetime:

    # 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装饰器的属性函数,可依据函数名知道其具体作用,不作详细说明
@property
def year(self) -> int: ...
@property
def month(self) -> int: ...
@property
def day(self) -> int: ...
@property
def hour(self) -> int: ...
@property
def minute(self) -> int: ...
@property
def second(self) -> int: ...
@property
def microsecond(self) -> int: ...

# 该属性函数,表示datetime类对象的时区信息,默认为空
@property
def tzinfo(self) -> Optional[_tzinfo]: ...

# 当python版本大于等于3.6时,添加一个fold属性函数
if sys.version_info >= (3, 6):  
        @property
        def fold(self) -> int: ...

# 将一个时间戳格式的数字,转换为datetime类型对象,例如 datetime.fromtimestamp(1582982934.11)=datetime.datetime(2020, 2, 29, 21, 28, 54, 110000)
@classmethod
def fromtimestamp(cls, t: float, tz: Optional[_tzinfo] = ...) -> datetime: ...

# 一般情况下和fromtimestamp返回结果一样,如果有UTC时间偏差则会出现结果偏差
@classmethod
def utcfromtimestamp(cls, t: float) -> datetime: ...、

# 返回今天的具体日期时间,例如datetime.today()=datetime.datetime(2018, 7, 22, 9, 59, 6, 907570)
@classmethod
def today(cls) -> datetime: ...

# 传入具体天数,返回当前天数的从公元1年1月1日开始计算后的日期时间
@classmethod
def fromordinal(cls, n: int) -> datetime: ...

# 返回当前系统时间戳对应的日期时间,例如:datetime.now()=datetime.datetime(2018, 7, 22, 10, 3, 21, 38726)
@classmethod
def now(cls, tz: Optional[_tzinfo] = ...) -> datetime: ...

#返回当前系统UTC时间戳对应的日期时间
@classmethod
def utcnow(cls) -> datetime: ...
    if sys.version_info >= (3, 6): # 依据Python版本是否大于等于3.6,定义combine函数
        @classmethod
        def combine(cls, date: date, time: time, tzinfo: Optional[_tzinfo] = ...) -> datetime: ...
    else:
        @classmethod
        def 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)
@classmethod
def 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
@overload
def __sub__(self, other: datetime) -> timedelta: ...

#减运算,参数类型为timedelta,返回值类型为datetime
@overload
def __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() 方法,该方法接收一个格式字符串,输出日期时间的字符串表示。支持的转换格式如下:

字符

 含义 

 例子 

%a

英文星期的简写

Sun, Mon, …, Sat

%A

英文星期的全拼

Sunday, Monday, …, Saturday

%w

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

0, 1, …, 6

%d

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

01, 02, …, 31

%b

月份英文简写

Jan, Feb, …, Dec

%B

月份英文全拼

January, February, …, December

%m

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

01, 02, …, 12

%y

不带世纪的年份

00, 01, …, 99

%Y

带有世纪的年份

1970, 1988, 2001, 2013

%H

24小时制的小时数

00, 01, …, 23

%I

12小时制的小时数

01, 02, …, 12

%p

AM或者PM

AM, PM

%M

分钟

00, 01, …, 59

%S

秒数

00, 01, …, 59

%f

微秒

000000, 000001, …, 999999

%z

与utc时间的间隔

(), +0000, -0400, +1030

%Z

时区

(), UTC, EST, CST

%j

当年的第几天

001, 002, …, 366

%U

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

00, 01, …, 53

%W

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

00, 01, …, 53

%c

日期时间的字符串表示

Tue Aug 16 21:30:00 1988

%X

时间字符串表示

21:30:00

%x

日期字符串表示

08/16/88

%%

相当于转意等于一个%

%

 

 


3 time模块time.pyi源码解析

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

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

序号

属性

0

tm_year

2008

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 (60或61 是闰秒)

6

tm_wday

0到6 (0是周一)

7

tm_yday

1 到 366(儒略历)

8

tm_isdst

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

 

# Stubs for time

# Ron Murawski <ron@horizonchess.com>

 

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

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

 

import sys
from typing import Any, NamedTuple, Tuple, Union
from types import SimpleNamespace

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'
def strftime(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)
def strptime(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: ...

 

 

 

 


参考资料:

posted @ 2018-07-22 14:34 舞动的心 阅读(...) 评论(...) 编辑 收藏