*** empty log message ***
diff --git a/Demo/classes/Complex.py b/Demo/classes/Complex.py
index 5880c64..b7ba2e0 100755
--- a/Demo/classes/Complex.py
+++ b/Demo/classes/Complex.py
@@ -4,16 +4,21 @@
from math import sqrt
-def complex(re, im):
- return Complex().init(re, im)
+class complex:
-
-class Complex:
-
- def init(self, re, im):
+ def __init__(self, re, im):
self.re = float(re)
self.im = float(im)
- return self
+
+ def __coerce__(self, other):
+ if type(other) == type(self):
+ if other.__class__ == self.__class__:
+ return self, other
+ else:
+ raise TypeError, 'cannot coerce to complex'
+ else:
+ # The cast to float() may raise an exception!
+ return self, complex(float(other), 0.0)
def __repr__(self):
return 'complex' + `self.re, self.im`
@@ -60,9 +65,16 @@
def test():
a = complex(2, 0)
b = complex(3, 4)
- print a, b
- print a+b, a-b, a*b, a/b
- print b+a, b-a, b*a, b/a
+ print a
+ print b
+ print a+b
+ print a-b
+ print a*b
+ print a/b
+ print b+a
+ print b-a
+ print b*a
+ print b/a
i = complex(0, 1)
print i, i*i, i*i*i, i*i*i*i
j = complex(1, 1)
diff --git a/Demo/classes/Dbm.py b/Demo/classes/Dbm.py
index 0bd5491..8d7fe0f 100755
--- a/Demo/classes/Dbm.py
+++ b/Demo/classes/Dbm.py
@@ -41,11 +41,11 @@
def test():
- d = Dbm('@dbm', 'rw', 0666)
+ d = Dbm('@dbm', 'rw', 0600)
print d
while 1:
try:
- key = eval(raw_input('key: '))
+ key = input('key: ')
if d.has_key(key):
value = d[key]
print 'currently:', value
diff --git a/Demo/classes/README b/Demo/classes/README
index f821f78..cca7524 100644
--- a/Demo/classes/README
+++ b/Demo/classes/README
@@ -1,4 +1,4 @@
-Examples of classes that implement special operators (see class.doc):
+Examples of classes that implement special operators (see reference manual):
Complex.py Complex numbers
Dates.py Date manipulation package by Tim Peters
diff --git a/Demo/classes/Range.py b/Demo/classes/Range.py
index b8bc9be..e7b6be2 100755
--- a/Demo/classes/Range.py
+++ b/Demo/classes/Range.py
@@ -16,7 +16,7 @@
start, stop, step = a
else:
raise TypeError, 'range() needs 1-3 arguments'
- return Range().init(start, stop, step)
+ return Range(start, stop, step)
# Class implementing a range object.
@@ -26,14 +26,13 @@
class Range:
# initialization -- should be called only by range() above
- def init(self, start, stop, step):
+ def __init__(self, start, stop, step):
if step == 0:
raise ValueError, 'range() called with zero step'
self.start = start
self.stop = stop
self.step = step
self.len = max(0, int((self.stop - self.start) / self.step))
- return self
# implement `x` and is also used by print x
def __repr__(self):
diff --git a/Demo/classes/Rat.py b/Demo/classes/Rat.py
index 0d3e515..d10e4df 100755
--- a/Demo/classes/Rat.py
+++ b/Demo/classes/Rat.py
@@ -2,7 +2,7 @@
def rat(num, den):
- return Rat().init(num, den)
+ return Rat(num, den)
def gcd(a, b):
@@ -13,13 +13,12 @@
class Rat:
- def init(self, num, den):
+ def __init__(self, num, den):
if den == 0:
raise ZeroDivisionError, 'rat(x, 0)'
g = gcd(num, den)
self.num = num/g
self.den = den/g
- return self
def __repr__(self):
return 'rat' + `self.num, self.den`
@@ -49,8 +48,10 @@
return a, rat(b, 1L)
if t == type(0.0):
return a.__float__(), b
+ if t == type(a) and a.__class__ == b.__class__:
+ return a, b
raise TypeError, 'Rat.__coerce__: bad other arg'
-
+
def __add__(a, b):
if type(b) <> type(a):
a, b = a.__coerce__(b)
@@ -93,4 +94,4 @@
except ZeroDivisionError:
print 'OK'
-#test()
+test()
diff --git a/Demo/classes/Rev.py b/Demo/classes/Rev.py
index 5cf4602..c1874c6 100755
--- a/Demo/classes/Rev.py
+++ b/Demo/classes/Rev.py
@@ -8,7 +8,7 @@
# ...
# !dlroW olleH
#
-# The .forw is so you can use anonymous sequences in init, and still
+# 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
diff --git a/Demo/classes/Vec.py b/Demo/classes/Vec.py
index 6e2bc47..8289bc8 100755
--- a/Demo/classes/Vec.py
+++ b/Demo/classes/Vec.py
@@ -2,16 +2,15 @@
def vec(*v):
- return apply(Vec().init, v)
+ return apply(Vec, v)
class Vec:
- def init(self, *v):
+ def __init__(self, *v):
self.v = []
for x in v:
self.v.append(x)
- return self
def fromlist(self, v):
diff --git a/Demo/classes/bitvec.py b/Demo/classes/bitvec.py
index 40cd13f..69718d7 100755
--- a/Demo/classes/bitvec.py
+++ b/Demo/classes/bitvec.py
@@ -48,7 +48,7 @@
class BitVec:
- def init(self, *params):
+ def __init__(self, *params):
self._data = 0L
self._len = 0
if not len(params):
@@ -93,20 +93,12 @@
else:
raise error, 'bitvec() requires 0 -- 2 parameter(s)'
- return self
-
-
- def _init(self, data, len):
- self._data = data
- self._len = len
- return self
-
def append(self, item):
#_check_value(item)
#self[self._len:self._len] = [item]
self[self._len:self._len] = \
- BitVec()._init(long(not not item), 1)
+ BitVec(long(not not item), 1)
def count(self, value):
@@ -138,7 +130,7 @@
def insert(self, index, item):
#_check_value(item)
#self[index:index] = [item]
- self[index:index] = BitVec()._init(long(not not item), 1)
+ self[index:index] = BitVec(long(not not item), 1)
def remove(self, value):
@@ -163,7 +155,7 @@
def copy(self):
- return BitVec()._init(self._data, self._len)
+ return BitVec(self._data, self._len)
def seq(self):
@@ -229,7 +221,7 @@
#rprt(`self`+'.__getslice__'+`i, j`+'\n')
i, j = _check_slice(self._len, i, j)
if i >= j:
- return BitVec()._init(0L, 0)
+ return BitVec(0L, 0)
if i:
ndata = self._data >> i
else:
@@ -239,7 +231,7 @@
#we'll have to invent faster variants here
#e.g. mod_2exp
ndata = ndata & ((1L << nlength) - 1)
- return BitVec()._init(ndata, nlength)
+ return BitVec(ndata, nlength)
def __setslice__(self, i, j, sequence, *rest):
#rprt(`self`+'.__setslice__'+`(i, j, sequence) + rest`+'\n')
@@ -274,16 +266,16 @@
if type(multiplier) != type(0):
raise TypeError, 'sequence subscript not int'
if multiplier <= 0:
- return BitVec()._init(0L, 0)
+ return BitVec(0L, 0)
elif multiplier == 1:
return self.copy()
#handle special cases all 0 or all 1...
if self._data == 0L:
- return BitVec()._init(0L, self._len * multiplier)
+ return BitVec(0L, self._len * multiplier)
elif (~self)._data == 0L:
- return ~BitVec()._init(0L, self._len * multiplier)
+ return ~BitVec(0L, self._len * multiplier)
#otherwise el cheapo again...
- retval = BitVec()._init(0L, 0)
+ retval = BitVec(0L, 0)
while multiplier:
retval, multiplier = retval + self, multiplier - 1
return retval
@@ -293,7 +285,7 @@
if type(otherseq) != type(self):
otherseq = apply(bitvec, (otherseq, ) + rest)
#sequence is now of our own type
- return BitVec()._init(self._data & otherseq._data, \
+ return BitVec(self._data & otherseq._data, \
min(self._len, otherseq._len))
@@ -302,7 +294,7 @@
if type(otherseq) != type(self):
otherseq = apply(bitvec, (otherseq, ) + rest)
#sequence is now of our own type
- return BitVec()._init(self._data ^ otherseq._data, \
+ return BitVec(self._data ^ otherseq._data, \
max(self._len, otherseq._len))
@@ -311,13 +303,13 @@
if type(otherseq) != type(self):
otherseq = apply(bitvec, (otherseq, ) + rest)
#sequence is now of our own type
- return BitVec()._init(self._data | otherseq._data, \
+ return BitVec(self._data | otherseq._data, \
max(self._len, otherseq._len))
def __invert__(self):
#rprt(`self`+'.__invert__()\n')
- return BitVec()._init(~self._data & ((1L << self._len) - 1), \
+ return BitVec(~self._data & ((1L << self._len) - 1), \
self._len)
def __coerce__(self, otherseq, *rest):
@@ -337,5 +329,4 @@
return float(self._data)
-def bitvec(params):
- return apply(BitVec().init, params)
+bitvec = BitVec