CODEWITHSUNDEEP
pythonoopclassinheritance
user670416
user670416

Reputation: 756

Basic usage of python class inheritance

I'm just getting started with Python, and am trying to figure out the Right Way to use classes.

My program currently has two classes, call them Planner and Model. The Planner is model-agnostic, given that any Model it uses presents a consistent interface. So, it seems like if I want to have several different available models, they should all inherit from something, in order to enforce the consistent interface. Additionally, some of the Model classes will share functionality. For example, a singleAgent Model might simulate one agent, while a doubleAgent Model would simulate two agents, each behaving just like the singleAgent.

So - how should I implement this / what language features do I need?

EDIT: Thanks for the fast responses straightening me out about duck classes! So, it sounds like I would only use inheritance if I wanted to override a subset of another Model's functionality? (And for my doubleAgent, I'd probably just use singleAgents as class members?)

I've taken a look through a few other questions with similar tags, but they seem to be more concerned with syntax rather than design choices. I've also looked at the official Python documentation on classes and not found what I'm looking for. (Possibly because I don't know enough to recognize it.)

Upvotes: 2

Views: 246

Answers (3)

radkappe
radkappe

Reputation: 1

Basically the link you provided on Classes in Python answers all your questions under the section about inheritance. In your case just define a class called Model and then two subclasses: singleAgent und doubleAgent.:

class Model:
    pass

class singleAgent(Model):
    pass

If you really, really need abstract classes take a look into "abstract base class"es: http://docs.python.org/library/abc.html

Upvotes: 0

Nate
Nate

Reputation: 12819

One of Python's strengths (and, as many would argue, weaknesses) is that it does not rely on compile-time type checking to enforce interfaces. This means that it is not required for a set of objects to inherit from a common base class in order to have the same interface - they can still be used interchangeably in any function. This behavior is commonly known as duck typing.

In fact, because Python is dynamically typed, you would be hard pressed to "enforce a consistent interface", as you said. For this reason, things like zope.interface have been created. The main benefit you'll get from classes in your case is code reuse - if all Model types implement some common behavior.

To take this even one step further, if you should have some unrelated object type in a third party library out of your control that you wish to use as a Model, you can even do what is called "monkey patching" or "duck punching" in order to add the code necessary to provide your Model interface!

Upvotes: 2

David Heffernan
David Heffernan

Reputation: 612784

In Python you don't generally use quite the same approaches to OOP as in statically typed languages. Specifically you don't actually need an object to implement a specific interface or derive from an abstract base class and so on. Rather that object just needs to be able to do the required operations. This is colloquially known as duck typing. If it walks like a duck and talks like a duck then, to all intents and purposes it is a duck.

So just decide what methods are required for your objects and make sure that they always have them. Should you wish to share implementation between different actors in your system then you can consider class inheritance. But if not then you may as well implement disjoint class hierarchies.

Upvotes: 3

Related Questions