[python] 다중 상속으로 부모 클래스 __init__ 호출, 올바른 방법은 무엇입니까?

귀하의 질문에 대한 답변은 매우 중요한 측면에 달려 있습니다. 기본 클래스는 다중 상속을 위해 설계 되었습니까?

세 가지 시나리오가 있습니다.

1. 기본 클래스는 관련이없는 독립형 클래스입니다.

   기본 클래스가 독립적으로 작동 할 수 있고 서로를 모르는 별도의 엔터티 인 경우 다중 상속을 위해 설계 되지 않았습니다 . 예:

   class Foo:
       def __init__(self):
           self.foo = 'foo'
   
   class Bar:
       def __init__(self, bar):
           self.bar = bar

   중요 : 전화 도받지 Foo않습니다 ! 이것이 코드가 올바르게 작동하지 않는 이유입니다. 파이썬에서 다이아몬드 상속이 작동하는 방식 때문에 기본 클래스가있는 클래스는 호출하면 안됩니다 . 아시다시피 그렇게하면 다중 상속이 중단됩니다. 결국 다른 클래스를 호출 하지 않기 때문 입니다. ( 면책 조항 : 방지 에 -subclasses 것은 내 개인 추천하고 의미없이 합의 된 파이썬 지역 사회의 합의를 어떤 사람들이 사용하는 것을 선호합니다. 당신은 항상 쓸 수 있다는 주장, 모든 클래스에서 어댑터를 클래스로 작동하지 않는 경우 당신은 기대합니다.)Barsuper().__init__()objectsuper().__init__()__init__object.__init__()super().__init__()objectsuper

   이것은 또한 메소드를 상속 받거나 메소드 object가없는 클래스를 작성해서는 안됨을 의미합니다 __init__. __init__메소드를 전혀 정의하지 않으면 호출하는 것과 같은 효과가 super().__init__()있습니다. 클래스가에서 직접 상속하는 경우 다음 object과 같이 빈 생성자를 추가하십시오.

   class Base(object):
       def __init__(self):
           pass

   어쨌든이 상황에서는 각 부모 생성자를 수동으로 호출해야합니다. 이를 수행하는 두 가지 방법이 있습니다.

   • 없이 super

     class FooBar(Foo, Bar):
         def __init__(self, bar='bar'):
             Foo.__init__(self)  # explicit calls without super
             Bar.__init__(self, bar)

   • 와 super

     class FooBar(Foo, Bar):
         def __init__(self, bar='bar'):
             super().__init__()  # this calls all constructors up to Foo
             super(Foo, self).__init__(bar)  # this calls all constructors after Foo up
                                             # to Bar

   이 두 가지 방법은 각각 고유 한 장단점이 있습니다. 사용 super하면 클래스가 종속성 주입 을 지원 합니다. 반면에 실수하기가 더 쉽습니다. 예를 들어 당신이 순서 변경하는 경우 Foo와 Bar(같은를 class FooBar(Bar, Foo)), 당신은 업데이트해야 할 것입니다 super일치에 대한 호출을. 없이 super이에 대해 걱정할 필요가 없습니다, 그리고 코드는 훨씬 더 읽을 수 있습니다.

2. 수업 중 하나는 mixin입니다.

   믹스 인이 있어 클래스입니다 설계 다중 상속와 함께 사용하도록. 즉, 믹스 인이 자동으로 두 번째 생성자를 호출하기 때문에 두 부모 생성자를 수동으로 호출 할 필요가 없습니다. 이번에는 단일 생성자 만 호출하면되므로 super부모 클래스의 이름을 하드 코딩하지 않아도됩니다.

   예:

   class FooMixin:
       def __init__(self, *args, **kwargs):
           super().__init__(*args, **kwargs)  # forwards all unused arguments
           self.foo = 'foo'
   
   class Bar:
       def __init__(self, bar):
           self.bar = bar
   
   class FooBar(FooMixin, Bar):
       def __init__(self, bar='bar'):
           super().__init__(bar)  # a single call is enough to invoke
                                  # all parent constructors
   
           # NOTE: `FooMixin.__init__(self, bar)` would also work, but isn't
           # recommended because we don't want to hard-code the parent class.

   중요한 세부 사항은 다음과 같습니다.

   • 믹스 인은 super().__init__()수신 한 인수를 호출 하고 전달합니다.
   • 믹스 인의 서브 클래스 상속 첫째 : class FooBar(FooMixin, Bar). 기본 클래스의 순서가 틀리면 mixin의 생성자가 호출되지 않습니다.

3. 모든 기본 클래스는 협동 상속을 위해 설계되었습니다.

   협동 상속을 위해 설계된 클래스는 믹스 인과 매우 유사합니다. 사용되지 않는 모든 인수를 다음 클래스로 전달합니다. 이전과 마찬가지로 호출 super().__init__()하면 모든 부모 생성자가 체인 호출됩니다.

   예:

   class CoopFoo:
       def __init__(self, **kwargs):
           super().__init__(**kwargs)  # forwards all unused arguments
           self.foo = 'foo'
   
   class CoopBar:
       def __init__(self, bar, **kwargs):
           super().__init__(**kwargs)  # forwards all unused arguments
           self.bar = bar
   
   class CoopFooBar(CoopFoo, CoopBar):
       def __init__(self, bar='bar'):
           super().__init__(bar=bar)  # pass all arguments on as keyword
                                      # arguments to avoid problems with
                                      # positional arguments and the order
                                      # of the parent classes

   이 경우 부모 클래스의 순서는 중요하지 않습니다. 우리는 CoopBar처음 부터 상속받을 수도 있지만 코드는 여전히 동일하게 작동합니다. 그러나 모든 인수가 키워드 인수로 전달되기 때문에 사실입니다. 위치 인수를 사용하면 인수 순서가 잘못되기 쉬워 지므로 협동 클래스에서 키워드 인수 만 허용하는 것이 일반적입니다.

   이것은 또한 앞서 언급 규칙에 대한 예외입니다 : 모두 CoopFoo와 CoopBar상속 object,하지만 그들은 여전히 전화 super().__init__(). 그렇지 않은 경우에는 공동 상속이 없습니다.

결론 : 올바른 구현은 상속받는 클래스에 따라 다릅니다.

생성자는 클래스의 공용 인터페이스의 일부입니다. 클래스가 믹스 인으로 또는 공동 상속을 위해 설계된 경우이를 문서화해야합니다. 문서에 이런 종류의 내용이 언급되지 않은 경우 클래스 가 협력 다중 상속을 위해 설계 되지 않았다고 가정하는 것이 안전합니다 .

답변

class A(object):
    def __init__(self):
        print("-> A")
        super(A, self).__init__()
        print("<- A")

class B(object):
    def __init__(self):
        print("-> B")
        super(B, self).__init__()
        print("<- B")

class C(A, B):
    def __init__(self):
        print("-> C")
        # Use super here, instead of explicit calls to __init__
        super(C, self).__init__()
        print("<- C")

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

class A(object):
    def __init__(self):
        print("-> A")
        print("<- A")

class B(object):
    def __init__(self):
        print("-> B")
        # Don't use super here.
        print("<- B")

class C(A, B):
    def __init__(self):
        print("-> C")
        A.__init__(self)
        B.__init__(self)
        print("<- C")

>>> C()
-> C
-> A
<- A
-> B
<- B
<- C

class A(object):
    def __init__(self):
        print("-> A")
        print("<- A")

class B(object):
    def __init__(self):
        print("-> B")
        super(B, self).__init__()
        print("<- B")

class Adapter(object):
    def __init__(self):
        print("-> C")
        A.__init__(self)
        super(Adapter, self).__init__()
        print("<- C")

class C(Adapter, B):
    pass

>>> C()
-> C
-> A
<- A
-> B
<- B
<- C

class A(object):
    def __init__(self):
        print("-> A")
        super(A, self).__init__()
        print("<- A")

class B(object):
    def __init__(self):
        print("-> B")
        print("<- B")

class Adapter(object):
    def __init__(self):
        print("-> C")
        super(Adapter, self).__init__()
        B.__init__(self)
        print("<- C")

class C(Adapter, A):
    pass

>>> C()
-> C
-> A
<- A
-> B
<- B
<- C

class C(A, B):
    def __init__(self):
        print("entering c")
        for base_class in C.__bases__:  # (A, B)
             base_class.__init__(self)
        print("leaving c")