Is this Pythonic?

[phil hunt]

Suppose I'm writing an abstract superclass which will have some
concrete subclasses. I want to signal in my code that the subclasses
will implement certan methods. Is this a Pythonic way of doing what
I have in mind:

class Foo: # abstract superclass
def bar(self):
raise Exception, "Implemented by subclass"
def baz(self):
raise Exception, "Implemented by subclass"

class Concrete(Foo):
def bar(self):
#...actual implemtation...
def baz(self):
#...actual implemtation...


--
Email: zen19725 at zen dot co dot uk

[Peter Hansen]

phil hunt wrote:

Suppose I'm writing an abstract superclass which will have some
concrete subclasses. I want to signal in my code that the subclasses
will implement certan methods. Is this a Pythonic way of doing what
I have in mind:

class Foo: # abstract superclass
def bar(self):
raise Exception, "Implemented by subclass"
def baz(self):
raise Exception, "Implemented by subclass"

Change those to "raise NotImplementedError('blah')" instead and you'll
be taking the more idiomatic approach.

-Peter

[Benji York]

phil hunt wrote:

Suppose I'm writing an abstract superclass which will have some
concrete subclasses. I want to signal in my code that the subclasses
will implement certan methods. Is this a Pythonic way of doing what

See http://docs.python.org/lib/module-ex...s.html#l2h-298
(NotImplementedError)
--
Benji York

[Caleb Hattingh]

Peter

To my mind, this kind of setup (interface class, or abstact class) is more
usually used in static languages to benefit polymorphism - but python is
dynamically typed, so in which situations would this setup be useful in a
python program? You see, I expected your post to say that it wouldn't
even be necessary, but you didn't :)

I have spent a little effort training myself not to bother setting up
class hierarchies like this in python, due to the fact that I use Delphi a
lot at work (I do pretty much the code below to let myself know when an
inherited/abstract class method is being called in error).

regards
Caleb

On Mon, 01 Aug 2005 18:52:02 +0200, Peter Hansen <pe***@engcorp.com> wrote:

phil hunt wrote:

Suppose I'm writing an abstract superclass which will have some
concrete subclasses. I want to signal in my code that the subclasses
will implement certan methods. Is this a Pythonic way of doing what I
have in mind:
class Foo: # abstract superclass
def bar(self):
raise Exception, "Implemented by subclass"
def baz(self):
raise Exception, "Implemented by subclass"

Change those to "raise NotImplementedError('blah')" instead and you'll
be taking the more idiomatic approach.

-Peter

[Bruno Desthuilliers]

Caleb Hattingh a écrit :

Peter

To my mind, this kind of setup (interface class, or abstact class
are two different things.
) is
more usually used in static languages
True.
to benefit polymorphism
This is a good reason to use an interface in Java. C++ has no notion of
'interface', so you have to use abstract classes to achieve the same result.
- but
python is dynamically typed, so in which situations would this setup be
useful in a python program?
Abstract classes ? When you want to factor out common implementation in
a base class and force derived class to implement specific parts. One
common use case is the template method (aka "hollywood", aka "don't call
us, we'll call you") pattern.
You see, I expected your post to say that
it wouldn't even be necessary, but you didn't :)
Implementation inheritance is never "necessary". Nor are OO, modularity,
structured programming, and human-readable programming languages !-)

It's a fact that inheritence being "only" (err... should I say "mostly"
?) an implementation mechanism in dynamic languages, class hierarchies
tends to be much more flat. But this doesn't mean that abstract base
classes are useless.
I have spent a little effort training myself not to bother setting up
class hierarchies like this in python

I had this pattern too.

[Erik Max Francis]

phil hunt wrote:

Suppose I'm writing an abstract superclass which will have some
concrete subclasses. I want to signal in my code that the subclasses
will implement certan methods. Is this a Pythonic way of doing what
I have in mind:

class Foo: # abstract superclass
def bar(self):
raise Exception, "Implemented by subclass"
def baz(self):
raise Exception, "Implemented by subclass"

class Concrete(Foo):
def bar(self):
#...actual implemtation...
def baz(self):
#...actual implemtation...

Yes, but raise NotImplementedError instead of Exception. Another trick
you can use is to prevent people from instantiating the abstract class:

class Foo:
def __init__(self):
if self.__class__ is Foo:
raise NotImplementedError
...

def bar(self):
raise NotImplementedError

--
Erik Max Francis && ma*@alcyone.com && http://www.alcyone.com/max/
San Jose, CA, USA && 37 20 N 121 53 W && AIM erikmaxfrancis
Everything's gonna be all right / Everything's gonna be okay
-- Sweetbox

[phil hunt]

On Mon, 01 Aug 2005 12:52:02 -0400, Peter Hansen <pe***@engcorp.com> wrote:

phil hunt wrote:

Suppose I'm writing an abstract superclass which will have some
concrete subclasses. I want to signal in my code that the subclasses
will implement certan methods. Is this a Pythonic way of doing what
I have in mind:

class Foo: # abstract superclass
def bar(self):
raise Exception, "Implemented by subclass"
def baz(self):
raise Exception, "Implemented by subclass"

Change those to "raise NotImplementedError('blah')" instead and you'll
be taking the more idiomatic approach.

Ta

--
Email: zen19725 at zen dot co dot uk

[phil hunt]

On Mon, 01 Aug 2005 22:01:06 +0200, Caleb Hattingh <ca****@telkomsa.net> wrote:

Peter

To my mind, this kind of setup (interface class, or abstact class) is more
usually used in static languages to benefit polymorphism - but python is
dynamically typed, so in which situations would this setup be useful in a
python program? You see, I expected your post to say that it wouldn't
even be necessary, but you didn't :)
I realise it's not necessary. I just thought it would be nice to
document the interfaces my concrete classes will be using.
I have spent a little effort training myself not to bother setting up
class hierarchies like this in python, due to the fact that I use Delphi a
lot at work (I do pretty much the code below to let myself know when an
inherited/abstract class method is being called in error).

I started doing OO stuff with Smalltalk, where it isn't necessary,
then moved to C++, where it is, and liked it.

--
Email: zen19725 at zen dot co dot uk

[phil hunt]

On Mon, 01 Aug 2005 14:07:46 -0700, Erik Max Francis <ma*@alcyone.com> wrote:

Yes, but raise NotImplementedError instead of Exception. Another trick
you can use is to prevent people from instantiating the abstract class:

class Foo:
def __init__(self):
if self.__class__ is Foo:
raise NotImplementedError
...

def bar(self):
raise NotImplementedError

That's a clever trick, but it's obvious from the code that the class
is intended to be abstract, so if people are stupid enough to shoot
themselves in the foot by creating an instance, I don't feel like
adding extra code to protect themselves from their stupidity.

--
Email: zen19725 at zen dot co dot uk

[Erik Max Francis]

phil hunt wrote:

That's a clever trick, but it's obvious from the code that the class
is intended to be abstract, so if people are stupid enough to shoot
themselves in the foot by creating an instance, I don't feel like
adding extra code to protect themselves from their stupidity.

Right. But even if you're not worried about stupidity, it's useful to
have it fail in an explicit way as early as possible, rather than later
on. With that addition, the moment you try to create an instance of an
abstract class, you get an exception. Even if it's just a typo, and not
severe negligence, that helps the problem get fixed sooner, rather than
later.

--
Erik Max Francis && ma*@alcyone.com && http://www.alcyone.com/max/
San Jose, CA, USA && 37 20 N 121 53 W && AIM erikmaxfrancis
Morality is a weakness of the mind.
-- Arthur Rimbaud

[Michael Hudson]

ze******@zen.co.uk (phil hunt) writes:

Suppose I'm writing an abstract superclass which will have some
concrete subclasses. I want to signal in my code that the subclasses
will implement certan methods. Is this a Pythonic way of doing what
I have in mind:

class Foo: # abstract superclass
def bar(self):
raise Exception, "Implemented by subclass"
def baz(self):
raise Exception, "Implemented by subclass"

class Concrete(Foo):
def bar(self):
#...actual implemtation...
def baz(self):
#...actual implemtation...

Well, I guess you know this, but if Foo contains no implementation at
all, why inherit from it? It would (possibly) be more Pythonic to
define an interface instead, or just use duck typing.

Cheers,
mwh

--
nonono, while we're making wild conjectures about the behavior
of completely irrelevant tasks, we must not also make serious
mistakes, or the data might suddenly become statistically valid.
-- Erik Naggum, comp.lang.lisp

[phil hunt]

On Tue, 02 Aug 2005 08:31:27 GMT, Michael Hudson <mw*@python.net> wrote:

ze******@zen.co.uk (phil hunt) writes:

Suppose I'm writing an abstract superclass which will have some
concrete subclasses. I want to signal in my code that the subclasses
will implement certan methods. Is this a Pythonic way of doing what
I have in mind:

class Foo: # abstract superclass
def bar(self):
raise Exception, "Implemented by subclass"
def baz(self):
raise Exception, "Implemented by subclass"

class Concrete(Foo):
def bar(self):
#...actual implemtation...
def baz(self):
#...actual implemtation...
Well, I guess you know this, but if Foo contains no implementation at
all, why inherit from it?

(in fact the class I'm using/creating does contain some
implementation)
It would (possibly) be more Pythonic to
define an interface instead,

Does Python have the concept of an interface? When was that added?
--
Email: zen19725 at zen dot co dot uk

[Michael Hudson]

ze******@zen.co.uk (phil hunt) writes:

It would (possibly) be more Pythonic to
define an interface instead,

Does Python have the concept of an interface? When was that added?

It doesn't have one included, but there are at least two
implementations, zope.interface and PyProtocols (I'm sure google will
find you more on both of these).

--
... with these conditions cam the realisation that ... nothing
turned a perfectly normal healthy individual into a great political
or military leader better than irreversible brain damage.
-- The Hitch-Hikers Guide to the Galaxy, Episode 11