[Python] Super

Python의 super() 함수는 상속을 다루는 데 필수적인 기능입니다. 특히 객체 지향 프로그래밍(OOP)에서 부모 클래스의 메서드를 자식 클래스에서 호출하는 데 사용됩니다. 이 글에서는 super() 함수에 대해 작성해 보겠습니다.

Python의 super() 함수

1. super() 함수란 무엇인가?

super() 함수는 부모 클래스(슈퍼클래스)의 메서드를 호출할 때 사용됩니다. 이는 상속 구조에서 중복 코드를 줄이고, 다중 상속의 경우에도 정확한 부모 클래스의 메서드를 호출하는 데 유용합니다.

2. super() 함수의 기본 사용법

기본 예제

가장 기본적인 형태는 자식 클래스에서 부모 클래스의 메서드를 호출하는 것입니다.

class Parent:
    def __init__(self, name):
        self.name = name
    
    def greet(self):
        print(f"Hello, {self.name}!")

class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name)  # Parent 클래스의 __init__ 호출
        self.age = age

    def greet(self):
        super().greet()  # Parent 클래스의 greet 호출
        print(f"You are {self.age} years old.")

# 사용 예시
child = Child("Alice", 10)
child.greet()

위 예제에서 super().__init__(name)은 부모 클래스인 Parent의 초기화 메서드를 호출하여 name 속성을 초기화합니다. super().greet()은 Parent 클래스의 greet 메서드를 호출합니다.

3. super()의 동작 방식

MRO(Method Resolution Order)

super() 함수는 클래스 계층 구조에서 메서드를 찾는 순서를 정의하는 MRO(Method Resolution Order)를 따릅니다. MRO는 __mro__ 속성으로 확인할 수 있습니다.

class A:
    pass

class B(A):
    pass

class C(B):
    pass

print(C.__mro__)

출력:

(<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)

4. Python과 Java의 다중 상속

Python

Python은 다중 상속을 지원합니다. 이는 한 클래스가 여러 부모 클래스로부터 상속받을 수 있음을 의미합니다. 다중 상속 시, 메서드 해석 순서(MRO; Method Resolution Order)를 통해 어떤 부모 클래스의 메서드를 호출할지 결정합니다.

class A:
    def greet(self):
        print("Hello from A")

class B(A):
    def greet(self):
        print("Hello from B")

class C(A):
    def greet(self):
        print("Hello from C")

class D(B, C):
    def greet(self):
        super().greet()

# 사용 예시
d = D()
d.greet()

출력:

Hello from B

MRO에 따라 B 클래스의 greet 메서드가 호출됩니다. MRO는 D -> B -> C -> A 순서입니다.

Java

Java는 다중 상속을 지원하지 않습니다. 이는 하나의 클래스가 오직 하나의 부모 클래스를 가질 수 있음을 의미합니다. 그러나 인터페이스를 통해 다중 상속의 효과를 구현할 수 있습니다.

class A {
    void greet() {
        System.out.println("Hello from A");
    }
}

class B extends A {
    void greet() {
        System.out.println("Hello from B");
    }
}

class C extends B {
    void greet() {
        System.out.println("Hello from C");
        super.greet();
    }
}

// 사용 예시
C c = new C();
c.greet();

출력:

Hello from C
Hello from B

Java에서는 클래스 계층 구조가 단순하며, 부모 클래스의 메서드를 호출할 때 super 키워드를 사용합니다. 다중 상속이 불가능하므로 다이아몬드 문제와 같은 복잡한 문제를 피할 수 있습니다.

다중 상속 예제

다중 상속의 실제 활용 예제는 GUI 라이브러리나 게임 개발 등에서 많이 사용됩니다. 아래는 다중 상속을 활용한 간단한 GUI 컴포넌트 예제입니다.

class Drawable:
    def draw(self):
        raise NotImplementedError

class Clickable:
    def click(self):
        raise NotImplementedError

class Button(Drawable, Clickable):
    def draw(self):
        print("Drawing a button")

    def click(self):
        print("Button clicked")

# 사용 예시
button = Button()
button.draw()
button.click()

출력:

Drawing a button
Button clicked

5. 활용

super()와 메서드 오버라이딩

super()는 자식 클래스에서 부모 클래스의 메서드를 오버라이드하면서도 부모 클래스의 메서드를 호출하고 싶을 때 사용됩니다.

class Parent:
    def say_hello(self):
        print("Hello from Parent")

class Child(Parent):
    def say_hello(self):
        print("Hello from Child")
        super().say_hello()

# 사용 예시
child = Child()
child.say_hello()

출력:

Hello from Child
Hello from Parent

super()를 사용한 다이아몬드 문제 해결

다이아몬드 문제는 다중 상속 시 여러 경로를 통해 같은 부모 클래스를 상속받는 경우 발생할 수 있는 문제입니다.

class A:
    def __init__(self):
        print("A's __init__")
        super().__init__()

class B(A):
    def __init__(self):
        print("B's __init__")
        super().__init__()

class C(A):
    def __init__(self):
        print("C's __init__")
        super().__init__()

class D(B, C):
    def __init__(self):
        print("D's __init__")
        super().__init__()

# 사용 예시
d = D()

출력:

D's __init__
B's __init__
C's __init__
A's __init__

D 클래스의 __init__ 메서드는 super()를 사용하여 MRO에 따라 부모 클래스의 __init__ 메서드를 차례로 호출합니다.

Python과 Java의 메서드 오버라이딩

Python

Python에서는 메서드 오버라이딩 시 super()를 사용하여 부모 클래스의 메서드를 호출합니다. 이는 자식 클래스가 부모 클래스의 메서드를 확장하거나 변경할 수 있게 합니다.

class Parent:
    def greet(self):
        print("Hello from Parent")

class Child(Parent):
    def greet(self):
        print("Hello from Child")
        super().greet()

# 사용 예시
child = Child()
child.greet()

출력:

Hello from Child
Hello from Parent

Java

Java에서도 메서드 오버라이딩 시 super 키워드를 사용합니다. Java의 모든 메서드는 기본적으로 가상 메서드이므로, 메서드 오버라이딩이 가능합니다.

class Parent {
    void greet() {
        System.out.println("Hello from Parent");
    }
}

class Child extends Parent {
    void greet() {
        System.out.println("Hello from Child");
        super.greet();
    }
}

// 사용 예시
Child child = new Child();
child.greet();

출력:

Hello from Child
Hello from Parent

6. super() 함수의 잘못된 사용 피하기

올바른 사용

super()는 클래스 내부에서 사용해야 하며, 인스턴스나 클래스 메서드에서만 호출되어야 합니다.

잘못된 사용

class Wrong:
    def wrong_method():
        super().some_method()  # 잘못된 사용: 인스턴스 메서드가 아님

위 코드에서는 super()를 인스턴스 메서드가 아닌 곳에서 호출하고 있어 오류가 발생합니다.

7. super()의 장단점

장점

1. 코드 재사용성: 부모 클래스의 메서드를 호출하여 중복 코드를 줄일 수 있습니다.
2. 유지 보수성: 부모 클래스의 메서드를 변경하면 자식 클래스에도 적용되므로, 유지 보수가 용이합니다.
3. 다중 상속 지원: Python에서는 다중 상속 구조에서도 MRO를 통해 올바른 부모 클래스의 메서드를 호출할 수 있습니다.
4. 명확한 계층 구조: 상속 계층 구조를 명확히 하여 코드의 가독성을 높입니다.

단점

1. 복잡성 증가: 다중 상속 및 MRO를 사용하는 경우, 상속 계층 구조가 복잡해질 수 있습니다.
2. 예상치 못한 동작: 상속 계층 구조에 따라 의도하지 않은 부모 클래스의 메서드가 호출될 수 있습니다.
3. 성능 문제: 다중 상속 및 MRO를 사용하는 경우, 메서드 호출 시 성능이 저하될 수 있습니다.

super()의 유용한 팁

• 다중 상속 시 명확한 MRO 이해: MRO를 명확히 이해하고 super()를 사용하면 예기치 않은 동작을 피할 수 있습니다.
• 부모 클래스의 __init__ 호출: 자식 클래스의 __init__에서 부모 클래스의 __init__을 호출하여 초기화를 올바르게 수행하세요.
• 다이아몬드 문제 피하기: Python의 super()는 다이아몬드 문제를 해결할 수 있지만, 복잡한 상속 구조는 피하는 것이 좋습니다.

결론

Python의 super() 함수는 객체 지향 프로그래밍에서 강력한 도구입니다. 상속 구조에서 부모 클래스의 메서드를 호출하여 코드의 재사용성을 높이고, 유지 보수를 용이하게 합니다. Java와의 차이점을 이해하고, super()의 장단점을 파악하여 올바르게 사용하면 더 효율적이고 견고한 코드를 작성할 수 있습니다.