I have 3 reasons for sending it out:
1) I've found various versions of this to be useful, so maybe you will
too. Python's actual coercion rules aren't documented in full, so
maybe studying this will save you some poke-and-hope time too.
2) I'm wondering whether anyone sees a better way to worm around the
coercion problems (date+date doesn't make sense, but date-date does
and doesn't at all mean the same thing as date-int; etc). The sole
advantage of the strange method used here is that it works.
3) I'm wondering whether other people have tried to implement new
"numeric" types, and if so how that went for them. I'm particularly
curious as to whether you found that automatic coercion was more of a
help or a stumbling block. On the one hand, int+new_type has to go
thru _some_ trickery else new_type.__add__ would get the arguments in
the wrong order (as int*new_type already does ...); on the other,
sometimes you really don't want to lose the info that the left (or
right) argument was an int.
That suggests: (a) no automatic coercion; and (b), the __add__ etc
methods would be better as two methods, say __addl__ and __addr__,
that distinguished between new-type-was-on-the-left and new-type-
was-on-the-right.
It also suggests that maybe date arithmetic is an abuse of the
intended uses <grin>.
curiously y'rs - tim
Tim Peters tim@ksr.com
not speaking for Kendall Square Research Corp
# Class Date supplies date objects that support date arithmetic.
#
# Date(month,day,year) returns a Date object. An instance prints as,
# e.g., 'Mon 16 Aug 1993'.
#
# Addition, subtraction, comparison operators, min, max, and sorting
# all work as expected for date objects: int+date or date+int returns
# the date `int' days from `date'; date+date raises an exception;
# date-int returns the date `int' days before `date'; date2-date1 returns
# an integer, the number of days from date1 to date2; int-date raises an
# exception; date1 < date2 is true iff date1 occurs before date2 (&
# similarly for other comparisons); min(date1,date2) is the earlier of
# the two dates and max(date1,date2) the later; and date objects can be
# used as dictionary keys.
#
# Date objects support one visible method, date.weekday(). This returns
# the day of the week the date falls on, as a string.
#
# Date objects also have 4 (conceptually) read-only data attributes:
# .month in 1..12
# .day in 1..31
# .year int or long int
# .ord the ordinal of the date relative to an arbitrary staring point
#
# The Dates module also supplies function today(), which returns the
# current date as a date object.
#
# Those entranced by calendar trivia will be disappointed, as no attempt
# has been made to accommodate the Julian (etc) system. On the other
# hand, at least this package knows that 2000 is a leap year but 2100
# isn't, and works fine for years with a hundred decimal digits <wink>.
_MONTH_NAMES = [ 'January', 'February', 'March', 'April', 'May',
'June', 'July', 'August', 'September', 'October',
'November', 'December' ]
_DAY_NAMES = [ 'Friday', 'Saturday', 'Sunday', 'Monday',
'Tuesday', 'Wednesday', 'Thursday' ]
_DAYS_IN_MONTH = [ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ]
_DAYS_BEFORE_MONTH = []
dbm = 0
for dim in _DAYS_IN_MONTH:
_DAYS_BEFORE_MONTH.append(dbm)
dbm = dbm + dim
del dbm, dim
_INT_TYPES = type(1), type(1L)
def _is_leap( year ): # 1 if leap year, else 0
if year % 4 != 0: return 0
if year % 400 == 0: return 1
return year % 100 != 0
def _days_in_year( year ): # number of days in year
return 365 + _is_leap(year)
def _days_before_year( year ): # number of days before year
return year*365L + (year+3)/4 - (year+99)/100 + (year+399)/400
def _days_in_month( month, year ): # number of days in month of year
if month == 2 and _is_leap(year): return 29
return _DAYS_IN_MONTH[month-1]
def _days_before_month( month, year ): # number of days in year before month
return _DAYS_BEFORE_MONTH[month-1] + (month > 2 and _is_leap(year))
def _date2num( date ): # compute ordinal of date.month,day,year
return _days_before_year( date.year ) + \
_days_before_month( date.month, date.year ) + \
date.day
_DI400Y = _days_before_year( 400 ) # number of days in 400 years
def _num2date( n ): # return date with ordinal n
if type(n) not in _INT_TYPES:
raise TypeError, 'argument must be integer: ' + `type(n)`
ans = Date(1,1,1) # arguments irrelevant; just getting a Date obj
ans.ord = n
n400 = (n-1)/_DI400Y # # of 400-year blocks preceding
year, n = 400 * n400, n - _DI400Y * n400
more = n / 365
dby = _days_before_year( more )
if dby >= n:
more = more - 1
dby = dby - _days_in_year( more )
year, n = year + more, int(n - dby)
try: year = int(year) # chop to int, if it fits
except ValueError: pass
month = min( n/29 + 1, 12 )
dbm = _days_before_month( month, year )
if dbm >= n:
month = month - 1
dbm = dbm - _days_in_month( month, year )
ans.month, ans.day, ans.year = month, n-dbm, year
return ans
def _num2day( n ): # return weekday name of day with ordinal n
return _DAY_NAMES[ int(n % 7) ]
class Date:
def __init__( self, month, day, year ):
if not 1 <= month <= 12:
raise ValueError, 'month must be in 1..12: ' + `month`
dim = _days_in_month( month, year )
if not 1 <= day <= dim:
raise ValueError, 'day must be in 1..' + `dim` + ': ' + `day`
self.month, self.day, self.year = month, day, year
self.ord = _date2num( self )
def __cmp__( self, other ):
return cmp( self.ord, other.ord )
# define a hash function so dates can be used as dictionary keys
def __hash__( self ):
return hash( self.ord )
# print as, e.g., Mon 16 Aug 1993
def __repr__( self ):
return '%.3s %2d %.3s ' % (
self.weekday(),
self.day,
_MONTH_NAMES[self.month-1] ) + `self.year`
# automatic coercion is a pain for date arithmetic, since e.g.
# date-date and date-int mean different things. So, in order to
# sneak integers past Python's coercion rules without losing the info
# that they're really integers (& not dates!), integers are disguised
# as instances of the derived class _DisguisedInt. That this works
# relies on undocumented behavior of Python's coercion rules.
def __coerce__( self, other ):
if type(other) in _INT_TYPES:
return self, _DisguisedInt(other)
# if another Date, fine
if type(other) is type(self) and other.__class__ is Date:
return self, other
# Python coerces int+date, but not date+int; in the former case,
# _DisguisedInt.__add__ handles it, so we only need to do
# date+int here
def __add__( self, n ):
if type(n) not in _INT_TYPES:
raise TypeError, 'can\'t add ' + `type(n)` + ' to date'
return _num2date( self.ord + n )
# Python coerces all of int-date, date-int and date-date; the first
# case winds up in _DisguisedInt.__sub__, leaving the latter two
# for us
def __sub__( self, other ):
if other.__class__ is _DisguisedInt: # date-int
return _num2date( self.ord - other.ord )
else:
return self.ord - other.ord # date-date
def weekday( self ):
return _num2day( self.ord )
# see comments before Date.__add__
class _DisguisedInt( Date ):
def __init__( self, n ):
self.ord = n
# handle int+date
def __add__( self, other ):
return other.__add__( self.ord )
# complain about int-date
def __sub__( self, other ):
raise TypeError, 'Can\'t subtract date from integer'
def today():
import time
local = time.localtime(time.time())
return Date( local[1], local[2], local[0] )
DateTestError = 'DateTestError'
def test( firstyear, lastyear ):
a = Date(9,30,1913)
b = Date(9,30,1914)
if `a` != 'Tue 30 Sep 1913':
raise DateTestError, '__repr__ failure'
if (not a < b) or a == b or a > b or b != b or \
a != 698982 or 698982 != a or \
(not a > 5) or (not 5 < a):
raise DateTestError, '__cmp__ failure'
if a+365 != b or 365+a != b:
raise DateTestError, '__add__ failure'
if b-a != 365 or b-365 != a:
raise DateTestError, '__sub__ failure'
try:
x = 1 - a
raise DateTestError, 'int-date should have failed'
except TypeError:
pass
try:
x = a + b
raise DateTestError, 'date+date should have failed'
except TypeError:
pass
if a.weekday() != 'Tuesday':
raise DateTestError, 'weekday() failure'
if max(a,b) is not b or min(a,b) is not a:
raise DateTestError, 'min/max failure'
d = {a-1:b, b:a+1}
if d[b-366] != b or d[a+(b-a)] != Date(10,1,1913):
raise DateTestError, 'dictionary failure'
# verify date<->number conversions for first and last days for
# all years in firstyear .. lastyear
lord = _days_before_year( firstyear )
y = firstyear
while y <= lastyear:
ford = lord + 1
lord = ford + _days_in_year(y) - 1
fd, ld = Date(1,1,y), Date(12,31,y)
if (fd.ord,ld.ord) != (ford,lord):
raise DateTestError, ('date->num failed', y)
fd, ld = _num2date(ford), _num2date(lord)
if (1,1,y,12,31,y) != \
(fd.month,fd.day,fd.year,ld.month,ld.day,ld.year):
raise DateTestError, ('num->date failed', y)
y = y + 1
>>> END OF MSG