def opendbm(filename, mode, perm):

return Dbm().init(filename, mode, perm)

class Dbm:

def init(self, filename, mode, perm):

import dbm

self.db = dbm.open(filename, mode, perm)

return self

def __repr__(self):

s = ''

for key in self.keys():

t = `key` + ': ' + `self[key]`

if s: t = t + ', '

s = s + t

return '{' + s + '}'

def __len__(self):

return len(self.db)

def __getitem__(self, key):

return eval(self.db[`key`])

def __setitem__(self, key, value):

self.db[`key`] = `value`

def __delitem__(self, key):

del self.db[`key`]

def keys(self):

res = []

for key in self.db.keys():

res.append(eval(key))

return res

def has_key(self, key):

return self.db.has_key(`key`)

def test():

d = opendbm('@dbm', 'rw', 0666)

print d

while 1:

try:

key = eval(raw_input('key: '))

if d.has_key(key):

value = d[key]

print 'currently:', value

value = eval(raw_input('value: '))

if value == None:

del d[key]

else:

d[key] = value

except KeyboardInterrupt:

print ''

print d

except EOFError:

print '[eof]'

break

print d

test()

Examples of classes that implement special operators (see class.doc):

Complex.py Complex numbers

Dbm.py Wrapper around built-in dbm, supporting arbitrary values

Range.py Example of a generator: re-implement built-in range()

Rat.py Rational numbers

Vec.py A simple vector class

(For straightforward examples of basic class features, such as use of

methods and inheritance, see the library code -- especially the window

modules are full of them.)

def range(*a):

if len(a) == 1:

start, stop, step = 0, a[0], 1

elif len(a) == 2:

start, stop = a

step = 1

elif len(a) == 3:

start, stop, step = a

else:

raise TypeError, 'range() needs 1-3 arguments'

return Range().init(start, stop, step)

class Range:

# initialization -- should be called only by range() above

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):

return 'range' + `self.start, self.stop, self.step`

# implement len(x)

def __len__(self):

return self.len

# implement x[i]

def __getitem__(self, i):

if 0 <= i < self.len:

return self.start + self.step * i

else:

raise IndexError, 'range[i] index out of range'

def test():

import time, builtin

print range(10), range(-10, 10), range(0, 10, 2)

for i in range(100, -100, -10): print i,

print

t1 = time.millitimer()

for i in range(1000):

pass

t2 = time.millitimer()

for i in builtin.range(1000):

pass

t3 = time.millitimer()

print t2-t1, 'msec (class)'

print t3-t2, 'msec (built-in)'

test()

def rat(num, den):

return Rat().init(num, den)

def gcd(a, b):

while b:

a, b = b, a%b

return a

class Rat:

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`

def __cmp__(a, b):

c = a-b

if c.num < 0:

return -1

if c.num > 0:

return 1

return 0

def __float__(self):

return float(self.num) / float(self.den)

def __long__(self):

return long(self.num) / long(self.den)

def __int__(self):

return int(self.num / self.den)

def __coerce__(a, b):

t = type(b)

if t == type(0):

return a, rat(b, 1)

if t == type(0L):

return a, rat(b, 1L)

if t == type(0.0):

return a.__float__(), b

raise TypeError, 'Rat.__coerce__: bad other arg'

def __add__(a, b):

return rat(a.num*b.den + b.num*a.den, a.den*b.den)

def __sub__(a, b):

return rat(a.num*b.den - b.num*a.den, a.den*b.den)

def __mul__(a, b):

return rat(a.num*b.num, a.den*b.den)

def __div__(a, b):

return rat(a.num*b.den, a.den*b.num)

def __neg__(self):

return rat(-self.num, self.den)

def test():

print rat(-1L, 1)

print rat(1, -1)

a = rat(1, 10)

print int(a), long(a), float(a)

b = rat(2, 5)

l = [a+b, a-b, a*b, a/b]

print l

l.sort()

print l

print rat(0, 1)

print rat(1, 0)

print a+1

print a+1L

print a+1.0

test()

def vec(*v):

return apply(Vec().init, v)

class Vec:

def init(self, *v):

self.v = []

for x in v:

self.v.append(x)

return self

def fromlist(self, v):

self.v = []

if type(v) <> type([]):

raise TypeError

self.v = v[:]

return self

def __repr__(self):

return 'vec(' + `self.v`[1:-1] + ')'

def __len__(self):

return len(self.v)

def __getitem__(self, i):

return self.v[i]

def __add__(a, b):

# Element-wise addition

v = []

for i in range(len(a)):

v.append(a[i] + b[i])

return Vec().fromlist(v)

def __sub__(a, b):

# Element-wise subtraction

v = []

for i in range(len(a)):

v.append(a[i] - b[i])

return Vec().fromlist(v)

def __mul__(self, scalar):

# Multiply by scalar

v = []

for i in range(len(self.v)):

v.append(self.v[i]*scalar)

return Vec().fromlist(v)

def test():

a = vec(1, 2, 3)

b = vec(3, 2, 1)

print a

print b

print a+b

print a*3.0

test()