基於Python的datetime模塊和time模塊源碼閱讀分析

時間  2020-12-08
標籤 html python git github 架構 函數 源碼分析 this spa .net 欄目 Python 简体版
原文   原文鏈接

目錄html

1 前言 python

2 datetime.pyi源碼分步解析git

2.1 頭部定義源碼分析github

2.2 tzinfo類源碼分析架構

2.3 date類源碼分析函數

2.4 time類源碼分析源碼分析

2.5 timedelta類源碼分析this

2.6 datetime類源碼分析spa

2.7 格式化字符串.net

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: ...

 

 

 

參考資料：

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程