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]]

>>> 

  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.（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 doesnt 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 months 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 months 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 months 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 months 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 months 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 years 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（colwidthm+c（m-1））.rstrip（））

345         a（\nl）

346         header = self.formatweekheader（w）

347         for （i， row） in enumerate（self.yeardays2calendar（theyear， m））:

348             ＃ months in this row

349             months = range（mi+1， min（m（i+1）+1， 13））

350             a（\nl）

351             names = （self.formatmonthname（theyear， k， colwidth， False）

352                      for k in months）

353             a（formatstring（names， colwidth， c）.rstrip（））

354             a（\nl）

355             headers = （header for k in months）

356             a（formatstring（headers， colwidth， c）.rstrip（））

357             a（\nl）

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 years 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 = 73 - 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  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  GMT.

599     year， month， day， hour， minute， second = tuple[:6]

600     days = datetime.date（year， month， 1）.toordinal（） - _EPOCH_ORD + day - 1

601     hours = days24 + hour

602     minutes = hours60 + minute

603     seconds = minutes60 + 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  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）