Python 상속과 다형성 개념 정리

1️⃣ 상속 기초

클래스 간의 코드 재사용을 위한 메커니즘이다.

# 기본 상속
class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return f"{self.name}가 멍멍!"

class Cat(Animal):
    def speak(self):
        return f"{self.name}가 야옹!"

dog = Dog("멍멍이")
print(dog.speak())  # 멍멍이가 멍멍!

# 상속 관계 확인
print(isinstance(dog, Dog))     # True
print(isinstance(dog, Animal))  # True
print(issubclass(Dog, Animal))  # True

# 메서드 추가
class Bird(Animal):
    def speak(self):
        return f"{self.name}가 짹짹!"
    
    def fly(self):
        return f"{self.name}가 날아갑니다!"

✅ 특징:

코드 재사용
메서드 오버라이딩
계층 구조
is-a 관계 표현
공통 인터페이스 제공

2️⃣ 다중 상속

Python은 여러 클래스를 동시에 상속받을 수 있는 다중 상속을 지원한다.

class Flying:
    def fly(self):
        return "날 수 있음"

class Swimming:
    def swim(self):
        return "수영할 수 있음"

class Duck(Flying, Swimming):
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        return f"{self.name}이 꽥꽥!"

# 다중 상속 사용
duck = Duck("도널드")
print(duck.fly())    # 날 수 있음
print(duck.swim())   # 수영할 수 있음
print(duck.speak())  # 도널드이 꽥꽥!

# 메서드 해석 순서(MRO) 확인
print(Duck.__mro__)

# 다이아몬드 문제
class A:
    def who_am_i(self):
        return "I am A"

class B(A):
    def who_am_i(self):
        return "I am B"

class C(A):
    def who_am_i(self):
        return "I am C"

class D(B, C):
    pass

# D의 who_am_i는 B의 메서드가 호출됨
print(D().who_am_i())  # I am B
print(D.__mro__)  # 메서드 해석 순서 확인

✅ 특징:

여러 클래스 상속
기능 조합
Method Resolution Order (MRO) 고려
다이아몬드 문제 해결
C3 선형화 알고리즘 사용

3️⃣ super() 사용

부모 클래스의 메서드를 호출하기 위한 내장 함수이다.

class Parent:
    def __init__(self, name):
        self.name = name
    
    def greet(self):
        return f"안녕, 나는 {self.name}"

class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name)  # 부모 클래스의 __init__ 호출
        self.age = age
    
    def greet(self):
        return super().greet() + f", {self.age}살이야"

# super() 사용
child = Child("영희", 10)
print(child.greet())  # 안녕, 나는 영희, 10살이야

# 다중 상속에서의 super()
class A:
    def method(self):
        print("A.method 호출")

class B(A):
    def method(self):
        print("B.method 호출")
        super().method()

class C(A):
    def method(self):
        print("C.method 호출")
        super().method()

class D(B, C):
    def method(self):
        print("D.method 호출")
        super().method()

# MRO를 따라 D -> B -> C -> A 순서로 메서드 호출
D().method()

✅ 특징:

부모 클래스 메서드 호출
초기화 체인
메서드 확장
다중 상속에서의 MRO 활용
코드 중복 방지
유지보수성 향상

4️⃣ 추상 클래스

추상 클래스는 하위 클래스가 구현해야 하는 메서드를 정의하는 틀이다.

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass
    
    @abstractmethod
    def perimeter(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height
    
    def perimeter(self):
        return 2 * (self.width + self.height)

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        import math
        return math.pi * self.radius ** 2
    
    def perimeter(self):
        import math
        return 2 * math.pi * self.radius

# 추상 클래스는 인스턴스화할 수 없음
# shape = Shape()  # TypeError 발생

# 모든 추상 메서드를 구현하지 않으면 에러 발생
# class InvalidShape(Shape):
#     def area(self):
#         return 0
#     # perimeter 메서드가 없어 에러 발생

# 다형성 활용
shapes = [Rectangle(5, 4), Circle(3)]
for shape in shapes:
    print(f"면적: {shape.area():.2f}, 둘레: {shape.perimeter():.2f}")

✅ 특징:

인터페이스 정의
구현 강제
설계 명확화
다형성 지원
메서드 시그니처 표준화
코드 품질 개선

5️⃣ 믹스인(Mixin) 패턴

믹스인은 상속을 통해 클래스에 기능을 추가하는 방법이다.

class JSONMixin:
    def to_json(self):
        import json
        return json.dumps(self.__dict__)

class CSVMixin:
    def to_csv(self):
        return ",".join(str(v) for v in self.__dict__.values())

class User(JSONMixin, CSVMixin):
    def __init__(self, name, age):
        self.name = name
        self.age = age

user = User("홍길동", 30)
print(user.to_json())  # {"name": "홍길동", "age": 30}
print(user.to_csv())   # 홍길동,30

# 다양한 믹스인 조합
class LoggingMixin:
    def log(self, message):
        print(f"[LOG] {message}")

class ValidationMixin:
    def validate(self):
        for key, value in self.__dict__.items():
            if value is None:
                return False
        return True

class Product(JSONMixin, LoggingMixin, ValidationMixin):
    def __init__(self, name, price, description=None):
        self.name = name
        self.price = price
        self.description = description
        self.log(f"Product created: {name}")

product = Product("노트북", 1500000)
print(product.validate())  # True
print(product.to_json())   # {"name": "노트북", "price": 1500000, "description": null}

✅ 특징:

기능 재사용
코드 모듈화
유연한 확장
관심사 분리
다중 상속 패턴
단일 책임 원칙 준수
구성 가능한 동작

6️⃣ 메서드 오버라이딩과 다형성

상속받은 메서드를 재정의하여 다양한 형태로 동작하게 하는 개념이다.

# 메서드 오버라이딩
class Vehicle:
    def __init__(self, name):
        self.name = name
    
    def start(self):
        return f"{self.name} 시동을 겁니다."
    
    def move(self):
        return f"{self.name} 이동 중"

class Car(Vehicle):
    def start(self):
        return f"{self.name} 엔진을 켭니다."
    
    def move(self):
        return f"{self.name} 도로를 달립니다."

class Boat(Vehicle):
    def start(self):
        return f"{self.name} 모터를 가동합니다."
    
    def move(self):
        return f"{self.name} 물 위를 항해합니다."

# 다형성 활용
vehicles = [Vehicle("운송수단"), Car("소나타"), Boat("요트")]
for vehicle in vehicles:
    print(vehicle.start())
    print(vehicle.move())

# 부분 메서드 오버라이딩
class ElectricCar(Car):
    def start(self):
        # 부모 메서드를 호출한 후 확장
        parent_result = super().start()
        return f"{parent_result} (전기모터 활성화)"
    
    # move 메서드는 오버라이딩하지 않음 (Car의 메서드 사용)

electric_car = ElectricCar("테슬라")
print(electric_car.start())  # 테슬라 엔진을 켭니다. (전기모터 활성화)
print(electric_car.move())   # 테슬라 도로를 달립니다.

✅ 특징:

자식 클래스에서 메서드 재정의
다양한 구현 제공
동일한 인터페이스
런타임 다형성
코드 유연성
확장성 향상
부분적 오버라이딩 가능

7️⃣ 상속과 구성

상속과 구성(Composition)은 코드 재사용을 위한 두 가지 주요 방법이다.

# 상속 방식 (is-a 관계)
class Engine:
    def start(self):
        return "엔진 시동"
    
    def stop(self):
        return "엔진 정지"

class Car(Engine):  # Car is an Engine (?)
    def drive(self):
        return f"{self.start()} 후 주행"

# 구성 방식 (has-a 관계)
class BetterCar:
    def __init__(self):
        self.engine = Engine()  # Car has an Engine
    
    def drive(self):
        return f"{self.engine.start()} 후 주행"
    
    def park(self):
        return f"주차 후 {self.engine.stop()}"

# 더 복잡한, 유연한 구성 예시
class SteeringWheel:
    def turn_left(self):
        return "좌회전"
    
    def turn_right(self):
        return "우회전"

class Wheel:
    def rotate(self):
        return "바퀴 회전"

class AdvancedCar:
    def __init__(self, engine_type):
        if engine_type == "gasoline":
            self.engine = Engine()
        elif engine_type == "electric":
            self.engine = ElectricEngine()
        self.steering = SteeringWheel()
        self.wheels = [Wheel() for _ in range(4)]
    
    def drive(self):
        return f"{self.engine.start()}, {self.wheels[0].rotate()}"
    
    def turn(self, direction):
        if direction == "left":
            return self.steering.turn_left()
        else:
            return self.steering.turn_right()

✅ 특징:

상속: is-a 관계 표현
구성: has-a 관계 표현
구성은 더 유연한 설계 제공
구성은 런타임에 구성요소 변경 가능
"상속보다 구성을 선호하라" 원칙
기능 재사용을 위한 대안적 접근법
의존성 관리 용이

8️⃣ 다중 상속 고급 기법

다중 상속의 복잡성을 관리하고 효과적으로 활용하는 고급 기법이다.

# 협력적 다중 상속 (Cooperative Multiple Inheritance)
class Base:
    def __init__(self):
        print("Base.__init__")

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

class B(Base):
    def __init__(self):
        super().__init__()
        print("B.__init__")

class C(A, B):
    def __init__(self):
        super().__init__()
        print("C.__init__")

# 출력:
# Base.__init__ (한 번만 호출됨)
# B.__init__
# A.__init__
# C.__init__
c = C()
print(C.__mro__)

# 믹스인과 기본 클래스의 조합
class Serializable:
    def serialize(self):
        return str(self.__dict__)

class Loggable:
    def log(self, message):
        print(f"[LOG] {message}")

class Displayable:
    def display(self):
        print(str(self))

class GameObject(Serializable, Loggable, Displayable):
    def __init__(self, x, y, name):
        self.x = x
        self.y = y
        self.name = name
        self.log(f"Created {name} at ({x}, {y})")
    
    def __str__(self):
        return f"{self.name} at ({self.x}, {self.y})"

# 다중 상속과 명명된 튜플
from collections import namedtuple
from dataclasses import dataclass

Point = namedtuple('Point', ['x', 'y'])

@dataclass
class ColorPoint(Point):  # 명명된 튜플 상속
    color: str = "black"
    
    def __init__(self, x, y, color="black"):
        super().__init__(x, y)  # 실패! namedtuple 확장 시 주의

✅ 특징:

협력적 다중 상속
MRO 깊이 이해
믹스인 계층 구조
다중 상속 디자인 패턴
상속 제한 및 주의점
namedtuple, dataclass 상속 주의
인터페이스 조합

주요 팁

✅ 모범 사례:

단일 상속 우선 사용
다중 상속 시 MRO 고려
추상 클래스로 인터페이스 정의
super() 활용하여 부모 클래스 메서드 호출
적절한 메서드 오버라이딩으로 다형성 구현
믹스인으로 기능 확장
타입 검사 활용 (isinstance, issubclass)
명확한 계층 구조 설계
"상속보다 구성을 선호하라" 원칙 고려
깊은 상속 계층 피하기 (3-4단계 이하 유지)
공통 기능은 상위 클래스로 이동
협력적 메서드 호출 패턴 사용
추상화 수준 일관성 유지
리스코프 치환 원칙 준수
명확한 is-a 관계만 상속 사용
has-a 관계는 구성 사용

KR_Inheritance - somaz94/python-study GitHub Wiki

Python 상속과 다형성 개념 정리

1️⃣ 상속 기초

2️⃣ 다중 상속

3️⃣ super() 사용

4️⃣ 추상 클래스

5️⃣ 믹스인(Mixin) 패턴

6️⃣ 메서드 오버라이딩과 다형성

7️⃣ 상속과 구성

8️⃣ 다중 상속 고급 기법

주요 팁

⚠️ GitHub.com Fallback ⚠️

KR_Inheritance - somaz94/python-study GitHub Wiki

Python 상속과 다형성 개념 정리

1️⃣ 상속 기초

2️⃣ 다중 상속

3️⃣ super() 사용

4️⃣ 추상 클래스

5️⃣ 믹스인(Mixin) 패턴

6️⃣ 메서드 오버라이딩과 다형성

7️⃣ 상속과 구성

8️⃣ 다중 상속 고급 기법

주요 팁

⚠️ **GitHub.com Fallback** ⚠️

⚠️ GitHub.com Fallback ⚠️