[python] 파이썬에서 ‘슈퍼’는 무엇을합니까?

super()부모의 클래스 메서드, 인스턴스 메서드 또는 정적 메서드의 버전을 확인하기 위해 호출 할 때 우리는 범위를 첫 번째 인수로 사용하는 현재 클래스를 전달하여 해결하려는 부모 범위를 나타냅니다. 두 번째 인수는 해당 범위에 적용하려는 객체를 나타내는 관심 객체입니다.

고려 클래스 계층 A, B및 C각 클래스를 다음 하나의 부모이며, 어디에서 a, b그리고 c각각의 각각의 인스턴스.

super(B, b)
# resolves to the scope of B's parent i.e. A 
# and applies that scope to b, as if b was an instance of A

super(C, c)
# resolves to the scope of C's parent i.e. B
# and applies that scope to c

super(B, c)
# resolves to the scope of B's parent i.e. A 
# and applies that scope to c

super정적 메서드와 함께 사용

예를 들어 방법 super()내에서 __new__()사용

class A(object):
    def __new__(cls, *a, **kw):
        # ...
        # whatever you want to specialize or override here
        # ...

        return super(A, cls).__new__(cls, *a, **kw)

설명:

1- __new__()호출하는 클래스에 대한 참조를 첫 번째 매개 변수 로 사용하는 것이 일반적이지만 Python에서는 클래스 메서드로 구현 되지 않고 정적 메서드입니다. 즉, 클래스에 대한 참조는 __new__()직접 호출 할 때 첫 번째 인수로 명시 적으로 전달되어야 합니다.

# if you defined this
class A(object):
    def __new__(cls):
        pass

# calling this would raise a TypeError due to the missing argument
A.__new__()

# whereas this would be fine
A.__new__(A)

2- super()부모 클래스에 도달하기 위해 호출 할 때 우리는 자식 클래스 A를 첫 번째 인수로 전달 한 다음 관심 객체에 대한 참조를 전달합니다.이 경우 A.__new__(cls)호출 될 때 전달 된 클래스 참조입니다 . 대부분의 경우 자식 클래스에 대한 참조이기도합니다. 예를 들어 여러 세대 상속의 경우에는 그렇지 않을 수 있습니다.

super(A, cls)

3- 일반적 __new__()으로 정적 super(A, cls).__new__메서드이므로 정적 메서드도 반환하므로이 경우 insterest 객체에 대한 참조를 포함하여 모든 인수를 명시 적으로 제공해야합니다 cls.

super(A, cls).__new__(cls, *a, **kw)

4-없이 같은 일을 super

class A(object):
    def __new__(cls, *a, **kw):
        # ...
        # whatever you want to specialize or override here
        # ...

        return object.__new__(cls, *a, **kw)

super인스턴스 메소드와 함께 사용

예를 들어 super()내부에서 사용__init__()

class A(object):
    def __init__(self, *a, **kw):
        # ...
        # you make some changes here
        # ...

        super(A, self).__init__(*a, **kw)

설명:

1- __init__는 인스턴스 메소드입니다. 즉, 첫 번째 인수로 인스턴스에 대한 참조가 필요합니다. 인스턴스에서 직접 호출하면 참조가 암시 적으로 전달되므로이를 지정할 필요가 없습니다.

# you try calling `__init__()` from the class without specifying an instance
# and a TypeError is raised due to the expected but missing reference
A.__init__() # TypeError ...

# you create an instance
a = A()

# you call `__init__()` from that instance and it works
a.__init__()

# you can also call `__init__()` with the class and explicitly pass the instance 
A.__init__(a)

2- super()안에서 호출 할 때 __init__()우리는 자식 클래스를 첫 번째 인수로, 관심 객체를 두 번째 인수로 전달합니다. 일반적으로 자식 클래스의 인스턴스에 대한 참조입니다.

super(A, self)

3- 호출 super(A, self)은 범위를 해결하고 self이제 부모 클래스의 인스턴스 인 것처럼 적용하는 프록시를 반환합니다 . 프록시라고 부르 자 s. __init__()인스턴스 메소드 이므로 호출 s.__init__(...)은 암시 적으로 self부모의 첫 번째 인수로의 참조를 전달합니다 __init__().

4- super부모의 버전에 인스턴스에 대한 참조를 명시 적으로 전달할 필요 없이 동일한 작업을 수행합니다 __init__().

class A(object):
    def __init__(self, *a, **kw):
        # ...
        # you make some changes here
        # ...

        object.__init__(self, *a, **kw)

super클래스 메소드와 함께 사용

class A(object):
    @classmethod
    def alternate_constructor(cls, *a, **kw):
        print "A.alternate_constructor called"
        return cls(*a, **kw)

class B(A):
    @classmethod
    def alternate_constructor(cls, *a, **kw):
        # ...
        # whatever you want to specialize or override here
        # ...

        print "B.alternate_constructor called"
        return super(B, cls).alternate_constructor(*a, **kw)

설명:

1- 클래스 메소드를 클래스에서 직접 호출 할 수 있으며 클래스에 대한 참조를 첫 번째 매개 변수로 사용합니다.

# calling directly from the class is fine,
# a reference to the class is passed implicitly
a = A.alternate_constructor()
b = B.alternate_constructor()

2- super()클래스 메소드 내에서 부모의 버전으로 해석하기 위해 호출 할 때 , 우리는 현재 자식 클래스를 첫 번째 인수로 전달하여 어느 부모의 범위를 확인하려고하는지, 관심있는 객체를 두 번째 인수로 전달하려고합니다. 범위를 적용하려는 객체를 나타 내기 위해 일반적으로 하위 클래스 자체 또는 하위 클래스 중 하나에 대한 참조입니다.

super(B, cls_or_subcls)

3- 통화 super(B, cls)가 범위로 ​​해결되어에 A적용됩니다 cls. alternate_constructor()클래스 메소드 이므로 호출 super(B, cls).alternate_constructor(...)은 의 버전에 cls대한 첫 번째 인수로의 참조를 암시 적으로 전달합니다.Aalternate_constructor()

super(B, cls).alternate_constructor()

4-를 사용하지 않고 동일한 작업을 수행하려면 바인딩되지 않은 버전 (즉, 명시적인 함수 버전)에 super()대한 참조를 가져와야A.alternate_constructor() 합니다. 단순히 이렇게하면 작동하지 않습니다.

class B(A):
    @classmethod
    def alternate_constructor(cls, *a, **kw):
        # ...
        # whatever you want to specialize or override here
        # ...

        print "B.alternate_constructor called"
        return A.alternate_constructor(cls, *a, **kw)

이 A.alternate_constructor()메소드는 A첫 번째 인수로 암시 적 참조를 취하기 때문에 작동하지 않습니다 . cls여기 전달되는이 두 번째 인자가 될 것입니다.

class B(A):
    @classmethod
    def alternate_constructor(cls, *a, **kw):
        # ...
        # whatever you want to specialize or override here
        # ...

        print "B.alternate_constructor called"
        # first we get a reference to the unbound 
        # `A.alternate_constructor` function 
        unbound_func = A.alternate_constructor.im_func
        # now we call it and pass our own `cls` as its first argument
        return unbound_func(cls, *a, **kw)

답변

Class Jen(Cain, Sue):

class SuperObject:
    def __init__(self, **kwargs):
        print('SuperObject')
        mro = type(self).__mro__
        assert mro[-1] is object
        if mro[-2] is not SuperObject:
            raise TypeError(
                'all top-level classes in this hierarchy must inherit from SuperObject',
                'the last class in the MRO should be SuperObject',
                f'mro={[cls.__name__ for cls in mro]}'
            )

        # super().__init__ is guaranteed to be object.__init__        
        init = super().__init__
        init()

class A(SuperObject):
    def __init__(self, **kwargs):
        print("A")
        super(A, self).__init__(**kwargs)

class B(SuperObject):
    def __init__(self, **kwargs):
        print("B")
        super(B, self).__init__(**kwargs)

class C(A):
    def __init__(self, age, **kwargs):
        print("C",f"age={age}")
        super(C, self).__init__(age=age, **kwargs)

class D(B):
    def __init__(self, name, **kwargs):
        print("D", f"name={name}")
        super(D, self).__init__(name=name, **kwargs)

class E(C,D):
    def __init__(self, name, age, *args, **kwargs):
        print( "E", f"name={name}", f"age={age}")
        super(E, self).__init__(name=name, age=age, *args, **kwargs)

E(name='python', age=28)

E name=python age=28
C age=28
A
D name=python
B
SuperObject