做项目的时候，有一个简单需求，就是取到当前时间5年后的某个时间点，这个要怎么做？
这个不是简单的加5年时间，需要库里有自动识别哪一年是闰年，最后返回准确结果。
看起来简单的需求，但因为对Python类库不熟悉，可能被多个时间对象搞懵！
唯一的办法，只能把python中所有关于时间的模块全部学习一遍，以下记录学习的笔记。
通过学习，得出解决这个问题的方法：
from datetime import datetime
from datetime import timedelta
from calendar
# 方法一、只需要将365*5就是五年的天数，但这里未考虑到闰年的情况
# 如果能判断5年中哪一些是闰年再加相应天数就可以得到正确的天数总和
dt = datetime.now()
td1 = timedelta(days=365*5) # 这里的365不是固定的，不能这样写
print(dt td1)
# 方法二、如果刚好碰上今年是闰年的2月29日，如果5年后又正好不是闰年，2月份没有29天，那么就会报错，所以还是要判断闰年。
d1 = date.today()
print(d1.replace(year=d1.year 5))
# 方法三、可以用到calendar模块中的isleap(year)方法，这样就没问题了！
dt1 = datetime.now()
days = 0
for i in range(dt1.year 1,dt1.year 2):
# 判断是否是闰年
if calendar.isleap(i):
days = 366
else:
days = 365
print(dt1 timedelta(days=days))
以下重点内容标红显示
一、背景知识介绍：
1、时间是人类规定的产物，与长度单位是一个道理，米这个单位也是人类发明的。简单说就是地球自转1圈为1天，地球饶太阳公转1圈为1年，而且根据公转自转度量时间都是不可靠的（因为非匀速无法准确度量），关键是找到匀速的度量工具。
历史上时间计量的方法，比如：
- 太阳时：以太阳为基础的相对于原子时不十分精准的时间
- 历书时：描述天体运动的方程式中采用的时间﹐或天体历表中应用的时间，已经被原子时替代，不多做讨论。
- 格林威治时间标准时间（GMT）：以本初子午线的平子夜起算的平太阳时，1960年以前曾作为基本时间计量系统被广泛应用，因为地球自转非匀速，所以并不是一个很好的时间度量系统，已经被原子时替代。但是一些原则却被保留了下来，比如将世界分为24个时区。
- 协调世界时（UTC）：这是现在主要用的时间系统，为了保证时间的匀速统一，采用原子正常衰变的时间做为基准来度量时间（具体理论不深究），由原子钟提供原子时，然后对世界时进行纠正，在适当的实际加减秒数以达到一致。所以，在不需要精确到秒的情况下，通常将GMT 和UTC 视作等同。
- 中国属于UTC 8区，也就是东八区，需要在UTC时间的基础上加8小时得到北京时间。
- 夏令时：为了节约能源，人为将时钟调快的行为，这是非普遍行为所以在程序中可以不考虑，在中国已经废除了这个制度。
- 如果一定要考虑这个因素可以用到tzinfo对象，因只使用简单时间所以本文未对tzinfo对象做研究。
- ISO8601 ：国际标准化组织制定的ISO8601国际标准，是日期和时间的表示方法。比如：2004-05-03T17:30:08 08:00，中间的T代表间隔符，最后的 08:00代表时差。
- 简单型时间：不考虑时区、夏时令等因素，而仅通过运行程序所在地获得时间的返回值。简单型对象更易于理解和使用，代价则是忽略了某些现实性考量。推荐使用！
- 感知型时间：考虑时区、夏时令等因素，将所有情况都考虑进去后得到矫正的时间值，其用来表示一个没有解释空间的固定时间点。python提供一个抽象类接口tzinfo，通过实现其子类来完善时间，datetime模块只提供了一个tzinfo类，即timezone类。
2、为什么要知道这些背景知识？
因为Python中出现很多关于时间的术语，比如UTC，如果一个方法返回的是UTC时间，如果不知道以上知识，就无法对返回值有预期。
二、Python 的时间类库概述：
- time模块：包含时间的访问和转换函数，此模块包含一些底层的接口，比如让线程休眠的sleep()，还有提取cpu时间的方法。如果要实现更复杂时间操作，可以用到下面几个对象。
- timedelta对象：这是一个代表时间间隔的对象，可以对时间进行计算，还支持与date和datetime对象进行特定的相加和相减运算
- date对象：代表年、月、日的日期对象，也就是说该对象重点操作对象是年月日，忽略时分秒。两个date对象之间，或者date对象和timedalta对象之间，可以做加减运算，可以比大小。
- time对象：代表某日的（本地）时间，它独立于任何特定日期，并可通过 tzinfo 对象来调整。（tzinfo 对象涉及到时区和夏令时等概念，本文不做讨论）
- datetime对象：对象是包含来自 date 对象和 time 对象的所有信息的单一对象。意味着我们大部分情况下只需要用这个对象即可。
- calendar模块：这个模块让你可以输出日历，它还提供了其它与日历相关的实用函数。
- 类继承关系：
三、time 模块：包含时间的访问和转换功能，time模块不同于datetime中的time对象
1、class time.struct_time：为 gmtime() 、 localtime() 和 strptime()的返回值 。它是带有 named tuple 接口的对象：可以通过索引和属性名访问值。 存在以下值：
2、时间戳类型，形式是从 epoch 开始的秒数（浮点型 float），epoch的值可以用time.gmtime(0)查看，一般是1970年1月1日0时开始。
3、字符串类型，形式是字符串，这里包含了时间格式转换成自定义格式字符串的各种函数。
4、函数介绍：
- asctime([t])：struct_time转字符串，[t]为struct_time类型，不提供此参数则默认用localtime()的值，返回结果如：Sun Jun 2023:21:05 2020
- ctime([secs])：将时间戳类型转字符串，[secs]为时间戳秒数，如果不提供则默认以time.time()的值，ctime(secs)等价于asctime(localtime(secs))，返回结果如：Sun Jun 2023:21:05 2020
- gmtime([secs])：将时间戳类型转struct_time类型，注意返回结果是UTC时间，也就是世界标准是时间，不是本地时间，如北京时间是UTC 8小时得到的。[secs]如果不提供则用time.time()的值，反向操作用calendar.timegm()
- localtime([secs])：同上，将时间戳类型转struct_time类型，区别在于localtime返回的是本地时间，比如北京时间。
- mktime(t)：将struct_time类型转成时间戳类型，是localtime()的逆函数，是本地时间，不是UTC时间
- monotonic() ：返回一个float秒数数值，且不受系统更新时间影响，即如果把系统时间改了那么用time()返回的是修改后的时间戳秒数，因为monotonic()不是从1970-1-1开始的，这就能用来计算两个monotonic()秒数的间隔。
- monotonic_ns() ：同上，返回int纳秒
- sleep(secs)：暂停执行调用线程达到给定的秒数
- strftime(format[, t])：struct_time类型转字符串，format字符格式化是必须要指定的（格式如下表），stuct_time不指定的话默认用localtime()的值：
图2
- strptime(string[, format])：字符串转struct_time类型，format 参数同上，string 和 format 都必须是字符串。
- time() ：返回以float数表示的从 epoch 开始的秒数的时间值，epoch的值可以用gmtime(0)获得，gmtime()和localtime()默认使用time()，前者返回UTC时间，后者返回本地时间。
四、timedelta模块：这是一个代表时间间隔的对象，可以对时间进行计算
1、timedelta对象的标准化：timedelta会将输入的值都归结到天数上，如：timedelta(days=50,seconds=27,microseconds=10,milliseconds=29000,minutes=5,hours=8,weeks=2)，将得到datetime.timedelta(days=64, seconds=29156, microseconds=10)的结果
2、支持timedelta对象对象之间的运算：
3、支持timedelta对象之间用关系运算符计算：
>>> from datetime import timedelta
>>> delta1 = timedelta(seconds=57)
>>> delta2 = timedelta(hours=25, seconds=2)
>>> delta2 != delta1
True
>>> delta2 == 5
False
##########################################
>>> delta2 > delta1
True
>>> delta2 > 5
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: '>' not supported between instances of 'datetime.timedelta' and 'int'
4、timedelta 对象还支持与 date 和 datetime 对象进行特定的相加和相减运算：这在下面的date模块中介绍。
5、timedelta.total_seconds()：返回timedelta对象所表示的时间段以秒为单位的数值。
五、date模块：代表年、月、日的日期对象，也就是说该对象重点操作对象是年月日，忽略时分秒。两个date对象之间，或者date对象和timedalta对象之间，可以做加减运算，可以比对大、小和相等关系。
1、函数介绍：
- today()：返回当前本地日期，比如：date.today()，返回2020-04-14，相当于date.fromtimestamp(time.time())
- fromtimestamp(timestamp)：返回时间戳格式的日期字符串，timestamp为时间戳，是必填参数，比如：date.fromtimestamp(time.time())，返回：2020-04-14
- fromordinal(days)：返回对应于预期格列高利历序号的日期。传入一个从公元1年1月1日开始计算的天数，返回一个具体的年份，现在还没想到应用场景。比如：date.fromordinal(2)，返回：0001-01-02。也就是公元1年1月1日。
- fromisoformat(date_string)：返回一个字符串日期的date对象，只支持 YYYY-MM-DD 格式，是date.isoformat() 的逆操作方法，比如：fromisoformat(“2010-04-20”)，返回：datetime.date(2019, 12, 4)
- fromisocalendar(year,week,day)：返回指定时间的日期，year为年份，week为此年份第几个星期(值范围：平年是1~52，闰年是1~53，闰年是52周加2天所以是53)，day为此星期的星期几(值范围：1~7)
- replace(year=self.year, month=self.month, day=self.day)：替换年月日为一个新日期
>>> from datetime import date
>>> d = date(2002, 12, 31)
>>> d.replace(day=26)
datetime.date(2002, 12, 26)
- timetuple()：返回struct_time类型，即 time.localtime() 所返回的类型。但只有year，month，days。另外hours, minutes 和 seconds 值均为 0
- toordinal()：与fromordinal(days)是相对应的一对函数，返回日期的对应的从公元1年1月1日开始的天数。比如：date(2020,4,14).toordinal()，返回：737529
- isoweekday()：返回星期几，1~7，0代表星期一，以此类推。比如：date(2020,4,14).isoweekday()，返回：1
- isocalendar()：返回一个 3 元组 (ISO 年份, ISO 周序号, ISO 周日期)，比如：date(2020,4,14).isocalendar()，返回：(2020, 16, 2)，代表2020年第16周第二天
- isoformat()：返回格式 YYYY-MM-DD 来表示日期的字符串，这是 date.fromisoformat() 的逆操作。比如：date.today().isoformat()，返回：2020-04-14
- ctime()：返回一个日期字符串，等效于：time.ctime(time.mktime(d.timetuple()))，比如：date(2002, 12, 4).ctime()，返回：'Wed Dec 4 00:00:00 2002'
- replace(year=self.year, month=self.month, day=self.day)：替换年月日返回一个新的date对象。
- strftime(format)：返回指定格式的时间字符串。format格式如上面< 图2 >，比如：date.today().strftime("%d/%m/%y")，返回：'11/03/02'
2、运算：支持与timedalta对象的运算。
3、date代码示例
# #计算距离特定事件天数的例子:
>>> import time
>>> from datetime import date
>>> today = date.today()
>>> my_birthday = date(today.year, 6, 24)
>>> if my_birthday < today: # 如果生日已经过去，则创建明年的生日
... my_birthday = my_birthday.replace(year=today.year 1)
>>> my_birthday datetime.date(2008, 6, 24)
>>> time_to_birthday = abs(my_birthday - today)
>>> time_to_birthday.days
202 #明年生日距离今天的天数
>>> from datetime import date
>>> # 输出特定格式的日期字符串，注意这里用到的缩写格式字符
>>>print('The {1} is {0:%d}, the {2} is {0:%B}.'.format(d.today(), "day", "month"))
输出：The day is 15, the month is April.
六、time对象：代表某日的（本地）时间，它独立于任何特定日期，并可通过 tzinfo 对象来调整。（tzinfo 对象涉及到时区和夏令时等概念，本文不做讨论）
1、函数介绍：
- 构造方法datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)：这个对象只有时分秒和微秒，没有年月日，tzinfo代表时区调整对象，fold代表夏时令。
- 类方法time.fromisoformat(time_string)：返回对应于 time.isoformat() 所提供的某种 time_string 格式的 time，比如：
>>> from datetime import time
>>> time.fromisoformat('04:23:01')
返回：datetime.time(4, 23, 1)
>>> time.fromisoformat('04:23:01.000384')
返回：datetime.time(4, 23, 1, 384)
>>> time.fromisoformat('04:23:01 04:00')
返回：datetime.time(4, 23, 1, tzinfo=datetime.timezone(datetime.timedelta(seconds=14400)))
- 对象方法time.replace(hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, tzinfo=self.tzinfo, * fold=0) ：修改参数将返回一个代表新值的time对象。
- 对象方法time.isoformat(timespec='auto')：返回时间的字符串，可以通过timespec选择相应的部分返回，比如：timespec='hours': 以两个数码的 HH 格式。
- 对象方法time.strftime(format)：指定格式并且返回时间字符串，格式化字符参考<图3>。
2、time对象计算：time 对象支持 time 与 time 的比较，当 a 时间在 b 之前时，则认为 a 小于 b
>>>from datetime import time
>>>t1 = time(1,2,4,333)
>>>t2 = time(1,2,4,333)
>>>if t1 == t2:
>>> print("t1==t2")
>>>elif t1 > t2:
>>> print("t1>t2")
>>>else:
>>> print("t1<t2")
结果是：t1==t2
七、datetime对象：对象是包含来自 date 对象和 time 对象的所有信息的单一对象。意味这我们只需要用这个对象即可。
1、函数介绍：
- 构造器datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)：year, month, day是必须的参数。tzinfo代表时区，fold代表夏令时，这两者可以忽略，返回一个datetime对象 。比如：print(datetime(2001,1,1))
- 类方法datetime.today()：返回当地时间的datetime对象，等价于datetime.fromtimestamp(time.time()) 和 now()方法，但此方法不涉及时区，而now()可以设置时区。
- 类方法datetime.now(tz=None)：返回当地时间的datetime对象，tz为时区未指定跟today()一样，此方法比time.time()返回更高精度的时间(微妙级别100万精度)，此函数可以替代today()和utcnow()。比如：datetime.now()
- 类方法datetime.utcnow()：返回表示当前UTC时间的datetime对象，UTC时间和当地时间的区别在于时区，可以参考前文背景分析。
- 类方法datetime.fromtimestamp(timestamp, tz=None)：通过时间戳返回datetime对象。
- 类方法datetime.utcfromtimestamp(timestamp)：通过时间戳返回UTC时间的datetime对象。
- 类方法datetime.fromordinal(ordinal)：返回对应于预期格列高利历序号的datetime对象，ordinal代表从公元1年1月1日开始的int型天数，但时分秒都为0。比如：print(datetime.fromordinal(2))，返回：0001-01-02 00:00:00
- 类方法datetime.combine(date, time, tzinfo=self.tzinfo)：返回date对象和time对象的datetime对象，比如：
>>>d1 = datetime.today()
>>>print(d1.date()) 2020-04-15
>>>print(d1.time()) 14:08:41.000856
>>>d2 = datetime.today()
>>>print(d2.date()) 2020-04-15
>>>print(d2.time()) 14:08:41.000856
>>>if d2 == datetime.combine(d1.date(), d1.time(), d1.tzinfo):
>>> print("这两个datetime对象相等")
结果：这两个datetime对象相等
- 类方法datetime.fromisoformat(date_string)：从字符串转成datetime对象，字符串参数可以由date.isoformat() 和 datetime.isoformat() 来提供，比如：
>>> from datetime import datetime
>>> datetime.fromisoformat('2011-11-04')
datetime.datetime(2011, 11, 4, 0, 0)
>>>datetime.fromisoformat('2011-11-04T00:05:23')
datetime.datetime(2011, 11, 4, 0, 5, 23)
>>> datetime.fromisoformat('2011-11-04 00:05:23.283')
datetime.datetime(2011, 11, 4, 0, 5, 23, 283000)
>>> datetime.fromisoformat('2011-11-04 00:05:23.283 00:00')
datetime.datetime(2011, 11, 4, 0, 5, 23, 283000, tzinfo=datetime.timezone.utc)
>>> datetime.fromisoformat('2011-11-04T00:05:23 04:00')
datetime.datetime(2011, 11, 4, 0, 5, 23, tzinfo=datetime.timezone(datetime.timedelta(seconds=14400)))
- 类方法datetime.fromisocalendar(year, week, day)：提供年、该年第几个星期、该星期几日，返回一个datetime对象，这是函数 datetime.isocalendar() 的逆操作，比如：datetime.fromisocalendar(2000, 1, 1)，返回：2000-01-03 00:00:00
- 类方法datetime.strptime(date_string, format)：字符串转datetime对象。比如：
>>>datetime.strptime("2001-01-01", "%Y-%m-%d")
2001-01-01 00:00:00
>>># 等价于下面的写法，这里将time和datetime对象串联起来了
>>>print(datetime(*(time.strptime("2001-01-01", "%Y-%m-%d")[0:6])))
2001-01-01 00:00:00
- 对象方法datetime.date()：返回具有同样 year, month 和 day 值的 date 对象。比如：print(datetime.now().date())，返回：2020-04-15
- 对象方法datetime.time()：返回具有同样 hour, minute, second, microsecond 和 fold 值的 time 对象。比如：print(datetime.now().time())，返回：15:52:16.589417
- 对象方法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类型，需要注意的是，这个函数是会识别闰年的，如下：
>>>d1 = datetime(2020,2,29) #2020年为闰年2月有29天
>>>print(d1)
>>>print(datetime.replace(d1,year=d1.year 5)) #如果加5年也就是2025年不是闰年，则2月没有29天，会报错！
结果：ValueError: day is out of range for month
- 对象方法datetime.astimezone(tz=None)：返回一个新时区的datetime类型。
- 对象方法datetime.timetuple()：返回一个time.struct_time类型。对象方法datetime.toordinal()：返回datetime从公元1年1月1日开始的天数。比如：print(datetime.now().toordinal())，返回：737530
- 对象方法datetime.timestamp()：返回datetime的时间戳
- 对象方法datetime.isoweekday()：返回星期几
- 对象方法datetime.isocalendar()：返回一个 3 元组 (ISO 年份, ISO 周序号, ISO 周日期)。 等同于 self.date().isocalendar()。
- 对象方法datetime.isoformat()：返回ISO格式的日期UTC字符串（日期和时间中间用T割开，如果不想有符号间隔可以用isoformat(" ")），d1.__str__()等价于d1.isoformat(" ")等价于str(d1)
- 对象方法datetime.ctime()：返回一个表示日期和时间的字符串，比如：print(d1.ctime())，返回：Sat Feb 29 10:02:02 2020
- 对象方法datetime.strftime(format)：返回格式字符串所指明的代表日期和时间的字符串，格式字符串如上图<图3>
2、datetime对象的计算
八、calendar对象：这个模块让你可以输出日历，它还提供了其它与日历相关的实用函数。
1、函数介绍：
- 构造函数calendar.Calendar(firstweekday=0)：创建一个 Calendar 对象。 firstweekday 是一个整数，用于指定一周的第一天。 0 是星期一（默认值），6 是星期天。
- 对象方法c1.iterweekdays()：返回一个迭代器，迭代器的内容为一星期的数字。迭代器的第一个值与 firstweekday 属性的值一至。
- 对象方法c1.itermonthdates(year, month)：返回一个迭代器，迭代器的内容为 year 年 month 月(1-12)的日期。这个迭代器返回当月的所有日期 ( datetime.date 对象)，日期包含了本月头尾用于组成完整一周的日期，其实就是纸质日历完整一页的内容
- 对象方法c1.itermonthdays(year, month)：返回一个迭代器，返回的日期为当月每一天的日期对应的天数序号。不在当月的日期，天数序号显示为 0。备注：完整一页纸质日历头尾都有一些天数不属于这个月，可能是上个月，也可能是下个月，这些不属于本月的就显示0，属于本月的按本月第几天排序。
- 对象方法c1.itermonthdays2(year, month)：返回一个迭代器，由输出天数序号和星期几组成的元组，格式为：(不在本月为0,星期几),(天数序号,星期几),(天数序号,星期几)，不在当月的日期，天数序号显示为0。
- 对象方法c1.itermonthdays3(year, month)：返回一个迭代器，由年，月，日组成的元组。格式为：(年,月,日),(年,月,日),(年,月,日)对象方法c1.itermonthdays4(year, month)：返回一个迭代器，由年，月，日，星期几组成的元组。格式为：(年,月,日,星期几),(年,月,日,星期几),(年,月,日,星期几)
- 对象方法c1.monthdatescalendar(year, month)：返回一个表示指定年月的周列表。周列表由七个 datetime.date
- 对象组成。格式为：[datetime.date(2020, 3, 30), datetime.date(2020, 3, 31), datetime.date(2020, 4, 1)...]
- 对象方法c1.monthdays2calendar(year, month)：返回一个表示指定年月的周列表。周列表由七个代表日期的数字和代表周几的数字组成的二元元组。格式如下：
import calendar
cal = calendar.Calendar(firstweekday=0)
for i in cal.monthdays2calendar(year=2020,month=4):
print(i)
输出如下：打印了一个日历格式，X轴代表星期几
[(0, 0), (0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]
[(6, 0), (7, 1), (8, 2), (9, 3), (10, 4), (11, 5), (12, 6)]
[(13, 0), (14, 1), (15, 2), (16, 3), (17, 4), (18, 5), (19, 6)]
[(20, 0), (21, 1), (22, 2), (23, 3), (24, 4), (25, 5), (26, 6)]
[(27, 0), (28, 1), (29, 2), (30, 3), (0, 4), (0, 5), (0, 6)]
- 对象方法c1.monthdayscalendar(year, month)：返回一个表示指定年月的周列表。周列表由七个代表日期的数字组成。格式如下：
import calendar
cal = calendar.Calendar(firstweekday=0)
for i in cal.monthdayscalendar(year=2020,month=4):
print(i)
输出如下：
[0, 0, 1, 2, 3, 4, 5]
[6, 7, 8, 9, 10, 11, 12]
[13, 14, 15, 16, 17, 18, 19]
[20, 21, 22, 23, 24, 25, 26]
[27, 28, 29, 30, 0, 0, 0]
- 对象方法c1.yeardatescalendar(year, width=3)：返回一个年列表，里面最小的元素是date类型代表天，由天组成星期列表->由星期列表组成月列表->由月列表组成年列表->最后返回。width=3代表月份列表有几个月组成，默认3个月组成一个月份列表
- 对象方法c1.yeardays2calendar(year, width=3)：返回一个年列表，里面最小的元素是天序号和星期几组成的元组，由元组组成星期列表->由星期列表组成月列表->由月列表组成年列表->最后返回。width=3的含义同上。
- 对象方法c1.yeardayscalendar(year, width=3)：返回一个列表，里面最小的元素是天数序号(非本月日期标识为0)，由天序号组成星期列表->由星期列表组成月列表->由月列表组成年列表->最后返回。width=3的含义同上。
- 类方法calendar.TextCalendar(firstweekday=0)：返回一个TextCalendar对象，可以使用这个
- 类方法calendar.HTMLCalendar(firstweekday=0)：返回一个HTMLCalendar对象，可以使用这个
- 类方法calendar.isleap(year)：返回一个bool值，可用来判断是否是闰年。
- 类方法calendar.leapdays(y1, y2)：返回y1,y2之间的闰年的年数。
- 类方法calendar.weekday(year, month, day)：返回某年某月某日是星期几，结果要加1用来表示中文星期几。
- 类方法calendar.weekheader(n)：返回一个包含星期几的缩写名的头。 n 指定星期几缩写的字符宽度
- 类方法calendar.c(year, month)：返回第一天是星期几和这个月的天数的元组。
- 类方法calendar.monthcalendar(year, month)：返回表示一个月的日历的矩阵。每一行代表一周；此月份外的日子由零表示。
- 类方法calendar.prmonth(theyear, themonth, w=0, l=0)：打印由 month() 返回的一个月的日历。
- 类方法calendar.month(theyear, themonth, w=0, l=0)：返回月份日历。使用 TextCalendar
- 类的 formatmonth() 以多行字符串形式。
- 类方法calendar.prcal(year, w=0, l=0, c=6, m=3)：返回整年日历。
- 类方法calendar.timegm(tuple)：返回时间戳，参数是struct_time类型，他是 time.gmtime() 的逆函数。
- 类属性calendar.day_name：返回数组，在当前语言环境下表示星期几的数组。
- 类属性calendar.day_abbr：返回数组，在当前语言环境下表示星期几缩写的数组。
- 类属性calendar.month_name：返回数组，在当前语言环境下表示一年中月份的数组。
- 类属性calendar.month_abbr：返回数组，在当前语言环境下表示一年中月份缩写的数组
文章到此结束了，希望对大家有帮助，喜欢的记得关注一下小编，点赞收藏奥。
下方了解更多是用Python实现人机对战
,
