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...

 

[Peter Hansen]

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]

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-exceptions.html#l2h-298
(NotImplementedError)

 

[phil hunt]

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

Ta

 

[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

 

[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]

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

 

[phil hunt]

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.

 

[phil hunt]

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.

 

[Erik Max Francis]

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.

 

[Michael Hudson]

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

 

[phil hunt]

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?

 

[Michael Hudson]

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