M11 - 상속과 오버라이딩

1. 상속

상속: 한 클래스가 다른 클래스의 속성과 메서드를 물려받는 것

상속의 필요성

● 코드의 재사용성이 높아짐

● 새로운 기능을 추가하거나 기존 코드를 유지/보수하기가 편리함 → 버전 업데이트 관리하기가 쉬움

 

다음은 Library_v1 클래스의 기능을 Library_v2 클래스가 물려받는 모습을 나타낸 것이다.

# 라이브러리 버전1 클래스
class Library_v1:
    pass
    ## func1()...
    ## func2()...

# 라이브러리 버전2 클래스
class Library_v2(Library_v1):
    pass
    ## func3()...

# 라이브러리 버전2의 인스턴스 생성
instance_v2 = Library_v2()

 

Library_v2의 클래스의 인스턴스는 본인의 클래스에 직접 작성한 함수 func3뿐 아니라 v1 클래스에 있는 함수 func1, func2 도 사용할 수 있다.

v2가 기존 v1의 기능도 포함하고 새로운 함수도 가지고 있는 업데이트 버전이다.

새로운 버전을 관리함에 있어 코드를 다시 작성하는 것이 아니라 v1의 기능을 그대로 물려받아 코드의 재사용성을 높인다.

 

v2를 v1의 자식 클래스, v1을 v2의 부모 클래스라고 부른다.

 

 

2. 오버라이딩(overriding)

오버라이딩: 자식 클래스에서 부모 클래스의 메서드(함수)를 재정의 하는 기능

자식 클래스가 부모 클래스의 메서드를 자신의 필요에 맞게 수정할 수 있다.

 

다음은 Library_v1클래스를 Library_v2가 상속받고 Library_v1에 있던 메서드를 오버라이딩 하는 예시이다.

# 라이브러리 버전1 클래스
class Library_v1:
    def calculate(self, a, b):
        return a + b

# 라이브러리 버전2 클래스
class Library_v2(Library_v1):
    def calculate(self, a, b):
        return a * b

# 라이브러리 버전1과 버전1을 상속하는 버전2
instance_v1 = Library_v1()
instance_v2 = Library_v2()

print(instance_v1.calculate(3, 2)) # 출력: 5
print(instance_v2.calculate(3, 2)) # 출력: 6

 

v1에 있던 덧셈을 하는 calculate라는 함수가 v2에서는 곱셈을 하는 함수로 변경된 것을 알 수 있다.

오버라이딩이 진행된 instance_v2에서는 calculate함수를 호출하면 상속받은 v1에 있는 calculate이 호출되는 것이 아닌 오버라이딩한 곱셈 calculate가 실행되어 instance_v1에서와의 값과 다른 결과가 출력된다.

 

** 오버라이딩 시에 변수명과 변수의 개수를 변경하는 것이 자유로우며 함수의 이름만 같으면 된다.

 

 

3. super() 메소드

super(): 자식 클래스에서 부모 클래스의 메서드나 속성에 접근할 수 있도록 해주는 함수

주로 오버라이딩된 메서드에서 부모 클래스의 메서드를 호출할 때 사용한다.

(부모 클래스의 기능을 유지하면서 자식 클래스에서 추가적인 동작을 구현하고 싶을 때)

 

다음은 상속과 오버라이딩이 적용된 자식 클래스에서 super()함수를 통해 부모 클래스에 있는 함수를 호출하는 예시이다.

# 라이브러리 버전1 클래스
class Library_v1:
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def calculate(self):
        return self.a + self.b

# 라이브러리 버전2 클래스
class Library_v2(Library_v1):
    def __init__(self, x, y):
        super().__init__(x, y)
    def calculate(self):
        return self.a * self.b
        

# 라이브러리 버전1과 버전1을 상속하는 버전2
instance_v1 = Library_v1(3, 2)
instance_v2 = Library_v2(3, 4)

print(instance_v1.calculate()) # 출력: 5
print(instance_v2.calculate()) # 출력: 12

 

** __init__(): 클래스 초기화 함수로 인스턴스가 생성될 때 자동적으로 가장먼저 실행되는 함수이다.

Library_v2함수에서 Library_v1에 있는 __init__()함수를 오버라이딩하고 super()를 통해 Library_v1에 있는 __init__()함수를 호출하였다.

 

instance_v1에는 바로 Library_v1에 있는 init함수가 실행되어 a = 3, b = 2에 대입된다.

instance_v2에는 Library_v2에 있는 init함수에서 super()를 사용하여 부모의 init함수를 호출하고 있기 때문에 x,y에 들어온 변수가 a와 b에 대입되어 a = 3, b = 4가 대입된다.

(부모를 상속받은 자식은 부모의 함부뿐만 아니라 변수도 사용할 수 있음)

 

 

4. Magic Method

1. __init__: 클래스 초기화 함수

2. __repr__: print할때 호출되는 함수

3. __call__: 클래스를 괄호를 이용해 호출

4.__add__: 클래스의 인스턴스끼리 덧셈할 때 호출되는 함수

 

# int 클래스 버전 업데이트 하기 위해 생성한 클래스
class int_v3(int):
    # print 할 때 출력되는 magic method (오버라이딩)
    def __repr__(self):
        return str(self * 100)

    # 클래스를 괄호로 호출할 때 나오는 magic method
    def __call__(self):
        # 부모 클래스의 원래 __repr__ 함수 호출
        return super().__repr__()

# int 클래스 버전3의 인스턴스 생성
a = int_v3(3.5)

print(a) # 출력: 300
print(a()) # 출력: 3 --> call함수 실행

######################################################################################

# int 클래스 버전 업데이트 하기 위해 생성한 클래스
class int_v4(int):
    # 인스턴스끼리 덧셈 연산할 때의 함수
    def __add__(self, x):
        return self - x

# int 클래스 버전4의 인스턴스 생성
a = int_v4(3.5)

print(a+4) # 출력: -1
## self에 3, x에 4가 대입됐다고 생각하면 됨.
print(4+a) # 출력: 7
## 숫자 4는 인스턴스가 아니기 때문에 원래의 덧셈 연산자로 적용됨.(덧셈의 순서 중요)
######################################################################################

# int 클래스 버전 업데이트 하기 위해 생성한 클래스
class int_v4(int):
    # 인스턴스끼리 덧셈 연산할 때의 함수
    def __add__(self, x):
        return self - x

# int 클래스 버전4의 인스턴스 생성
a = int_v4(3.5)
b = int_v4(6.5)

print(a+b) # 출력: -3
print(b+a) # 출력: 3
## a,b 모두 클래스의 인스턴스 이므로 덧셈의 순서 관계없이 __add__()함수가 호출됨.