I am building a code for surface meshes (triangulations for instance).
I need to implement Body objects (bodies can be points, segments,
triangles and so on), then a Mesh will be a collection of bodies,
together with their neighbourhood relations.
I also need OrientedBody objects, which consist in a body
together with a plus or minus sign to describe its orientation.
So, basically an OrientedBody is just a Body with an
integer label stuck on it.

I implemented it in a very crude manner:
------------------------------------------
class Body:
  [...]
class OrientedBody:
  def __init__ (self,b,orient=1):
    # b is an already existing body
    assert isinstance(b,Body)
    self.base = b
    self.orientation = orient
-------------------------------------------

My question is: can it be done using inheritance ?
I recall that I need three distinct objects:
the basic (non-oriented) body, the same body with positive
orientation and the same body with negative orientation.

class Body(object):

class OrientedBody(Body):
   def __init__(self, orient=1):
     Body.__init__(self)
     self.orient = 1

class OrientedBody (Body):
    def __init__(self, orientation = 1) :
        Body.__init__(self)
         self.orientation = orientation

as noted

But, also.

as a rule of thumb .. if you are using "isinstance" in a class to
determine what class a parameter is ... you have broken the OO contract.
  Remember, every class ought to have a well defined internal state and
a well defined interface to its state.

If I write --

class foo (object):
    def __init__ :
       pass

    def some_func (self, val) :
       if isinstance (val, "bar") :
        ....

Then I am either doing something very wrong or very clever (either can
get me in trouble)

In Python it is preferred that I write two functions some_func_a and
some_func_b

e.g.

     def some_func_a (self, val = None, class = bar) :
         assert(isinstance (class, "bar"), True)
         ....

     def some_func_b (self, val = None, class = baz) :
         assert (isinstance (class, "baz"), True)

C++ and Java try to enforce the OO contract by making data and methods
private, protected or public.  Which helps -- but leads to some
confusion (what is protected inheritance in C++????)  Python exposes all
of its classes internals to everyone -- but that doesn't mean you should
touch them!!

As Larry Wall once wrote, "There is a difference between, 'do not enter
my living room because I asked you not to' and 'do not enter my living
room because I have a shotgun'"

Python adopts the 'do not touch my private parts because I asked you not
to' idiom.  (In C++, only friends can touch your privates ... ;-)

So -- be mindful that checking the class of well defined parameters at
anytime is breaking the contract -- you may need to do it -- but it is
more likely that you aren't adhering to good OOD.

Does that make any sense?

Seriously -- I have not had any coffee yet and I am still new at Python.

-- Andrew

Having a real multidispatch (or rule-based dispatch etc) system either
builtin or in the stdlib would indeed be much cleaner. Until then, there
are a couple third-part packages solving this problem, but it can be
overkill for simple problems (and add unneeded/unwanted dependencies).

In what concerns other suggestion, about Python language,
I shall do my best to understand them and apply them.

-- Paul

class BodyWithoutOrientation(object):
    def __init__(self,color):
        self.color = color
    def show_orientation(self):
        print "I don't lean one way or the other"

class OrientedBody(object):
    def __init__(self,base,orientation):
        self.base_body = base
        self.orientation = orientation
    def show_orientation(self):
        print "I lean to the " + \
            {
            OrientedBody.RIGHT : "right",
            OrientedBody.LEFT : "left",
            }[self.orientation],
        print "and my color is " + self.color
    # delegate any other attr lookups to the base_body object
    def __getattr__(self,attr):
        return getattr(self.base_body,attr)
OrientedBody.RIGHT = object()
OrientedBody.LEFT = object()

class LeftRightBody(object):
    def __init__(self,b):
        self.common_base = b
        self.left = OrientedBody(b,OrientedBody.LEFT)
        self.right = OrientedBody(b,OrientedBody.RIGHT)
    def show_orientation(self):
        print "I do both of these:"
        print "- ",
        self.left.show_orientation()
        print "- ",
        self.right.show_orientation()

base = BodyWithoutOrientation("purple")
lr = LeftRightBody(base)

base.show_orientation()
lr.show_orientation()

Now the good news is that Python makes composition/delegation close to
a no-brainer:

class Body(object):
    # definitions here

class OrientedBody(object):
    # notice that we *dont* inherit from Body
    def __init__(self, body, orient):
      self._body = body
      self.orient = orient

    def __getattr__(self, name):
      try:
        return getattr(self._body, name)
      except AttributeError:
        raise AttributeError(
          "OrientedBody object has no attribute %s" % name
        )