python标准库学习（2）
标准库time、datetime和calendar
2019-09-10
python标准库中处理时间、日期的主要是time、datetime和calendar这3个库，尽管一些第三方库如dateutil、Arrow、pendulum、moment、maya、Delorean、When.py等在时间和日期处理方面扩展了很多功能，使得处理更加简洁或人性化，但标准库处理时间和日期仍然是最常见和常用的。
1. time：时间获取与转换
time库提供了近30个方法和10多个常量，是python处理时间相关的数据类型的基础。time提供的方法主要有3类：时间获取、时间转换和时间相关的操作。
1.1 时间的表示方式
时间的表示方式主要有3种：
- 时间戳（timestamp）：表示从1970年1月1日0时0分0秒开始，按秒计算的时间偏移量；这里的1970年1月1日0时0分0秒被称为epoch，是时间开始的点，取决于系统平台。
- 时间元组（struct_time）：也称“结构体时间”，用一个元组表示的时间信息；
- 时间字符串：用字符串来格式化显示时间。
以上3中表示形式在time中都有体现：
import time time.time() # 时间戳：. time.localtime() # 结构体时间：time.struct_time(tm_year=2019, / # tm_mon=9, tm_mday=16, tm_hour=18, tm_min=31, / # tm_sec=56, tm_wday=0, tm_yday=259, tm_isdst=0) # 注意这个时间结构体是一个元组，不能通过类似time.localtime()['tm_min']来取值 time.ctime() # 'Mon Sep 16 18:31:40 2019' 以下是获取时间的常用方法：
| 方法 | 作用 | 备注 |
|---|---|---|
| time.time() | 时间戳，返回浮点数的秒数，以epoch为起点，截止当前时间，时区为标准时间 | 无参数 |
| time.time_ns() | 时间戳，返回浮点数的纳秒数，以epoch为起点，截止当前时间，时区为标准时间 | 无参数 |
| time.gmtime([secs]) | 将时间戳转换为为单位的时间转换为标准时间下的结构体元组 | 参数为以秒为单位的数，默认为time.time() |
| time.localtime([secs]) | 将时间戳转换为为单位的时间转换为系统所在时区下的结构体元组 | 参数为以秒为单位的数，默认为time.time() |
| time.ctime([secs]) | 返回的时间转换为表示本地时间的字符串，以epoch为起点，截止当前时间 | 参数为以秒为单位的数，默认为time.time() |
在结构体时间中，一般会返回一个包含8个元素的struct_time对象，这个元组可以通过位置索引（index）访问：
| 索引 | 属性 | 值 | 含义 |
|---|---|---|---|
| 0 | tm_year | （例如，1993） | 年份 |
| 1 | tm_mon | range [1, 12] | 月份 |
| 2 | tm_mday | range [1, 31] | 当月第几天 |
| 3 | tm_hour | range [0, 23] | 当日第几小时 |
| 4 | tm_min | range [0, 59] | 分 |
| 5 | tm_sec | range [0, 61] | 秒 |
| 6 | tm_wday | range [0, 6] ，周一为 0 | 周几 |
| 7 | tm_yday | range [1, 366] | 当年的第几天 |
| 8 | tm_isdst | 0, 1 或 -1 | 是否是夏令时 |
1.2 不同时间表示之间的转换
先来看时间戳的两种转化形式：
讯享网import time sect = time.ctime(sect) # 'Sat Dec 20 02:27:27 2008' time.gmtime(sect) # time.struct_time(tm_year=2008, tm_mon=12, / # tm_mday=19, tm_hour=18, tm_min=27, tm_sec=27, / # tm_wday=4, tm_yday=354, tm_isdst=0)
strptime和strftime实现了字符串和时间元组之间的相互转换，由于涉及将时间元组转化为一定格式的时间字符串，因此需要指定format格式，一般用%加一个字母来表示一个时间字段（文档中称为directive，“指令”）：
| 指令 | 含义 |
|---|---|
| %a | 本地化的缩写星期中每日的名称 |
| %A | 本地化的星期中每日的完整名称 |
| %b | 本地化的月缩写名称 |
| %B | 本地化的月完整名称 |
| %c | 本地化的适当日期和时间表示 |
| %d | 十进制数 [01,31] 表示的月中日。 |
| %H | 十进制数 [00,23] 表示的小时（24小时制）。 |
| %I | 十进制数 [01,12] 表示的小时（12小时制）。 |
| %j | 十进制数 [001,366] 表示的年中日。 |
| %m | 十进制数 [01,12] 表示的月。 |
| %M | 十进制数 [00,59] 表示的分钟。 |
| %p | 本地化的 AM 或 PM 。 |
| %S | 十进制数 [00,61] 表示的秒。 |
| %U | 十进制数 [00,53] 表示的一年中的周数（星期日作为一周的第一天） |
| %w | 十进制数 [0(星期日),6] 表示的周中日。 |
| %W | 十进制数 [00,53] 表示的一年中的周数（星期一作为一周的第一天）。 |
| %x | 本地化的适当日期表示。 |
| %X | 本地化的适当时间表示。 |
| %y | 十进制数 [00,99] 表示的没有世纪的年份。 |
| %Y | 十进制数表示的带世纪的年份。 |
| %z | 时区偏移以格式 |
| %Z | 时区名称（如果不存在时区，则不包含字符）。 |
| %% | 字面的 ‘%’ 字符。 |
以下示例说明，字符串和时间元组之间的转换可以非常灵活：
import time # 将字符串转化为时间元组 dt = '2018-12-31' ts = time.strptime(dt, '%Y-%m-%d') print(ts) # time.struct_time(tm_year=2018, / # tm_mon=12, tm_mday=31, tm_hour=0, tm_min=0, tm_sec=0, / # tm_wday=0, tm_yday=365, tm_isdst=-1) # 将时间元组转化为字符串 tm = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()) print(tm) # '2019-09-17 19:41:02' 1.3 time模块中的其他函数
除时间获取和转换外，time另外还有2个方面的功能：使程序暂停指定时间和计算程序运行时间。
暂停指定时间用time.sleep(secs)方法，根据文档，“暂停执行调用线程达到给定的秒数。参数可以是浮点数，以指示更精确的睡眠时间。实际的暂停时间可能小于请求的时间，因为任何捕获的信号将在执行该信号的捕获例程后终止sleep()。此外，由于系统中其他活动的安排，暂停时间可能比请求的时间长任意量。”
计算程序运行时间方面，python标准库中提供了timeit，这个库可以用命令行方式和调用方法的方式计算程序运行时间。time中主要可以通过3个方法来测量程序运行时间：
| 函数 | 说明 |
|---|---|
| time.time() | 返回epoch为起点的系统时间的秒数，依赖于系统平台 |
| time.perf_counter() | 返回一个CPU级别的精确的秒数。包括睡眠期间经过的时间，并且是系统范围的。返回值的参考点未定义，因此只有连续调用结果之间的差异才有效 |
| time.process_time() | 返回当前进程的系统和用户CPU时间总和的值（以小数秒为单位）。它不包括睡眠期间经过的时间。根据定义，它在整个进程范围中。返回值的参考点未定义，因此只有连续调用结果之间的差异才有效 |
以上3个方法返回的单位都是秒，对应地有3个带_ns返回以纳秒为单位的数字：time_ns()、perf_counter_ns()、process_time_ns()。以下用一个例子来说明计时功能的实现，以及这些方法的不同：
讯享网def fibonacci(n): a, b = 0, 1 while n > 0: a, b = b, a + b n -= 1 yield a a_point_tm = time.time() a_point_perf = time.perf_counter() a_point_proc = time.process_time() result_u = sum([i for i in fibonacci(300)]) time.sleep(10) result_s = sum([i for i in fibonacci(20)]) print(result_s + result_u) b_point_tm = time.time() b_point_perf = time.perf_counter() b_point_proc = time.process_time() print('time()计算结果：',b_point_tm-a_point_tm) print('perf_counter()计算结果：',b_point_perf-a_point_perf) print('process_time()计算结果：',b_point_proc-a_point_proc) ''' time()计算结果： 10.0067 perf_counter()计算结果： 10.0034 process_time()计算结果： 0.0 '''
2. datetime：基本的日期和时间类型
datetime提供了几种操作日期和时间的数据类型，主要有time、date、datetime、timedelta、tzinfo和timezone等6种数据类型；最后的两个tzinfo和timezone和时区有关（tzinfo定义了时区信息的基类），以下内容暂不涉及。
datetime中，既包含了time中的数据类型（对应于datetime.datetime），时间精度是到毫秒级（1 毫秒 = 0.001 秒，而不是ns纳秒级），也有date数据类型，时间单位到天，和表示一天内某个时间的time。datetime库对time库最主要的扩展体现在表示时间差（时间间隔）的timedelta类型，使得时间之间可以进行各种运算。
2.1 datetime.timedelta
文档中的完整形式是：class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)，所有的参数都是可选的并且默认值为 0。这些参数可以是整数或者浮点数，也可以是正数或者负数。timedelta中只会储存days, seconds, microseconds这3个单位，其余参数都是用这3个基本的单位转化的。
timedelta对象支持本身类型的对象，以及date和 datetime类型对象的计算（date和 datetime类型对象之间进行计算，返回的就是一个timedelta对象）。支持的计算类型如下表：
| 运算 | 结果 |
|---|---|
| t1 = t2 + t3 | t2 和 t3 的和 |
| t1 = t2 - t3 | t2 减 t3 的差 |
| t1 = t2 * i 或 t1 = i * t2 | 乘以一个整数 |
| t1 = t2 * f 或 t1 = f * t2 | 乘以一个浮点数，结果会被舍入到 timedelta 最接近的整数倍。 |
| f = t2 / t3 | 总时间 t2 除以间隔单位 t3。 返回一个 float 对象。 |
| t1 = t2 / f 或 t1 = t2 / i | 除以一个浮点数或整数。 结果会被舍入到 timedelta 最接近的整数倍。 精度使用四舍五偶入奇不入规则。 |
| t1 = t2 // i or t1 = t2 // t3 | 取整除，余数部分(如果有的话)将被丢弃 |
| t1 = t2 % t3 | 余数为一个 timedelta 对象 |
| q, r = divmod(t1, t2) | 通过 : q = t1 // t2 (3) and r = t1 % t2 计算出商和余数。q是一个整数，r是一个 timedelta 对象 |
| +t1 | 返回一个相同数值的 timedelta 对象。 |
| -t1 | 等价于 timedelta(-t1.days, -t1.seconds, -t1.microseconds), 和 t1* -1. (1)(4) |
| abs(t) | 当 t.days >= 0`时等于 +t, 当t.days < 0 时 -t |
| str(t) | 返回一个形如 [D day[s], ][H]H:MM:SS[.UUUUUU] 的字符串，当 t 为负数的时候， D 也为负数 |
| repr(t) | 返回一个 timedelta 对象的字符串表示形式，作为附带正规属性值的构造器调用 |
以计算前一天为例，可以用当天时间直接减去一个timedelta对象就行（注意timedelta实例化时，其中的参数都是带“s”的，如days）：
import datetime td = datetime.datetime.now() # datetime.datetime(2019, 9, 26, 21, 58, 21, ) ys = td - datetime.timedelta(days=1) # datetime.datetime(2019, 9, 25, 21, 57, 46, ) ys_p = ys.strftime('%Y-%m-%d %H:%M:%S') # '2019-09-25 22:03:23' 两个时间对象计算后，得到的结果也是timedelta：
import datetime td = datetime.datetime.now() # datetime.datetime(2019, 9, 26, 21, 58, 21, ) bth = datetime.datetime(2019,1,11, 15, 10, 40, 96) result = td - bth # datetime.timedelta(days=258, seconds=25307, microseconds=) timedelta有一个实例方法timedelta.total_seconds()，返回时间间隔包含了多少秒。
td = datetime.datetime.today() yd = datetime.datetime(2010,10,31) dlt = td - yd print(dlt.total_seconds()) # . 2.2 datetime中的几种数据类型
2.2.1 datetime.date
datetime.date包含3个实例属性：year, month, day；以及3个类属性：date.min（date(MINYEAR, 1, 1)）、date.max（date(MAXYEAR, 12, 31)）和date.resolution（两个日期对象的最小间隔，timedelta(days=1)），返回的格式为year-month-day；datetime.date类有5种构造方式，最基本的构造函数是__new__(year, month, day)
import datetime import time td = datetime.date(2019, 9, 18) print(td) # 2019-09-18 tdr = datetime.date.today() print(tdr) # 2019-09-18 td_ts = datetime.date.fromtimestamp(time.time()) print(td_ts) # 2019-09-18 td_d = datetime.date.fromordinal() # 传入一个正整数n，为自公元元年1月1日开始的第n天，例如1为公元1年1月1日 print(td_d) # 2019-09-18 td_iso = datetime.date.fromisoformat('2019-09-18') print(td_iso) # 2019-09-18 当构造了一个datetime.date对象后，这个对象就有了year, month, day这3个实例属性，可以通过对象.year类似的形式访问（也可以通过对象.__getattribute__('year')来实现）。
datetime.date对象的实例方法主要有3类：日期参数替换、日期表示、日期的日历信息。日期参数替换的方法是date.replace(year=self.year, month=self.month, day=self.day)，这个方法可以用来替换实例属性中的值：
td = datetime.date.today() # datetime.date(2019, 10, 8) rd = td.replace(year=2018, day=1) print(rd) # 2018-10-01，返回的对象仍是datetime.date类型 日期的表示和日历信息相关的实例方法，可以与前面构造方法的部分对比来看，例如isoformat()可以看做是fromisoformat()的对用函数，toordinal()是fromordinal()的对应函数等。
日期表示的方法主要有时间元组和字符串两种，表示为时间元组的是date.timetuple()，返回的是与time.localtime()相同类型的结构体时间（时间元组）：
std = datetime.date(2018, 10, 11) print(std.timetuple()) # time.struct_time(tm_year=2018, tm_mon=10, tm_mday=11, # tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=284, tm_isdst=-1) 日期的字符串表示，可以使用date.isoformat()（或date.__str__()）表示为标准的字符串形式，以及date.ctime()表示为代表日期的字符串，还包括使用date.strftime(format)（或date.__format__(format)），这三种表示方式可以参看以下示例：
rd = datetime.date(2018, 5, 23) print(rd.isoformat()) # 2018-05-23 print(str(rd)) # 2018-05-23 print(rd.ctime()) # Wed May 23 00:00:00 2018 print(rd.strftime('%Y_%m_%d')) # 2018_05_23 print(rd.__format__('%Y-%m-%d')) # 2018-05-23 日期的日历信息，主要包括日期的星期信息，日历位置信息，和格列高利历序号（即以公元1年1月1日为第1天的序号）。星期信息有两种表示方式：date.weekday()和date.isoweekday()，区别是weekday()中星期一用“0”表示（周日是“6”），isoweekday()中星期一用“1”表示（周日是“7”），返回的是数字（int）。
rd = datetime.date(2018, 5, 23) print(rd.weekday()) # 2 print(rd.isoweekday()) # 3 date.isocalendar()返回一个三元组：(ISO year, ISO week number, ISO weekday) ，其中ISO是国际标准的意思，文档中举了一个例子可以作为说明：“2004 年的第一天是一个星期四，因此 ISO 2004 年的第一个星期开始于 2003 年 12 月 29 日星期一，结束于 2004 年 1 月 4 日星期日，因此
date(2003, 12, 29).isocalendar() == (2004, 1, 1) and date(2004, 1, 4).isocalendar() == (2004, 1, 7)”
rd = datetime.date(2018, 5, 23) print(rd.isocalendar()) # (2018, 21, 3) 除此之外，datetime.date也支持比较运算（类似地，以下提到的datetime.time和datetime.datetime也支持）：
lt = datetime.date(2019, 10, 9) rt = datetime.date(2018, 10, 8) lt > rt # True lt >= rt # True lt == rt # False 2.2.2 datetime.time
datetime.time表示一天中的某个时间点（不包含日期信息），包含6个实例属性：hour、minute、second、microsecond、tzinfo和fold，最后一个fold的含义是“用于在重复的时间段中消除边界时间歧义”，取值为0或1（默认为0）。除了直接通过赋值实例化之外，datetime.time还有一个构造方法time.fromisoformat(time_string)，但文档提示这个方式只是time.isoformat()的逆操作，并不能解析所有格式的ISO时间字符串。
实例方法中，除了与时区相关的操作外，与前面datetime.date类似，也有time.isoformat(timespec='auto')，time.strftime(format)和time.replace(hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, tzinfo=self.tzinfo, * fold=0)方法，详见文档。
2.2.3 datetime.datetime
datetime.time是包含了datetime.date和datetime.time所有信息的数据类型，包含9个实例属性：year、month、day、hour、minute、second、microsecond、tzinfo和fold。
datetime.datetime数据类型的实例化（构造方法）有很多：
import time import datetime # 传入参数进行构造 td = datetime.datetime(2019, 10, 8) # datetime.datetime(2019, 10, 8, 0, 0) # 表示当前时间，带utc的为标准时间，其余为本地时间 td = datetime.datetime.today() # datetime.datetime(2019, 10, 8, 15, 17, 11, ) td = datetime.datetime.now() # datetime.datetime(2019, 10, 8, 15, 17, 11, ) td = datetime.datetime.utcnow() # datetime.datetime(2019, 10, 8, 7, 18, 44, 10496) # 传入时间戳，带utc的为标准时间，其余为本地时间 td = datetime.datetime.fromtimestamp(time.time()) # datetime.datetime(2019, 10, 8, 15, 20, 36, ) td = datetime.datetime.utcfromtimestamp(time.time()) # datetime.datetime(2019, 10, 8, 7, 22, 5, ) # 传入格列高利历序号（即公元1年1月1日起的第几天） td = datetime.datetime.fromordinal() # datetime.datetime(2019, 10, 8, 0, 0) # 传入标准的时间字符串 td = datetime.datetime.fromisoformat('2019-10-08 15:25:23') # datetime.datetime(2019, 10, 8, 15, 25, 23) # 合并日期和时间的数据 td = datetime.datetime.combine(datetime.date.today(), datetime.time(12, 5, 34)) # datetime.datetime(2019, 10, 8, 12, 5, 34)fold # 字符串序列化 td = datetime.datetime.strptime('2019-10-08 15:25:23', '%Y-%m-%d %H:%M:%S') # datetime.datetime(2019, 10, 8, 15, 25, 23) datetime.datetime有min、max、resolution等3个类方法，以及year、month、day、hour、minute、second、microsecond、tzinfo和fold等9个实例方法：
datetime.datetime.resolution # datetime.timedelta(microseconds=1) td = datetime.datetime.now() # datetime.datetime(2019, 10, 8, 22, 35, 24, ) td.day # 8 datetime.datetime的实例方法主要有3类：参数替换、时间表示（以及表示方式的转换）、时间的日历信息以及时区操作等4类。
参数替换的方法是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.date()和datetime.time()用于将datetime.datetime对象转换为datetime.date或datetime.time类型的对象；datetime.timetuple()和datetime.utctimetuple()可以将datetime.datetime对象转换为时间元组格式；datetime.toordinal()会返回日期的预期格列高利历序号；datetime.timestamp()会返回时间戳；datetime.isoformat()会返回一个标准的时间戳（ISO 8601 格式表示日期和时间的字符串 YYYY-MM-DDTHH:MM:SS.ffffff）；datetime.ctime()返回一个表示时间的字符串datetime.strftime(format)返回一个由显式格式字符串所指明的代表日期和时间的字符串：
td = datetime.datetime.now() # datetime.datetime(2019, 10, 8, 23, 10, 4, ) td.date() # datetime.date(2019, 10, 8) td.time() #datetime.time(23, 10, 4, ) td.timetuple() # time.struct_time(tm_year=2019, tm_mon=10, # tm_mday=8, tm_hour=23, tm_min=10, tm_sec=53, tm_wday=1, tm_yday=281, tm_isdst=-1) td.toordinal() # td.timestamp() # . td.isoformat() # '2019-10-08T23:14:17.' td.ctime() # 'Tue Oct 8 23:16:56 2019' td.strftime('%Y-%m-%d %H-%M-%S') # '2019-10-08 23-19-02' 此外与datetime.date中相同，datetime.datetime也提供了关于日历信息的方法，主要有以下3个：
td = datetime.datetime.fromisoformat('2019-10-08 15:25:23') td.weekday() # 1 td.isoweekday() # 2 td.isocalendar() # (2019, 41, 2) 3. calendar：日历相关函数
calendar定义了一些日历相关的数据类型，并基于此提供了一系列操作日期的相关函数。默认情况下，这些日历（数据类型）把星期一当作一周的第一天，星期天为一周的最后一天（按照欧洲惯例）。
calendar主要由类Calendar、Calendar一些子类（TextCalendar，HTMLCalendar以及这两个类的子类）以及一些方法构成。最基本的用法是通过calendar.calendar(year, w=2, l=1, c=6, m=3)方法来实例化一个日历：
import calendar cld = calendar.calendar(2019) print(cld) ''' 2019 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 3 4 5 6 1 2 3 1 2 3 7 8 9 10 11 12 13 4 5 6 7 8 9 10 4 5 6 7 8 9 10 14 15 16 17 18 19 20 11 12 13 14 15 16 17 11 12 13 14 15 16 17 21 22 23 24 25 26 27 18 19 20 21 22 23 24 18 19 20 21 22 23 24 28 29 30 31 25 26 27 28 25 26 27 28 29 30 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 4 5 6 7 1 2 3 4 5 1 2 8 9 10 11 12 13 14 6 7 8 9 10 11 12 3 4 5 6 7 8 9 15 16 17 18 19 20 21 13 14 15 16 17 18 19 10 11 12 13 14 15 16 22 23 24 25 26 27 28 20 21 22 23 24 25 26 17 18 19 20 21 22 23 29 30 27 28 29 30 31 24 25 26 27 28 29 30 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 4 5 6 7 1 2 3 4 1 8 9 10 11 12 13 14 5 6 7 8 9 10 11 2 3 4 5 6 7 8 15 16 17 18 19 20 21 12 13 14 15 16 17 18 9 10 11 12 13 14 15 22 23 24 25 26 27 28 19 20 21 22 23 24 25 16 17 18 19 20 21 22 29 30 31 26 27 28 29 30 31 23 24 25 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 3 4 5 6 1 2 3 1 7 8 9 10 11 12 13 4 5 6 7 8 9 10 2 3 4 5 6 7 8 14 15 16 17 18 19 20 11 12 13 14 15 16 17 9 10 11 12 13 14 15 21 22 23 24 25 26 27 18 19 20 21 22 23 24 16 17 18 19 20 21 22 28 29 30 31 25 26 27 28 29 30 23 24 25 26 27 28 29 30 31 ''' calendar.calendar(year, w=2, l=1, c=6, m=3)，根据文档的说明，是“使用 TextCalendar 类的 formatyear() 返回整年的3列的日历以多行字符串的形式”，可选参数 w, l, 和 c 分别表示日期列数， 周的行数， 和月之间的间隔。
这相当于：
cld = calendar.TextCalendar() result = cld.formatyear(2019) print(result) 可以通过calendar.setfirstweekday(weekday)来指定一周的开始（0表示星期一，6表示星期天）：
calendar.setfirstweekday(6) cld = calendar.calendar(2019) print(cld) ''' 2019 January February March Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa 1 2 3 4 5 1 2 1 2 6 7 8 9 10 11 12 3 4 5 6 7 8 9 3 4 5 6 7 8 9 13 14 15 16 17 18 19 10 11 12 13 14 15 16 10 11 12 13 14 15 16 20 21 22 23 24 25 26 17 18 19 20 21 22 23 17 18 19 20 21 22 23 27 28 29 30 31 24 25 26 27 28 24 25 26 27 28 29 30 31 April May June Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa 1 2 3 4 5 6 1 2 3 4 1 7 8 9 10 11 12 13 5 6 7 8 9 10 11 2 3 4 5 6 7 8 14 15 16 17 18 19 20 12 13 14 15 16 17 18 9 10 11 12 13 14 15 21 22 23 24 25 26 27 19 20 21 22 23 24 25 16 17 18 19 20 21 22 28 29 30 26 27 28 29 30 31 23 24 25 26 27 28 29 30 July August September Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa 1 2 3 4 5 6 1 2 3 1 2 3 4 5 6 7 7 8 9 10 11 12 13 4 5 6 7 8 9 10 8 9 10 11 12 13 14 14 15 16 17 18 19 20 11 12 13 14 15 16 17 15 16 17 18 19 20 21 21 22 23 24 25 26 27 18 19 20 21 22 23 24 22 23 24 25 26 27 28 28 29 30 31 25 26 27 28 29 30 31 29 30 October November December Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa 1 2 3 4 5 1 2 1 2 3 4 5 6 7 6 7 8 9 10 11 12 3 4 5 6 7 8 9 8 9 10 11 12 13 14 13 14 15 16 17 18 19 10 11 12 13 14 15 16 15 16 17 18 19 20 21 20 21 22 23 24 25 26 17 18 19 20 21 22 23 22 23 24 25 26 27 28 27 28 29 30 31 24 25 26 27 28 29 30 29 30 31 ''' 类似地，calendar提供了calendar.monthcalendar(year, month)方法，输出某个月的日历，也可以通过calendar.prcal(year, w=0, l=0, c=6, m=3)和calendar.prmonth(theyear, themonth, w=0, l=0)直接打印出日历或月历。
除了纯文本意外的另一种输出形式是html格式（默认参数可以参考之前列出的，这是一个没有边框线的月历）：
cld = calendar.HTMLCalendar() result = cld.formatmonth(2019,10) print(result) ''' <table border="0" cellpadding="0" cellspacing="0" class="month"> <tr><th colspan="7" class="month">October 2019</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"> </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"> </td><td class="noday"> </td><td class="noday"> </td></tr> </table> ''' 除以上两种显示日历的方式外，calendar还提供了一些很有用方法。calendar.isleap(year)判断这个年份是否是闰年；calendar.leapdays(y1, y2)返回两个年份之间闰年的数量：
calendar.isleap(2019) # False calendar.leapdays(2010,2019) # 2 calendar.weekday(year, month, day)可以判断某个日期是星期几，返回一个数字（0代表星期一）：
calendar.weekday(-101,11,2) # 3 calendar.timegm(tuple)被文档称为“一个不相关但很好用的函数”（an unrelated but handy function），“它接收一个时间元组例如 time 模块中的 gmtime() 函数的返回并返回相应的 Unix 时间戳，假定 1970 年开始计数”，可以与time模块的time.mktime()对比：
import time import datetime import calendar dy = datetime.date(2018, 11, 1) dytuple = dy.timetuple() res_a = calendar.timegm(dytuple) res_b = time.mktime(dytuple) print(res_a) # ，这是基于标准时间的结果 print(res_b) # .0，这是基于本地时间的结果
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请联系我们，一经查实，本站将立刻删除。
如需转载请保留出处：https://51itzy.com/kjqy/22479.html