标签：2.7 cells 日期 bytes lib 工作效率 sof 哈希 父类
目录
最近工作需求上对于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模块内部只有相关调用方法，源码较少。
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
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的一个别名，前面加一个下划线，表示该别名只能在当前类内部使用
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]: ...
下述方法有部分和上面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定义的别名，只限本类中使用
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: ...
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]: ...
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 |
|
%% |
相当于转意等于一个% |
% |
先说一下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: ...
参考资料：
基于Python的datetime模块和time模块源码阅读分析
标签：2.7 cells 日期 bytes lib 工作效率 sof 哈希 父类
原文地址：https://www.cnblogs.com/liuzhen1995/p/9350125.html
