How about "pure virtual methods"?
sjmachin at lexicon.net
Sun Dec 19 10:27:19 CET 2004
Alex Martelli wrote:
> class Meta_for_NR(type):
> def __init__(cls, cn, cb, cd):
> super(Meta_for_NR, cls).__init__(cn, cb, cd)
> abstract_methods = 
> for n, v in inspect.getmembers(cls, inspect.ismethod):
> if v is notimplemented: abstract_methods.append(n)
etc etc etc
I'm missing the point of the question and Alex's answer. Let's step
1. Programmer A designs a base class some (or all) of whose methods are
abstract i.e. not implemented in a do-something-useful fashion; they
may be only stubs which document their arguments.
2. Programmer B designs a sub-class, which *should* implement methods
which override those of the base class.
3. Programmer C writes an application which *should* create instances
of the sub-class.
4. Things that can go wrong are (a) C instantiates the base class (b) B
has not provided all the methods (c) B has provided methods but they
don't work properly (d) C's app doesn't invoke B's methods in the
approved manner or sequence or with meaningful arguments or ...
5. The standard approach in Python is to have the virtual methods raise
an exception if invoked. This of course doesn't help with problems c
and d. In an attempt to root out instances of problems c and d,
programmer C will unit-test the @#$% out of the app. This will quickly
discover any instances of problems a and b. One would hope that as well
B has unit-tested the @#$% out of the sub-class.
6. Alex's magnum opus appears to operate on problem a, and maybe on b
(it's over my head). It involves a fair chunk of mucking about -- for
what? Early warning, a few microseconds ahead of the invocation of a
method which will cause the stub in the base class to raise an
More information about the Python-list