动态选择从哪个子类继承方法？

Question

假设我有不同的类提供对不同子系统的访问但具有通用接口。它们都提供相同的方法集，但每个类以不同的方式实现它们（想想使用 foo.write() 写入文件或通过套接字发送数据等）

由于接口相同，我想创建一个能够选择正确类但仅基于构造函数/初始化器参数的类。

在代码上，它看起来像

class Foo(object):
    def who_am_i(self):
        print "Foo"

class Bar(object):
    def who_am_i(self):
        print "Bar"

# Class that decides which one to use and adds some methods that are common to both
class SomeClass(Foo, Bar):
    def __init__(self, use_foo):
        # How inherit methods from Foo -OR- Bar?

在给定__init__ 和/或__new__ 参数的情况下，SomeClass 如何从Foo 继承方法或 Bar？

目标应该是这样的

>>> some_object = SomeClass(use_foo=True)
>>> some_object.who_am_i()
Foo
>>> another_object = SomeClass(use_foo=False)
>>> another_object.who_am_i()
Bar

是否有一些干净的“pythonic”方式来实现这一点？我不想使用函数来动态定义SomeClass，但我没有找到其他方法来做到这一点。

谢谢！

Answer 1

如 cmets 中所述，这可以通过工厂函数（伪装成类的函数）来完成：

def SomeClass(use_foo):
    if use_foo:
        return Foo()
    else:
        return Bar()

Answer 2

据我所知，您的继承权完全倒退；而不是您提议的多重继承：

Foo              Bar
- foo code       - bar code

     \          /

      SomeClass(Foo, Bar)
      - common code

您可以使用更简单的单继承模型：

      SomeClass
      - common code

     /          \

Foo(SomeClass)   Bar(SomeClass)
- foo code       - bar code

这使您的问题之一是选择要实例化哪个子类（只需做出一次决定）而不是调用哪个超类方法（可能需要在每个方法调用上进行）。这可以通过以下方式解决：

thing = Foo() if use_foo else Bar()

Answer 3

这里可以使用类工厂。请注意使用字典以确保 same 子类实例用于每个基类。

def makeclass(baseclass, classes={}):
    if baseclass not in classes:
        class Class(baseclass):
            pass   # define your methods here
        classes[baseclass] = Class
    return classes[baseclass]

obj1 = makeclass(Foo)(...)
obj2 = makeclass(Bar)(...)

isinstance(obj1, makeclass(Foo)) # True
isinstance(obj1, Foo)            # True
issubclass(makeclass(Foo), Foo)  # True
issubclass(type(obj1), Foo)      # True

你也可以用__missing__ 方法创建一个dict 子类来做同样的事情；它更明确地表明您有一个存储类的容器，但可以按需创建它们：

class ClassDict(dict):
     def __missing__(self, baseclass):
         class Class(baseclass):
             pass   # define your methods here
         self[baseclass] = Class
         return Class

subclasses = ClassDict()
obj1 = subclasses[Foo]
obj2 = subclasses[Bar]

Answer 4

从对答案的不一致来看，也许问题就是问题。 jonrsharpe's comment 对这个问题给出了一个有趣的见解：这应该不通过继承来解决。

考虑SomeClass定义如下：

# Class that uses Foo or Bar depending on the environment
# Notice it doesn't subclasses either Foo or Bar
class SomeClass(object):
    def __init__(self, use_foo):
        if use_foo:
            self.handler = Foo() 
        else:
            self.handler = Bar() 

    # Makes more sense asking 'Who implements?' instead of 'Who am I?'
    def who_implements(self):
        return self.handler

    # Explicitly expose methods from the handler
    def some_handler_method(self, *args, **kwargs):
        return self.handler.some_handler_method(*args, **kwargs)

    def another_handler_method(self, *args, **kwargs):
        return self.handler.another_handler_method(*args, **kwargs)

如果我们需要获取有关处理程序实现的详细信息，只需获取handler 属性。 SomeClass 子类的其他类甚至不会直接看到处理程序，这实际上是有道理的。

Answer 5

为此可以使用__new__ 方法：

_foos = {}
_bars = {}
class SomeClass(object):
     def __new__(cls,use_foo,*args,**kwargs):
         if use_foo:
            if cls not in _foos:
                class specialized(cls,Foo):pass
                _foos[cls] = specialized
           else:
               specialized = _foos[cls]
         else:
            if cls not in _bars:
                class specialized(cls,Bar):pass
                _bars[cls] = specialized
           else:
               specialized = _bars[cls]
         specialized.__name__ = cls.__name__
         return object.__new__(specialized,*args,**kwargs)
     #common methods to both go here
     pass

与工厂函数相比，它的优点是isinstance(SomeClass(True),SomeClass) 可以工作，并且SomeClass 可以被子类化。