diff options
Diffstat (limited to 'Demo/classes')
| -rwxr-xr-x | Demo/classes/Dates.py | 233 | ||||
| -rwxr-xr-x | Demo/classes/Rev.py | 89 |
2 files changed, 322 insertions, 0 deletions
diff --git a/Demo/classes/Dates.py b/Demo/classes/Dates.py new file mode 100755 index 0000000..4e8bbf7 --- /dev/null +++ b/Demo/classes/Dates.py @@ -0,0 +1,233 @@ +# 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>. + +# Tim Peters tim@ksr.com +# not speaking for Kendall Square Research Corp + +_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 diff --git a/Demo/classes/Rev.py b/Demo/classes/Rev.py new file mode 100755 index 0000000..5cf4602 --- /dev/null +++ b/Demo/classes/Rev.py @@ -0,0 +1,89 @@ +# A class which presents the reverse of a sequence without duplicating it. +# From: "Steven D. Majewski" <sdm7g@elvis.med.virginia.edu> + +# It works on mutable or inmutable sequences. +# +# >>> for c in Rev( 'Hello World!' ) : sys.stdout.write( c ) +# ... else: sys.stdout.write( '\n' ) +# ... +# !dlroW olleH +# +# The .forw is so you can use anonymous sequences in init, and still +# keep a reference the forward sequence. ) +# If you give it a non-anonymous mutable sequence, the reverse sequence +# will track the updated values. ( but not reassignment! - another +# good reason to use anonymous values in creating the sequence to avoid +# confusion. Maybe it should be change to copy input sequence to break +# the connection completely ? ) +# +# >>> nnn = range( 0, 3 ) +# >>> rnn = Rev( nnn ) +# >>> for n in rnn: print n +# ... +# 2 +# 1 +# 0 +# >>> for n in range( 4, 6 ): nnn.append( n ) # update nnn +# ... +# >>> for n in rnn: print n # prints reversed updated values +# ... +# 5 +# 4 +# 2 +# 1 +# 0 +# >>> nnn = nnn[1:-1] +# >>> nnn +# [1, 2, 4] +# >>> for n in rnn: print n # prints reversed values of old nnn +# ... +# 5 +# 4 +# 2 +# 1 +# 0 +# >>> +# +# WH = Rev( 'Hello World!' ) +# print WH.forw, WH.back +# nnn = Rev( range( 1, 10 ) ) +# print nnn.forw +# print nnn +# +# produces output: +# +# Hello World! !dlroW olleH +# [1, 2, 3, 4, 5, 6, 7, 8, 9] +# [9, 8, 7, 6, 5, 4, 3, 2, 1] +# +# >>>rrr = Rev( nnn ) +# >>>rrr +# <1, 2, 3, 4, 5, 6, 7, 8, 9> + +from string import joinfields +class Rev: + def __init__( self, seq ): + self.forw = seq + self.back = self + def __len__( self ): + return len( self.forw ) + def __getitem__( self, j ): + return self.forw[ -( j + 1 ) ] + def __repr__( self ): + seq = self.forw + if type(seq) == type( [] ) : + wrap = '[]' + sep = ', ' + elif type(seq) == type( () ) : + wrap = '()' + sep = ', ' + elif type(seq) == type( '' ) : + wrap = '' + sep = '' + else: + wrap = '<>' + sep = ', ' + outstrs = [] + for item in self.back : + outstrs.append( str( item ) ) + return wrap[:1] + joinfields( outstrs, sep ) + wrap[-1:] |