[Edu-sig] Gutless classes

Kirby Urner urnerk at qwest.net
Thu Sep 8 19:42:34 CEST 2005

I'm thinking about how, in Ruby, class definitions are never closed, meaning
you can add methods to a script in various locations.  You don't supersede
the old class def when you reopen it for more stuff.  There's also this idea
of defining a module full of methods and then binding those to a class -- I
haven't really learned this fully yet.

In Python, we have the ability to define methods externally to classes, as
ordinary functions, except we need the implicit 'self' variable as a first
argument.  For example:

 >>> def __init__(self, a,b):
 	 self.a = a
	 self.b = b

 >>> def __repr__(self):
	 return 'Duh object (%s, %s)' % (self.a, self.b)

 >>> class Duh(object):

 >>> Duh.__init__ = __init__
 >>> Duh.__repr__ = __repr__
 >>> o = Duh(1,2)
 >>> o
 Duh object (1, 2) 

Or we could do it this way:

 >>> class Duh2(object):
	 __init__ = __init__
	 __repr__ = __repr__

 >>> o = Duh2(3,4)
 >>> o
 Duh object (3, 4)

Why do it this way?  I suppose you might have several classes that all use
some method.  Define the method once, then shove it into more than one
gutless class.

In the above case, I guess there's no reason to use underunder syntax in the
external function name, given the rebinding to a local attribute at runtime.
I.e. we might as well go:

 >>> def representer(self):
	 return 'Duh object (%s, %s)' % (self.a, self.b)

 >>> class Duh(object):

 >>> Duh.__init__ = constructor
 >>> Duh.__repr__ = representer
 >>> o = Duh(9,10)
 Duh object (9, 10)


More information about the Edu-sig mailing list