Python 다중 상속에 대한 자세한 설명

class A(object):    # A must be new-style class
   def __init__(self):
    print "enter A"
    print "leave A"
  
class B(C):     # A --> C
   def __init__(self):
    print "enter B"
    super(B, self).__init__()
    print "leave B"

우리의 인상으로는 super(B, self).__init__()는 다음과 같이 이해됩니다. super(B, self)는 먼저 B를 찾습니다. 상위 클래스( 즉, 클래스 A), 클래스 B의 개체 자체를 클래스 A의 개체로 변환한 다음 "변환된" 클래스 A 개체가 자체 __init__ 함수를 호출합니다.

어느 날 동료가 비교적 복잡한 수업 시스템 구조를 설계했는데(수업 시스템 설계가 합리적인지 아닌지 고민하지 말고 이 예제를 주제로 공부하세요) 코드는 다음과 같습니다

코드 세그먼트 4:

class A(object):
    def __init__(self):
        print "enter A"
        print "leave A"
  
class B(object):
    def __init__(self):
        print "enter B"
        print "leave B"
  
class C(A):
    def __init__(self):
        print "enter C"
        super(C, self).__init__()
        print "leave C"
  
class D(A):
    def __init__(self):
        print "enter D"
        super(D, self).__init__()
        print "leave D"
        class E(B, C):
        def __init__(self):
        print "enter E"
        B.__init__(self)
        C.__init__(self)
        print "leave E"
  
class F(E, D):
    def __init__(self):
        print "enter F"
        E.__init__(self)
        D.__init__(self)
        print "leave F"

f = F( ) , 결과는 다음과 같습니다.

Enter F Enter E Enter B Leave B Enter C Enter D Enter A Leave A Leave D Leave C Leave E Enter D Enter A Leave A Leave D Leave F

당연히 클래스 A와 클래스 D의 초기화 함수가 두 번 호출되었는데, 이는 우리가 기대했던 결과가 아닙니다! 예상되는 결과는 클래스 A의 초기화 함수가 최대 두 번 호출된다는 것입니다. 실제로 이는 다중 상속 클래스 시스템이 직면해야 하는 문제입니다. 우리는 아래와 같이 코드 세그먼트 4의 클래스 시스템을 그립니다:

object
| E |
|
F

super에 대한 우리의 이해에 따르면, 그림을 보면 C 클래스의 초기화 함수를 호출할 때 A 클래스의 초기화 함수를 호출해야 하는데 실제로는 D 클래스의 초기화 함수를 호출하고 있는 것을 알 수 있다. 정말 이상한 질문입니다!

즉, mro는 클래스의 모든 기본 클래스의 클래스 유형 순서를 기록합니다. mro의 기록을 보면 7개의 요소가 포함되어 있고 7개의 클래스 이름은 다음과 같습니다.

F E B C D A object

> 이는 C에서 super(C, self)가 사용되는 이유를 설명합니다. .__init__. __init__()는 클래스 D의 초기화 함수를 호출합니다. ???

코드 세그먼트 4를 다음과 같이 다시 작성합니다.

코드 세그먼트 5:

class A(object):
    def __init__(self):
        print "enter A"
        super(A, self).__init__()  # new
        print "leave A"
  
class B(object):
    def __init__(self):
        print "enter B"
        super(B, self).__init__()  # new
        print "leave B"
  
class C(A):
    def __init__(self):
        print "enter C"
        super(C, self).__init__()
        print "leave C"
  
class D(A):
    def __init__(self):
        print "enter D"
        super(D, self).__init__()
        print "leave D"
        class E(B, C):
        def __init__(self):
        print "enter E"
        super(E, self).__init__()  # change
        print "leave E"
  
class F(E, D):
    def __init__(self):
        print "enter F"
        super(F, self).__init__()  # change
        print "leave F"

f = F (), 실행 결과:

enter F enter E enter B enter C enter D Enter A Leave A Leave D Leave C Leave B Leave E Leave F

초기화되는 것을 볼 수 있습니다. F는 완료될 뿐만 아니라 모든 상위 클래스 호출이 제거되고 각 상위 클래스의 초기화 함수는 한 번만 호출되도록 보장됩니다.

요약

1. super는 함수가 아니라 클래스 이름입니다. super(B, self) 형식은 실제로 슈퍼 클래스의 초기화 함수를 호출합니다.
슈퍼 객체가 생성됩니다.

2. 슈퍼 클래스의 초기화 함수는 특별한 작업을 수행하지 않고 단순히 클래스 유형과 특정 인스턴스를 기록합니다.

3. super(B, self) 호출. func는 현재 클래스의 상위 클래스의 func 함수를 호출하는 데 사용되지 않습니다.

4. Python의 다중 상속 클래스는 mro를 사용하여 각 상위 클래스의 함수가 하나씩 호출되도록 합니다. 각 상위 클래스 함수

한 번만 호출됩니다(모든 클래스가 super를 사용하는 경우)
5. 슈퍼 클래스와 바인딩 해제된 함수를 혼합하는 것은 위험한 동작으로, 호출되어야 하는 상위 클래스 함수가 ​​호출되지 않거나 호출되지 않을 수 있습니다.
상위 클래스 함수가 ​​여러 번 호출됩니다.

좀 더 심층적인 질문: 보시다시피 F.__mro__를 인쇄할 때 내부 요소의 순서가 F E B C D A 개체임을 알 수 있습니다. 이는 F의 기본 클래스 검색 순서입니다. 왜 이 순서인지, 그리고 Python mro 시퀀스 구현과 관련된 내장 다중 상속 시퀀스를 구현하는 방법