精华内容
下载资源
问答
  • 不了解这个模块,没有关系,直接告诉大家经常会和time模块做比较,要不然就是结合在一起出现...calendar模块是什么?大家白话理解为:日历模板吧,日历周边内容,基本上都是靠这个模块。模块实例代码演示:import...

    不了解这个模块,没有关系,直接告诉大家经常会和time模块做比较,要不然就是结合在一起出现使用,那么大家应该有了一定的认知,之前其实都跟这模块有着一面之缘,比如我们所说过的制作日历那个章节,就导入这个模块使用,如果被小伙伴们遗忘了,也不必懊恼。接下来的内容就是给大家回忆时刻。

    calendar模块是什么?

    大家白话理解为:日历模板吧,日历周边内容,基本上都是靠这个模块的。

    模块实例代码演示:import calendar

    from tkinter import *

    root = Tk()

    labels = [['Mon','Tue','Wed','Thu','Fri','Sat','Sun']]

    MonthCal = calendar.monthcalendar(2020, 5)

    for i in range(len(MonthCal)):

    labels.append(MonthCal[i])

    for r in range(len(MonthCal)+1):

    for c in range(7):

    if labels[r][c] == 0:

    labels[r][c] = ' '

    label = Label(root,

    padx=5,

    pady=5,

    text=str(labels[r][c]))

    label.grid(row=r,column=c)

    root.mainloop()

    最终效果展示:

    这个功能模块的使用,需要非常简单,啥功能都没有,就是来了个模块给我们展示这个是日历界面模板,如果在搭配着其他内容使用,就能够相当成熟了,看吧,python内容其实就是这么简单。

    展开全文
  • calendar中的函数 import calendar #获取指定年份的日历字符串 calendar.calendar(1993) ''' return-> 1993 January February March Mo Tu We

    calendar中的函数

    import calendar
    
    #获取指定年份的日历字符串
    calendar.calendar(1993)
    '''
    return->
                                      1993
    
          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       1  2  3  4  5  6  7       1  2  3  4  5  6  7
     4  5  6  7  8  9 10       8  9 10 11 12 13 14       8  9 10 11 12 13 14
    11 12 13 14 15 16 17      15 16 17 18 19 20 21      15 16 17 18 19 20 21
    18 19 20 21 22 23 24      22 23 24 25 26 27 28      22 23 24 25 26 27 28
    25 26 27 28 29 30 31                                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                      1  2          1  2  3  4  5  6
     5  6  7  8  9 10 11       3  4  5  6  7  8  9       7  8  9 10 11 12 13
    12 13 14 15 16 17 18      10 11 12 13 14 15 16      14 15 16 17 18 19 20
    19 20 21 22 23 24 25      17 18 19 20 21 22 23      21 22 23 24 25 26 27
    26 27 28 29 30            24 25 26 27 28 29 30      28 29 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  4                         1             1  2  3  4  5
     5  6  7  8  9 10 11       2  3  4  5  6  7  8       6  7  8  9 10 11 12
    12 13 14 15 16 17 18       9 10 11 12 13 14 15      13 14 15 16 17 18 19
    19 20 21 22 23 24 25      16 17 18 19 20 21 22      20 21 22 23 24 25 26
    26 27 28 29 30 31         23 24 25 26 27 28 29      27 28 29 30
                              30 31
    
          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       1  2  3  4  5  6  7             1  2  3  4  5
     4  5  6  7  8  9 10       8  9 10 11 12 13 14       6  7  8  9 10 11 12
    11 12 13 14 15 16 17      15 16 17 18 19 20 21      13 14 15 16 17 18 19
    18 19 20 21 22 23 24      22 23 24 25 26 27 28      20 21 22 23 24 25 26
    25 26 27 28 29 30 31      29 30                     27 28 29 30 31
    '''
    
    
    #获取指定年月的日历字符串
    calendar.month(2008,1)
    '''
    return->
        January 2008
    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
    '''
    
    
    #获取指定年月的矩阵列表
    calendar.monthcalendar(2008,8)
    '''
    return->
    [
        [0, 0, 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, 0, 0, 0, 0, 0]
    ]
    结果中0表示不是该月的数值,1-31才是当月信息
    '''
    
    
    #检测是否是润年
    calendar.isleap(2008)
    '''
    return->
    True
    '''
    
    
    #检测指定时间段内润年的个数
    calendar.leapdays(2008,2018)
    '''
    return->
    3
    '''
    
    
    #获取指定月份的信息
    calendar.monthrange(1998,5)
    '''
    return->
    (4,31)
    (周几,天数)
    注意:0-6表示周一到周天
    '''
    
    
    #根据指定的年月日,计算星期几
    calendar.weekday(2018,1,16)
    '''
    return->
    1
    '''
    
    
    #将时间元组转换成时间戳,以UTC时间为标准(时间元组->(年,月,日,时,分,秒,0,0,0))
    calendar.timegm((2018,1,16,1,1,1))
    '''
    return->
    1516064461
    '''


    展开全文
  • python开发_calendar

    2019-10-04 13:36:08
    如果你用过linux,你可能知道在linux下面的有一个强大的calendar功能,即日历 ... 1 #python中的calendar 2 3 import calendar 4 5 #返回指定年的某月 6 def get_month(year, month): 7 ...

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

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

    下面是我做的demo

     1 #python中的calendar
     2 
     3 import calendar
     4 
     5 #返回指定年的某月
     6 def get_month(year, month):
     7     return calendar.month(year, month)
     8 
     9 #返回指定年的日历
    10 def get_calendar(year):
    11     return calendar.calendar(year)
    12 
    13 #判断某一年是否为闰年,如果是,返回True,如果不是,则返回False
    14 def is_leap(year):
    15     return calendar.isleap(year)
    16 
    17 #返回某个月的weekday的第一天和这个月的所有天数
    18 def get_month_range(year, month):
    19     return calendar.monthrange(year, month)
    20 
    21 #返回某个月以每一周为元素的序列
    22 def get_month_calendar(year, month):
    23     return calendar.monthcalendar(year, month)
    24 
    25 def main():
    26     year = 2013
    27     month = 8
    28     test_month = get_month(year, month)
    29     print(test_month)
    30     print('#' * 50)
    31     #print(get_calendar(year))
    32     print('{0}这一年是否为闰年?:{1}'.format(year, is_leap(year)))
    33     print(get_month_range(year, month))
    34     print(get_month_calendar(year, month))
    35     
    36 if __name__ == '__main__':
    37     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的源码:

      1 """Calendar printing functions
      2 
      3 Note when comparing these calendars to the ones printed by cal(1): By
      4 default, these calendars have Monday as the first day of the week, and
      5 Sunday as the last (the European convention). Use setfirstweekday() to
      6 set the first day of the week (0=Monday, 6=Sunday)."""
      7 
      8 import sys
      9 import datetime
     10 import locale as _locale
     11 
     12 __all__ = ["IllegalMonthError", "IllegalWeekdayError", "setfirstweekday",
     13            "firstweekday", "isleap", "leapdays", "weekday", "monthrange",
     14            "monthcalendar", "prmonth", "month", "prcal", "calendar",
     15            "timegm", "month_name", "month_abbr", "day_name", "day_abbr"]
     16 
     17 # Exception raised for bad input (with string parameter for details)
     18 error = ValueError
     19 
     20 # Exceptions raised for bad input
     21 class IllegalMonthError(ValueError):
     22     def __init__(self, month):
     23         self.month = month
     24     def __str__(self):
     25         return "bad month number %r; must be 1-12" % self.month
     26 
     27 
     28 class IllegalWeekdayError(ValueError):
     29     def __init__(self, weekday):
     30         self.weekday = weekday
     31     def __str__(self):
     32         return "bad weekday number %r; must be 0 (Monday) to 6 (Sunday)" % self.weekday
     33 
     34 
     35 # Constants for months referenced later
     36 January = 1
     37 February = 2
     38 
     39 # Number of days per month (except for February in leap years)
     40 mdays = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
     41 
     42 # This module used to have hard-coded lists of day and month names, as
     43 # English strings.  The classes following emulate a read-only version of
     44 # that, but supply localized names.  Note that the values are computed
     45 # fresh on each call, in case the user changes locale between calls.
     46 
     47 class _localized_month:
     48 
     49     _months = [datetime.date(2001, i+1, 1).strftime for i in range(12)]
     50     _months.insert(0, lambda x: "")
     51 
     52     def __init__(self, format):
     53         self.format = format
     54 
     55     def __getitem__(self, i):
     56         funcs = self._months[i]
     57         if isinstance(i, slice):
     58             return [f(self.format) for f in funcs]
     59         else:
     60             return funcs(self.format)
     61 
     62     def __len__(self):
     63         return 13
     64 
     65 
     66 class _localized_day:
     67 
     68     # January 1, 2001, was a Monday.
     69     _days = [datetime.date(2001, 1, i+1).strftime for i in range(7)]
     70 
     71     def __init__(self, format):
     72         self.format = format
     73 
     74     def __getitem__(self, i):
     75         funcs = self._days[i]
     76         if isinstance(i, slice):
     77             return [f(self.format) for f in funcs]
     78         else:
     79             return funcs(self.format)
     80 
     81     def __len__(self):
     82         return 7
     83 
     84 
     85 # Full and abbreviated names of weekdays
     86 day_name = _localized_day('%A')
     87 day_abbr = _localized_day('%a')
     88 
     89 # Full and abbreviated names of months (1-based arrays!!!)
     90 month_name = _localized_month('%B')
     91 month_abbr = _localized_month('%b')
     92 
     93 # Constants for weekdays
     94 (MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY) = range(7)
     95 
     96 
     97 def isleap(year):
     98     """Return True for leap years, False for non-leap years."""
     99     return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
    100 
    101 
    102 def leapdays(y1, y2):
    103     """Return number of leap years in range [y1, y2).
    104        Assume y1 <= y2."""
    105     y1 -= 1
    106     y2 -= 1
    107     return (y2//4 - y1//4) - (y2//100 - y1//100) + (y2//400 - y1//400)
    108 
    109 
    110 def weekday(year, month, day):
    111     """Return weekday (0-6 ~ Mon-Sun) for year (1970-...), month (1-12),
    112        day (1-31)."""
    113     return datetime.date(year, month, day).weekday()
    114 
    115 
    116 def monthrange(year, month):
    117     """Return weekday (0-6 ~ Mon-Sun) and number of days (28-31) for
    118        year, month."""
    119     if not 1 <= month <= 12:
    120         raise IllegalMonthError(month)
    121     day1 = weekday(year, month, 1)
    122     ndays = mdays[month] + (month == February and isleap(year))
    123     return day1, ndays
    124 
    125 
    126 class Calendar(object):
    127     """
    128     Base calendar class. This class doesn't do any formatting. It simply
    129     provides data to subclasses.
    130     """
    131 
    132     def __init__(self, firstweekday=0):
    133         self.firstweekday = firstweekday # 0 = Monday, 6 = Sunday
    134 
    135     def getfirstweekday(self):
    136         return self._firstweekday % 7
    137 
    138     def setfirstweekday(self, firstweekday):
    139         self._firstweekday = firstweekday
    140 
    141     firstweekday = property(getfirstweekday, setfirstweekday)
    142 
    143     def iterweekdays(self):
    144         """
    145         Return a iterator for one week of weekday numbers starting with the
    146         configured first one.
    147         """
    148         for i in range(self.firstweekday, self.firstweekday + 7):
    149             yield i%7
    150 
    151     def itermonthdates(self, year, month):
    152         """
    153         Return an iterator for one month. The iterator will yield datetime.date
    154         values and will always iterate through complete weeks, so it will yield
    155         dates outside the specified month.
    156         """
    157         date = datetime.date(year, month, 1)
    158         # Go back to the beginning of the week
    159         days = (date.weekday() - self.firstweekday) % 7
    160         date -= datetime.timedelta(days=days)
    161         oneday = datetime.timedelta(days=1)
    162         while True:
    163             yield date
    164             try:
    165                 date += oneday
    166             except OverflowError:
    167                 # Adding one day could fail after datetime.MAXYEAR
    168                 break
    169             if date.month != month and date.weekday() == self.firstweekday:
    170                 break
    171 
    172     def itermonthdays2(self, year, month):
    173         """
    174         Like itermonthdates(), but will yield (day number, weekday number)
    175         tuples. For days outside the specified month the day number is 0.
    176         """
    177         for date in self.itermonthdates(year, month):
    178             if date.month != month:
    179                 yield (0, date.weekday())
    180             else:
    181                 yield (date.day, date.weekday())
    182 
    183     def itermonthdays(self, year, month):
    184         """
    185         Like itermonthdates(), but will yield day numbers. For days outside
    186         the specified month the day number is 0.
    187         """
    188         for date in self.itermonthdates(year, month):
    189             if date.month != month:
    190                 yield 0
    191             else:
    192                 yield date.day
    193 
    194     def monthdatescalendar(self, year, month):
    195         """
    196         Return a matrix (list of lists) representing a month's calendar.
    197         Each row represents a week; week entries are datetime.date values.
    198         """
    199         dates = list(self.itermonthdates(year, month))
    200         return [ dates[i:i+7] for i in range(0, len(dates), 7) ]
    201 
    202     def monthdays2calendar(self, year, month):
    203         """
    204         Return a matrix representing a month's calendar.
    205         Each row represents a week; week entries are
    206         (day number, weekday number) tuples. Day numbers outside this month
    207         are zero.
    208         """
    209         days = list(self.itermonthdays2(year, month))
    210         return [ days[i:i+7] for i in range(0, len(days), 7) ]
    211 
    212     def monthdayscalendar(self, year, month):
    213         """
    214         Return a matrix representing a month's calendar.
    215         Each row represents a week; days outside this month are zero.
    216         """
    217         days = list(self.itermonthdays(year, month))
    218         return [ days[i:i+7] for i in range(0, len(days), 7) ]
    219 
    220     def yeardatescalendar(self, year, width=3):
    221         """
    222         Return the data for the specified year ready for formatting. The return
    223         value is a list of month rows. Each month row contains upto width months.
    224         Each month contains between 4 and 6 weeks and each week contains 1-7
    225         days. Days are datetime.date objects.
    226         """
    227         months = [
    228             self.monthdatescalendar(year, i)
    229             for i in range(January, January+12)
    230         ]
    231         return [months[i:i+width] for i in range(0, len(months), width) ]
    232 
    233     def yeardays2calendar(self, year, width=3):
    234         """
    235         Return the data for the specified year ready for formatting (similar to
    236         yeardatescalendar()). Entries in the week lists are
    237         (day number, weekday number) tuples. Day numbers outside this month are
    238         zero.
    239         """
    240         months = [
    241             self.monthdays2calendar(year, i)
    242             for i in range(January, January+12)
    243         ]
    244         return [months[i:i+width] for i in range(0, len(months), width) ]
    245 
    246     def yeardayscalendar(self, year, width=3):
    247         """
    248         Return the data for the specified year ready for formatting (similar to
    249         yeardatescalendar()). Entries in the week lists are day numbers.
    250         Day numbers outside this month are zero.
    251         """
    252         months = [
    253             self.monthdayscalendar(year, i)
    254             for i in range(January, January+12)
    255         ]
    256         return [months[i:i+width] for i in range(0, len(months), width) ]
    257 
    258 
    259 class TextCalendar(Calendar):
    260     """
    261     Subclass of Calendar that outputs a calendar as a simple plain text
    262     similar to the UNIX program cal.
    263     """
    264 
    265     def prweek(self, theweek, width):
    266         """
    267         Print a single week (no newline).
    268         """
    269         print(self.formatweek(theweek, width), end=' ')
    270 
    271     def formatday(self, day, weekday, width):
    272         """
    273         Returns a formatted day.
    274         """
    275         if day == 0:
    276             s = ''
    277         else:
    278             s = '%2i' % day             # right-align single-digit days
    279         return s.center(width)
    280 
    281     def formatweek(self, theweek, width):
    282         """
    283         Returns a single week in a string (no newline).
    284         """
    285         return ' '.join(self.formatday(d, wd, width) for (d, wd) in theweek)
    286 
    287     def formatweekday(self, day, width):
    288         """
    289         Returns a formatted week day name.
    290         """
    291         if width >= 9:
    292             names = day_name
    293         else:
    294             names = day_abbr
    295         return names[day][:width].center(width)
    296 
    297     def formatweekheader(self, width):
    298         """
    299         Return a header for a week.
    300         """
    301         return ' '.join(self.formatweekday(i, width) for i in self.iterweekdays())
    302 
    303     def formatmonthname(self, theyear, themonth, width, withyear=True):
    304         """
    305         Return a formatted month name.
    306         """
    307         s = month_name[themonth]
    308         if withyear:
    309             s = "%s %r" % (s, theyear)
    310         return s.center(width)
    311 
    312     def prmonth(self, theyear, themonth, w=0, l=0):
    313         """
    314         Print a month's calendar.
    315         """
    316         print(self.formatmonth(theyear, themonth, w, l), end=' ')
    317 
    318     def formatmonth(self, theyear, themonth, w=0, l=0):
    319         """
    320         Return a month's calendar string (multi-line).
    321         """
    322         w = max(2, w)
    323         l = max(1, l)
    324         s = self.formatmonthname(theyear, themonth, 7 * (w + 1) - 1)
    325         s = s.rstrip()
    326         s += '\n' * l
    327         s += self.formatweekheader(w).rstrip()
    328         s += '\n' * l
    329         for week in self.monthdays2calendar(theyear, themonth):
    330             s += self.formatweek(week, w).rstrip()
    331             s += '\n' * l
    332         return s
    333 
    334     def formatyear(self, theyear, w=2, l=1, c=6, m=3):
    335         """
    336         Returns a year's calendar as a multi-line string.
    337         """
    338         w = max(2, w)
    339         l = max(1, l)
    340         c = max(2, c)
    341         colwidth = (w + 1) * 7 - 1
    342         v = []
    343         a = v.append
    344         a(repr(theyear).center(colwidth*m+c*(m-1)).rstrip())
    345         a('\n'*l)
    346         header = self.formatweekheader(w)
    347         for (i, row) in enumerate(self.yeardays2calendar(theyear, m)):
    348             # months in this row
    349             months = range(m*i+1, min(m*(i+1)+1, 13))
    350             a('\n'*l)
    351             names = (self.formatmonthname(theyear, k, colwidth, False)
    352                      for k in months)
    353             a(formatstring(names, colwidth, c).rstrip())
    354             a('\n'*l)
    355             headers = (header for k in months)
    356             a(formatstring(headers, colwidth, c).rstrip())
    357             a('\n'*l)
    358             # max number of weeks for this row
    359             height = max(len(cal) for cal in row)
    360             for j in range(height):
    361                 weeks = []
    362                 for cal in row:
    363                     if j >= len(cal):
    364                         weeks.append('')
    365                     else:
    366                         weeks.append(self.formatweek(cal[j], w))
    367                 a(formatstring(weeks, colwidth, c).rstrip())
    368                 a('\n' * l)
    369         return ''.join(v)
    370 
    371     def pryear(self, theyear, w=0, l=0, c=6, m=3):
    372         """Print a year's calendar."""
    373         print(self.formatyear(theyear, w, l, c, m))
    374 
    375 
    376 class HTMLCalendar(Calendar):
    377     """
    378     This calendar returns complete HTML pages.
    379     """
    380 
    381     # CSS classes for the day <td>s
    382     cssclasses = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"]
    383 
    384     def formatday(self, day, weekday):
    385         """
    386         Return a day as a table cell.
    387         """
    388         if day == 0:
    389             return '<td class="noday">&nbsp;</td>' # day outside month
    390         else:
    391             return '<td class="%s">%d</td>' % (self.cssclasses[weekday], day)
    392 
    393     def formatweek(self, theweek):
    394         """
    395         Return a complete week as a table row.
    396         """
    397         s = ''.join(self.formatday(d, wd) for (d, wd) in theweek)
    398         return '<tr>%s</tr>' % s
    399 
    400     def formatweekday(self, day):
    401         """
    402         Return a weekday name as a table header.
    403         """
    404         return '<th class="%s">%s</th>' % (self.cssclasses[day], day_abbr[day])
    405 
    406     def formatweekheader(self):
    407         """
    408         Return a header for a week as a table row.
    409         """
    410         s = ''.join(self.formatweekday(i) for i in self.iterweekdays())
    411         return '<tr>%s</tr>' % s
    412 
    413     def formatmonthname(self, theyear, themonth, withyear=True):
    414         """
    415         Return a month name as a table row.
    416         """
    417         if withyear:
    418             s = '%s %s' % (month_name[themonth], theyear)
    419         else:
    420             s = '%s' % month_name[themonth]
    421         return '<tr><th colspan="7" class="month">%s</th></tr>' % s
    422 
    423     def formatmonth(self, theyear, themonth, withyear=True):
    424         """
    425         Return a formatted month as a table.
    426         """
    427         v = []
    428         a = v.append
    429         a('<table border="0" cellpadding="0" cellspacing="0" class="month">')
    430         a('\n')
    431         a(self.formatmonthname(theyear, themonth, withyear=withyear))
    432         a('\n')
    433         a(self.formatweekheader())
    434         a('\n')
    435         for week in self.monthdays2calendar(theyear, themonth):
    436             a(self.formatweek(week))
    437             a('\n')
    438         a('</table>')
    439         a('\n')
    440         return ''.join(v)
    441 
    442     def formatyear(self, theyear, width=3):
    443         """
    444         Return a formatted year as a table of tables.
    445         """
    446         v = []
    447         a = v.append
    448         width = max(width, 1)
    449         a('<table border="0" cellpadding="0" cellspacing="0" class="year">')
    450         a('\n')
    451         a('<tr><th colspan="%d" class="year">%s</th></tr>' % (width, theyear))
    452         for i in range(January, January+12, width):
    453             # months in this row
    454             months = range(i, min(i+width, 13))
    455             a('<tr>')
    456             for m in months:
    457                 a('<td>')
    458                 a(self.formatmonth(theyear, m, withyear=False))
    459                 a('</td>')
    460             a('</tr>')
    461         a('</table>')
    462         return ''.join(v)
    463 
    464     def formatyearpage(self, theyear, width=3, css='calendar.css', encoding=None):
    465         """
    466         Return a formatted year as a complete HTML page.
    467         """
    468         if encoding is None:
    469             encoding = sys.getdefaultencoding()
    470         v = []
    471         a = v.append
    472         a('<?xml version="1.0" encoding="%s"?>\n' % encoding)
    473         a('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">\n')
    474         a('<html>\n')
    475         a('<head>\n')
    476         a('<meta http-equiv="Content-Type" content="text/html; charset=%s" />\n' % encoding)
    477         if css is not None:
    478             a('<link rel="stylesheet" type="text/css" href="%s" />\n' % css)
    479         a('<title>Calendar for %d</title>\n' % theyear)
    480         a('</head>\n')
    481         a('<body>\n')
    482         a(self.formatyear(theyear, width))
    483         a('</body>\n')
    484         a('</html>\n')
    485         return ''.join(v).encode(encoding, "xmlcharrefreplace")
    486 
    487 
    488 class different_locale:
    489     def __init__(self, locale):
    490         self.locale = locale
    491 
    492     def __enter__(self):
    493         self.oldlocale = _locale.getlocale(_locale.LC_TIME)
    494         _locale.setlocale(_locale.LC_TIME, self.locale)
    495 
    496     def __exit__(self, *args):
    497         _locale.setlocale(_locale.LC_TIME, self.oldlocale)
    498 
    499 
    500 class LocaleTextCalendar(TextCalendar):
    501     """
    502     This class can be passed a locale name in the constructor and will return
    503     month and weekday names in the specified locale. If this locale includes
    504     an encoding all strings containing month and weekday names will be returned
    505     as unicode.
    506     """
    507 
    508     def __init__(self, firstweekday=0, locale=None):
    509         TextCalendar.__init__(self, firstweekday)
    510         if locale is None:
    511             locale = _locale.getdefaultlocale()
    512         self.locale = locale
    513 
    514     def formatweekday(self, day, width):
    515         with different_locale(self.locale):
    516             if width >= 9:
    517                 names = day_name
    518             else:
    519                 names = day_abbr
    520             name = names[day]
    521             return name[:width].center(width)
    522 
    523     def formatmonthname(self, theyear, themonth, width, withyear=True):
    524         with different_locale(self.locale):
    525             s = month_name[themonth]
    526             if withyear:
    527                 s = "%s %r" % (s, theyear)
    528             return s.center(width)
    529 
    530 
    531 class LocaleHTMLCalendar(HTMLCalendar):
    532     """
    533     This class can be passed a locale name in the constructor and will return
    534     month and weekday names in the specified locale. If this locale includes
    535     an encoding all strings containing month and weekday names will be returned
    536     as unicode.
    537     """
    538     def __init__(self, firstweekday=0, locale=None):
    539         HTMLCalendar.__init__(self, firstweekday)
    540         if locale is None:
    541             locale = _locale.getdefaultlocale()
    542         self.locale = locale
    543 
    544     def formatweekday(self, day):
    545         with different_locale(self.locale):
    546             s = day_abbr[day]
    547             return '<th class="%s">%s</th>' % (self.cssclasses[day], s)
    548 
    549     def formatmonthname(self, theyear, themonth, withyear=True):
    550         with different_locale(self.locale):
    551             s = month_name[themonth]
    552             if withyear:
    553                 s = '%s %s' % (s, theyear)
    554             return '<tr><th colspan="7" class="month">%s</th></tr>' % s
    555 
    556 
    557 # Support for old module level interface
    558 c = TextCalendar()
    559 
    560 firstweekday = c.getfirstweekday
    561 
    562 def setfirstweekday(firstweekday):
    563     if not MONDAY <= firstweekday <= SUNDAY:
    564         raise IllegalWeekdayError(firstweekday)
    565     c.firstweekday = firstweekday
    566 
    567 monthcalendar = c.monthdayscalendar
    568 prweek = c.prweek
    569 week = c.formatweek
    570 weekheader = c.formatweekheader
    571 prmonth = c.prmonth
    572 month = c.formatmonth
    573 calendar = c.formatyear
    574 prcal = c.pryear
    575 
    576 
    577 # Spacing of month columns for multi-column year calendar
    578 _colwidth = 7*3 - 1         # Amount printed by prweek()
    579 _spacing = 6                # Number of spaces between columns
    580 
    581 
    582 def format(cols, colwidth=_colwidth, spacing=_spacing):
    583     """Prints multi-column formatting for year calendars"""
    584     print(formatstring(cols, colwidth, spacing))
    585 
    586 
    587 def formatstring(cols, colwidth=_colwidth, spacing=_spacing):
    588     """Returns a string formatted from n strings, centered within n columns."""
    589     spacing *= ' '
    590     return spacing.join(c.center(colwidth) for c in cols)
    591 
    592 
    593 EPOCH = 1970
    594 _EPOCH_ORD = datetime.date(EPOCH, 1, 1).toordinal()
    595 
    596 
    597 def timegm(tuple):
    598     """Unrelated but handy function to calculate Unix timestamp from GMT."""
    599     year, month, day, hour, minute, second = tuple[:6]
    600     days = datetime.date(year, month, 1).toordinal() - _EPOCH_ORD + day - 1
    601     hours = days*24 + hour
    602     minutes = hours*60 + minute
    603     seconds = minutes*60 + second
    604     return seconds
    605 
    606 
    607 def main(args):
    608     import optparse
    609     parser = optparse.OptionParser(usage="usage: %prog [options] [year [month]]")
    610     parser.add_option(
    611         "-w", "--width",
    612         dest="width", type="int", default=2,
    613         help="width of date column (default 2, text only)"
    614     )
    615     parser.add_option(
    616         "-l", "--lines",
    617         dest="lines", type="int", default=1,
    618         help="number of lines for each week (default 1, text only)"
    619     )
    620     parser.add_option(
    621         "-s", "--spacing",
    622         dest="spacing", type="int", default=6,
    623         help="spacing between months (default 6, text only)"
    624     )
    625     parser.add_option(
    626         "-m", "--months",
    627         dest="months", type="int", default=3,
    628         help="months per row (default 3, text only)"
    629     )
    630     parser.add_option(
    631         "-c", "--css",
    632         dest="css", default="calendar.css",
    633         help="CSS to use for page (html only)"
    634     )
    635     parser.add_option(
    636         "-L", "--locale",
    637         dest="locale", default=None,
    638         help="locale to be used from month and weekday names"
    639     )
    640     parser.add_option(
    641         "-e", "--encoding",
    642         dest="encoding", default=None,
    643         help="Encoding to use for output."
    644     )
    645     parser.add_option(
    646         "-t", "--type",
    647         dest="type", default="text",
    648         choices=("text", "html"),
    649         help="output type (text or html)"
    650     )
    651 
    652     (options, args) = parser.parse_args(args)
    653 
    654     if options.locale and not options.encoding:
    655         parser.error("if --locale is specified --encoding is required")
    656         sys.exit(1)
    657 
    658     locale = options.locale, options.encoding
    659 
    660     if options.type == "html":
    661         if options.locale:
    662             cal = LocaleHTMLCalendar(locale=locale)
    663         else:
    664             cal = HTMLCalendar()
    665         encoding = options.encoding
    666         if encoding is None:
    667             encoding = sys.getdefaultencoding()
    668         optdict = dict(encoding=encoding, css=options.css)
    669         write = sys.stdout.buffer.write
    670         if len(args) == 1:
    671             write(cal.formatyearpage(datetime.date.today().year, **optdict))
    672         elif len(args) == 2:
    673             write(cal.formatyearpage(int(args[1]), **optdict))
    674         else:
    675             parser.error("incorrect number of arguments")
    676             sys.exit(1)
    677     else:
    678         if options.locale:
    679             cal = LocaleTextCalendar(locale=locale)
    680         else:
    681             cal = TextCalendar()
    682         optdict = dict(w=options.width, l=options.lines)
    683         if len(args) != 3:
    684             optdict["c"] = options.spacing
    685             optdict["m"] = options.months
    686         if len(args) == 1:
    687             result = cal.formatyear(datetime.date.today().year, **optdict)
    688         elif len(args) == 2:
    689             result = cal.formatyear(int(args[1]), **optdict)
    690         elif len(args) == 3:
    691             result = cal.formatmonth(int(args[1]), int(args[2]), **optdict)
    692         else:
    693             parser.error("incorrect number of arguments")
    694             sys.exit(1)
    695         write = sys.stdout.write
    696         if options.encoding:
    697             result = result.encode(options.encoding)
    698             write = sys.stdout.buffer.write
    699         write(result)
    700 
    701 
    702 if __name__ == "__main__":
    703     main(sys.argv)

     

    转载于:https://www.cnblogs.com/hongten/p/hongten_python_calendar.html

    展开全文
  • python中calendar模块有什么用发布时间:2020-12-07 10:16:39来源:亿速云阅读:80作者:小新这篇文章主要介绍python中calendar模块有什么用,文中介绍非常详细,具有一定参考价值,感兴趣小伙伴们一定要看完...

    python中calendar模块有什么用

    发布时间:2020-12-07 10:16:39

    来源:亿速云

    阅读:80

    作者:小新

    这篇文章主要介绍python中calendar模块有什么用,文中介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们一定要看完!

    经历过细致学习语言的历程,也都知道大家由浅入深学习的历程差不多,有些是我们学习上的必经之路,比如模块、正则、字符串等等,还有一个虽然很渺小,但是基本上每一个项目都离开操作的,对时间的更改,这个并非大家所认为的时分秒,是在日历上所用的时间模块,这就是开篇标题——calendar 模块,它就是主攻日历编写。

    常见方式1、先看一组比较有意思的代码演示:import calendar

    print(calendar.calendar())

    简单两行代码可以把日历打出来,比如我们带入2020年的日历。print(calendar.calendar(theyear=2020, w=2, l=1, c=6))

    然后大家打印看下效果,一定是关于2020年的所有日历模块。

    常见方式2、生成一月的格式化文本输出import calendar

    c = calendar.TextCalendar(calendar.SUNDAY)

    c.prmonth(2017, 7)

    输出结果:July 2017

    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

    以上是“python中calendar模块有什么用”这篇文章的所有内容,感谢各位的阅读!希望分享的内容对大家有帮助,更多相关知识,欢迎关注亿速云行业资讯频道!

    展开全文
  • calendar,是与日历相关模块。calendar模块文件里定义了很多类型,主要有Calendar,TextCalendar以及HTMLCalendar类型。其中,Calendar是TextCalendar与HTMLCalendar基类。该模块文件还对外提供了很多方法,例如...
  • calendar模块提供了三大类:一、calendar.Calendar(firstweekday=0)该类提供了许多生成器,如星期生成器,某月日历生成器二、calendar.TextCalendar(firstweekday=0)该类提供了按月、按年生成日历字符串方法。...
  • 我想从我日历到python程序获取事件列表,但是我无法理解oauth大量文档。在这就是我正在尝试代码。它一半是零碎。谁能帮我修好这个吗import gflagsimport httplib2from apiclient.discovery import ...
  • 摘要:下文讲述使用Python代码中calendar.setfirstweekday(weekday)函数功能说明,如下所示:calendar.monthrange功能说明:calendar.setfirstweekday(weekday)方法用于设置每周星期起始数calendar.setfirstweekday...
  • 摘要:下文讲述使用Python代码中calendar.timegm(tupletime)函数功能说明,如下所示:calendar.monthrange功能说明:calendar.timegm(tupletime)方法用于将一个时间元组转换为时间戳calendar.timegm(tupletime)方法...
  • 其实有点类似于查询功能,但是小编想要收到用python中解决方法。本篇还是着重推荐使用calendar来返回某一时间点方法,大家可以看看,顺便拓展其他小知识点。 calendar 还支持返回指定月份日历: print...
  • python中calendar模块常用方法 import calendar calendar.isleap(2000) #判断是否是闰年 True calendar.isleap(2100) False calendar.month(2100,12) #查看2100年12日历 ’ December 2100\nMo Tu We Th Fr Sa...
  • Python中calendar模块

    2019-05-23 17:40:16
    calendar模块中的常用方法
  • 想要在python中写代码游刃有余,没有函数的支持是万万不行的。很多小伙伴反映,最近函数的应用知识不够了,所以小编挑选了python3时间中的函数,希望可以帮助大家在处理日历方面更加的迅速。其他更多的函数,大家也...
  • 本文整理汇总了Python中calendar.isleap方法典型用法代码示例。如果您正苦于以下问题:Python calendar.isleap方法具体用法?Python calendar.isleap怎么用?Python calendar.isleap使用例子?那么恭喜您, ...
  • 摘要:下文讲述使用Python代码中calendar.monthrange(year,month)函数功能说明,如下所示:calendar.monthrange功能说明:calendar.monthrange(year,month)方法可返回两个整数第一个整数:代表本月起始星期数(0:星期一...
  • 摘要:下文讲述使用Python代码中calendar.weekday(year,month,day)函数功能说明,如下所示:calendar.monthrange功能说明:calendar.weekday(year,month,day)方法用于返回指定年份,月份,日期对应星期数calendar....
  • import calendar calendar.setfirstweekday(0) # 设置...c = calendar.calendar(2020) # 获取某年日历 print© print(calendar.month(2020, 1)) # 获取某年某月日历 print(calendar.isleap(2020)) # 判断某年...
  • 这个模块让你可以输出像 Unix cal 那样日历,它还提供了其它与日历相关实用函数。 默认情况下,这些日历把星期一当作一周第一天,星期天为一周最后一天(按照欧洲惯例)。...在这个模块定义函数和类...
  • >>> import calendar >>> calendar.isleap(2000) #判断是否是闰年 True >... calendar.isleap(2100) ... calendar.month(2100,12) #查看2100年12日历 ' December 2100\nM...
  • 常用模块:calendar、time、datetime、timeit、os、shutil、zip、math、string上述所有模块使用理论上都应该先导入,string是特例-calendar,time,datatime区别参考中文意思calendar:-跟日历相关模块获取一年...
  • 跟日历相关模块import calendar# calendar : 获取一年日历字符串# w = 每个日期之间间隔字符数# l = 每周所占用行数# c = 每个月之间间隔字符数cal = calendar.calendar(2018)print(type(cal))print(cal)...
  • 本文整理汇总了Python中calendar.weekday方法典型用法代码示例。如果您正苦于以下问题:Python calendar.weekday方法具体用法?Python calendar.weekday怎么用?Python calendar.weekday使用例子?那么恭喜您,...
  • 日历模块允许输出类似于程序的日历,并提供与日历...Python中的monthdayscalendar()方法用于获取一年中一个月中的整周列表。用法: monthdayscalendar(year, month)参数:year: year of the calendarmonth: month o...
  • 想要在python中写代码游刃有余,没有函数的支持是万万不行的。很多小伙伴反映,最近函数的应用知识不够了,所以小编挑选了python3时间中的函数,希望可以帮助大家在处理日历方面更加的迅速。其他更多的函数,大家也...
  • calendar日历模块 month(theyear,themonth): 返回指定某年某月日历   参数 theyear - - 年   参数 themonth- - 月 import calendar print(calendar.month(2020)) ...
  • 1,calendar.calendar():返回某一年日历 import calendar # 返回某一年日历,w=3, l=2, c=10, m=2调整打印行和间隙可以不写 c=calendar.calendar(2018,w=3, l=2, c=10, m=2) print(c) 2,calendar....
  • import timeprint time.gmtime()#获取当前时间struct_time对象print time.gmtime(time.time() - 24 * 60 * 60)#获取昨天这个时间struct_time对象#---- result#time.struct_time(tm_year=2009, tm_mon=6, tm_mday...
  • 日历模块允许输出类似于...Python中的yeardatescalendar()方法用于获取一年中一个月中的整周列表。周列表中的条目是天数。这个月以外的天数为零。用法: yeardatescalendar(year, width)参数:year: year of the ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 927
精华内容 370
关键字:

python中的calendar

python 订阅