Mixins是编程中的一个概念，其中类提供功能，但并不用于实例化。Mixins的主要目的是提供独立的功能，最好是Mixins本身没有与其他Mixins的继承，并且避免状态。在Ruby等语言中，有一些直接的语言支持，但对于Python则没有。但是，您可以使用多类继承来执行Python中提供的功能。

我看了这个视频http://www.youtube.com/watch?v=v_uKI2NOLEM来了解mixin的基础知识。对于初学者来说，了解mixin的基础知识、它们的工作原理以及在实现它们时可能遇到的问题是非常有用的。

维基百科仍然是最好的:http://en.wikipedia.org/wiki/Mixin

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

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

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

mixin是一种特殊的多重继承。使用mixin的主要情况有两种:

您希望为类提供大量可选特性。 你想在很多不同的类中使用一个特定的特性。

对于第一个例子，考虑werkzeug的请求和响应系统。我可以这样创建一个普通的request对象:

from werkzeug import BaseRequest

class Request(BaseRequest):
    pass

如果我想添加接受报头支持，我会这样做

from werkzeug import BaseRequest, AcceptMixin

class Request(AcceptMixin, BaseRequest):
    pass

如果我想让一个请求对象支持接受头，标签，身份验证和用户代理支持，我可以这样做:

from werkzeug import BaseRequest, AcceptMixin, ETagRequestMixin, UserAgentMixin, AuthenticationMixin

class Request(AcceptMixin, ETagRequestMixin, UserAgentMixin, AuthenticationMixin, BaseRequest):
    pass

区别是微妙的，但是在上面的例子中，mixin类并不是独立存在的。在更传统的多重继承中，AuthenticationMixin(例如)可能更像Authenticator。也就是说，这个类可能被设计成独立存在的。

我认为这里有一些很好的解释，但我想提供另一个角度。

In Scala, you can do mixins as has been described here but what is very interesting is that the mixins are actually 'fused' together to create a new kind of class to inherit from. In essence, you do not inherit from multiple classes/mixins, but rather, generate a new kind of class with all the properties of the mixin to inherit from. This makes sense since Scala is based on the JVM where multiple-inheritance is not currently supported (as of Java 8). This mixin class type, by the way, is a special type called a Trait in Scala.

它在定义类的方式中有所暗示: NewClass用SecondMixin和ThirdMixin扩展了FirstMixin …

我不确定CPython解释器是否做同样的事情(mixin class-composition)，但我不会感到惊讶。同样，作为c++背景，我不会将ABC或“接口”称为等同于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

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构造函数将如何导致编译错误。