100天精通Python（基础篇）——第31天：时间模块time、datetime、calendar基础大总结+代码实战

一、time模块介绍

time库就像是Python中的时间大管家，负责处理各种时间数据的事务。它是Python处理时间的标准库，就像是你的私人时间管家，帮你处理各种时间问题。

想象一下，你是一位忙碌的大亨，每天都有无数的时间安排需要处理。你需要知道当前的时间，你需要计算时间的差距，你需要将时间转换成不同的格式。这些琐碎的时间事务，如果没有时间库的帮助，你将会陷入时间的迷宫中。

但是，有了time库，一切都变得简单了。它提供了各种函数和方法，让你可以轻松地处理时间数据。你可以获取当前的时间，你可以计算时间的差距，你可以格式化时间的显示。time库就像是你的时间大管家，帮你解决各种时间问题。

所以，不要再为时间的琐事烦恼了，让time库成为你的得力助手吧！它会让你的时间管理变得轻松愉快。

import time

time模块中三种时间表示方式：

时间戳（数字类型）
结构化时间对象
格式化时间字符串

1、时间戳

你想要获取当前时间戳？那就像是在抓住时间的尾巴一样！Python中有一个简单的方法来做到这一点。使用time.time()函数，它会返回一个浮点数，表示从1970年1月1日午夜开始到现在的秒数。

>>> import time
>>> time.time()
1647853836.377331

这样，你就能得到一个内部时间值，就像是在数数一样，只不过是用浮点数来表示的。现在你可以用这个时间戳来进行各种计算了！

2、结构化时间对象

索引	属性
0	tm_year（年）
1	tm_mon（月）
2	tm_mday（日）
3	tm_hour（时）
4	tm_min（分）
5	tm_sec（秒）
6	tm_wday（周）
7	tm_yday（一年内第几天）
8	tm_isdst（夏时令）

time.gmtime()

time.gmtime()函数就像是一位时间旅行者，它可以将以秒表示的时间转换为一个特殊的时间结构体，这个结构体标志始终为零的UTC时区。就像是一个时间机器，它可以带你回到自纪元以来的时光，让你感受到那个时代的氛围。

如果你没有提供具体的秒数或者将参数设置为None，那么time.gmtime()函数就会默认使用当前的时间作为输入。这就好像是你没有告诉时间旅行者你要去哪个时代，它就会带你去当前的时代一样。

使用time.gmtime()函数就像是在使用一台时间机器，你可以随时随地穿越时空，感受不同的时代。它是Python中的一个重要工具，让你能够更好地处理时间相关的任务。所以，快来和时间旅行者一起探索未知的时空吧！

>>> import time
>>> type(time.gmtime())
<class 'time.struct_time'>
>>> time.gmtime()
time.struct_time(tm_year=2022, tm_mon=3, tm_mday=21, tm_hour=9, tm_min=16, tm_sec=36, tm_wday=0, tm_yday=80, tm_isdst=0)

函数返回的值还可使用索引或者变量继续获取内部的变量

嘿，小伙伴们！想要获取当前时间的年份吗？那就来试试这个酷炫的代码吧：time.gmtime().tm_year！就像是你在时间的大海中捕捉到了一只年份的鱼儿一样，轻松获取到了当前的年份！当然，如果你想获取其他时间信息，也可以类似地操作哦。就像是你在时间的世界中探险，发现了一个又一个宝藏一样，每一个代码都是一个新的冒险！快来一起探索吧！

>>> import time
>>> time.gmtime()[0]
2022
>>> time.gmtime().tm_year
2022
>>> time.gmtime()[1]
3
>>> time.gmtime().tm_mon
3
>>> time.gmtime()[2]
21
>>> time.gmtime().tm_mday
21
>>> print("今天是 {}-{}-{}".format(time.gmtime()[0], time.gmtime()[1], time.gmtime()[2]))
今天是 2024-5-20
>>> print("今天是 星期{}".format(time.gmtime().tm_wday + 1))
今天是 星期1

time.localtime()

time()函数是一个非常有用的函数，它可以帮助我们获取当前的当地时间。它就像是一个时光机，可以将我们带回到我们所在的时区，让我们感受到当地的时间流动。

这个函数非常灵活，它可以接受一个参数 secs，表示从1970年1月1日以来的秒数。如果你不提供这个参数，它会默认使用当前的时间。就像是一个自动调时的闹钟，总是能准确地告诉你现在的时间。

另外，如果你将 secs 设置为 None，那么 time() 函数会自动使用当前的时间。这就像是一个智能的时钟，能够自动调整到正确的时间。

总之，time() 函数就像是一个当地时间的导航仪，帮助我们准确地获取当前的时间。无论你是在哪个时区，它都能带你回到当地的时间。让我们感受时间的流动，享受生活的美好！

>>> import time
>>> type(time.localtime())
<class 'time.struct_time'>
>>> time.localtime()
time.struct_time(tm_year=2022, tm_mon=3, tm_mday=26, tm_hour=10, tm_min=44, tm_sec=53, tm_wday=5, tm_yday=85, tm_isdst=0)
>>> print("今天是 {}-{}-{}".format(time.localtime()[0], time.gmtime()[1], time.gmtime()[2]))
今天是 2024-5-20

3、格式化时间的字符串

time.ctime()

获取当前时间并以易读方式表示，返回字符串

>>> import time
>>> time.ctime()
'Mon May 20 17:14:36 2024'

time.asctime([t])

接受时间元组、通过函数 gmtime() 或 localtime()返回的时间值，返回一个可读的形式的字符串。如果未提供t，则使用返回的当前时间。

注意：asctime()不添加尾随换行符

>>> import time
>>> time.asctime(time.localtime())
'Sat Mar 26 10:28:02 2022'

time.strftime(）

要格式化日期，就像给一只猫穿上一件漂亮的衣服一样，我们需要将一个struct_time类型的时间转换成一个可读的字符串，就像给猫咪一个可爱的名字一样。

首先，我们需要使用strftime()函数来完成这个任务。这个函数就像是一位时尚设计师，可以根据我们的要求来设计出不同风格的衣服。我们只需要告诉它我们想要的格式，它就会为我们量身定制一件完美的衣服。

例如，如果我们想要将时间格式化成"年-月-日时:分:秒"的形式，我们可以使用"%Y-%m-%d %H:%M:%S"作为参数传递给strftime()函数。这就像是告诉设计师我们想要一件时尚又经典的衣服，它会为我们设计出一套完美的装扮。

接下来，我们只需要将这个格式化后的字符串返回给调用者，就像将一只穿着漂亮衣服的猫咪展示给大家一样。大家可以欣赏到这只猫咪的美丽，也可以轻松地读取到这个可读的时间字符串。

所以，记住，要格式化日期，就像给猫咪穿上漂亮的衣服一样，使用strftime()函数来设计出一个完美的时间字符串，让大家都能欣赏到这个可爱的时刻！

格式化字符串	日期/时间说明	值范围和实例
%Y	年份	0000~9999，例如：2022
%m	月份	01~12，例如：3
%B	月份名称	January~December，例如：April
%b	月份名称缩写	Jan~Dec，例如：Apr
%d	日期	01~31，例如：20
%A	星期	Monday~Sunday，例如：Wednesday
%a	星期缩写	Mon~Sun，例如：Wed
%H	小时（24h制）	00~23，例如：12
%I	小时（12h制）	01~12，例如：7
%p	上\下午	AM\PM，例如：PM
%M	分钟	00~59，例如：10
%S	秒	00~59，例如：20
%w	星期几（具体）	1~7，例如：7
%W	整年的第几周	1-52，例如：2

>>> import time
>>> time.strftime('%Y-%m-%d %H:%M:%S')
'2022-03-24 20:11:08'
>>> time.strftime('%Y年%m月%d日 %H时:%M分:%S秒')
'2022年03月24日 20时:12分:08秒'
>>> time.strftime('%Y年%m月%d日 星期%w %H时:%M分:%S秒')
'2022年03月24日 星期4 20时:18分:33秒'

4、三种格式之间的转换

图解：

时间戳 -> 结构化对象

使用time.gmtime(时间戳)或者time.localtime(时间戳)

import time

# 方法1 UTC时间
print(time.gmtime())
print(time.gmtime(time.time() - 3600))
print("-" * 20)
# 方法2（常用）
print(time.localtime())
print(time.localtime(time.time() - 3600))

输出结果：

结构化对象 -> 时间戳

使用time.mktime(结构化对象)

import time

print(time.time())
print(time.mktime(time.localtime())) # 精度到秒

输出结果：

1648125741.9042373
1648125741.0

结构化对象 -> 格式化时间字符串

使用time.strftime(格式化形式, time.localtime())或者time.strftime(格式化形式, time.gmtime())

import time

print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()))
print(time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime()))

输出结果：

2022-03-24 20:46:02
2022-03-24 12:46:02

格式化时间字符串 -> 结构化对象

使用strptime(str, format) 指定时间字符串

import time

time_str = '2020-07-25 13:23:58'
print(time.strptime(time_str, '%Y-%m-%d %H:%M:%S'))

输出结果：

time.struct_time(tm_year=2020, tm_mon=7, tm_mday=25, tm_hour=13, tm_min=23, tm_sec=58, tm_wday=5, tm_yday=207, tm_isdst=-1)

5、计数函数

time.sleep(num)

使用sleep(s) 函数可以让该线程睡眠s秒，s秒之后自动唤醒。s是拟休眠的时间，单位是秒，可以是浮点数。

案例1：

import time

t1 = time.time()
time.sleep(2)  # 让程序岁两秒
t2 = time.time()
print("执行了 {:.3f} 秒".format(t2 - t1))

输出结果：

执行了 2.004 秒

案例2：爬虫小技巧与random搭配使用模拟人工点击

import time
import random

sleep_time = random.uniform(1, 5)
time.sleep(sleep_time)

time.perf_counter()

返回性能计数器的值，就像一个超高清晰度的时钟，以小数秒为单位，专门用来测量那些短暂的时间。它不仅包括你在睡梦中度过的时间，还能计算整个系统的时间。不过要注意，这个返回值的参考点是未定义的，所以只有连续调用结果之间的差才是有效的。就像你在比赛中用秒表计时一样，只有记录下来的时间差才能真正反映出你的表现。

import time

start = time.perf_counter()
time.sleep(1)
end = time.perf_counter()
print("耗时：", end - start)

输出结果：

耗时： 1.0125934

time.process_time()

返回当前进程的系统和用户CPU时间总和的值（以小数秒为单位）。它不包括睡眠期间经过的时间。返回值的参考点未定义，因此只有连续调用结果之间的差异才有效。

import time

start = time.process_time()
time.sleep(1)
end = time.process_time()
print("耗时：", end - start)

输出结果：

耗时： 0.0

二、datetime模块介绍

让我们来谈谈datetime模块吧。它就像是一个重新装饰过的time模块，提供了更多的接口，让时间处理变得更加直观和易于调用，就像是给时间穿上了一套时尚的新衣服。

首先，让我们来看看如何更有效地解析datetime对象的属性，以便进行格式化输出和数据操作。你可以像解开一个礼物盒子一样，轻松地获取年、月、日、小时、分钟和秒等属性。这就像是把时间拆成了小块，让你可以随心所欲地操作它们，就像是在拼装一张时间拼图。

当然，datetime模块还提供了一些强大的功能，比如计算时间差、比较时间大小等。你可以像数学家一样，轻松地进行时间的加减运算，就像是在玩时间的游戏。你可以计算两个时间之间的差距，比如相差多少天、多少小时、多少分钟，甚至可以计算出相差的秒数。这就像是在用时间的尺子来测量时间的长度，让你更好地理解时间的概念。

总之，datetime模块就像是给时间增添了一些魔法和魅力。它让时间处理变得更加直观和易于调用，就像是给时间穿上了一套时尚的新衣服。无论是解析属性、格式化输出还是进行数据操作，datetime模块都能满足你的需求，让你在时间的世界里游刃有余。所以，快来探索datetime模块的奇妙之处吧！

主要介绍四个标准类：

datetime.date
datetime.time
datetime.datetime
datetime.timedelta

1、datetime.date类

date 类表示一个由年、月、日组成的日期，格式为：datetime.date(year, month, day)

类方法（属性）说明：

方法（属性）	说明
today()	返回当地的当前日期
fromtimestamp(timestamp)	根据给定的时间戮，返回本地日期
min	date 所能表示的最小日期
max	date 所能表示的最大日期
resolution	时间间隔

案例如下：

>>> import time
>>> import datetime

# 查看类型
>>> type(datetime.date.today())
<class 'datetime.date'>

# today()生成
>>> print(datetime.date.today())
2022-03-26

# 指定日期
>>> print(datetime.date(2022, 5, 20))
2022-05-20

# 根据给定的时间戮，返回本地日期
>>> print(datetime.date.fromtimestamp(time.time()))
2022-03-26

# 类属性
>>> print(datetime.date.min)
0001-01-01
>>> print(datetime.date.max)
9999-12-31
>>> print(datetime.date.resolution)
1 day, 0:00:00

实例方法（属性）说明：

方法（属性）	说明
year	年
month	月
day	日
timetuple()	返回结构化时间对象 struct_time
replace()	替换（可以替换年、月、日）
weekday()	返回一个整数代表星期几（ 0：星期一， 6：星期天）
isoweekday()	返回一个整数代表星期几（ 1：星期一， 7：星期天）
isocalendar()	返回格式为 (year，month，day) 的元组
isoformat()	返回格式如 YYYY-MM-DD 格式化的时间字符串
strftime(format)	返回自定义格式的字符串

案例如下：

>>> import datetime
# 实例属性
>>> datetime.date.today().year
2022
>>> datetime.date.today().month
3
>>> datetime.date.today().day
26
>>> datetime.date.today().weekday()
5
>>> datetime.date.today().isoweekday()
6
>>> datetime.date.today().isocalendar()
(2022, 12, 6)
>>> datetime.date.today().isoformat()
'2022-03-26'
>>> datetime.date.today().strftime('%Y年%m月%d日 %H时:%M分:%S秒')
'2022年03月26日 00时:00分:00秒'

# 实例方法
>>> datetime.date.today().timetuple()
time.struct_time(tm_year=2022, tm_mon=3, tm_mday=26, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=5, tm_yday=85, tm_isdst=-1)

# 替换日期
>>> print(datetime.date.today().replace(2222))
2222-03-26
>>> print(datetime.date.today().replace(2022,1,30))
2022-01-30
>>> print(datetime.date.today().replace(day=29))
2022-03-29

2、datetime.time类

time 类表示由时、分、秒、微秒组成的时间，格式为：time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)。

类方法和实例属性如下：

方法（属性）	说明
min	time 所能表示的最小日期
max	time 所能表示的最大日期
resolution	时间相加的最小单位
hour	时
minute	分
second	秒
microsecond	微秒
isoformat()	返回格式如 YYYY-MM-DD 格式化的时间字符串
strftime(format)	返回自定义格式的字符串
replace()	创建一个新的时间对象，用参数指定的时、分、秒、微秒代替原有对象中的属性

案例如下：

>>> import datetime
>>> t = datetime.time(15, 10, 45, 888888)

# 类方法
>>> print(t.min)
00:00:00
>>> print(t.max)
23:59:59.999999
>>> print(t.resolution)
0:00:00.000001

# 实例属性
>>> t.hour
15
>>> t.minute
10
>>> t.second
45
>>> t.microsecond
888888

# 其他方法
>>> print(t.isoformat())
15:10:45.888888
>>> print(t.strftime('%Y年%m月%d日 %H时:%M分:%S秒'))
1900年01月01日 15时:10分:45秒
>>> print(t.replace(hour=8, minute=8))
08:08:45.888888

3、datetime.datetime类（最常用）

哎呀呀，datetime这个包可是个全能型选手哦！它包含了date和time的所有信息，就像是一个装满了各种数据的大礼包。格式嘛，就是这样的：datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)。你可以把这些参数想象成是给这个大礼包装饰的各种装饰品，让它更加炫酷。

当然，这些参数的取值范围是有限的，就像是你在选购装饰品时，也不能买到天上的星星或者大海的珍珠一样。具体的取值范围，你可以参考一下date类和time类的规定，它们可是datetime包的好朋友哦。

总之，datetime包就像是一个超级英雄，拥有date和time的全部能力，让你可以轻松处理时间和日期的各种操作。快来使用它，让你的代码时间飞行吧！

类方法和属性如下所示：

方法（属性）	说明
today()	返回当地的当前时间
now(tz=None)	类似于 today()，可选参数 tz 可指定时区
utcnow()	类似于 now()，返回当前 UTC 时间
fromtimestamp(时间戳)	根据时间戳返回对应时间
utcfromtimestamp(时间戳)	根据时间戳返回对应 UTC 时间
strptime(字符串,format)	跟着字符串（对应的格式）返回时间
combine(date, time)	根据 date 和 time 返回对应时间

案例如下：

>>> import datetime
>>> print(datetime.datetime.today())
2022-03-26 14:50:56.924335
>>> print(datetime.datetime.now(tz=None))
2022-03-26 14:51:22.981125
>>> print(datetime.datetime.utcnow())
2022-03-26 06:51:56.038939
# 时间戳 -> dt
>>> print(datetime.datetime.fromtimestamp(time.time()))
2022-03-26 14:55:50.609014
>>> print(datetime.datetime.utcfromtimestamp(time.time()))
2022-03-26 06:57:36.143067
# 字符串 -> dt
>>> print(datetime.datetime.strptime('2022年03月26日 00时:00分:00秒', '%Y年%m月%d日 %H时:%M分:%S 秒'))
2022-03-26 00:00:00
# date+time -> datetime
>>> print(datetime.datetime.combine(datetime.date(2222, 2, 2), datetime.time(2, 2, 2)))
2222-02-02 02:02:02

实例方法说明：

方法（属性）	说明
year	年
month	月
day	日
hour	时
minute	分
second	秒
microsecond	微秒
replace()	生成一个新的日期对象，用参数指定的年，月，日，时，分，秒…代替原有对象中的属性
timestamp()	datetime -> 时间戳
strftime(format)	返回自定义格式的字符串

案例如下：

>>> import datetime
>>> dt = datetime.datetime(2022, 8, 20, 13, 22, 34, 88888)
>>> print(dt, type(dt))
2022-08-20 13:22:34.088888 <class 'datetime.datetime'>
# 属性
>>> dt.year
2022
>>> dt.month
8
>>> dt.day
20
>>> dt.hour
13
>>> dt.minute
22
>>> dt.second
34
>>> dt.microsecond
88888
>>> print(dt.replace(second=57, day=20))
2022-08-20 13:22:57.088888
# datetime -> 时间戳
>>> print(dt.timestamp())
1660972954.088888
# datetime -> 格式化字符串
>>> print(dt.strftime('%Y年%m月%d日 %H时:%M分:%S 秒'))
2022年08月20日 13时:22分:34 秒

图解：datetime.datetime类对时间戳与时间字符串进行转换

4、datetime.timedalta类

计算时间差的类，格式：class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, hours=0, weeks=0)

案例如下：

>>> import time
>>> import datetime
# 生成时间差
>>> td = datetime.timedelta(days=10)
>>> print(td, type(td))
10 days, 0:00:00 <class 'datetime.timedelta'>
>>> td = datetime.timedelta(days=10,hours=5)
>>> print(td)
10 days, 5:00:00
>>> td = datetime.timedelta(days=10,hours=-5)
>>> print(td)
9 days, 19:00:00

# 计算目标日期
>>> dt = datetime.datetime.today()
>>> print("现在是 {}".format(dt.strftime('%Y年%m月%d日 %H时:%M分:%S秒')))
现在是 2022年03月26日 15时:47分:13秒
>>> delta = datetime.timedelta(days=10)
>>> target = dt + delta
>>> print("十天后是 {}".format(target.strftime('%Y年%m月%d日 %H时:%M分:%S秒')))
十天后是 2022年04月05日 15时:47分:13秒

>>> dt = datetime.datetime.today()
>>> print("现在是 {}".format(dt.strftime('%Y年%m月%d日 %H时:%M分:%S秒')))
现在是 2022年03月26日 15时:47分:13秒
>>> delta = datetime.timedelta(hours=-5)
>>> target = dt + delta
>>> print("五小时之前是 {}".format(target.strftime('%Y年%m月%d日 %H时:%M分:%S秒')))
五小时之前是 2022年03月26日 10时:47分:13秒

# 计算时间差

>>> dt1 = datetime.datetime.today()
>>> dt2 = datetime.datetime.utcnow()
>>> td = dt1 - dt2
>>> print("我们与UTC时间差是：{}小时".format(td.seconds/3600))
我们与UTC时间差是：7.994166666666667小时
>>> print("我们与UTC时间差是：{:.0f}小时".format(td.seconds/3600))
我们与UTC时间差是：8小时

三、calendar模块介绍

嘿，我是calendar模块，我可以帮你输出像Unix cal程序一样的日历，还能提供其他与日历相关的有用功能。听起来很酷吧！

默认情况下，我把星期一当作一周的第一天，把星期日当作一周的最后一天，就像欧洲人的习惯一样。这样一来，你就可以轻松地安排你的日程了。

除了输出日历，我还能帮你做其他事情。比如，我可以告诉你某一年是否是闰年，还可以计算两个日期之间的天数差距。简直就像是一个万能的日历小助手！

所以，如果你需要处理日期和日历相关的任务，不妨试试我，我会给你带来惊喜的！

1、常用方法

month(year, month, w=0, l=0)：返回一个月的日历的多行文本字符串。year指定年份，month指定月份，w每个单元格宽度，l每列换l行

import calendar

print(calendar.month(2022, 3))

输出结果：
     March 2022
Mo Tu We Th Fr Sa Su
    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 31

prcal(year, w=0, l=0, c=6, m=3)：打印一年的日历，w每个单元格宽度，默认0，内部已做处理，最小宽度为2，l每列换l行，默认为0，内部已做处理，至少换行1行，c表示月与月之间的间隔宽度，默认为6，内部已做处理，最小宽度为2，m表示将12个月分为m列

import calendar

calendar.prcal(2022)

输出结果：
                                  2022

      January                   February                   March
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
                1  2          1  2  3  4  5  6          1  2  3  4  5  6
 3  4  5  6  7  8  9       7  8  9 10 11 12 13       7  8  9 10 11 12 13
10 11 12 13 14 15 16      14 15 16 17 18 19 20      14 15 16 17 18 19 20
17 18 19 20 21 22 23      21 22 23 24 25 26 27      21 22 23 24 25 26 27
24 25 26 27 28 29 30      28                        28 29 30 31
31

       April                      May                       June
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
             1  2  3                         1             1  2  3  4  5
 4  5  6  7  8  9 10       2  3  4  5  6  7  8       6  7  8  9 10 11 12
11 12 13 14 15 16 17       9 10 11 12 13 14 15      13 14 15 16 17 18 19
18 19 20 21 22 23 24      16 17 18 19 20 21 22      20 21 22 23 24 25 26
25 26 27 28 29 30         23 24 25 26 27 28 29      27 28 29 30
                          30 31

        July                     August                  September
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
             1  2  3       1  2  3  4  5  6  7                1  2  3  4
 4  5  6  7  8  9 10       8  9 10 11 12 13 14       5  6  7  8  9 10 11
11 12 13 14 15 16 17      15 16 17 18 19 20 21      12 13 14 15 16 17 18
18 19 20 21 22 23 24      22 23 24 25 26 27 28      19 20 21 22 23 24 25
25 26 27 28 29 30 31      29 30 31                  26 27 28 29 30

      October                   November                  December
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
                1  2          1  2  3  4  5  6                1  2  3  4
 3  4  5  6  7  8  9       7  8  9 10 11 12 13       5  6  7  8  9 10 11
10 11 12 13 14 15 16      14 15 16 17 18 19 20      12 13 14 15 16 17 18
17 18 19 20 21 22 23      21 22 23 24 25 26 27      19 20 21 22 23 24 25
24 25 26 27 28 29 30      28 29 30                  26 27 28 29 30 31
31

calendar(year, w=2, l=1, c=6, m=3)：以多行字符串形式返回一年的日历。w每个单元格宽度，l每列换l行，c表示月与月之间的间隔宽度，m表示将12个月分为m列

import calendar

print(calendar.calendar(2022))

输出结果：
                                  2022

      January                   February                   March
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
                1  2          1  2  3  4  5  6          1  2  3  4  5  6
 3  4  5  6  7  8  9       7  8  9 10 11 12 13       7  8  9 10 11 12 13
10 11 12 13 14 15 16      14 15 16 17 18 19 20      14 15 16 17 18 19 20
17 18 19 20 21 22 23      21 22 23 24 25 26 27      21 22 23 24 25 26 27
24 25 26 27 28 29 30      28                        28 29 30 31
31

       April                      May                       June
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
             1  2  3                         1             1  2  3  4  5
 4  5  6  7  8  9 10       2  3  4  5  6  7  8       6  7  8  9 10 11 12
11 12 13 14 15 16 17       9 10 11 12 13 14 15      13 14 15 16 17 18 19
18 19 20 21 22 23 24      16 17 18 19 20 21 22      20 21 22 23 24 25 26
25 26 27 28 29 30         23 24 25 26 27 28 29      27 28 29 30
                          30 31

        July                     August                  September
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
             1  2  3       1  2  3  4  5  6  7                1  2  3  4
 4  5  6  7  8  9 10       8  9 10 11 12 13 14       5  6  7  8  9 10 11
11 12 13 14 15 16 17      15 16 17 18 19 20 21      12 13 14 15 16 17 18
18 19 20 21 22 23 24      22 23 24 25 26 27 28      19 20 21 22 23 24 25
25 26 27 28 29 30 31      29 30 31                  26 27 28 29 30

      October                   November                  December
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
                1  2          1  2  3  4  5  6                1  2  3  4
 3  4  5  6  7  8  9       7  8  9 10 11 12 13       5  6  7  8  9 10 11
10 11 12 13 14 15 16      14 15 16 17 18 19 20      12 13 14 15 16 17 18
17 18 19 20 21 22 23      21 22 23 24 25 26 27      19 20 21 22 23 24 25
24 25 26 27 28 29 30      28 29 30                  26 27 28 29 30 31
31

setfirstweekday(weekday)：设置每一周的开始(0 表示星期一，6 表示星期天)

import calendar

# 设置星期2为每周第一天
calendar.setfirstweekday(firstweekday=1)

firstweekday()：返回当前设置的每星期的第一天的数值

import calendar

# 设置星期2为每周第一天
calendar.setfirstweekday(firstweekday=1)
print(calendar.firstweekday()) 

输出结果：
1

isleap(year)：判断指定是否是闰年，闰年为True，平年为False

import calendar

print(calendar.isleap(2020))
print(calendar.isleap(2021))

输出结果：
True
False

leapdays(y1, y2)：返回y1与y2年份之间的闰年数量，y1与y2皆为年份。包括起始年，不包括结束年

import calendar

print(calendar.leapdays(2000, 2022))
# 闰年有2000、2004、2008、2012、2016、2020

输出结果：
6

weekday(year, month, day)：获取指定日期为星期几

import calendar

print(calendar.weekday(2022, 3, 26))

输出结果：
5 # 代表星期六

weekheader(n)：返回包含星期的英文缩写，n表示英文缩写所占的宽度
```
import calendar

print(calendar.weekheader(2))

输出结果：
Mo Tu We Th Fr Sa Su
```
monthrange(year, month)：返回一个由一个月第一个天的星期与当前月的天数组成的元组
```
import calendar

print(calendar.monthrange(2022, 3))

输出结果：
(1, 31)
```

monthcalendar(year, month)：返回一个月中天数列表(不是当前月份的天数为0)，按周划分，为一个二维数组。包括月份开始那周的所有日期和月份结束那周的所有日期

import calendar

print(calendar.month(2022, 3))
print(calendar.monthcalendar(2022, 3))

输出结果：可以看出0与日历表每行空白处相对应

     March 2022
Mo Tu We Th Fr Sa Su
    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 31

[[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, 31, 0, 0, 0]]

2、Calendar类

Calendar 对象提供了一些日历数据格式化的方法

iterweekdays()：获取一周的数字的迭代器，迭代器的第一个值与firstweekday的值相同

from calendar import Calendar

c = Calendar()
print(list(c.iterweekdays()))  
     
c = Calendar(firstweekday=6)
print(list(c.iterweekdays()))

输出结果：
[0, 1, 2, 3, 4, 5, 6]代表星期一至星期日，0为星期一，即一周的第一天
[6, 0, 1, 2, 3, 4, 5]代表星期日至星期六，6为星期日，即一周的第一天

itermonthdates(year, month)：获取一个月日期的迭代器，此迭代器会返回指定月份的所有日期，包括月份开始那周的所有日期和月份结束那周的所有日期
```
from calendar import Calendar

c = Calendar(firstweekday=6)
for item in c.itermonthdates(2022, 3):
    print(item)

输出结果：
2022-03-28
2022-03-29
........
2022-04-30
2022-05-01
```

3、TextCalendar 类

嘿，我是你的日历助手！我是一个很酷的 Calendar 子类，可以帮你生成纯文本的日历。你可以告诉我一周的第一天是星期几，然后我就会根据这个信息来生成日历啦！

让我来介绍一下我的两个超级厉害的方法：

formatmonth(year, month, w=0, l=0)：这个方法会以多行字符串的形式返回一个月的日历。你只需要告诉我年份和月份，我就会为你生成一个漂亮的日历。如果你想调整每个单元格的宽度，可以传入参数 w，默认是0，但是我会在内部做处理，最小宽度是2哦！还有，如果你想让每列之间有一些空行，可以传入参数 l，默认是0，但是我也会在内部做处理，至少会换行1行哦！

我会尽力让你的日历看起来很美观，让你的时间管理更加轻松愉快！快来试试吧！

from calendar import TextCalendar

c = TextCalendar()
print(c.formatmonth(2022, 3))

输出结果：
     March 2022
Mo Tu We Th Fr Sa Su
    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 31

prmonth(theyear, themonth, w=0, l=0)：打印formatmonth(theyear, themonth, w=0, l=0)的结果，无返回值

from calendar import TextCalendar

c = TextCalendar(firstweekday=6)
c.prmonth(2022, 3)

输出结果：
     March 2022
Su Mo Tu We Th Fr Sa
       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 31

formatyear(theyear, w=2, l=1, c=6, m=3)：以多行字符串形式返回一年的日历，w每个单元格宽度，l每列换l行，c月与月之间的间隔宽度，m表示将12个月分为m列

from calendar import TextCalendar

c = TextCalendar()
print(c.formatyear(2022))

输出结果：
                                  2022

      January                   February                   March
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
                1  2          1  2  3  4  5  6          1  2  3  4  5  6
 3  4  5  6  7  8  9       7  8  9 10 11 12 13       7  8  9 10 11 12 13
10 11 12 13 14 15 16      14 15 16 17 18 19 20      14 15 16 17 18 19 20
17 18 19 20 21 22 23      21 22 23 24 25 26 27      21 22 23 24 25 26 27
24 25 26 27 28 29 30      28                        28 29 30 31
31

       April                      May                       June
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
             1  2  3                         1             1  2  3  4  5
 4  5  6  7  8  9 10       2  3  4  5  6  7  8       6  7  8  9 10 11 12
11 12 13 14 15 16 17       9 10 11 12 13 14 15      13 14 15 16 17 18 19
18 19 20 21 22 23 24      16 17 18 19 20 21 22      20 21 22 23 24 25 26
25 26 27 28 29 30         23 24 25 26 27 28 29      27 28 29 30
                          30 31

        July                     August                  September
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
             1  2  3       1  2  3  4  5  6  7                1  2  3  4
 4  5  6  7  8  9 10       8  9 10 11 12 13 14       5  6  7  8  9 10 11
11 12 13 14 15 16 17      15 16 17 18 19 20 21      12 13 14 15 16 17 18
18 19 20 21 22 23 24      22 23 24 25 26 27 28      19 20 21 22 23 24 25
25 26 27 28 29 30 31      29 30 31                  26 27 28 29 30

      October                   November                  December
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
                1  2          1  2  3  4  5  6                1  2  3  4
 3  4  5  6  7  8  9       7  8  9 10 11 12 13       5  6  7  8  9 10 11
10 11 12 13 14 15 16      14 15 16 17 18 19 20      12 13 14 15 16 17 18
17 18 19 20 21 22 23      21 22 23 24 25 26 27      19 20 21 22 23 24 25
24 25 26 27 28 29 30      28 29 30                  26 27 28 29 30 31
31

4、HTMLCalendar类

嘿，我是HTMLCalendar类，我是Calendar的一个酷炫子类！我可以帮你生成一个漂亮的HTML日历。你只需要告诉我年份和月份，我就能为你生成一个月的日历。

哦，对了，还有一个可选参数withyear，默认为True。如果你想在日历上显示年份，就把它设为True，不想显示就设为False。

让我来给你展示一下我的超能力吧！使用formatmonth(theyear, themonth, withyear=True)方法，我会返回一个包含整个月份日历的HTML内容。这样你就可以在网页上展示出来了！

记住，我还有一个小秘密，就是firstweekday属性。这个属性可以帮你指定一周的第一天是星期几。默认情况下，我是以星期一作为一周的第一天的。但是，如果你更喜欢星期日作为一周的开始，那就把firstweekday设为6吧！

所以，快来使用我吧！我会帮你创建出一个令人惊叹的HTML日历！

from calendar import HTMLCalendar

c = HTMLCalendar()
print(c.formatmonth(2022, 3, withyear=False))

输出结果：
<table border="0" cellpadding="0" cellspacing="0" class="month">
<tr><th colspan="7" class="month">March</th></tr>
<tr><th class="mon">Mon</th><th class="tue">Tue</th><th class="wed">Wed</th><th class="thu">Thu</th><th class="fri">Fri</th><th class="sat">Sat</th><th class="sun">Sun</th></tr>
<tr><td class="noday">&nbsp;</td><td class="tue">1</td><td class="wed">2</td><td class="thu">3</td><td class="fri">4</td><td class="sat">5</td><td class="sun">6</td></tr>
<tr><td class="mon">7</td><td class="tue">8</td><td class="wed">9</td><td class="thu">10</td><td class="fri">11</td><td class="sat">12</td><td class="sun">13</td></tr>
<tr><td class="mon">14</td><td class="tue">15</td><td class="wed">16</td><td class="thu">17</td><td class="fri">18</td><td class="sat">19</td><td class="sun">20</td></tr>
<tr><td class="mon">21</td><td class="tue">22</td><td class="wed">23</td><td class="thu">24</td><td class="fri">25</td><td class="sat">26</td><td class="sun">27</td></tr>
<tr><td class="mon">28</td><td class="tue">29</td><td class="wed">30</td><td class="thu">31</td><td class="noday">&nbsp;</td><td class="noday">&nbsp;</td><td class="noday">&nbsp;</td></tr>
</table>

formatyear(theyear, width=3)：返回一年日历的html内容，width表示将12个月分为width列
```
from calendar import HTMLCalendar

c = HTMLCalendar()
print(c.formatyear(2022, width=3))
```
formatyearpage(theyear, width=3, css=’calendar.css’, encoding=None)：返回一年日历的html内容，width表示将12个月分为width列，css可自定义css样式，encoding编码方式
```
from calendar import HTMLCalendar

c = HTMLCalendar()
print(c.formatyearpage(2022, width=4))
```