python开发_calendar

如果你用过linux，你可能知道在linux下面的有一个强大的calendar功能，即日历

在python中，同样也有这样的一个强大的calendar

下面是我做的demo：

 #python中的calendar

 import calendar

 #返回指定年的某月
 def get_month(year, month):
     return calendar.month(year, month)

 #返回指定年的日历
 def get_calendar(year):
     return calendar.calendar(year)

 #判断某一年是否为闰年，如果是，返回True，如果不是，则返回False
 def is_leap(year):
     return calendar.isleap(year)

 #返回某个月的weekday的第一天和这个月的所有天数
 def get_month_range(year, month):
     return calendar.monthrange(year, month)

 #返回某个月以每一周为元素的序列
 def get_month_calendar(year, month):
     return calendar.monthcalendar(year, month)

 def main():
     year = 2013
     month = 8
     test_month = get_month(year, month)
     print(test_month)
     print('#' * 50)
     #print(get_calendar(year))
     print('{0}这一年是否为闰年？：{1}'.format(year, is_leap(year)))
     print(get_month_range(year, month))
     print(get_month_calendar(year, month))

 if __name__ == '__main__':
     main()

运行效果：

Python 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:03:43) [MSC v.1600 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> ================================ RESTART ================================
>>>
    August 2013
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

##################################################
2013这一年是否为闰年？：False
(3, 31)
[[0, 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, 31, 0]]
>>> 

再附上calendar.py的源码：

 """Calendar printing functions

 Note when comparing these calendars to the ones printed by cal(1): By
 default, these calendars have Monday as the first day of the week, and
 Sunday as the last (the European convention). Use setfirstweekday() to
 set the first day of the week (0=Monday, 6=Sunday)."""

 import sys
 import datetime
 import locale as _locale

 __all__ = ["IllegalMonthError", "IllegalWeekdayError", "setfirstweekday",
            "firstweekday", "isleap", "leapdays", "weekday", "monthrange",
            "monthcalendar", "prmonth", "month", "prcal", "calendar",
            "timegm", "month_name", "month_abbr", "day_name", "day_abbr"]

 # Exception raised for bad input (with string parameter for details)
 error = ValueError

 # Exceptions raised for bad input
 class IllegalMonthError(ValueError):
     def __init__(self, month):
         self.month = month
     def __str__(self):
         return "bad month number %r; must be 1-12" % self.month

 class IllegalWeekdayError(ValueError):
     def __init__(self, weekday):
         self.weekday = weekday
     def __str__(self):
         return "bad weekday number %r; must be 0 (Monday) to 6 (Sunday)" % self.weekday

 # Constants for months referenced later
 January = 1
 February = 2

 # Number of days per month (except for February in leap years)
 mdays = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

 # This module used to have hard-coded lists of day and month names, as
 # English strings.  The classes following emulate a read-only version of
 # that, but supply localized names.  Note that the values are computed
 # fresh on each call, in case the user changes locale between calls.

 class _localized_month:

     _months = [datetime.date(2001, i+1, 1).strftime for i in range(12)]
     _months.insert(0, lambda x: "")

     def __init__(self, format):
         self.format = format

     def __getitem__(self, i):
         funcs = self._months[i]
         if isinstance(i, slice):
             return [f(self.format) for f in funcs]
         else:
             return funcs(self.format)

     def __len__(self):
         return 13

 class _localized_day:

     # January 1, 2001, was a Monday.
     _days = [datetime.date(2001, 1, i+1).strftime for i in range(7)]

     def __init__(self, format):
         self.format = format

     def __getitem__(self, i):
         funcs = self._days[i]
         if isinstance(i, slice):
             return [f(self.format) for f in funcs]
         else:
             return funcs(self.format)

     def __len__(self):
         return 7

 # Full and abbreviated names of weekdays
 day_name = _localized_day('%A')
 day_abbr = _localized_day('%a')

 # Full and abbreviated names of months (1-based arrays!!!)
 month_name = _localized_month('%B')
 month_abbr = _localized_month('%b')

 # Constants for weekdays
 (MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY) = range(7)

 def isleap(year):
     """Return True for leap years, False for non-leap years."""
     return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)

 def leapdays(y1, y2):
     """Return number of leap years in range [y1, y2).
        Assume y1 <= y2."""
     y1 -= 1
     y2 -= 1
     return (y2//4 - y1//4) - (y2//100 - y1//100) + (y2//400 - y1//400)

 def weekday(year, month, day):
     """Return weekday (0-6 ~ Mon-Sun) for year (1970-...), month (1-12),
        day (1-31)."""
     return datetime.date(year, month, day).weekday()

 def monthrange(year, month):
     """Return weekday (0-6 ~ Mon-Sun) and number of days (28-31) for
        year, month."""
     if not 1 <= month <= 12:
         raise IllegalMonthError(month)
     day1 = weekday(year, month, 1)
     ndays = mdays[month] + (month == February and isleap(year))
     return day1, ndays

 class Calendar(object):
     """
     Base calendar class. This class doesn't do any formatting. It simply
     provides data to subclasses.
     """

     def __init__(self, firstweekday=0):
         self.firstweekday = firstweekday # 0 = Monday, 6 = Sunday

     def getfirstweekday(self):
         return self._firstweekday % 7

     def setfirstweekday(self, firstweekday):
         self._firstweekday = firstweekday

     firstweekday = property(getfirstweekday, setfirstweekday)

     def iterweekdays(self):
         """
         Return a iterator for one week of weekday numbers starting with the
         configured first one.
         """
         for i in range(self.firstweekday, self.firstweekday + 7):
             yield i%7

     def itermonthdates(self, year, month):
         """
         Return an iterator for one month. The iterator will yield datetime.date
         values and will always iterate through complete weeks, so it will yield
         dates outside the specified month.
         """
         date = datetime.date(year, month, 1)
         # Go back to the beginning of the week
         days = (date.weekday() - self.firstweekday) % 7
         date -= datetime.timedelta(days=days)
         oneday = datetime.timedelta(days=1)
         while True:
             yield date
             try:
                 date += oneday
             except OverflowError:
                 # Adding one day could fail after datetime.MAXYEAR
                 break
             if date.month != month and date.weekday() == self.firstweekday:
                 break

     def itermonthdays2(self, year, month):
         """
         Like itermonthdates(), but will yield (day number, weekday number)
         tuples. For days outside the specified month the day number is 0.
         """
         for date in self.itermonthdates(year, month):
             if date.month != month:
                 yield (0, date.weekday())
             else:
                 yield (date.day, date.weekday())

     def itermonthdays(self, year, month):
         """
         Like itermonthdates(), but will yield day numbers. For days outside
         the specified month the day number is 0.
         """
         for date in self.itermonthdates(year, month):
             if date.month != month:
                 yield 0
             else:
                 yield date.day

     def monthdatescalendar(self, year, month):
         """
         Return a matrix (list of lists) representing a month's calendar.
         Each row represents a week; week entries are datetime.date values.
         """
         dates = list(self.itermonthdates(year, month))
         return [ dates[i:i+7] for i in range(0, len(dates), 7) ]

     def monthdays2calendar(self, year, month):
         """
         Return a matrix representing a month's calendar.
         Each row represents a week; week entries are
         (day number, weekday number) tuples. Day numbers outside this month
         are zero.
         """
         days = list(self.itermonthdays2(year, month))
         return [ days[i:i+7] for i in range(0, len(days), 7) ]

     def monthdayscalendar(self, year, month):
         """
         Return a matrix representing a month's calendar.
         Each row represents a week; days outside this month are zero.
         """
         days = list(self.itermonthdays(year, month))
         return [ days[i:i+7] for i in range(0, len(days), 7) ]

     def yeardatescalendar(self, year, width=3):
         """
         Return the data for the specified year ready for formatting. The return
         value is a list of month rows. Each month row contains upto width months.
         Each month contains between 4 and 6 weeks and each week contains 1-7
         days. Days are datetime.date objects.
         """
         months = [
             self.monthdatescalendar(year, i)
             for i in range(January, January+12)
         ]
         return [months[i:i+width] for i in range(0, len(months), width) ]

     def yeardays2calendar(self, year, width=3):
         """
         Return the data for the specified year ready for formatting (similar to
         yeardatescalendar()). Entries in the week lists are
         (day number, weekday number) tuples. Day numbers outside this month are
         zero.
         """
         months = [
             self.monthdays2calendar(year, i)
             for i in range(January, January+12)
         ]
         return [months[i:i+width] for i in range(0, len(months), width) ]

     def yeardayscalendar(self, year, width=3):
         """
         Return the data for the specified year ready for formatting (similar to
         yeardatescalendar()). Entries in the week lists are day numbers.
         Day numbers outside this month are zero.
         """
         months = [
             self.monthdayscalendar(year, i)
             for i in range(January, January+12)
         ]
         return [months[i:i+width] for i in range(0, len(months), width) ]

 class TextCalendar(Calendar):
     """
     Subclass of Calendar that outputs a calendar as a simple plain text
     similar to the UNIX program cal.
     """

     def prweek(self, theweek, width):
         """
         Print a single week (no newline).
         """
         print(self.formatweek(theweek, width), end=' ')

     def formatday(self, day, weekday, width):
         """
         Returns a formatted day.
         """
         if day == 0:
             s = ''
         else:
             s = '%2i' % day             # right-align single-digit days
         return s.center(width)

     def formatweek(self, theweek, width):
         """
         Returns a single week in a string (no newline).
         """
         return ' '.join(self.formatday(d, wd, width) for (d, wd) in theweek)

     def formatweekday(self, day, width):
         """
         Returns a formatted week day name.
         """
         if width >= 9:
             names = day_name
         else:
             names = day_abbr
         return names[day][:width].center(width)

     def formatweekheader(self, width):
         """
         Return a header for a week.
         """
         return ' '.join(self.formatweekday(i, width) for i in self.iterweekdays())

     def formatmonthname(self, theyear, themonth, width, withyear=True):
         """
         Return a formatted month name.
         """
         s = month_name[themonth]
         if withyear:
             s = "%s %r" % (s, theyear)
         return s.center(width)

     def prmonth(self, theyear, themonth, w=0, l=0):
         """
         Print a month's calendar.
         """
         print(self.formatmonth(theyear, themonth, w, l), end=' ')

     def formatmonth(self, theyear, themonth, w=0, l=0):
         """
         Return a month's calendar string (multi-line).
         """
         w = max(2, w)
         l = max(1, l)
         s = self.formatmonthname(theyear, themonth, 7 * (w + 1) - 1)
         s = s.rstrip()
         s += '\n' * l
         s += self.formatweekheader(w).rstrip()
         s += '\n' * l
         for week in self.monthdays2calendar(theyear, themonth):
             s += self.formatweek(week, w).rstrip()
             s += '\n' * l
         return s

     def formatyear(self, theyear, w=2, l=1, c=6, m=3):
         """
         Returns a year's calendar as a multi-line string.
         """
         w = max(2, w)
         l = max(1, l)
         c = max(2, c)
         colwidth = (w + 1) * 7 - 1
         v = []
         a = v.append
         a(repr(theyear).center(colwidth*m+c*(m-1)).rstrip())
         a('\n'*l)
         header = self.formatweekheader(w)
         for (i, row) in enumerate(self.yeardays2calendar(theyear, m)):
             # months in this row
             months = range(m*i+1, min(m*(i+1)+1, 13))
             a('\n'*l)
             names = (self.formatmonthname(theyear, k, colwidth, False)
                      for k in months)
             a(formatstring(names, colwidth, c).rstrip())
             a('\n'*l)
             headers = (header for k in months)
             a(formatstring(headers, colwidth, c).rstrip())
             a('\n'*l)
             # max number of weeks for this row
             height = max(len(cal) for cal in row)
             for j in range(height):
                 weeks = []
                 for cal in row:
                     if j >= len(cal):
                         weeks.append('')
                     else:
                         weeks.append(self.formatweek(cal[j], w))
                 a(formatstring(weeks, colwidth, c).rstrip())
                 a('\n' * l)
         return ''.join(v)

     def pryear(self, theyear, w=0, l=0, c=6, m=3):
         """Print a year's calendar."""
         print(self.formatyear(theyear, w, l, c, m))

 class HTMLCalendar(Calendar):
     """
     This calendar returns complete HTML pages.
     """

     # CSS classes for the day <td>s
     cssclasses = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"]

     def formatday(self, day, weekday):
         """
         Return a day as a table cell.
         """
         if day == 0:
             return '<td class="noday">&nbsp;</td>' # day outside month
         else:
             return '<td class="%s">%d</td>' % (self.cssclasses[weekday], day)

     def formatweek(self, theweek):
         """
         Return a complete week as a table row.
         """
         s = ''.join(self.formatday(d, wd) for (d, wd) in theweek)
         return '<tr>%s</tr>' % s

     def formatweekday(self, day):
         """
         Return a weekday name as a table header.
         """
         return '<th class="%s">%s</th>' % (self.cssclasses[day], day_abbr[day])

     def formatweekheader(self):
         """
         Return a header for a week as a table row.
         """
         s = ''.join(self.formatweekday(i) for i in self.iterweekdays())
         return '<tr>%s</tr>' % s

     def formatmonthname(self, theyear, themonth, withyear=True):
         """
         Return a month name as a table row.
         """
         if withyear:
             s = '%s %s' % (month_name[themonth], theyear)
         else:
             s = '%s' % month_name[themonth]
         return '<tr><th colspan="7" class="month">%s</th></tr>' % s

     def formatmonth(self, theyear, themonth, withyear=True):
         """
         Return a formatted month as a table.
         """
         v = []
         a = v.append
         a('<table border="0" cellpadding="0" cellspacing="0" class="month">')
         a('\n')
         a(self.formatmonthname(theyear, themonth, withyear=withyear))
         a('\n')
         a(self.formatweekheader())
         a('\n')
         for week in self.monthdays2calendar(theyear, themonth):
             a(self.formatweek(week))
             a('\n')
         a('</table>')
         a('\n')
         return ''.join(v)

     def formatyear(self, theyear, width=3):
         """
         Return a formatted year as a table of tables.
         """
         v = []
         a = v.append
         width = max(width, 1)
         a('<table border="0" cellpadding="0" cellspacing="0" class="year">')
         a('\n')
         a('<tr><th colspan="%d" class="year">%s</th></tr>' % (width, theyear))
         for i in range(January, January+12, width):
             # months in this row
             months = range(i, min(i+width, 13))
             a('<tr>')
             for m in months:
                 a('<td>')
                 a(self.formatmonth(theyear, m, withyear=False))
                 a('</td>')
             a('</tr>')
         a('</table>')
         return ''.join(v)

     def formatyearpage(self, theyear, width=3, css='calendar.css', encoding=None):
         """
         Return a formatted year as a complete HTML page.
         """
         if encoding is None:
             encoding = sys.getdefaultencoding()
         v = []
         a = v.append
         a('<?xml version="1.0" encoding="%s"?>\n' % encoding)
         a('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">\n')
         a('<html>\n')
         a('<head>\n')
         a('<meta http-equiv="Content-Type" content="text/html; charset=%s" />\n' % encoding)
         if css is not None:
             a('<link rel="stylesheet" type="text/css" href="%s" />\n' % css)
         a('<title>Calendar for %d</title>\n' % theyear)
         a('</head>\n')
         a('<body>\n')
         a(self.formatyear(theyear, width))
         a('</body>\n')
         a('</html>\n')
         return ''.join(v).encode(encoding, "xmlcharrefreplace")

 class different_locale:
     def __init__(self, locale):
         self.locale = locale

     def __enter__(self):
         self.oldlocale = _locale.getlocale(_locale.LC_TIME)
         _locale.setlocale(_locale.LC_TIME, self.locale)

     def __exit__(self, *args):
         _locale.setlocale(_locale.LC_TIME, self.oldlocale)

 class LocaleTextCalendar(TextCalendar):
     """
     This class can be passed a locale name in the constructor and will return
     month and weekday names in the specified locale. If this locale includes
     an encoding all strings containing month and weekday names will be returned
     as unicode.
     """

     def __init__(self, firstweekday=0, locale=None):
         TextCalendar.__init__(self, firstweekday)
         if locale is None:
             locale = _locale.getdefaultlocale()
         self.locale = locale

     def formatweekday(self, day, width):
         with different_locale(self.locale):
             if width >= 9:
                 names = day_name
             else:
                 names = day_abbr
             name = names[day]
             return name[:width].center(width)

     def formatmonthname(self, theyear, themonth, width, withyear=True):
         with different_locale(self.locale):
             s = month_name[themonth]
             if withyear:
                 s = "%s %r" % (s, theyear)
             return s.center(width)

 class LocaleHTMLCalendar(HTMLCalendar):
     """
     This class can be passed a locale name in the constructor and will return
     month and weekday names in the specified locale. If this locale includes
     an encoding all strings containing month and weekday names will be returned
     as unicode.
     """
     def __init__(self, firstweekday=0, locale=None):
         HTMLCalendar.__init__(self, firstweekday)
         if locale is None:
             locale = _locale.getdefaultlocale()
         self.locale = locale

     def formatweekday(self, day):
         with different_locale(self.locale):
             s = day_abbr[day]
             return '<th class="%s">%s</th>' % (self.cssclasses[day], s)

     def formatmonthname(self, theyear, themonth, withyear=True):
         with different_locale(self.locale):
             s = month_name[themonth]
             if withyear:
                 s = '%s %s' % (s, theyear)
             return '<tr><th colspan="7" class="month">%s</th></tr>' % s

 # Support for old module level interface
 c = TextCalendar()

 firstweekday = c.getfirstweekday

 def setfirstweekday(firstweekday):
     if not MONDAY <= firstweekday <= SUNDAY:
         raise IllegalWeekdayError(firstweekday)
     c.firstweekday = firstweekday

 monthcalendar = c.monthdayscalendar
 prweek = c.prweek
 week = c.formatweek
 weekheader = c.formatweekheader
 prmonth = c.prmonth
 month = c.formatmonth
 calendar = c.formatyear
 prcal = c.pryear

 # Spacing of month columns for multi-column year calendar
 _colwidth = 7*3 - 1         # Amount printed by prweek()
 _spacing = 6                # Number of spaces between columns

 def format(cols, colwidth=_colwidth, spacing=_spacing):
     """Prints multi-column formatting for year calendars"""
     print(formatstring(cols, colwidth, spacing))

 def formatstring(cols, colwidth=_colwidth, spacing=_spacing):
     """Returns a string formatted from n strings, centered within n columns."""
     spacing *= ' '
     return spacing.join(c.center(colwidth) for c in cols)

 EPOCH = 1970
 _EPOCH_ORD = datetime.date(EPOCH, 1, 1).toordinal()

 def timegm(tuple):
     """Unrelated but handy function to calculate Unix timestamp from GMT."""
     year, month, day, hour, minute, second = tuple[:6]
     days = datetime.date(year, month, 1).toordinal() - _EPOCH_ORD + day - 1
     hours = days*24 + hour
     minutes = hours*60 + minute
     seconds = minutes*60 + second
     return seconds

 def main(args):
     import optparse
     parser = optparse.OptionParser(usage="usage: %prog [options] [year [month]]")
     parser.add_option(
         "-w", "--width",
         dest="width", type="int", default=2,
         help="width of date column (default 2, text only)"
     )
     parser.add_option(
         "-l", "--lines",
         dest="lines", type="int", default=1,
         help="number of lines for each week (default 1, text only)"
     )
     parser.add_option(
         "-s", "--spacing",
         dest="spacing", type="int", default=6,
         help="spacing between months (default 6, text only)"
     )
     parser.add_option(
         "-m", "--months",
         dest="months", type="int", default=3,
         help="months per row (default 3, text only)"
     )
     parser.add_option(
         "-c", "--css",
         dest="css", default="calendar.css",
         help="CSS to use for page (html only)"
     )
     parser.add_option(
         "-L", "--locale",
         dest="locale", default=None,
         help="locale to be used from month and weekday names"
     )
     parser.add_option(
         "-e", "--encoding",
         dest="encoding", default=None,
         help="Encoding to use for output."
     )
     parser.add_option(
         "-t", "--type",
         dest="type", default="text",
         choices=("text", "html"),
         help="output type (text or html)"
     )

     (options, args) = parser.parse_args(args)

     if options.locale and not options.encoding:
         parser.error("if --locale is specified --encoding is required")
         sys.exit(1)

     locale = options.locale, options.encoding

     if options.type == "html":
         if options.locale:
             cal = LocaleHTMLCalendar(locale=locale)
         else:
             cal = HTMLCalendar()
         encoding = options.encoding
         if encoding is None:
             encoding = sys.getdefaultencoding()
         optdict = dict(encoding=encoding, css=options.css)
         write = sys.stdout.buffer.write
         if len(args) == 1:
             write(cal.formatyearpage(datetime.date.today().year, **optdict))
         elif len(args) == 2:
             write(cal.formatyearpage(int(args[1]), **optdict))
         else:
             parser.error("incorrect number of arguments")
             sys.exit(1)
     else:
         if options.locale:
             cal = LocaleTextCalendar(locale=locale)
         else:
             cal = TextCalendar()
         optdict = dict(w=options.width, l=options.lines)
         if len(args) != 3:
             optdict["c"] = options.spacing
             optdict["m"] = options.months
         if len(args) == 1:
             result = cal.formatyear(datetime.date.today().year, **optdict)
         elif len(args) == 2:
             result = cal.formatyear(int(args[1]), **optdict)
         elif len(args) == 3:
             result = cal.formatmonth(int(args[1]), int(args[2]), **optdict)
         else:
             parser.error("incorrect number of arguments")
             sys.exit(1)
         write = sys.stdout.write
         if options.encoding:
             result = result.encode(options.encoding)
             write = sys.stdout.buffer.write
         write(result)

 if __name__ == "__main__":
     main(sys.argv)