time、datetime、calendar模块使用方法总结

time模块
datetime模块
calendar模块

关于时间、日期的模块介绍。

time模块

From	To	Use
计算从纪元以来的秒	在UTC中的`struct_time`	`gmtime()`
计算从纪元以来的秒	在当地时间的`struct_time`	`localtime()`
在UTC中的`struct_time`	计算从纪元以来的秒	`calendar.timegm()`
在当地时间中的`struct_time`	计算从纪元以来的秒	`mktime()`

time.asctime([t]) 由gmtime()、localtime()返回的时间转换为输出的形式。t不填则代表输出当前时间。

 time.asctime()
Out[3]: 'Sun Apr  7 10:40:11 2019'

time.clock() 此函数返回自第一次调用此函数依赖经过的挂钟秒，返回参数数据类型是浮点数。

time.clock()
Out[4]: 9.275375223710456e-07

time.clock()
Out[5]: 11.851292082957102

time.pthread_getcpuclockid(thread_id) 返回指定threading.get_ident()的特定线程的CPU时间始终的clk_id。

注：3.7中的新函数，在此不进行演示。

time.clock_getres(clk_id) 返回指定时钟clk_id的精度。有关clk_id的可接受值列表。
time.ctime([secs]) 以秒为单位转换为本地时间的字符串。如果没有提供secs，则使用当前时间。ctime(secs)相当于asctime(localtime(sece))。ctime()不能使用区域设置信息。

time.ctime()
Out[6]: 'Sun Apr  7 11:08:03 2019'

time.get_clock_info(name) 获取有关指定时钟的信息作为命名空间对象。支持的clock name 和读取其值的相应函数是：

clock name	function
`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：如果时钟可以自动更改或者有系统管理员手动更改则是True，否则为False。
implementation：用于获取时钟值。
monotonic：如果为时钟不能倒退则为True，否则为False。
resolution：时钟的精度。

time.gmtime([secs]) 以秒为单位转换为UTC中的struct_time。如果没有提供secs则输出由time.time()转换的时间。

time.gmtime()
Out[7]: time.struct_time(tm_year=2019, tm_mon=4, tm_mday=7, tm_hour=3, tm_min=27, tm_sec=18, tm_wday=6, tm_yday=97, tm_isdst=0)

time.gmtime(0)
Out[8]: 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)

time.localtime([secs]) 等同于gmtime()，但是转换为当地时间。如果没有给secs参数，用time()返回的返回前时间。当DST应用于给定时间时，dst标志设置为1。

time.localtime()
Out[11]: time.struct_time(tm_year=2019, tm_mon=4, tm_mday=7, tm_hour=11, tm_min=28, tm_sec=47, tm_wday=6, tm_yday=97, tm_isdst=0)

time.mktime(t) 理解为time.localtime()的反函数，参数是struct_time或者完整的9个数构成的元组，返回一个浮点数。eg：time.mktime(time.localtime())

time.mktime(time.localtime())
Out[13]: 1554607998.0

time.localtime()
Out[14]: time.struct_time(tm_year=2019, tm_mon=4, tm_mday=7, tm_hour=11, tm_min=33, tm_sec=33, tm_wday=6, tm_yday=97, tm_isdst=0)

time.mktime((2018, 1, 1, 10, 22, 22, 5, 97, 0))
Out[15]: 1514773342.0

time.localtime(1514773342.0)
Out[16]: time.struct_time(tm_year=2018, tm_mon=1, tm_mday=1, tm_hour=10, tm_min=22, tm_sec=22, tm_wday=0, tm_yday=1, tm_isdst=0)

time.sleep(secs) 暂停执行调用线程达到给定的秒数。参数可以是浮点数，以指示更精确的睡眠时间。

time.sleep(10) 

time.strftime(format[, t]) 转换struct_time为由format指定的字符串。如果未提供t，则使用localtime()返回当前的时间。format必须是一个字符串。如果t中的任何字段超出允许范围则引发ValueError。

time.strftime("%a, %d %b %m %Y %H:%M:%S +0000", time.gmtime())
Out[17]: 'Sun, 07 Apr 04 2019 03:39:27 +0000'

Directive	Meaning	notes
`%a`	缩写工作日的名称
`%A`	完整工作日名称
`%b`	缩写月份名称
`%B`	完整月份名称
`%c`	适当日期和时间表示
`%d`	月份的天用十进制数, [01, 31]
`%H`	小时用十进制数(二十四小时制)[00, 23]
`%I`	小时用十进制数(十二小时制)[01,12]
`%j`	一年中的天数用十进制数[01, 366]
`%m`	月份用十进制数[01, 12]
`%M`	分数用十进制数[00, 59]
`%p`	AM or PM	(1)
`%S`	秒是十进制数[00, 61]	(2)
`%U`	一年中的周数(星期日作为一周的第一天)作为十进制数[00, 53]。新的一年中的第一个星期日之前的天被作为第0周	(3)
`%w`	工作日作为十进制数[0(星期日), 6]
`%W`	一年中的周数(星期一作为一周的第一天)用十进制表示[00, 53]。新的一年中在第一个星期一之前的的天被认为是第0周	(3)
`%x`	适当的日期表示
`%X`	适当的时间表示
`%y`	没有世纪的年份作为十进制数[00, 99]
`%Y`	年份以世纪为十进制数
`%z`	时区偏移指示与格式+HHMM或-HHMM形式的UTC/GMT的正或负时差，其中H表示十进制小时数字，M表示小数分钟数字[-23:59, +23:59]
`%Z`	时区名称(如果不存时区，则不包含字符)
`%%`	`%`字符

Notes:
(1) 当与strptime()函数一起使用时，如果%I用于解析小时，则%p仅影响输出小时字段。
(2) 范围确实是0到61，value为60时在闰秒的时间戳中有效，并且由于历史原因支持值61。
(3) 当与使用strptime()功能，%U和%W仅在确定了一周中的天数、一年中的天数时用于计算。

time.strptime(string[, format]) 根据格式解析表示时间的字符串。返回值是struct_time，类似于gmtime()或localtime()的返回值。(理解为time.strftime()的反函数)

time.strptime("30 Nov 00", "%d %b %y")
Out[18]: time.struct_time(tm_year=2000, tm_mon=11, tm_mday=30, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=335, tm_isdst=-1)

time.time() 返回于起始时间相差多少，返回值是一个浮点数。

time.time()
Out[19]: 1554612250.9789116

序号	名称	范围
0	tm_year	eg:1993
1	tm_mon	[1, 12]
2	tm_mday	[1, 31]
3	tm_hour	[0, 23]
4	tm_min	[0, 59]
5	tm_sec	[0, 61]
6	tm_wday	[0, 6]
7	tm_yday	[1,366]
8	tm_isdst	0.1, -1
N/A	tm_zone	时区名称缩写
N/A	tm_gmtoff	与东时区便宜了几秒

datetime模块

import datetime

#允许设定的最小年份 
> datetime.MINYEAR
1 

#允许设定的最大年份
> datetime.MAXYEAR
9999

#时间单位的换算。datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)。
> d = datetime.timedelta(weeks=-1)
> d.days, d.seconds, d.microseconds
-8, 0, 0

#允许设定的最小时间差
> datetime.timedelta.min
datetime.timedelta(-999999999)

#允许设定的最大时间差
> datetime.timedelta.min
datetime.timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999)

#timedelta之间可能的最小差异
> datetime.timedelta.resolution
datetime.timedelta(0, 0, 1)

timedelta.total_seconds() 返回持续时间中包含的总秒数。等效于启用真正出发计算。

>>> from datetime import timedelta
>>> year = timedelta(days=365)
>>> another_year = timedelta(weeks=40, days=84, hours=23,
...                          minutes=50, seconds=600)  # adds up to 365 days
>>> year.total_seconds()
31536000.0
>>> year == another_year
True
>>> ten_years = 10 * year
>>> ten_years, ten_years.days // 365
(datetime.timedelta(3650), 10)
>>> nine_years = ten_years - year
>>> nine_years, nine_years.days // 365
(datetime.timedelta(3285), 9)
>>> three_years = nine_years // 3;
>>> three_years, three_years.days // 365
(datetime.timedelta(1095), 3)
>>> abs(three_years - ten_years) == 2 * three_years + year
True

datetime.date(year, month, day) 所有参数都是必须的。参数可以是整数或长整数，参数的范围。

MINYEAR <= year <= MAXYEAR
1 <= month <= 12
1 <= day <= number of days in the given month and year

date.today() 返回当前的本地日期。相当于`date.fromtimestamp(time.time())。

>>> datetime.date.today()
datetime.date(2019, 4, 7)

date.fromtimestamp(timestamp) 返回与POSIX时间戳对应的本地日期，例如返回的日期time.time()。如果时间戳超出范围则返回ValueError错误。

>>> datetime.date.fromtimestamp(1577777777)
datetime.date(2019, 12, 31)

date.fromordinal(ordinal) 返回对应于公历格里高利序数的日期，其中第1年1月1日有序数1。

>>> d.fromordinal(1)
datetime.date(1, 1, 1)
>>> d.fromordinal(7520)
datetime.date(21, 8, 3)

datetime.combine(date, time) 返回一个新datetime对象。
date.replace(year = self.year，month = self.month，day = self.day) 返回具有相同值的日期，但通过指定的任何关键字参数给定新值的参数除外。

>>> import datetime
>>> d = datetime.date(2002, 12, 31)
>>> d.replace(day = 26) == datetime.date(2002, 12, 26)
True

date.timetuple() 返回time.struct_time和time.localtime()的返回值类似。d.timetuple()相当于从当年1月1日开始的日期编号。

#小时，分钟和秒为0，DST标志为-1。
>>> d = datetime.date(2002, 12, 31)
>>> yday = d.toordinal() - datetime.date(d.year, 1, 1).toordinal() + 11
>>> time.struct_time((d.year, d.month, d.day, 0, 0, 0, d.weekday(), yday, -1))
time.struct_time(tm_year=2002, tm_mon=12, tm_mday=31, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=375, tm_isdst=-1)

date.toordinal() 返回日期的公历序数，其中对任何date对象的1年1月1日的有序数是1。

>>> d = datetime.date(2002, 12, 31)
>>> datetime.date.fromordinal(d.toordinal()) == d
True
>>> d.toordinal()
731215
>>> datetime.date.fromordinal(731215)
datetime.date(2002, 12, 31)

date.weekday() 以星期为单位返回星期几，其中星期一为1，星期日为7.

>>> datetime.date(2002, 12, 4).isoweekday() == 3
True

date.isocalendar() 返回三元组(ISO年份, ISO周编号, ISO工作日)

ISO日历是公里中广泛使用的变体。有关详细说明, ISO年份包括52或53整周，其中一周从星期一开始，到星期日结束。

>>> datetime.date(2003, 12, 29).isocalendar() == (2004, 1, 1)
True
>>> datetime.date(2004, 1, 4).isocalendar() == (2004, 1, 7)
True

date.isoformat(sep =’T’, timespec =’auto’) 返回表示ISO 8601格式的日期字符串’YYYY-MM-DD’。

>>> datetime.date(2002, 12, 4).isoformat() == '2002-12-04'
True
>>> from datetime import tzinfo, timedelta, datetime
>>> class TZ(tzinfo):
...     def utcoffset(self, dt): return timedelta(minutes=-399)
...
>>> datetime(2002, 12, 25, tzinfo=TZ()).isoformat(' ')
'2002-12-25 00:00:00-06:39'

date.str() 对于日期d，str(d) 相当于d.isformat()
date.ctime() 返回表示日期的字符串。

>>> datetime.date(2002, 12, 4).ctime()
'Wed Dec  4 00:00:00 2002'
>>> datetime.date(2002, 12, 4).ctime() == 'Wed Dec  4 00:00:00 2002'
True

date.strftime(format) 与date.strftime()相同。

计算时间天数的示例：

>>> import time
>>> from datetime import date
>>> today = date.today()
>>> today
datetime.date(2007, 12, 5)
>>> today == date.fromtimestamp(time.time())
True
>>> 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

date使用示例：

>>> from datetime import date
>>> d = date.fromordinal(730920) # 730920th day after 1. 1. 0001
>>> d
datetime.date(2002, 3, 11)
>>> t = d.timetuple()
>>> for i in t:     
...     print(i)
2002                # year
3                   # month
11                  # day
0
0
0
0                   # weekday (0 = Monday)
70                  # 70th day in the year
-1
>>> ic = d.isocalendar()
>>> for i in ic:    
...     print(i)
2002                # ISO year
11                  # ISO week number
1                   # ISO day number ( 1 = Monday )
>>> d.isoformat()
'2002-03-11'
>>> d.strftime("%d/%m/%y")
'11/03/02'
>>> d.strftime("%A %d. %B %Y")
'Monday 11. March 2002'
>>> 'The {1} is {0:%d}, the {2} is {0:%B}.'.format(d, "day", "month")
'The day is 11, the month is March.'

datetime.timestamp() 返回与实例对应的POSIX时间戳。返回值与返回的值类似。

使用datetime对象的示例：  
```python
>>> from datetime import datetime, date, time
>>> # Using datetime.combine()
>>> d = date(2005, 7, 14)
>>> t = time(12, 30)
>>> datetime.combine(d, t)
datetime.datetime(2005, 7, 14, 12, 30)
>>> # Using datetime.now() or datetime.utcnow()
>>> datetime.now()   
datetime.datetime(2007, 12, 6, 16, 29, 43, 79043)   # GMT +1
>>> datetime.utcnow()   
datetime.datetime(2007, 12, 6, 15, 29, 43, 79060)
>>> # Using datetime.strptime()
>>> dt = datetime.strptime("21/11/06 16:30", "%d/%m/%y %H:%M")
>>> dt
datetime.datetime(2006, 11, 21, 16, 30)
>>> # Using datetime.timetuple() to get tuple of all attributes
>>> tt = dt.timetuple()
>>> for it in tt:   
...     print(it)
...
2006    # year
11      # month
21      # day
16      # hour
30      # minute
0       # second
1       # weekday (0 = Monday)
325     # number of days since 1st January
-1      # dst - method tzinfo.dst() returned None
>>> # Date in ISO format
>>> ic = dt.isocalendar()
>>> for it in ic:   
...     print(it)
...
2006    # ISO year
47      # ISO week
2       # ISO weekday
>>> # Formatting datetime
>>> dt.strftime("%A, %d. %B %Y %I:%M%p")
'Tuesday, 21. November 2006 04:30PM'
>>> '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 21, the month is November, the time is 04:30PM.'

将datetime与tzinfo一起使用：

>>> from datetime import timedelta, datetime, tzinfo
>>> class GMT1(tzinfo):
...     def utcoffset(self, dt):
...         return timedelta(hours=1) + self.dst(dt)
...     def dst(self, dt):
...         # DST starts last Sunday in March
...         d = datetime(dt.year, 4, 1)   # ends last Sunday in October
...         self.dston = d - timedelta(days=d.weekday() + 1)
...         d = datetime(dt.year, 11, 1)
...         self.dstoff = d - timedelta(days=d.weekday() + 1)
...         if self.dston <=  dt.replace(tzinfo=None) < self.dstoff:
...             return timedelta(hours=1)
...         else:
...             return timedelta(0)
...     def tzname(self,dt):
...          return "GMT +1"
...
>>> class GMT2(tzinfo):
...     def utcoffset(self, dt):
...         return timedelta(hours=2) + self.dst(dt)
...     def dst(self, dt):
...         d = datetime(dt.year, 4, 1)
...         self.dston = d - timedelta(days=d.weekday() + 1)
...         d = datetime(dt.year, 11, 1)
...         self.dstoff = d - timedelta(days=d.weekday() + 1)
...         if self.dston <=  dt.replace(tzinfo=None) < self.dstoff:
...             return timedelta(hours=1)
...         else:
...             return timedelta(0)
...     def tzname(self,dt):
...         return "GMT +2"
...
>>> gmt1 = GMT1()
>>> # Daylight Saving Time
>>> dt1 = datetime(2006, 11, 21, 16, 30, tzinfo=gmt1)
>>> dt1.dst()
datetime.timedelta(0)
>>> dt1.utcoffset()
datetime.timedelta(seconds=3600)
>>> dt2 = datetime(2006, 6, 14, 13, 0, tzinfo=gmt1)
>>> dt2.dst()
datetime.timedelta(seconds=3600)
>>> dt2.utcoffset()
datetime.timedelta(seconds=7200)
>>> # Convert datetime to another time zone
>>> dt3 = dt2.astimezone(GMT2())
>>> dt3     # doctest: +ELLIPSIS
datetime.datetime(2006, 6, 14, 14, 0, tzinfo=<GMT2 object at 0x...>)
>>> dt2     # doctest: +ELLIPSIS
datetime.datetime(2006, 6, 14, 13, 0, tzinfo=<GMT1 object at 0x...>)
>>> dt2.utctimetuple() == dt3.utctimetuple()
True

calendar模块

class calendar.Calendar([ firstweekday ]) 创建一个calendar对象。firstweekday是一个整数，指定一周的第一天。0是星期一(默认值)。
iterweekdays() 返回将使用一周的工作日数字的迭代器。迭代器的第一个值与firstweekday属性值相同。
itermonthdates(year, month) 返回一个可迭代的数据类型，此迭代器将返回datetime.date月份的所有日期（作为对象）以及月份开始前的所有日期或者在完成一周所需的月末之后的所有日期。
itermonthdays2(year, month) 返回一个迭代。类似于itermonthdays()。返回的天数将只是日期数字。
monthdatescalendar(year, month) 返回在一年中月份的星期的列表。星期的列表是七个datetime.date对象组成的。
monthdays2calendar(year, month) 返回在该月的周列表。周是七个元组的日数和工作日数的列表。
monthdayscalendar(year, month) 返回在该月的周列表。周是七天数的列表。
yeardatescalendar(year[, width]) 返回指定年份的数据以备格式化。返回值是月份的列表。每个月行包含最多宽度的月份(默认为3)。每个月包含4~6周，每周包含1~7天。天是datetime.date对象。
yeardays2calendar(year[, width]) 返回指定年份的数据以备格式化(类似于yeardatescalendar())。周列表中的条目是日期编号。本月以外的日数为零。
calendar.setfirstweekday(weekday) 将工作日(星期一是0，星期日是6)，值为MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, and SUNDAY

#将第一个工作日设置为星期日
import calendar
calendar.setfirstweekday(calendar.SUNDAY)

calendar.firstweekday() 返回每周开始的工作日的当前设置。

>>> import calendar
>>> calendar.firstweekday()
0  #表示一周的默认第一天为星期一

calendar.isleap(year) 如果year是闰年则返回True，否则返回False。

>>> calendar.isleap(2000)
True
>>> calendar.isleap(2019)
False

calendar.leapdays(y1，y2) 返回y1到y2(不包括)范围内的闰年数，其中y1，y2是年份。

>>> calendar.leapdays(1999, 2019)
5

calendar.weekday(year, month, day) 返回year(1970-)，month(1-12)，day(1-31)是星期几(0是星期一)。
calendar.weekheader(n) 返回包含缩写的工作日名称的标题。n指定一个工作日的字符宽度。

>>> calendar.weekday(2019, 4, 7)
6

calendar.monthrange(year, month) 返回指定年份和月份的第一天是星期几以及月份的天数。

>>> calendar.monthrange(2019, 4)
(0, 30)
>>> calendar.monthrange(2018, 2)
(3, 28)

calendar.monthcalendar(year, month) 返回表示月份日历的矩阵。每行代表一周；本月以外的日子由零代表。除非用setfirstweekday()设定，否则每周从星期一开始。

>>> calendar.monthcalendar(2019, 4)
[[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, 0, 0]]

calendar.prmonth(theyear, themonth[, w[, l]]) 打印用month()函数返回的一个月的日历。

>>> calendar.prmonth(2019, 4)
     April 2019
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

calendar.month(theyear, themonth[, w[, l]]) 返回使用多线串并且属于TextCalendar类的函数formatmonth()。返回一个月的日历。

>>> print(calendar.month(2019, 4))
     April 2019
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
>> print(calendar.month(2019, 4, 3, 2))
         April 2019

Mon Tue Wed Thu Fri Sat Sun

  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

calendar.prcal(year[, w[, l[c]]]) 打印返回整年的日历。类似于calendar()

>>> calendar.prcal(2019)
                                  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

calendar.calendar(year[, w[, l[c]]]) 返回一整年的3列日历中，TextCalendar类中的formatyear()函数返回的多行字符串。3个月一行，间隔距离为c。每日宽度间隔为w字符。每行长度为21*w+18+2*c。

>>> print(calendar.calendar(2019))
                                  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.timegm(tuple) 一个不相关但是很方便的函数，它接受一个时间元组，如time模块中的gmtime()函数的返回值。并返回相应的Unic时间戳值，假定1970年的纪元，以及POSIX编码。其实，time.gmtime()和timegh()互为反函数。

>>> calendar.timegm((2019, 4, 7, 22, 59, 00))
1554677940

calendar模块导出以下数据属性：

calendar.day_name: 一个数组，表示当前语言环境中的星期几。
calendar.day_abbr: 一个数字，表示当前语言环境中一周的缩写天数。
calendar.month_name: 一个数组，表示当前语言环境中一年的月份。这遵循1月为月号1，因此它的长度为13，并且month_name[0]是空字符串。
calendar.month_abbr: 一个数组，表示当前语言环境中年份的缩写月份。这遵循1月的月号1，因此它的长度为13，并且month_abbr[0]是空字符串。

参考文献：
https://docs.python.org/3/library/time.html
https://blog.csdn.net/wnma3mz/article/details/79192838
https://docs.python.org/3/library/datetime.html?highlight=datetime
https://docs.python.org/2/library/calendar.html

转载请注明：南梦婷的博客 » 点击阅读原文

time、datetime、calendar模块使用方法总结

time模块

datetime模块

calendar模块

Comments