也许举几个例子会有所帮助。

如果您正在构建一个类，并且希望它像字典一样工作，那么您可以定义所有必要的__ __方法。但这有点麻烦。作为一种替代方法，您可以只定义一些，并从UserDict继承(除了任何其他继承)。DictMixin(移动到集合。py3k中的DictMixin)。这将自动定义字典api的所有其余部分。

第二个例子:GUI工具包wxPython允许您创建具有多列的列表控件(例如，在Windows资源管理器中显示的文件)。默认情况下，这些列表相当基本。您可以添加额外的功能，例如通过单击列标题按特定列对列表进行排序的功能，可以从ListCtrl继承并添加适当的mixins。

我读到你有c#背景。因此，一个好的起点可能是。net的mixin实现。

你可能想在http://remix.codeplex.com/上查看codeplex项目

请观看lang.net Symposium链接以获得概述。codeplex页面上还有更多的文档。

问候 斯特凡

也许举几个例子会有所帮助。

如果您正在构建一个类，并且希望它像字典一样工作，那么您可以定义所有必要的__ __方法。但这有点麻烦。作为一种替代方法，您可以只定义一些，并从UserDict继承(除了任何其他继承)。DictMixin(移动到集合。py3k中的DictMixin)。这将自动定义字典api的所有其余部分。

第二个例子:GUI工具包wxPython允许您创建具有多列的列表控件(例如，在Windows资源管理器中显示的文件)。默认情况下，这些列表相当基本。您可以添加额外的功能，例如通过单击列标题按特定列对列表进行排序的功能，可以从ListCtrl继承并添加适当的mixins。

我认为之前的回答很好地定义了mixin是什么。然而, 为了更好地理解它们，从代码/实现的角度将mixin与抽象类和接口进行比较可能是有用的:

1. 抽象类

类，该类需要包含一个或多个抽象方法 抽象类可以包含状态(实例变量)和非抽象方法

2. 接口

接口只包含抽象方法(没有非抽象方法和内部状态)

3.mixin

mixin(像接口)不包含内部状态(实例变量) mixin包含一个或多个非抽象方法(与接口不同，它们可以包含非抽象方法)

在例如Python中，这些只是约定，因为上面所有的都被定义为类。然而，抽象类、接口和mixin的共同特征是它们不应该独立存在，也就是说不应该被实例化。

Mixin提供了一种在类中添加功能的方法，即您可以通过将模块包含在所需的类中来与模块中定义的方法进行交互。虽然ruby不支持多重继承，但提供了mixin作为实现这一目标的替代方案。

下面是一个示例，说明如何使用mixin实现多重继承。

module A    # you create a module
    def a1  # lets have a method 'a1' in it
    end
    def a2  # Another method 'a2'
    end
end

module B    # let's say we have another module
    def b1  # A method 'b1'
    end
    def b2  #another method b2
    end
end

class Sample    # we create a class 'Sample'
    include A   # including module 'A' in the class 'Sample' (mixin)
    include B   # including module B as well

    def S1      #class 'Sample' contains a method 's1'
    end
end

samp = Sample.new    # creating an instance object 'samp'

# we can access methods from module A and B in our class(power of mixin)

samp.a1     # accessing method 'a1' from module A
samp.a2     # accessing method 'a2' from module A
samp.b1     # accessing method 'b1' from module B
samp.b2     # accessing method 'a2' from module B
samp.s1     # accessing method 's1' inside the class Sample

mixin与多重继承的区别是什么?这只是语义上的问题吗?

mixin是一种有限形式的多重继承。在某些语言中，向类中添加mixin的机制(就语法而言)与继承的机制略有不同。

特别是在Python上下文中，mixin是一个父类，它为子类提供功能，但并不打算自己被实例化。

你可能会说，“这只是多重继承，而不是真正的mixin”，因为可能被混淆为mixin的类实际上可以被实例化和使用——所以这确实是语义上的，而且非常真实的区别。

多重继承示例

这个例子，来自文档，是一个OrderedCounter:

类OrderedCounter(计数器，OrderedDict): “计数器，记住第一次遇到的顺序元素” def __repr__(自我): 返回'%s(%r)' % (self.__class__. zip)。__name__ OrderedDict(自我) def __reduce__(自我): 回归自我。__class__进行(OrderedDict(自我),)

它从集合模块继承了Counter和OrderedDict。

Counter和OrderedDict都打算被实例化并单独使用。然而，通过将它们都子类化，我们可以拥有一个有序的计数器，并重用每个对象中的代码。

这是一种重用代码的强大方法，但也可能产生问题。如果发现其中一个对象存在bug，那么不加注意地修复它可能会在子类中创建一个bug。

Mixin的例子

mixin通常被推广为一种获得代码重用的方式，而不会出现协作多重继承(如OrderedCounter)可能存在的潜在耦合问题。当您使用mixin时，您使用的功能与数据不是紧密耦合的。

与上面的例子不同，mixin不打算单独使用。它提供了新的或不同的功能。

例如，标准库在socketserver库中有两个mixin。

可以创建每种类型服务器的分叉和线程版本 使用这些混合类。例如，ThreadingUDPServer是 创建如下: 类ThreadingMixIn, UDPServer: 通过 mix-in类首先出现，因为它覆盖了定义在 UDPServer。设置各种属性还会改变的行为 底层服务器机制。

在这种情况下，mixin方法覆盖UDPServer对象定义中的方法，以实现并发性。

重写的方法似乎是process_request，它还提供了另一个方法process_request_thread。这是来自源代码:

class ThreadingMixIn: """Mix-in class to handle each request in a new thread.""" # Decides how threads will act upon termination of the # main process daemon_threads = False def process_request_thread(self, request, client_address): """Same as in BaseServer but as a thread. In addition, exception handling is done here. """ try: self.finish_request(request, client_address) except Exception: self.handle_error(request, client_address) finally: self.shutdown_request(request) def process_request(self, request, client_address): """Start a new thread to process the request.""" t = threading.Thread(target = self.process_request_thread, args = (request, client_address)) t.daemon = self.daemon_threads t.start()

一个虚构的例子

这是一个主要用于演示目的的mixin -大多数对象将会进化到超出这个repr的有用性:

class SimpleInitReprMixin(object):
    """mixin, don't instantiate - useful for classes instantiable
    by keyword arguments to their __init__ method.
    """
    __slots__ = () # allow subclasses to use __slots__ to prevent __dict__
    def __repr__(self):
        kwarg_strings = []
        d = getattr(self, '__dict__', None)
        if d is not None:
            for k, v in d.items():
                kwarg_strings.append('{k}={v}'.format(k=k, v=repr(v)))
        slots = getattr(self, '__slots__', None)
        if slots is not None:
            for k in slots:
                v = getattr(self, k, None)
                kwarg_strings.append('{k}={v}'.format(k=k, v=repr(v)))
        return '{name}({kwargs})'.format(
          name=type(self).__name__,
          kwargs=', '.join(kwarg_strings)
          )

用法是:

class Foo(SimpleInitReprMixin): # add other mixins and/or extend another class here
    __slots__ = 'foo',
    def __init__(self, foo=None):
        self.foo = foo
        super(Foo, self).__init__()

和用法:

>>> f1 = Foo('bar')
>>> f2 = Foo()
>>> f1
Foo(foo='bar')
>>> f2
Foo(foo=None)