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

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

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

我认为它们是使用多重继承的一种有纪律的方式——因为最终mixin只是另一个python类，它(可能)遵循称为mixin的类的约定。

我对Mixin的理解是:

添加方法但不添加实例变量(类常量是可以的) 仅从object继承(Python中)

通过这种方式，它限制了多重继承的潜在复杂性，并通过限制必须查看的位置(与完整的多重继承相比)使跟踪程序流程变得相当容易。它们类似于ruby模块。

如果我想添加实例变量(具有比单继承所允许的更大的灵活性)，那么我倾向于组合。

话虽如此，我还见过名为XYZMixin的类确实有实例变量。

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)

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。也就是说，这个类可能被设计成独立存在的。

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

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

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

问候 斯特凡

这个概念来自Steve 's Ice Cream，这是一家由Steve Herrell于1973年在马萨诸塞州萨默维尔创立的冰淇淋店，在那里混合(糖果、蛋糕等)被混合成基本的冰淇淋口味(香草、巧克力等)。

受到Steve 's Ice Cream的启发，Lisp对象系统Flavors的设计者第一次在编程语言中包含了这个概念，其中mix-in是用于增强其他类的小型辅助类，flavour是大型独立类。

因此，主要的思想是mix-in是一个可重用的扩展(“可重用”而不是“独占”;' extension '而不是' base ')。

这个概念与单一或多个继承以及抽象或具体类的概念是正交的。混合类可以用于单个或多个继承，可以是抽象类也可以是具体类。混合类有不完整的接口，抽象类有不完整的实现，具体类有完整的实现。

Mix-in类名通常以' -MixIn '、' -able '或' -ible '作为后缀，以强调它们的性质，就像Python标准库中socketserver模块的ThreadingMixIn和ForkingMixIn类，以及集合的Hashable、Iterable、Callable、Awaitable、AsyncIterable和可逆类一样。美国广播公司(abc)模块。

下面是一个mix-in类的例子，用于扩展Python内置list和dict类的日志记录功能:

import logging

class LoggingMixIn:
    def __setitem__(self, key, value):
        logging.info('Setting %r to %r', key, value)
        super().__setitem__(key, value)
    def __delitem__(self, key):
        logging.info('Deleting %r', key)
        super().__delitem__(key)

class LoggingList(LoggingMixIn, list):
    pass

class LoggingDict(LoggingMixIn, dict):
    pass

>>> logging.basicConfig(level=logging.INFO)
>>> l = LoggingList([False])
>>> d = LoggingDict({'a': False})
>>> l[0] = True
INFO:root:Setting 0 to True
>>> d['a'] = True
INFO:root:Setting 'a' to True
>>> del l[0]
INFO:root:Deleting 0
>>> del d['a']
INFO:root:Deleting 'a'