我建议不要在新的Python代码中使用mix-in，如果你能找到其他方法(比如用复合代替继承，或者只是把方法打补丁到你自己的类中)，这样做并不费力。

在老式的类中，您可以使用mix- In作为从另一个类中抓取一些方法的一种方式。但在新风格的世界里，一切，甚至是混合，都继承自对象。这意味着任何多重继承的使用都会自然地引入MRO问题。

在Python中有很多方法可以使多继承MRO工作，最著名的是super()函数，但这意味着您必须使用super()来完成整个类层次结构，并且要理解控制流要困难得多。

这个答案旨在通过以下例子解释mixin:

自包含:简短，不需要知道任何库来理解示例。 Python，而不是其他语言。 可以理解，这里有来自其他语言(如Ruby)的例子，因为这个术语在这些语言中更常见，但这是一个Python线程。

它还应审议有争议的问题:

对于mixin的特征来说，多重继承是必要的还是不必要的?

定义

我还没有看到一个“权威”来源的引用清楚地说明什么是Python中的mixin。

我已经看到了mixin的两种可能的定义(如果它们被认为不同于其他类似的概念，如抽象基类)，人们并不完全同意哪一种是正确的。

不同语言之间的共识可能有所不同。

定义1:无多重继承

mixin是这样一个类，该类的一些方法使用了类中没有定义的方法。

因此，该类并不意味着要被实例化，而是作为基类使用。否则，实例将具有在不引发异常的情况下无法调用的方法。

一些源代码添加的约束是类不能包含数据，只能包含方法，但我不明白为什么这是必要的。然而在实践中，许多有用的mixin没有任何数据，没有数据的基类使用起来更简单。

一个经典的例子是从<=和==中实现所有比较运算符:

class ComparableMixin(object):
    """This class has methods which use `<=` and `==`,
    but this class does NOT implement those methods."""
    def __ne__(self, other):
        return not (self == other)
    def __lt__(self, other):
        return self <= other and (self != other)
    def __gt__(self, other):
        return not self <= other
    def __ge__(self, other):
        return self == other or self > other

class Integer(ComparableMixin):
    def __init__(self, i):
        self.i = i
    def __le__(self, other):
        return self.i <= other.i
    def __eq__(self, other):
        return self.i == other.i

assert Integer(0) <  Integer(1)
assert Integer(0) != Integer(1)
assert Integer(1) >  Integer(0)
assert Integer(1) >= Integer(1)

# It is possible to instantiate a mixin:
o = ComparableMixin()
# but one of its methods raise an exception:
#o != o 

这个特殊的例子可以通过functools. total_ordered()装饰器来实现，但这里的游戏是重新发明轮子:

import functools

@functools.total_ordering
class Integer(object):
    def __init__(self, i):
        self.i = i
    def __le__(self, other):
        return self.i <= other.i
    def __eq__(self, other):
        return self.i == other.i

assert Integer(0) < Integer(1)
assert Integer(0) != Integer(1)
assert Integer(1) > Integer(0)
assert Integer(1) >= Integer(1)

定义2:多重继承

mixin是一种设计模式，其中基类的一些方法使用了它没有定义的方法，并且该方法应该由另一个基类实现，而不是像定义1中那样由派生类实现。

术语mixin类指的是打算在该设计模式中使用的基类(TODO是使用该方法的基类，还是实现该方法的基类?)

判断一个给定的类是否为mixin并不容易:方法可以只是在派生类上实现，在这种情况下，我们回到定义1。你必须考虑作者的意图。

这种模式很有趣，因为它可以用不同的基类选择重新组合功能:

class HasMethod1(object):
    def method(self):
        return 1

class HasMethod2(object):
    def method(self):
        return 2

class UsesMethod10(object):
    def usesMethod(self):
        return self.method() + 10

class UsesMethod20(object):
    def usesMethod(self):
        return self.method() + 20

class C1_10(HasMethod1, UsesMethod10): pass
class C1_20(HasMethod1, UsesMethod20): pass
class C2_10(HasMethod2, UsesMethod10): pass
class C2_20(HasMethod2, UsesMethod20): pass

assert C1_10().usesMethod() == 11
assert C1_20().usesMethod() == 21
assert C2_10().usesMethod() == 12
assert C2_20().usesMethod() == 22

# Nothing prevents implementing the method
# on the base class like in Definition 1:

class C3_10(UsesMethod10):
    def method(self):
        return 3

assert C3_10().usesMethod() == 13

权威的Python事件

在官方的收藏文档展上。abc的文档明确使用术语Mixin方法。

它指出，如果一个类:

实现__next__ 继承自单个类Iterator

然后该类免费获得一个__iter__ mixin方法。

因此，至少在文档的这一点上，mixin不需要多重继承，并且与定义1一致。

文档在不同的地方当然可能是矛盾的，其他重要的Python库可能在它们的文档中使用其他定义。

本页还使用了术语Set mixin，这清楚地表明像Set和Iterator这样的类可以称为mixin类。

其他语言

Ruby:很明显，mixin不需要多重继承，就像主要的参考书如Programming Ruby和The Ruby Programming Language中提到的那样 c++:设为=0的虚方法是纯虚方法。 定义1与抽象类(具有纯虚方法的类)的定义一致。 该类不能被实例化。 定义2可以通过虚拟继承实现:两个派生类的多重继承

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

1. 抽象类

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

2. 接口

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

3.mixin

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

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

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)

OP提到他/她从未听说过c++中的mixin，可能是因为它们在c++中被称为奇怪的重复模板模式(CRTP)。另外，@Ciro Santilli提到，mixin在c++中是通过抽象基类实现的。虽然可以使用抽象基类来实现mixin，但这是一种过度使用，因为运行时的虚函数功能可以在编译时使用模板来实现，而不需要在运行时查找虚表。

这里将详细描述CRTP模式

我已经使用下面的模板类将@Ciro Santilli的回答中的python示例转换为c++:

    #include <iostream>
    #include <assert.h>

    template <class T>
    class ComparableMixin {
    public:
        bool operator !=(ComparableMixin &other) {
            return ~(*static_cast<T*>(this) == static_cast<T&>(other));
        }
        bool operator <(ComparableMixin &other) {
            return ((*(this) != other) && (*static_cast<T*>(this) <= static_cast<T&>(other)));
        }
        bool operator >(ComparableMixin &other) {
            return ~(*static_cast<T*>(this) <= static_cast<T&>(other));
        }
        bool operator >=(ComparableMixin &other) {
            return ((*static_cast<T*>(this) == static_cast<T&>(other)) || (*(this) > other));
        }
        protected:
            ComparableMixin() {}
    };

    class Integer: public ComparableMixin<Integer> {
    public:
     Integer(int i) {
         this->i = i;
     }
     int i;
     bool operator <=(Integer &other) {
         return (this->i <= other.i);
     }
     bool operator ==(Integer &other) {
         return (this->i == other.i);
     }
    };

int main() {

    Integer i(0) ;
    Integer j(1) ;
    //ComparableMixin<Integer> c; // this will cause compilation error because constructor is protected.
    assert (i < j );
    assert (i != j);
    assert (j >  i);
    assert (j >= i);

    return 0;
}

编辑:在ComparableMixin中添加了受保护的构造函数，这样它只能被继承而不能被实例化。更新了示例，以显示在创建ComparableMixin对象时protected构造函数将如何导致编译错误。

首先，您应该注意，mixin只存在于多继承语言中。你不能在Java或c#中做mixin。

基本上，mixin是一个独立的基类型，为子类提供有限的功能和多态共振。如果你在用c#思考，考虑一个你不需要实际实现的接口，因为它已经实现了;你只是继承了它，并从它的功能中受益。

mixin的范围通常很窄，不需要扩展。

[编辑——至于为什么:]

既然你问了，我想我该解释一下原因。最大的好处是你不需要自己一遍又一遍地做。在c#中，mixin最大的好处可能来自于处置模式。无论何时实现IDisposable，您几乎总是希望遵循相同的模式，但最终要编写和重写相同的基本代码，只是略有变化。如果有一个可扩展的处置mixin，您可以节省大量额外的输入。

[编辑2 -回答你的其他问题]

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

是的。mixin和标准多重继承之间的区别只是语义上的问题;具有多重继承的类可以利用mixin作为多重继承的一部分。

mixin的目的是创建一个可以通过继承“混合”到任何其他类型的类型，而不影响继承类型，同时仍然为该类型提供一些有益的功能。

同样，考虑一个已经实现的接口。

我个人不使用mixins，因为我主要是用一种不支持mixins的语言开发的，所以我很难想出一个像样的例子来为您提供“啊哈!”的时刻。但我会再试一次。我将使用一个人为设计的示例——大多数语言已经以某种方式提供了该特性——但希望这将解释mixin应该如何创建和使用。是:

Suppose you have a type that you want to be able to serialize to and from XML. You want the type to provide a "ToXML" method that returns a string containing an XML fragment with the data values of the type, and a "FromXML" that allows the type to reconstruct its data values from an XML fragment in a string. Again, this is a contrived example, so perhaps you use a file stream, or an XML Writer class from your language's runtime library... whatever. The point is that you want to serialize your object to XML and get a new object back from XML.

本例中另一个重要的一点是，您希望以通用的方式执行此操作。你不希望为你想要序列化的每一个类型都实现一个“ToXML”和“FromXML”方法，你需要一些通用的方法来确保你的类型能够做到这一点，并且它只是工作。您希望代码重用。

如果您的语言支持它，您可以创建XmlSerializable mixin来完成您的工作。这种类型将实现ToXML和FromXML方法。它将使用一些对示例不重要的机制，能够从混合在其中的任何类型收集所有必要的数据，以构建由ToXML返回的XML片段，并且在调用FromXML时同样能够恢复该数据。

和. .就是这样。要使用它，您需要从XmlSerializable继承任何需要序列化为XML的类型。每当需要序列化或反序列化该类型时，只需调用ToXML或FromXML即可。事实上，由于XmlSerializable是一种成熟的多态类型，因此可以想象，您可以构建一个文档序列化器，它对原始类型一无所知，只接受一个XmlSerializable类型数组。

现在想象一下将这个场景用于其他事情，比如创建一个mixin，以确保每个混合它的类都记录每个方法调用，或者为混合它的类型提供事务性的mixin。这样的例子不胜枚举。

如果您只是将mixin视为一个小型的基本类型，用于在不影响类型的情况下向类型添加少量功能，那么您就很好了。

希望。：）