Архитектура датчика может быть решена с помощью композиции, если вы хотите придерживаться исходного дизайна карты данных. Кажется, вы новичок в Python, поэтому я постараюсь свести идиомы к минимуму.

class IRSensor:
    def read(self): return {'ir_amplitude': 12}

class UltrasonicSensor:
    def read(self): return {'ultrasonic_amplitude': 63}

class SickLaserSensor:
    def read(self): return {'laser_amplitude': 55}

class CompositeSensor:
    """Wrap multiple component sensors, coalesce the results, and return
    the composite readout.
    """
    component_sensors = []

    def __init__(self, component_sensors=None):
        component_sensors = component_sensors or self.component_sensors
        self.sensors = [cls() for cls in component_sensors]

    def read(self):
        measurements = {}
        for sensor in self.sensors:
            measurements.update(sensor.read())
        return measurements

class MyCompositeSensor(CompositeSensor):
    component_sensors = [UltrasonicSensor, IRSensor]


composite_sensor = MyCompositeSensor()
measurement_map = composite_sensor.read()
assert measurement_map['ultrasonic_amplitude'] == 63
assert measurement_map['ir_amplitude'] == 12

Архитектурная проблема, которую вы описываете с исполнительными механизмами, решается с помощью миксинов и проксирования (через __getattr__), а не наследования. (Проксирование может быть хорошей альтернативой наследованию, поскольку объекты для прокси-сервера могут быть привязаны / отвязаны во время выполнения. Кроме того, вам не нужно беспокоиться об обработке всей инициализации в одном конструкторе с использованием этой техники.)

class MovementActuator:
    def __init__(self, x=0, y=0):
        self.x, self.y = (x, y)

    def move(self, x, y):
        print 'Moving to', x, y
        self.x, self.y = (x, y)

    def get_position(self):
        return (self.x, self.y)

class CommunicationActuator:
    def communicate(self):
        return 'Hey you out there!'

class CompositeActuator:
    component_actuators = []

    def __init__(self, component_actuators=None):
        component_actuators = component_actuators \
            or self.component_actuators
        self.actuators = [cls() for cls in component_actuators]

    def __getattr__(self, attr_name):
        """Look for value in component sensors."""
        for actuator in self.actuators:
            if hasattr(actuator, attr_name):
                return getattr(actuator, attr_name)
        raise AttributeError(attr_name)


class MyCompositeActuator(CompositeActuator):
    component_actuators = [MovementActuator, CommunicationActuator]

composite_actuator = MyCompositeActuator()
assert composite_actuator.get_position() == (0, 0)
assert composite_actuator.communicate() == 'Hey you out there!'

И, наконец, вы можете скинуть все это вместе с простым объявлением узла:

from sensors import *
from actuators import *

class AbstractNode:
    sensors = [] # Set of classes.
    actuators = [] # Set of classes.
    def __init__(self):
        self.composite_sensor = CompositeSensor(self.sensors)
        self.composite_actuator = CompositeActuator(self.actuators)

class MyNode(AbstractNode):
    sensors = [UltrasonicSensor, SickLaserSensor]
    actuators = [MovementActuator, CommunicationActuator]

    def think(self):
        measurement_map = self.composite_sensor.read()
        while self.composite_actuator.get_position()[1] >= 0:
            self.composite_actuator.move(100, -100)

my_node = MyNode()
my_node.think()

Это должно дать вам представление об альтернативах жесткой системе типов. Обратите внимание, что вам вообще не нужно полагаться на иерархию типов - просто реализуйте (потенциально неявный) общий интерфейс.

МЕНЬШЕ СТАРОЕ:

Прочитав вопрос более внимательно, я понял, что у вас есть классический пример наследования алмаза , которое является злом, которое заставляет людей бегать в сторону единственного наследования.

Вероятно, вы не хотите, чтобы это начиналось, поскольку иерархия классов в Python означает приседание. Что вы хотите сделать, так это создать SensorInterface (минимальные требования к датчику) и иметь кучу классов «миксинов» с полностью независимыми функциями, которые можно вызывать с помощью методов с разными именами. В своей сенсорной структуре вы не должны говорить что-то вроде isinstance(sensor, PositionSensor) - вы должны говорить что-то вроде "может ли этот датчик определять местоположение?" в следующем виде:

def get_position(sensor):
    try:
        return sensor.geolocate()
    except AttributeError:
        return None

Это суть философии утиного набора текста и EAFP (проще просить прощения, чем Permission), оба из которых поддерживает язык Python.

Вам, вероятно, следует описать, какие методы эти датчики фактически будут реализовывать, чтобы мы могли описать, как вы можете использовать классы миксинов для своей архитектуры плагина.

СТАРЫЙ:

Если они напишут код в модуле, который помещается в пакет плагина или что-то еще, вы можете волшебным образом инструментировать классы для них, когда вы импортируете их модули плагинов. Что-то вроде этого фрагмента (непроверено):

 import inspect
 import types

 from sensors import Sensor

 def is_class(obj):
     return type(obj) in (types.ClassType, types.TypeType)

 def instrumented_init(self, *args, **kwargs):
     Sensor.__init__(self, *args, **kwargs)

 for module in plugin_modules: # Get this from somewhere...
     classes = inspect.getmembers(module, predicate=is_class)
     for name, cls in classes:
         if hasattr(cls, '__init__'):
             # User specified own init, may be deriving from something else.
             continue 
         if cls.__bases__ != tuple([Sensor]):
             continue # Class doesn't singly inherit from sensor.
         cls.__init__ = instrumented_init

Вы можете найти модули в пакете с другой функцией.

super вызывает следующий класс в mro-списке. Это работает, даже если вы не укажете __init__ форму какого-либо класса.

class A(object):
  def __init__(self):
    super(A,self).__init__()
    print "Hello from A!"

class B(A):
  def __init__(self):
    super(B,self).__init__()
    print "Hello from B!"

class C(A):
  def __init__(self):
    super(C,self).__init__()
    print "Hello from C!"

class D(B,C):
  def __init__(self):
    super(D,self).__init__()
    print "Hello from D!"

class E(B,C):
  pass

Пример:

>>> x = D()
Hello from A!
Hello from C!
Hello from B!
Hello from D!
>>> y = E()
Hello from A!
Hello from C!
Hello from B!
>>> 

Изменить: переписал ответ. (снова)

Вот частичное решение:

class NodeMeta(type):
    def __init__(cls, name, bases, d):
        setattr(cls, '__inherits__', bases)

class Node(object):
    __metaclass__ = NodeMeta

    def __init__(self):
        for cls in self.__inherits__:
            cls.cls_init(self)

class Sensor(Node):
    def cls_init(self):
        print "Sensor initialized"

class PositionSensor(Sensor):
    def cls_init(self):
        print "PositionSensor initialized"
        self._bearing = 0

    def bearing(self):
        # calculate bearing:
        return self._bearing

class BearingSensor(Sensor):
    def cls_init(self):
        print "BearingSensor initialized"
        self._position = (0, 0)

    def position(self):
        # calculate position:
        return self._position

# -------- custom sensors --------

class CustomSensor(PositionSensor, BearingSensor):
    def think(self):
        print "Current position:", self.position()
        print "Current bearing:", self.bearing()

class CustomSensor2(PositionSensor, BearingSensor, Sensor):
    pass

>>> s = CustomSensor()
PositionSensor initialized
BearingSensor initialized
>>> s.think()
Current position: (0, 9)
Current bearing: 0

Вам придется переместить свой __init__ код из подклассов Node в какой-нибудь другой метод (я использовал cls_init).

Изменить: я опубликовал это до того, как увидел ваши обновления; Я перечитаю ваш вопрос и при необходимости обновлю это решение.