이 답변은 다음 과 같은 예제와 믹스 인을 설명하는 것을 목표로합니다 .

• 자체 포함 : 짧고 예제를 이해하기 위해 라이브러리를 알 필요가 없습니다.

• 다른 언어가 아닌 Python .

  Ruby와 같은 다른 언어의 예제가 있다는 것이 이해할 만합니다. 왜냐하면 용어는 해당 언어에서 훨씬 일반적이지만 파이썬 스레드입니다.

또한 논란의 여지가있는 질문을 고려해야한다.

믹스 인을 특성화하기 위해 다중 상속이 필요합니까?

정의

파이썬에서 믹스 인이 무엇인지 명확하게 말하는 “권한있는”출처의 인용을 아직 보지 못했습니다.

믹스 인에 대한 두 가지 가능한 정의를 보았으며 (추상적 인 기본 클래스와 같은 다른 유사한 개념과 다른 것으로 간주되는 경우) 사람들은 어느 것이 올바른지에 전적으로 동의하지 않습니다.

합의는 언어마다 다를 수 있습니다.

정의 1 : 다중 상속 없음

믹스 인은 클래스의 일부 메소드가 클래스에 정의되지 않은 메소드를 사용하도록 클래스입니다.

따라서이 클래스는 인스턴스화가 아니라 기본 클래스 역할을합니다. 그렇지 않으면 인스턴스에는 예외를 발생시키지 않고 호출 할 수없는 메소드가 있습니다.

일부 소스가 추가하는 제약 조건은 클래스에 데이터가없고 메서드 만 포함될 수 있지만 이것이 왜 필요한지 알 수 없다는 것입니다. 그러나 실제로 많은 유용한 믹스 인에는 데이터가 없으며 데이터가없는 기본 클래스는 사용하기가 더 쉽습니다.

전형적인 예는 모든 비교 연산자의 구현 <=과 ==:

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_ordering()데코레이터 를 통해 달성 할 수 있었지만 여기서 게임은 바퀴를 재발 명하는 것이 었습니다

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 : 다중 상속

믹스 인은 기본 클래스의 일부 메소드가 정의하지 않은 메소드를 사용하는 디자인 패턴이며, 해당 메소드는 정의 1에서 파생 된 것이 아니라 다른 기본 클래스에 의해 구현되어야합니다 .

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

권위있는 파이썬 어커런스

collections.abc에 대한 공식 문서 에서 설명서는 Mixin Methods 라는 용어를 명시 적으로 사용합니다 .

그것은 클래스라면 :

• 구현하다 __next__
• 단일 클래스에서 상속 Iterator

그런 다음 클래스는 무료 로 __iter__ mixin 메소드 를 얻습니다 .

따라서 최소한이 문서의 시점에서 mixin은 다중 상속을 요구하지 않으며 정의 1과 일치합니다.

물론 문서는 다른 시점에서 모순 될 수 있으며 다른 중요한 Python 라이브러리는 문서에서 다른 정의를 사용하고있을 수 있습니다.

이 페이지는 또한 용어를 사용합니다.이 용어 Set mixin는 클래스를 Mixin 클래스 Set와 같고 Iterator호출 할 수 있음을 명확하게 제안합니다 .

다른 언어로

• Ruby : Programming Ruby 및 The Ruby programming Language와 같은 주요 참고서에서 언급 한 것처럼 mixin에 대해 다중 상속이 필요하지 않습니다.

• C ++ : 구현되지 않은 메소드는 순수한 가상 메소드입니다.

  정의 1은 추상 클래스 (순수 가상 메서드가있는 클래스)의 정의와 일치합니다. 해당 클래스는 인스턴스화 할 수 없습니다.

  정의 2는 가상 상속으로 가능합니다. 두 개의 파생 클래스에서 다중 상속

답변

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)