>>> d = date.today()
>>> d.year
2019
>>> d.month
2
>>> d.day
28
date 实例对象支持如下操作：
| 操作 | 结果 |
|---|---|
| date2 = date1 + timedelta | date2表示给date1增加 timedeltla.days 天。（1） |
| date2 = date1 - timedelta | 计算date2，使得date2 + timedelta == date1。（2） |
| timedelta = date1 - date2 | 计算date1和date2之间的差值。（3） |
| date1 < date2 | 如果date1是比date2更早的时间，则date1小于date2。（4） |
注解：
(1). 如果 timedelta.days < 0，则 date2在日期上向后移动(即date2是比date1更早的日期)；如果 timedelta.days == 0，则date2与date1相等(即date2和date1表示相同的日期)；如果timedelta.days > 0，则date2在日期上向前移动(即date2是比date1更晚的日期)。之后，timedelta.seconds 和 timedelta.microseconds 将会被忽略。如果 date2.year 小于 MINYEAR 或大于 MAXYEAR，则会引发 OverflowError 异常。
(2). 这不完全等同于 date1 + (-timedelta)，因为 -timedelta 在单独的情况下可能会溢出，而 date2 - timedelta不会。timedelta.seconds 和 timedelta.microseconds 将会被忽略。
(3). 结果是精确的，并且不会溢出。之后，timedelta.seconds 和 timedelta.microseconds 都是0，并且 date2 + timedelta == date1。
(4). 只有当date1.toordinal() < date2.toordinal() 时，date1 < date2。为了防止比较操作回退到默认的比较对象地址的方式，如果另一比较对象不是 date 对象实例，通常会引发 TypeError 异常。但是，如果另一个比较对象具有 timetuple() 属性，则会返回 NotImplemented 。这个钩子为其他种类的日期对象实现混合型比较提供了机会，否则，将一个 date 对象实例与一个不同类型的对象进行非相等(==)或不等(!=)比较时，将会引发 TypeError 异常。
date 对象的实例可以作为字典的键。在布尔上下文中，所有的 date 对象实例均会被当作 True。
1.2.4.4 date对象实例方法
date实例对象有如下几个实例方法：
- date.replace(year=self.year, month=self.month, day=self.day)
将原实例对象中的属性值替换为由关键字参数指定的新的值，其他属性值保持不变。
>>> d = date.today()
>>> d
datetime.date(2019, 2, 28)
>>> d.replace() # 不指定参数，则返回相同的对象
datetime.date(2019, 2, 28)
>>> d.replace(2018) # 只替换年份
datetime.date(2018, 2, 28)
>>> d.replace(2018, 1, 17) # 替换年份、月份和日
datetime.date(2018, 1, 17)
- date.timetuple()
返回一个 time.struct_time 对象实例，类似于 time.localtime() 的返回值。其中，hours，minuts和seconds参数的值为0，DST flag的值为 -1。如果 d 是一个date对象的实例，那么，d.timetuple() 等价于以下表达式：
ime.struct_time((d.year, d.month, d.day, 0, 0, 0, d.weekday(), yday, -1))
其中，yday = d.toordinal() - date(d.year, 1, 1) + 1 。
>>> d = date.today()
>>> d.timetuple()
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=60, tm_isdst=-1)
>>> d.timetuple().tm_year
2019
>>> d.timetuple().tm_mon
3
>>> yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1
>>> yday
60
>>> _time.struct_time((d.year, d.month, d.day, 0, 0, 0, d.weekday(), yday, -1))
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=60, tm_isdst=-1)
>>> d1 = date(2019, 3, 1)
>>> d1
datetime.date(2019, 3, 1)
>>> t = d1.timetuple()
>>> for i in t:
... print(i)
...
2019 # year
3 # month
1 # day
0
0
0
4 # weekday (0 = Monday)
60 # 60th day in the year
-1
- date.toordinal()
返回date 实例对象的预期公历序数，其中第一年的1月1日的序数为1。对于任何日期对象d, date.fromordinal(d.toordinal()) == d
>>> date.today().toordinal()
737119
- date.weekday()
返回当前日期在一周内的序号，即星期几，其中周一表示为0，周日表示为6。
>>> date.today().weekday()
4
- date.isoweekday()
返回当前日期在一周内的序号，即星期几，其中周一表示为1，周日表示为7。
>>> date.today().isoweekday()
5
- date.isocalendar()
返回一个包含给定日期对象的ISO year、ISO week number和ISO weekday的三元组。
ISO日历是公历的一种变体。ISO年包括52或53个整周，其中一周从星期一开始到星期天结束。ISO年的第一周是一年中第一个包含星期四的(公历)日历周。这个周为周数1，并且这个周的星期四的ISO年和公历年相同。
例如，2004年从星期四开始，因此ISO 2004年的第一周从2003年12月29日星期一开始，到2004年1月4日星期日结束，因此 date(2003,12,29).isocalendar() ==(2004, 1, 1)，date(2004,1,4).isocalendar() ==(2004, 1, 7)。
>>> date(2003, 12, 29).isocalendar()
(2004, 1, 1)
>>> date(2004, 1, 4).isocalendar()
(2004, 1, 7)
>>> d = date.today
>>> d
datetime.date(2019, 3, 1)
>>> ic = d.isocalendar()
>>> for i in ic:
... print(i)
...
2019 # ISO year
9 # ISO week number
5 # ISO day number (1 = Monday)
- date.isoformat()
以ISO 8601格式返回表示日期的字符串’YYYY-MM-DD’。例如，date(2002, 12, 4).isoformat() == '2002-12-04'
>>> date.today().isoformat()
'2019-03-01'
- date.__str__()
对date 的实例对象d，str(d) 等同于 d.isoformat()
>>> date.today().isoformat()
'2019-03-01'
>>> str(date.today())
'2019-03-01'
>>> d.isoformat()
'2019-03-01'
- date.ctime()
返回表示日期的字符串。例如 date(2002, 12, 4).ctime() == 'Wed Dec 400:00:00 2002' 。在原生的C函数ctime()（time.ctime()调用它，但是date.ctime() 不调用它）遵守C标准的平台上，对于date的实例对象 d，d.ctime() 等同于 time.ctime(time.mktime(d.timetuple()))
>>> date.today().ctime()
'Fri Mar 1 00:00:00 2019'
>>> _time.ctime(_time.mktime(date.today().timetuple()))
'Fri Mar 1 00:00:00 2019'
- date.strftime(format)
返回表示日期的字符串，日期格式由显式的格式化字符串指定。如果格式化代码中引用到了小时、分或秒，那么对应的值将被置为0。完整的格式化指令，请参考 strftime() and strptime() Behavior 。
>>> d = date.today
>>> d
datetime.date(2019, 3, 1)
>>> d.strftime('%d/%m/%y')
'01/03/19'
- date.__format__(format)
与 date.strftime() 相同。同时，这也使得在使用 str.format() 时，可以使用带格式的字符串文本为日期对象指定格式字符串。完整的格式化指令，请参考 strftime() and strptime() Behavior 。
>>> d = date.today
>>> d
datetime.date(2019, 3, 1)
>>> 'The {1} is {0:%d}, the {2} is {0:%B}.'.format(d, "day", "month")
'The day is 01, the month is March.'
1.2.5 time类
time 对象表示一天中的(本地)时间，独立于任何特定的一天，并且可以通过 tzinfo 对象进行调整。
class datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0 )
所有参数都是可选的。tzinfo 可以是 None 或者 tzinfo 抽象类的子类的实例；其他参数可以是整型，取值范围如下：
- 0 <= hour < 24
- 0 <= minute < 60
- 0 <= second < 60
- 0 <= microsecond < 1000000
- fold 0或1
如果某个参数超过了其取值范围，会引发 ValueError 异常。除过tzinfo参数，其他参数的默认值均为0，tzinfo 参数的默认值是 None 。
1.2.5.1 time对象类属性
- time.min
可以表示的最早的时间，值为 time(0, 0)
>>> time.min
datetime.time(0, 0)
- time.max
可以表示的最晚的时间，值为 time(23, 59, 59, 999999)
>>> time.max
datetime.time(23, 59, 59, 999999)
- time.resolution
两个不相等的 time 对象的最小差值，即 timedelta(microseconds=1) 。
不过需要注意， time 对象不支持算术运算。
>>> time.resolution
datetime.timedelta(microseconds=1)
time 对象实例支持如下操作：
time对象实例之间的比较。
如果 time 实例对象 a 是比 time 实例对象 b 更早的时间，则 a < b。如果一个操作数是 naive 的，而另一个操作数是 aware 的，那么在进行顺序比较时将会引发 TypeError 异常。对于相等比较，一个 naive 的实例永远不会等于一个 aware 的实例。
如果两个操作数都是 aware 的，并且具有相同的 tzinfo 属性，那么将忽略共同的tzinfo 属性，并比较基本的 times 数据；如果两个操作数都是 aware 的并且具有不同的 tzinfo 属性，则首先通过减去它们的UTC偏移量（从self.utcoffset()获得）来调整比较数，然后再进行比较。为了防止混合类型之间的比较回退到默认的以对象地址进行的比较，当将time对象与其他类型的对象进行非相等(==)和不等(!=)比较时，会引发TypeError 异常。
- 可以当作字典的键。
- 可进行高效的
pickling操作。
1.2.5.2 time对象实例属性
time 对象实例有如下几个只读属性：
- time.hour
time 对象实例中的小时(hour)，范围为[0, 23]
- time.minute
time 对象实例中的分钟(minute)，范围为[0, 59]
- time.second
time 对象实例中的秒(second)，范围为[0, 59]
- time.microseond
time 对象实例中的微秒，范围为[0, 999999]
- time.tzinfo
time 构造方法中传递给 tzinfo 参数的对象。如果未给 tzinfo 参数传递值，则为 None 。
1.2.5.3 time对象类方法
time 对象有一个类方法 time.fromisoformat(time_string)，并且这个方法也是 time 类的另一个构造方法。
classmethod time.fromisoformat(time_string)
该方法根据给定的time_string 参数的字符串值和这个字符串值的时间格式，返回一个 time 对象实例，其中 time_string 参数的值所表示的时间格式与 time.isoformat() 的返回值一致。具体来说，该函数支持格式为HH[:MM[:SS[.fff[fff]]] [+HH:MM[:SS[.ffffff]] 的字符串。
注意，该方法并不支持解析任意的ISO 8601字符串——它只是作为time.isoformat()的逆操作。
1.2.5.4 time对象实例方法
time 对象有如下几个实例方法：
- time.replace(hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, tzinfo=self.tzinfo, *, fold=0)
返回由指定的关键字参数替换time 对象实例中同名属性值后的新的 time 对象实例。请注意，可以指定 tzinfo=None 来从 aware 时间创建 naive 时间，并且在此过程中不会进行时间数据的转换。
>>> t = time(14, 30, 15, 500)
>>> t
datetime.time(14, 30, 15, 500)
>>> t.replace(15, 50, 10, 300)
datetime.time(15, 50, 10, 300)
- time.isoformat(timespec=‘auto’)
返回一个表示时间的字符串，这个字符串的格式为ISO 8601格式 HH:MM:SS.ffffff；如果 microsecond 为0，则格式为 HH:MM:SS；如果 utcoffset() 方法的返回值不为 None，则追加一个字符串，给出UTC偏移量， 其格式为 HH:MM:SS.ffffff+HH:MM[:SS[.ffffff]；或者，如果 self.microsecond 是0， 则格式为 HH:MM:SS+HH:MM[:SS[.ffffff]] 。
可选参数 timespec 指定要包含的时间的其他组件的数量(默认值是 auto )。它可以是以下值：
+ `auto` ：如果 `microsecond` 为0，则与 `second` 相同，否则，与 `microseconds` 相同。
+ `hours`：包含 `hour`，格式为 `HH` 。
+ `minutes`：包含 `hour` 和 `minute`，格式为 `HH:MM`。
+ `seconds`：包含 `hour`、`minute` 和 `second`，格式为 `HH:MM:SS`。
+ `milliseconds`：包含完整的时间格式，但是会忽略微秒，并表示为这样的格式 `HH:MM:SS.sss`。
+ `microseconds`：包含完整的时间格式 `HH:MM:SS.ffffff`如果指定的 `timespec` 参数的值不在上述列举的范围内，则会引发 `ValueError` 异常。
>>> t = time(1, 1, 1, 300)
>>> t
datetime.time(1, 1, 1, 300)
>>> t.isoformat(timespec='milliseconds')
'01:01:01.000'
>>> t.isoformat(timespec='auto')
'01:01:01.000300'
>>> t.isoformat(timespec='hours')
'01'
>>> t.isoformat(timespec='minutes')
'01:01'
>>> t.isoformat(timespec='seconds')
'01:01:01'
>>> t.isoformat(timespec='microseconds')
'01:01:01.000300'
- time.__str__()
对于一个 time 对象实例 t， str(t) 等同于 t.isoformat()
>>> t = time(1, 1, 1, 200)
>>> str(t)
'01:01:01.000200'
>>> t.isoformat()
'01:01:01.000200'
- time.strftime(format)
返回表示时间的字符串，时间格式由显式的格式化字符串指定。完整的格式化指令，请参考 strftime() and strptime() Behavior 。
- time.__format__(format)
与 time.strftime() 方法功能相同。同时，这也使得在使用 str.format() 时，可以使用带格式的字符串文本为时间对象指定格式字符串。完整的格式化指令， strftime() and strptime() Behavior 。
- time.utcoffset()
返回使用 datetime.timedelta 对象实例表示的 time 实例对象的时区偏移量, UTC东部为正(UTC西部为负)。如果 tzinfo 为 None，则返回 None；否则返回 self.tzinfo.utcoffset(self) 的返回值；如果该方法的返回值不是 None 或者一个小于一天的 timedelta 对象，则会引发异常。
- time.dst()
返回 time 实例对象的DST偏移量。如果 tzinfo 为 None，则返回 None；否则返回 self.tzinfo.dst(self) 的返回值；如果DST未生效，则返回值为 datetime.timedelta(0)，如果DST生效，则返回使用 datetime.timedelta 对象实例表示的DST偏移量。如果该方法的返回值不是 None 或者一个小于一天的 timedelta 对象，则会引发异常。
- time.tzname()
返回 time 实例对象的时区名称。如果 tzinfo 为 None，则返回 None；否则返回 self.tzinfo.tzname(None) ；如果该方法的返回值不是 None 或者一个字符串对象，则会引发异常。
>>> class GMT1(tzinfo):
... def utcoffset(self, dt):
... return timedelta(hours=1)
... def dst(self, dt):
... return timedelta(0)
... def tzname(self, dt):
... return 'Europe/Prague'
...
>>> t = time(12, 10, 30, tzinfo=GMT1())
>>> t
datetime.time(12, 10, 30, tzinfo=<__main__.GMT1 object at 0x108171588>)
>>> gmt = GMT1()
>>> t.isoformat()
'12:10:30+01:00'
>>> t.dst()
datetime.timedelta(0)
>>> t.tzname()
'Europe/Prague'
>>> t.utcoffset()
datetime.timedelta(seconds=3600)
>>> t1 = time(13, 40, 14) # tzinfo参数值为None
>>> t1.utcoffset() # 返回值为None
>>> t1.tzname() # 返回值为None
>>> t1.dst() # 返回值为None
1.2.6 datetime类
datetime 对象是一个包含 date 对象和 time 对象所有信息的单个对象。像 date 对象一样，datetime 假设当前公历向两个方向扩展。像时间对象一样，datetime假设每天正好有3600*24秒。
datetime 类的构造函数如下：
class datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0,tzinfo=None)
其中，year，month，day 三个参数是必须的。tzinfo 可以是 None 或 tzinfo 子类的实例。其余参数必须是整形，各自的取值范围如下：
- MINYEAR <= year <= MAXYEAR
- 1 <= month <= 12
- 1 <= day <= 给定的年份内给定月份的天数
- 0 <= hour < 24
- 0 <= minute < 60
- 0 <= second < 60
- 0 <= microsecond < 1000000
- fold 0或1
1.2.6.1 datetime对象的类方法
datetime 对象有如下几个类方法，同时，这些类方法也是 datetime 类的构造方法：
- datetime.today()
返回表示当前本地日期时间的datetime 对象，其中 tzinfo 参数值为 None。该方法的返回值等同于 datetime.fromtimestamp(time.time())。
>>> import time as _time
>>> dt = datetime.today()
>>> dt
datetime.datetime(2019, 3, 1, 17, 38, 41, 90585)
- datetime.now(tz=None)
返回表示当前本地日期时间的datetime 对象。如果可选参数tz 为 None 或者未指定，该方法与 datetime.today() 方法相似。但是，如果可能，通过 time.time 时间戳可以提供更高的精度(例如，这在提供C gettimeofday() 函数的平台上是可能的)。
如果 tz 参数不为 None，则其必须为 tzinfo 抽象基类的子类实例，并且当前日期和时间将被转换为使用 tz 指定的时区表示。这种情况下，结果等价于:
tz.fromutc(datetime.utcnow().replace(tzinfo=tz))。
>>> class GMT1(tzinfo):
... def utcoffset(self, dt):
... return timedelta(hours=1)
... def dst(self, dt):
... return timedelta(0)
... def tzname(self, dt):
... return 'Europe/Prague'
...
>>> gmt = GMT1()
>>> dt = datetime.now(tz=gmt)
>>> str(dt)
'2019-03-01 10:52:33.900215+01:00'
- datetime.utcnow()
返回当前UTC日期和时间， tzinfo 为 None。该方法类似于 datetime.now() ，但是返回的是表示当前UTC日期和时间的 naive的 datetime 对象实例。要获取表示当前UTC日期和时间的 aware 的 datetime 对象实例，可以使用 datetime.now(timezone.utc) 。
>>> dt2 = datetime.utcnow()
>>> dt2
datetime.datetime(2019, 3, 1, 10, 10, 52, 172822)
>>> dt3 = datetime.now(tz=timezone.utc)
>>> dt3
datetime.datetime(2019, 3, 1, 10, 11, 20, 885170, tzinfo=datetime.timezone.utc)
- datetime.fromtimestamp(timestamp, tz=None)
返回POSIX时间戳对应的本地日期和时间，就像 time.time() 的返回值。如果可选参数 tz 为 None 或未指定，则时间戳将转换为平台的本地日期和时间，并且返回的datetime对象是 naive 的。
如果 tz 不是 None，那么它必须是 tzinfo 抽象基类的子类的一个实例，并且时间戳被转换为 tz 的时区。在这种情况下，结果等价于:
tz.fromutc(datetime.utcfromtimestamp(timestamp).replace(tzinfo=tz))。
如果时间戳超出平台C localtime() 或 gmtime() 函数支持的值的范围，fromtimestamp() 可能会引发 OverflowError 异常。如果 localtime() 或gmtime() 执行失败，则会引发 OSError 异常。常见的做法是将年份限制在1970到2038之间。注意，对于在时间戳概念中包含闰秒的非posix系统，fromtimestamp() 会忽略闰秒，这可能使得两个相差1秒的时间戳产生相同的 datetime 实例对象。参见utcfromtimestamp ()。
>>> dt = datetime.now()
>>> ts = dt.timestamp()
>>> dt1 = datetime.fromtimestamp(ts)
>>> dt1
datetime.datetime(2019, 3, 1, 18, 24, 18, 317862)
>>> dt2 = datetime.fromtimestamp(ts, tz=gmt)
>>> dt2
datetime.datetime(2019, 3, 1, 11, 24, 18, 317862, tzinfo=<__main__.GMT1 object at 0x108171668>)
>>> str(dt1)
'2019-03-01 11:24:18.317862+01:00'
>>> str(dt2)
'2019-03-01 11:24:18.317862+01:00'
- datetime.utcfromtimestamp(timestamp)
返回与POSIX时间戳对应的UTC datetime ，其中 tzinfo 为 None。如果时间戳超出了平台C gmtime()函数支持的值的范围，那么可能会导致 OverflowError 异常。如果gmtime() 执行失败则会引发 OSError 异常。常见的做法是将年份限制在1970到2038之间。
要获取 aware 的 datetime 对象实例，可以调用 fromtimestamp() 方法：
>>> ts = datetime.now().timestamp()
>>> datetime.fromtimestamp(ts, timezone.utc)
datetime.datetime(2019, 3, 1, 10, 33, 45, 746328, tzinfo=datetime.timezone.utc)
在兼容POSIX的平台上，上述方法的返回值等价于以下表达式：
>>> ts = datetime.now().timestamp()
>>> datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(seconds=ts)
datetime.datetime(2019, 3, 1, 10, 33, 45, 746328, tzinfo=datetime.timezone.utc)
但后者总是支持完整的年份范围：[MINYEAR, MAXYEAR] 。
- datetime.fromordinal(ordinal)
返回给定的公历序数对应的 datetime 对象实例，其中第一年的1月1日的序数为1。如果不满足 1 <= ordinal <= datetime.max.toordinal()，则会引发 ValueError 异常。其中返回的 datetime 对象实例的小时、分钟、秒和微秒都为0，tzinfo为 None。
>>> od = date.today().toordinal()
>>> od
737119
>>> datetime.fromordinal(od)
datetime.datetime(2019, 3, 1, 0, 0)
- datetime.combine(date, time, tzinfo=self.tzinfo)
返回一个新的 datetime 对象，其日期组件等于给定日期对象的日期组件，其时间组件等于给定时间对象的时间组件。如果提供了 tzinfo 参数，则使用其值设置结果的 tzinfo 属性，否则使用 time 参数的 tzinfo 属性。
对于任意 datetime 对象 d，d == datetime.combine(d.date(), d.time(), d.tzinfo)。如果 date 的值是 datetime 对象，则忽略其时间组件和 tzinfo 属性。
>>> d = date.today()
>>> d
datetime.date(2019, 3, 1)
>>> t = time(14, 30, 25)
>>> t
datetime.time(14, 30, 25)
>>> ntd = datetime.combine(d, t)
>>> ntd
datetime.datetime(2019, 3, 1, 14, 30, 25)
>>> ntd1 = datetime.combine(d, t, gmt)
>>> ntd1
datetime.datetime(2019, 3, 1, 14, 30, 25, tzinfo=<__main__.GMT1 object at 0x108171668>)
>>> str(ntd1)
'2019-03-01 14:30:25+01:00'
- datetime.fromisoformat(date_string)
以 date.isoformat() 和 datetime.isoformat() 发出的格式之一返回 date_string 对应的 datetime 对象实例。具体来说，该函数支持如下格式的字符串：
YYYY-MM-DD[*HH[:MM[:SS[.fff[fff]]]][+HH:MM[:SS[.ffffff]]]]
其中*可以匹配任何单个字符。
警告:这并不支持解析任意的ISO 8601字符串——它只是作为datetime.isoformat()的反向操作。
>>> dt = datetime.now()
>>> dt.isoformat()
'2019-03-01T19:04:18.736531'
>>> dt.fromisoformat(dt.isoformat())
datetime.datetime(2019, 3, 1, 19, 4, 18, 736531)
>>> date_str = '2019-03-01 19:04:18'
>>> dt.fromisoformat(date_str)
datetime.datetime(2019, 3, 1, 19, 4, 18)
- datetime.strptime(date_string, format)
返回一个 date_string 对应的 datetime 对象实例。这相当于如下的表达式的值：
datetime(*(time.strptime(date_string, format)[0:6]))
如果 date_string 参数和 format 参数不能被 time.strptime() 解析，或者它们解析后的返回值不是一个时间元组，就会引发 ValueError 异常。有关格式化指令的完整列表，请参见 strftime() and strptime() Behavior.
>>> dt = datetime.strptime("21/11/06 16:30", "%d/%m/%y %H:%M")
>>> dt
datetime.datetime(2006, 11, 21, 16, 30)
1.2.6.2 datetime 对象类属性
- datetime.min
表示 datetime 对象实例能表示的最早的日期时间，等同于：
datetime(MINYEAR, 1, 1, tzinfo=None)
- datetime.max
表示 datetime 对象实例能表示的最晚的日期时间，等同于：
datetime(MAXYEAR, 12, 31, 23, 59, 59, 999999,tzinfo=None)
- datetime.resolution
表示两个不相等的 datetime 对象实例的最小差值，等同于：
timedelta(microseconds=1)
>>> datetime.min
datetime.datetime(1, 1, 1, 0, 0)
>>> datetime.max
datetime.datetime(9999, 12, 31, 23, 59, 59, 999999)
>>> datetime.resolution
datetime.timedelta(microseconds=1)
1.2.6.3 datetime对象实例属性
datetime 对象实例有如下几个只读属性：
- datetime.year
datetime 对象实例的年份
- datetime.month
datetime 对象实例的月份
- datetime.day
datetime 对象实例的天
- datetime.hour
datetime 对象实例的小时
- datetime.minute
datetime 对象实例的分钟
- datetime.second
datetime 对象实例的秒
- datetime.microsecond
datetime 对象实例的微秒
- datetime.tzinfo
datetime 对象实例的时区
- datetime.fold
>>> dt = datetime.now(gmt)
>>> dt
datetime.datetime(2019, 3, 1, 12, 25, 58, 595967, tzinfo=<__main__.GMT1 object at 0x108171668>)
>>> dt.year
2019
>>> dt.month
3
>>> dt.day
1
>>> dt.hour
12
>>> dt.minute
25
>>> dt.second
58
>>> dt.microsecond
595967
>>> dt.tzinfo
<__main__.GMT1 object at 0x108171668>
datetime 对象实例支持如下操作：
| Operation | Result |
|---|---|
| datetime2 = datetime1 + timedelta | (1) |
| datetime2 = datetime1 - timedelta | (2) |
| timedelta = datetime1 - datetime2 | (3) |
| datetime1 < datetime2 | (4) 比较两个datetime 对象实例 |
(1). 如果 timedelta.days > 0，那么datetime2表示比datetime1更晚的时间；如果如果timedelta.days < 0， 那么datetime2表示比datetime1更早的时间。datetime2与datetime1的 tzinfo 属性值相同，并且 datetime2 - datetime1 == timedelta。如果datetime2.year 大于MAXYEAR或者datetime2.year小于MINYEAR，将会引发 OverflowError 异常。注意，即使 datetime1是 aware 的，在计算过程中，也不会出现时区的调整。
(2). 表示计算出一个 datetime 对象实例datetime2，使得 datetime2 + timedelta == datetime1。另外，datetime2与datetime1的 tzinfo 属性值相同，并且即使datetime1是 aware 的，在计算完以后，也不会出现时区的调整。
(3). 只有当两个操作数都是 aware的，或者两个操作数都是 naive 的，才可以定义从一个 datetime 对象实例中减去另一个 datetime 对象实例。如果其中一个是 aware 的，而另一个是 naive 的，则会引发 TypeError 异常。
如果两者都是 naive 的，或者都是有 aware 的，并且具有相同的 tzinfo 属性，则将会忽略 tzinfo 属性，并且结果会是一个 timedelta 对象实例 t，使得 datetime2 + t == datetime1。在这种情况下不会做时区调整。
如果两者都是有 aware 的，并且具有不同的 tzinfo 属性，那么在计算 a-b 时会先将a和b转换为 naive的UTC日期时间然后再进行计算。在不会溢出的情况下，结果将等于：
(a.replace(tzinfo=None) - a.utcoffset()) - (b.replace(tzinfo=None) - b.utcoffset())。
(4). 当datetime1表示的是比datetime2更早的时间时，我们认为 datetime1小于datetime2。如果一个比较对象是 naive 的，而另一个比较对象是 aware的，那么如果尝试进行顺序比较时，则会引发 TypeError 异常。对于相等比较，naive 的 datetime 对象实例永远不等于 aware的 datetime 对象实例。
如果两个比较数都是 aware 的，并且具有相同的 tzinfo 属性，则忽略公共 tzinfo 属性并比较基准日期时间。如果两个比较数都是 aware 的并且具有不同的 tzinfo 属性，则首先通过减去它们的UTC偏移量(从self.utcoffset()获得)来调整比较数。
注意，为了防止比较退回到比较对象地址的默认模式，如果另一个操作数不是datetime对象，那么datetime比较通常会引发 TypeError 异常。但是，如果另一个比较数具有timetuple()属性，则引发 NotImplemded 异常。这个钩子为其他类型的日期对象提供了实现混合类型比较的机会。如果另一个比较数不具有 timetuple() 属性，当将datetime对象与另一种类型的对象进行比较时，则会引发 TypeError 异常，除非是进行相等比较(==)或不相等比较(!=)。
datetime 对象实例可以作为字典的键。在布尔型上下文中， datetime 对象实例总是被当作 True。
1.2.6.4 datetime 对象的实例方法
- datetime.date()
返回与 datetime对象实例有相同的year、month和day属性的 date 对象实例。
>>> dt = datetime.now()
>>> dt
datetime.datetime(2019, 3, 2, 16, 47, 22, 670443)
>>> dt.date()
datetime.date(2019, 3, 2)
- datetime.time()
返回与 datetime对象实例有相同的hour、minute、second、microsecond、fold属性的 time 对象实例，并且tzinfo属性为None。
>>> dt = datetime.now()
>>> dt
datetime.datetime(2019, 3, 2, 16, 52, 34, 189630)
>>> t = dt.time()
>>> t
datetime.time(16, 52, 34, 189630)
>>> t.tzinfo is None
True
- datetime.timetz()
返回与 datetime对象实例有相同的hour、minute、second、microsecond、fold和tzinfo属性的 time 对象实例
>>> dt = datetime.now(tz=gmt)
>>> dt
datetime.datetime(2019, 3, 2, 9, 54, 56, 808581, tzinfo=<__main__.GMT1 object at 0x108171668>)
>>> t = dt.timetz()
>>> t
datetime.time(9, 54, 56, 808581, tzinfo=<__main__.GMT1 object at 0x108171668>)
>>> dt.tzinfo == t.tzinfo
True
- datetime.replace(year=self.year, month=self.month, day=self.day, hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, tzinfo=self.tzinfo, ** fold=0*)
返回由指定的关键字参数替换datetime 对象实例中同名属性值后的新的 datetime 对象实例。请注意，可以指定 tzinfo=None 来从 aware 的 datetime 对象实例创建 naive 的 datetime 对象实例，而不需要转换日期和时间数据。
>>> dt = datetime.now()
>>> dt
datetime.datetime(2019, 3, 2, 17, 2, 16, 122112)
>>> new_dt = dt.replace(year=2008, month=3, day=8, hour=14, minute=30, second=45, microsecond=9000, tzinfo=gmt, fold=1)
>>> new_dt
datetime.datetime(2008, 3, 8, 14, 30, 45, 9000, fold=1, tzinfo=<__main__.GMT1 object at 0x108171668>)
- datetime.astimezone(tz=None)
返回带有新 tzinfo 属性 tz 的 datetime 对象实例，调整日期和时间数据使结果与 self 的UTC时间相同，但为用 tz 表示的本地时间。
如果为 tz 参数提供非 None 值，则该值必须是 tzinfo 子类的实例，并且其 utcoffset() 和 dst() 方法不得返回 None 。self 必须是 aware 的(self.tzinfo不能是None，以及self.utcoffset()不能返回None)。
如果不带参数调用(或tz=None)，则假定使用系统本地时区。转换后的 datetime 实例的tzinfo属性将设置为 timezone 的实例，其带有从操作系统获取的时区名称和偏移量。
如果self.tzinfo 与 tz 参数值相同，则 self.astimezone(tz) 等于 self ，并且日期和时间数据不会调整。否则结果是使用时区 tz 表示的本地时间，表示与 tz 相同的UTC时间。astz = dt.astimezone(tz) 之后，astz -astz.utcoffset()通常具有与dt - dt.utcoffset()相同的日期和时间数据。类 tzinfo 的讨论解释了无法实现的在夏令时转换边界的情况（仅当 tz 同时建模标准时和夏令时的时候才出现问题）。
如果你只想在不调整日期和时间数据的情况下将时区对象 tz 附加到 datetime 实例对象 dt，请使用 dt.replace(tzinfo=tz)。如果你只想从 aware 的 datetime 实例对象 dt 中删除时区对象而不转换日期和时间数据，请使用 dt.replace(tzinfo=None)。
请注意，可以在 tzinfo 子类中覆盖默认的 tzinfo.fromutc() 方法，以影响 astimezone() 返回的结果。忽略错误情况，astimezone() 的行为如下：
def astimezone(self, tz):
if self.tzinfo is tz:
return self
# Convert self to UTC, and attach the new time zone object.
utc = (self - self.utcoffset()).replace(tzinfo=tz)
# Convert from UTC to tz's local time.
return tz.fromutc(utc)
该方法使用示例：
>>> class TestGMT(tzinfo):
... def utcoffset(self, dt):
... return timedelta(hours=1)
... def dst(self, dt):
... return timedelta(0)
... def tzname(self, dt):
... return 'Europe/Prague'
...
>>> gmt = TestGMT()
>>> dt = datetime.now()
>>> dt
datetime.datetime(2019, 3, 4, 0, 43, 13, 363694)
>>> dt1 = dt.astimezone()
>>> dt1
datetime.datetime(2019, 3, 4, 0, 43, 13, 363694, tzinfo=datetime.timezone(datetime.timedelta(seconds=28800), 'CST'))
>>> dt1.tzinfo
datetime.timezone(datetime.timedelta(seconds=28800), 'CST')
>>> dt1.tzname()
'CST'
>>> dt2 = dt1.astimezone(tz=gmt)
>>> dt2
datetime.datetime(2019, 3, 3, 17, 43, 13, 363694, tzinfo=<__main__.TestGMT object at 0x10462e978>)
>>> dt2.tzinfo
<__main__.TestGMT object at 0x10462e978>
>>> dt2.tzname()
'Europe/Prague'
- datetime.utcoffset()
返回使用 datetime.timedelta 对象实例表示的 datetime 实例对象的时区偏移量。如果 datetime 对象实例的 tzinfo 属性为 None，则返回 None；否则返回 self.tzinfo.utcoffset(self) 的返回值；如果该方法的返回值不是 None 或者一个小于一天的 timedelta 对象，则会引发异常。
>>> class GMT1(tzinfo):
... def utcoffset(self, dt):
... return timedelta(hours=1)
... def dst(self, dt):
... return timedelta(0)
... def tzname(self, dt):
... return 'Europe/Prague'
...
>>> gmt = GMT1()
>>> dt = datetime.now(gmt)
>>> dt
datetime.datetime(2019, 3, 2, 18, 54, 39, 389884, tzinfo=<__main__.GMT1 object at 0x10751e390>)
>>> dt.utcoffset()
datetime.timedelta(seconds=3600)
>>> dt1 = datetime.now()
>>> dt1.utcoffset() is None
True
- datetime.dst()
返回使用 datetime.timedelta 对象实例表示的 datetime 实例对象的时区偏移量。如果 datetime 对象实例的 tzinfo 属性为 None，则返回 None；否则返回 self.tzinfo.dst(self) 的返回值；如果该方法的返回值不是 None 或者一个小于一天的 timedelta 对象，则会引发异常。
>>> dt = datetime.now(gmt)
>>> dt.dst()
datetime.timedelta(0)
>>> dt1 = datetime.now()
>>> dt1.dst() is None
True
- datetime.tzname()
返回 datetime 实例对象的时区名称。如果 datetime 实例对象的 tzinfo 属性是 None，则返回 None，否则返回 self.tzinfo.tzname(self)。如果该方法的返回值不是 None 或者自一个字符串对象，则会引发异常。
>>> dt = datetime.now(gmt)
>>> dt.tzname()
'Europe/Prague'
>>> dt1 = datetime.now()
>>> dt1.tzname() is None
True
- datetime.timetuple()
返回一个 time.struct_time 对象实例，类似于 time.localtime() 的返回值。如果 d 是一个datetime对象的实例，那么，d.timetuple() 等价于以下表达式：
time.struct_time((d.year, d.month, d.day, d.hour, d.minute, d.second, d.weekday(), yday, -1))
其中，yday = d.toordinal() - date(d.year, 1, 1) + 1 。
tm_isdst 的取值由 dst() 方法的返回值决定：如果 tzinfo 是 None 或者 dst() 的返回值是 None，tm_isdst 的值将取-1；如果 dst() 方法的返回值是一个非零值，那么 tm_isdst 的值取1，否则，tm_isdst 的值取0。
>>> dt = datetime.now(gmt)
>>> dt.timetuple()
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=2, tm_hour=19, tm_min=0, tm_sec=35, tm_wday=5, tm_yday=61, tm_isdst=0)
>>> dt1 = datetime.now()
>>> dt1.timetuple()
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=3, tm_hour=1, tm_min=59, tm_sec=48, tm_wday=6, tm_yday=62, tm_isdst=-1)
- datetime.utctimetuple()
如果 datetime 实例 d 是 naive 的，那么这个方法的返回值与 timetuple() 方法的返回值相似，只是tm_isdst 被强制设置为0，而不管 d.dst()的返回值是什么。
如果 d 是 aware 的，则通过减去 d.utcoffset()，将 d 规范化为UTC时间，然后返回这个规范化时间的struct_time，并且 tm_isdst 强制为0。请注意，如果 d.year 是MINYEAR或MAXYEAR，并且UTC调整超出了一年的边界，那么可能会引发 OverflowError 异常。
>>> dt = datetime.now() # 当datetime实例是'naive'的时
>>> dt.utctimetuple()
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=3, tm_hour=2, tm_min=40, tm_sec=7, tm_wday=6, tm_yday=62, tm_isdst=0)
>>> dt1 = datetime.now(gmt) # 当datetime实例是'aware'的时
>>> dt1.utctimetuple()
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=2, tm_hour=18, tm_min=40, tm_sec=34, tm_wday=5, tm_yday=61, tm_isdst=0)
>>> dt1.utctimetuple() == (dt1 - dt1.utcoffset()).timetuple()
True
- datetime.toordinal()
返回日期的预期公历序号。与 self.date().toordinal() 的值相同。
>>> dt = datetime.now()
>>> dt.toordinal()
737121
>>> dt.date().toordinal()
737121
- datetime.timestamp()
返回与 datetime 实例对应的POSIX时间戳。返回值是一个类似于time.time()返回值的浮点数。
假定本地时间使用 navi 的 datetime 实例表示，并且该方法依赖于平台的C语言的 mktime()函数执行转换。由于在许多平台上 datetime 支持的值比 mktime() 的范围更广，因此这种方法可能会在过去或未来很长一段时间内产生OverflowError 异常。
对于 aware 的 datetime 实例，返回值由下面的表达式计算：
(dt - datetime(1970, 1, 1, tzinfo=timezone.utc)).total_seconds()
>>> import time as _time
>>> dt = datetime.now()
>>> dt.timestamp()
1551552673.72456
>>> _time.time()
1551552686.284929
- datetime.weekday()
返回当前日期在一周内的序号，即星期几，其中周一表示为0，周日表示为6。
>>> dt = datetime.now()
>>> dt.weekday()
6
>>> dt.date().weekday()
6
- datetime.isoweekday()
返回当前日期在一周内的序号，即星期几，其中周一表示为1，周日表示为7。
>>> dt = datetime.now()
>>> dt.isoweekday()
7
>>> dt.date().isoweekday()
7
- datetime.isocalendar()
返回一个包含给定日期时间对象的ISO year、ISO week number和ISO weekday的三元组。
>>> dt = datetime.now()
>>> dt.isocalendar()
(2019, 9, 7)
>>> dt.date().isocalendar()
(2019, 9, 7)
- datetime.isoformat(sep=‘T’, timespec=‘auto’)
返回一个使用 ISO 8601格式表示 datetime 实例的日期和时间的字符串。
如果给定实例的 microsecond 属性值不是0，那么具体格式为 YYYY-MM-DDTHH:MM:SS.ffffff 。
如果给定实例的 microsecond 属性值是0，那么具体格式为 YYYY-MM-DDTHH:MM:SS 。
如果给定实例的 utcoffset 方法返回值不是 None，则会附加一个字符串用来给出UTC偏移量，此时，字符串格式如下：
YYYY-MM-DDTHH:MM:SS.ffffff+HH:MM[:SS[.ffffff]] ；
如果给定实例的 microsecond 属性值是0，字符串的格式如下：
YYYY-MM-DDTHH:MM:SS+HH:MM[:SS[.ffffff]] ；
可选参数 sep (默认值为’T’) 是一个单字符分隔符，用来分隔结果中的日期和时间部分，例如：
>>> from datetime import tzinfo, timedelta, datetime
>>> class TZ(tzinfo):
... def utcoffset(self, dt): return timedelta(minutes=-399)
...
>>> datetime(2019, 3, 2, tzinfo=TZ()).isoformat(' ')
'2019-03-02 00:00:00-06:39'
可选参数 timespec 用来指定可选的时间组件数(默认值为’auto’)。该参数的取值可以是下列中的一个：
+ `auto` ：如果 `microsecond` 为0，则与 `second` 相同，否则，与 `microseconds` 相同。
+ `hours`：包含 `hour`，格式为 `HH` 。
+ `minutes`：包含 `hour` 和 `minute`，格式为 `HH:MM`。
+ `seconds`：包含 `hour`、`minute` 和 `second`，格式为 `HH:MM:SS`。
+ `milliseconds`：包含完整的时间格式，但是会忽略微秒，并表示为这样的格式 `HH:MM:SS.sss`。
+ `microseconds`：包含完整的时间格式 `HH:MM:SS.ffffff`如果指定的 `timespec` 参数的值不在上述列举的范围内，则会引发 `ValueError` 异常。
>>> dt = datetime.now()
>>> dt.isoformat(timespec='minutes')
'2019-03-03T03:56'
>>> dt.isoformat(timespec='seconds')
'2019-03-03T03:56:04'
>>> dt.isoformat(timespec='milliseconds')
'2019-03-03T03:56:04.772'
>>> dt.isoformat(timespec='microseconds')
'2019-03-03T03:56:04.772110'
- datetime.__str__()
对于 datetime 实例 d，str(d) 等同于 d.isoformat(' ')
>>> dt = datetime.now()
>>> str(dt)
'2019-03-03 04:00:08.416914'
>>> dt.isoformat(' ')
'2019-03-03 04:00:08.416914'
- datetimte.ctime()
返回表示给定 datetime 实例日期和时间的字符串。例如 date(2002, 12, 4, 20, 30, 40).ctime() == 'Wed Dec 4 20:30:40 2002' 。对于 datetime 的实例对象 d，在本地C语言的ctime() (调用time.ctime()而不是datetime.ctime())函数符合C标准的平台上，d.ctime()等价于如下表达式的值：
time.ctime(time.mktime(d.timetuple()))
>>> dt = datetime.now()
>>> dt.ctime()
'Sun Mar 3 04:30:52 2019'
- datetimte.__format__()
与 datetime.strftime() 方法功能相同。同时，这也使得在使用 str.format() 时，可以使用带格式的字符串文本为 datetime 对象实例指定格式字符串。完整的格式化指令，请参考 strftime() and strptime() Behavior 。
>>> dt = datetime.now()
>>> 'The {1} is {0:%d}, the {2} is {0:%B}, the {3} is {0:%I:%M%p}.'.format(dt, "day", "month", "time")
'The day is 03, the month is March, the time is 04:43AM.'
- datetime.strftime()
返回一个表示 datetime 实例的日期和时间的字符串，其格式由显式的格式化字符串指定。完整的格式化指令，请参考 strftime() and strptime() Behavior 。
>>> dt = datetime.now()
>>> dt.strftime('%A, %d. %B %Y %I:%M%p')
'Sunday, 03. March 2019 04:43AM'
>>> dt.strftime('%Y-%m-%d')
'2019-03-03'
2. time模块
2.1 time模块简介
尽管这个模块总是可用的，但是不是所有的这个模块内的方法(函数)在所有平台上都是可用的。这个模块内定义的大多数方法都会调用平台的C库的同名方法。由于这些函数的语义在不同的平台之间是不同的，因此，在使用时应该参考对应平台上的使用文档。
2.2 time模块详解
2.2.1 术语和约定
如下是对一些要使用到的术语和约定的解释：
- 纪元(epoch)
表示时间开始的点，与平台无关。对于Unix系统来说，纪元是UTC时间 “1970-01-01 00:00:00”。对于给定平台上的纪元，可以使用 gmtime(0) 方法获取。
>>> import time
>>> time.gmtime(0)
time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)
- 自纪元以来的秒(seconds since the epoch)
该术语指自纪元以来经过的秒的总数，通常不包括闰秒。在所有兼容posix的平台上，闰秒都不包括在这个总数中。
- 此模块中的函数可能无法处理纪元之前或很远的将来的日期和时间。未来的分界点由C库确定，对于32位系统，通常是在2038年。
- 2000年问题
Python依赖于平台的C库，该库通常没有2000年问题，因为所有日期和时间都在内部表示为自纪元之后的总的秒数。函数 strptime() 可以接受格式为 %y 的格式化代码并正确解析两位数年份。当解析两位数年份时，它们将根据POSIX和ISO C标准进行如下转换：
值69—99映射到1969—1999，值0—68映射到2000—2068。
- UTC是
协调世界时(Coordinated Universal Time)（以前称为格林威治标准时间(Greenwich Mean Time)，或GMT）。首字母缩略词UTC不是一个错误，而是英语和法语的一种折中方案。 - DST是
夏令时(Daylight Saving Time)，是指在一年中的某一段时间内时区(通常)调整一小时。DST规则由当地法律决定，并且每年都可能发生变化。C库有一个包含本地规则的表(通常是从系统文件中读取以获得以便具有灵活性)。 - 各种实时(real-time)函数的精度可能低于表示其值或参数的单位所建议的精度。例如，在大多数Unix系统上，时钟每秒只滴答(ticks)50或100次。
- 另一方面，
times()和sleep()能够获得比Unix上同名方法更好的精度：时间用浮点数表示，times()方法返回可用的最准确的时间(在可用的情况下使用Unix的gettimeofday()方法)，sleep()方法接受非零小数的时间作为参数(在可用的情况下使用Unix的select()方法实现)。 gmtime()方法、localtime()方法和strptime()方法返回的时间，以及asctime()方法、mktime()方法和strftime()方法接受的时间，是9个整数组成的序列。asctime()方法、mktime()方法和strftime()方法的返回值还为每个独立的项提供了属性名。
>>> import time
>>> lt = time.localtime()
>>> lt
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=5, tm_hour=15, tm_min=5, tm_sec=49, tm_wday=1, tm_yday=64, tm_isdst=0)
>>> lt.tm_year
2019
>>> lt.tm_yday
64
- 使用如下的几个方法进行时间的表示形式之间的转换：
2.2.2 time模块中的函数
time模块中包含如下一些常用方法：
- time.asctime([t])
将表示 gmtime() 或 localtime()返回值的 tuple 对象实例或 struct_time 对象转换为以下形式的字符串：
“Sun Jun 20 23:21:05 1993”
如果不提供参数 t，则使用 localtime() 返回的当前时间。该方法不使用区域信息。
>>> lt = time.localtime()
>>> time.asctime(lt)
'Tue Mar 5 16:11:45 2019'
>>> t = (2010, 2, 14, 10, 10, 30, 2, 66, 1)
>>> time.asctime(t)
'Wed Feb 14 10:10:30 2010'
>>> st = time.struct_time(t)
>>> st
time.struct_time(tm_year=2010, tm_mon=2, tm_mday=14, tm_hour=10, tm_min=10, tm_sec=30, tm_wday=2, tm_yday=66, tm_isdst=1)
>>> time.asctime(st)
'Wed Feb 14 10:10:30 2010'
- time.clock()
在Unix上，返回表示当前处理器时间的以秒为单位的浮点数。“处理器时间”的精度和定义，实际上取决于同名C函数。
在Windows上，该函数基于Win32函数 QueryPerformanceCounter() 返回以浮点数的形式表示的自第一次调用该函数以来的挂钟秒数。误差通常小于1微秒。
注意：该函数从3.3版本开始已被弃用，如果调用该函数，虽然可以得到返回值，但同时也将引发 DeprecationWarning 异常，并且从3.8版本以后，这个函数将被移除。建议使用 time.perf_counter 或 time.process_time 进行替换。
- time.pthread_getcpuclockid(thread_id)
为指定的 thread_id 返回特定于线程的cpu时间时钟的 clk_id。
使用 thread .get_ident() 或线程的 ident 属性为线程对象获取适合 thread_id 的值。
警告：传递一个无效或过期thread_id可能导致未定义行为，如段错误(segmentation fault)。
可用性：仅Unix平台可用
- time.clock_getres(clk_id)
返回指定的时钟 clk_id 的resolution(精度)。有关 clk_id 的可接受值列表，请参阅时钟ID常量。
可用性：仅Unix平台可用
- time.clock_gettime(clk_id) -> float
返回指定时钟 clk_id 的时间。有关 clk_id 的可接受值列表，请参阅时钟ID常量。
可用性：仅Unix平台可用
- time.clock_gettime_ns(clk_id) -> int
类似 clock_gettime()，但返回的时间为纳秒。
可用性：仅Unix平台可用
- time.clock_settime(clk_id, time: float)
设置指定时钟 clk_id 的时间。目前，CLOCK_REALTIME是 clk_id 唯一可接受的值。
可用性：仅Unix平台可用
- time.clock_settime_ns(clk_id, time: int)
类似 clock_settime()，但使用纳秒设置时间。
可用性：仅Unix平台可用
- time.ctime([secs])
将纪元后以秒为单位表示的时间转换为表示本地时间的字符串。如果未提供 secs 参数或该参数值为 None，则使用 time() 方法返回的当前时间。ctime(secs) 相当于 asctime(localtime(secs))。ctime() 不使用区域设置信息。
>>> time.ctime()
'Tue Mar 5 17:01:49 2019'
>>> time.ctime(5201314)
'Mon Mar 2 12:48:34 1970'
>>> time.ctime(5201314) == time.asctime(time.localtime(5201314))
True
- time.get_clock_info(name)
以命名空间对象的形式获取关于指定时钟的信息。支持的时钟名称和读取其值的对应函数如下：
+ clock“：time.clock()
+ monotonic：time.monotonic()
+ perf\_counter：time.perf\_counter()
+ process\_time：time.process\_time()
+ thread\_time：time.thread\_time()
+ time：time.time()该方法的返回值有如下属性：
+ adjustable：如果时钟能够被自动更改(例如，被NTP守护进程)或被系统管理员手动更改，那么这个值将为 `True`，否则则为 `False`。
+ implementation：获取时钟值的底层C函数。可能的值，请参阅 `时钟ID常量`。
+ monotonic：如果时钟不能倒退，则返回`True`，否则返回 `False`。
+ resolution：用浮点数表示的以秒为单位的时钟误差(resolution)。
>>> r = time.get_clock_info('time')
>>> r
namespace(adjustable=True, implementation='clock\_gettime(CLOCK\_REALTIME)', monotonic=False, resolution=1.0000000000000002e-06)
>>> r.__dict__
{'implementation': 'clock\_gettime(CLOCK\_REALTIME)', 'monotonic': False, 'adjustable': True, 'resolution': 1.0000000000000002e-06}
- time.gmtime([secs])
将以秒表示的纪元后时间转换为以 struct_time 实例表示的UTC时间，其中 dst 标志始终为零。如果没有提供 secs 参数或参数值为 None，则使用 time() 方法返回的当前时间。小数秒将被忽略。详情请参见struct_time 对象的描述。有关此函数的逆函数，请参见 calendar.timegm() 函数。
>>> time.gmtime(5201314)
time.struct_time(tm_year=1970, tm_mon=3, tm_mday=2, tm_hour=4, tm_min=48, tm_sec=34, tm_wday=0, tm_yday=61, tm_isdst=0)
>>> time.gmtime()
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=5, tm_hour=9, tm_min=43, tm_sec=52, tm_wday=1, tm_yday=64, tm_isdst=0)
>>> time.gmtime(None)
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=5, tm_hour=9, tm_min=43, tm_sec=59, tm_wday=1, tm_yday=64, tm_isdst=0)
>>> time.gmtime(4.6)
time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=4, tm_wday=3, tm_yday=1, tm_isdst=0)
- time.localtime([secs])
类似于 gmtime()，但返回值将被转换为本地时间。如果没有提供 secs 参数或参数值为 None，则使用time() 方法返回的当前时间。当 DST 适用于给定的时间时，dst 标志将被设置为1。
>>> time.localtime()
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=5, tm_hour=17, tm_min=45, tm_sec=11, tm_wday=1, tm_yday=64, tm_isdst=0)
>>> time.localtime(None)
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=5, tm_hour=17, tm_min=45, tm_sec=13, tm_wday=1, tm_yday=64, tm_isdst=0)
>>> time.gmtime(5201314) # 转化为UTC
time.struct_time(tm_year=1970, tm_mon=3, tm_mday=2, tm_hour=4, tm_min=48, tm_sec=34, tm_wday=0, tm_yday=61, tm_isdst=0)
>>> time.localtime(5201314) # 转换为本地时间，可以看到结果中的小时数已经加了8小时，即东八区时间
time.struct_time(tm_year=1970, tm_mon=3, tm_mday=2, tm_hour=12, tm_min=48, tm_sec=34, tm_wday=0, tm_yday=61, tm_isdst=0)
- time.mktime(t)
这是 localtime() 函数的逆函数。该方法的参数 t 必须是 struct_time 实例或一个9元组(因为需要 dst 标志；如果dst 是未知的，则使用-1作为 dst 标志)，返回值为表示本地时间而不是UTC的以秒为单位的浮点数。之所以返回值类行为浮点型主要是为了与 time()兼容。如果输入值不能表示为有效时间，则会引发 OverflowError 异常或 ValueError 异常(这取决于Python或底层C库是否捕捉到无效值)。该方法能够生成的最早的时间依赖于平台。
>>> time.mktime((1970, 3, 2, 12, 48, 34, 0, 61, 0))
5201314.0
st = time.struct_time((1970, 3, 2, 12, 48, 34, 0, 61, 0))
>>> st
time.struct_time(tm_year=1970, tm_mon=3, tm_mday=2, tm_hour=12, tm_min=48, tm_sec=34, tm_wday=0, tm_yday=61, tm_isdst=0)
>>> time.mktime(st)
5201314.0
>>> time.mktime(454)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Tuple or struct_time argument required
- time.monotonic() -> float
返回一个单调时钟的值(以小数秒为单位)。单调时钟不受系统时钟更新的影响。由于返回值的参考点没有定义，因此只有连续调用的结果之间的差异才是有效的。
- time.monotonic_ns() -> int
与 monotonic() 函数类似，但返回值的单位纳秒，类型为整形。
- time.perf_counter() -> float
返回性能计数器的值(以小数秒为单位)，例如，一个以最高的可用分辨率测量短地持续时间的时钟。它确实包括系统范围内睡眠期间经过的时间。由于返回值的参考点没有定义，因此只有连续调用的结果之间的差异是有效的。
- time.perf_counter_ns() -> int
与 perf_counter() 函数类似，但是返回值是以纳秒为单位，且类型为整形。
- time.process_time() -> float
返回当前进程的系统和用户CPU时间之和的值（以分数秒为单位）。它不包括在睡眠期间经过的时间，而是在进程范围内定义的。由于返回值的参考点未定义，因此只有连续调用结果之间的差异有效。
- time.process_time_ns() -> int
与 process_time() 函数类似，但范围值是以纳秒为单位，且类型为整形。
- time.sleep(secs)
在给定的秒数内暂停调用线程的执行。参数可以是一个浮点数，用以表示更精确的睡眠时间。实际的暂停时间可能小于请求的时间，因为任何捕获到的信号都会在执行该信号的捕获例程之后终止 sleep() 。此外，由于系统中其他活动的调度，实际的暂停时间可能比请求的暂停时间长任意地数量。
- time.strftime(format[, t])
将由 gmtime() 函数或 localtime() 函数返回的表示时间的元组或 struct_time 对象实例转换为字符串，其中，字符串的格式由字符串类型的参数format 指定。如果没有给参数 t 提供值，则使用 localtime() 函数返回的当前时间。如果 t 中的任何字段超出了允许的范围，则会引发 ValueError。
0 是时间元组中任何位置上的合法参数。如果 0 通常是非法的，那么它会被强制为一个正确的值。
以下指令可以嵌入到 format 参数中。它们没有可选的字段宽度和精度规范，而是由 strftime() 结果中指定的字符替换：
| 指令 | 含义 | 注释 |
|---|---|---|
| %a | 当前区域设置下工作日名称的缩写 | |
| %A | 当前区域设置下工作日名称的全称 | |
| %b | 当前区域设置下月份名称的缩写 | |
| %B | 当前区域设置下月份名称的全称 | |
| %c | 当前区域设置下日期和时间的适当表示 | |
| %d | 使用十进制数字表示的当前日期中的天在当前月份的序数，范围为[01, 31] | |
| %H | 使用十进制数字表示的当前时间中小时的序数(24小时制)，范围为[00, 23] | |
| %I | 使用十进制数字表示的当前时间中小时的序数(12小时制)，范围为[01, 12] | |
| %j | 使用十进制数字表示的当前日期中的天在当前年的序数，范围为[001, 366] | |
| %m | 使用十进制数字表示的当前日期中的月份的序数，范围为[01, 12] | |
| %M | 使用十进制数字表示的当前时间中的分钟在一小时内的序数，范围为[00, 59] | |
| %p | 当前区域设置下的上午(AM)或下午(PM) | （1） |
| %S | 使用十进制数字表示的当前时间中的秒在一分钟内的序数，范围为[00, 61] | （2） |
| %U | 使用十进制数字表示当前日期处于当年中的第几个星期，范围为[00, 53]。周日被看作每周的第一天。新年第一个星期日之前的所有日子都被认为是在第0周。 | （3） |
| %w | 使用十进制数字表示当前日期中的天在当前周的序号，范围为[0, 6]。其中，0表示周日，6表示周六 | |
| %W | 使用十进制数字表示当前日期处于当年中的第几个星期，范围为[00, 53]。周一被看作每周的第一天。新年第一个星期日之前的所有日子都被认为是在第0周。 | （3） |
| %x | 当前区域设置下日期的适当表示 | |
| %X | 当前区域设置下时间的适当表示 | |
| %y | 使用两位十进制数字表示当前日期中的年(不包括世纪)，范围为[00, 99] | |
| %Y | 使用十进制数字表示当前日期中的年(包含世纪) | |
| %z | 表示与UTC/GMT的正或负时差的时区偏移量，其形式为 +HHMM 或 -HHMM。其中 H 表示十进制小时数，M 表示十进制分钟数 | |
| %Z | 时区名称(如果没有时区信息则为空) | |
| %% | 表示一个 % 符号 |
注释：
最后
Python崛起并且风靡，因为优点多、应用领域广、被大牛们认可。学习 Python 门槛很低，但它的晋级路线很多，通过它你能进入机器学习、数据挖掘、大数据，CS等更加高级的领域。Python可以做网络应用，可以做科学计算，数据分析，可以做网络爬虫，可以做机器学习、自然语言处理、可以写游戏、可以做桌面应用…Python可以做的很多，你需要学好基础，再选择明确的方向。这里给大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！
👉Python所有方向的学习路线👈
Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
👉Python必备开发工具👈
工欲善其事必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。
👉Python全套学习视频👈
我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。
👉实战案例👈
学python就与学数学一样，是不能只看书不做题的，直接看步骤和答案会让人误以为自己全都掌握了，但是碰到生题的时候还是会一筹莫展。
因此在学习python的过程中一定要记得多动手写代码，教程只需要看一两遍即可。
👉大厂面试真题👈
我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
4358
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
