16. 파이썬의 상속

1. 상속

- 상속은 한 클래스의 속성과 메서드를 다른 클래스에 전달하는 기능을 의미

- 상속을 사용하면 기존의 코드를 재사용하고 확장할 수 있음

- 기본적으로 파이썬의 모든 클래스는 object라는 기본 클래스로부터 상속받음

class Parent:          # 부모클래스
    pass
class Child(Parent):   # 자식클래스
    pass

# 클래스 안에 있는 변수를 '속성'이라고 말함
# 클래스 안에 있는 함수를 '메서드'라고 말함
# 클래스 이름은 관례적으로 첫글자를 대문자로 씀

 

class Animal:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def eat(self, food):
    print(f'{self.name}은(는) {food}를 먹습니다')

  def sleep(self, hour):
    print(f'{self.name}은(는) {hour}시간 동안 잠을 잡니다')

animal = Animal('동물', 10)
animal.eat('먹이')
animal.sleep(10)

class Dog(Animal):
  pass

Rucy = Dog()   # 오류 : Animal 클래스를 상속받았기 때문에 Animal 클래스의 생성자 변수를 전달해야함

Rucy = Dog('루시', 14)
Rucy.eat('사료')
Rucy.sleep(9)

 

2. 클래스 상속 시 생성자 호출 순서

1) 자식 클래스(Child Class)의 생성자가 먼저 호출

2) 자식 클래스의 생성자에서 부모 클래스의 생성자가 호출

3) 만약 자식 생성자에서 부모 생성자로 직접 호출할 경우 super() 함수 사용

4) 부모 클래스의 생성자가 실행을 마치면 자식 클래스의 생성자로 돌아가 자식 클래스의 생성자 코드가 실행

class Parent:
  def __init__(self):
    print('부모 클래스 생성자 호출')

class Child(Parent):
  def __init__(self):
    print('Child 클래스 생성자 호출')
    super().__init__()             # 부모클래스 생성자 호출
    print('자식 클래스 생성자 호출')
  
  child = Child()    # Child -> 부모 -> 자식

 

3. object 클래스

object는 파이썬의 모든 클래스의 기본 클래스입니다.
object 클래스는 파이썬에서 모든 객체의 기본적인 동작과 특성을 정의합니다.

class Myclass:
    pass

# 위 클래스와 동일
class Myclass(object):
    pass

# num = 10 을 해도 10은 객체 취급

 

4. 메서드 오버라이딩

- 서브 클래스(자식 클래스)에서 슈퍼 클래스(부모 클래스)의 메서드를 재정의하는 것을 의미
- 서브 클래스에서 상속받은 메서드의 동작을 변경하거나 확장할 수 있음

# 부모클래스의 eat 메서드를 개편하고 싶다 -> 자식 클래스에서 재정의 (덮어쓰는 기능)
# super()를 통해 부모클래스의 매서드도 여전히 사용 가능

# 부모 클래스
class Animal:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def eat(self, food):
    print(f'{self.name}은(는) {food}를 먹습니다')

  def sleep(self, hour):
    print(f'{self.name}은(는) {hour}시간 동안 잠을 잡니다')

# 자식 클래스
class Dog(Animal):
  def run(self):
    print(f'{self.name}은(는) 달립니다')
    
Rucy = Dog('루시', 14)
Rucy.eat('시료')   # 부모 클래스
Rucy.run()        # 자식 클래스

 

같은 이름의 함수로 재정의

class Animal:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def eat(self, food):
    print(f'{self.name}은(는) {food}를 먹습니다')

  def sleep(self, hour):
    print(f'{self.name}은(는) {hour}시간 동안 잠을 잡니다')

class Dog(Animal):
  def run(self):
    print(f'{self.name}은(는) 달립니다')

  def eat(self, food):
    print(f'{self.name}은(는) {food}를 아주 많~~~~이 먹습니다')
  
  def superEat(self, food):
    super().eat(food)
   
Rucy = Dog('루시', 14)
Rucy.eat('사료')       # 자식 클래스의 eat메서드를 가져옴 (덮어썼기 때문)
Rucy.superEat('사료')  # super() 이용해서 부모 클래스의 eat메서드를 가져옴

 

부모 클래스에서 자식 클래스 객체의 메서드 사용 불가능

animal = Animal('동물', 10)
animal.eat('먹이')
# amnimal.run()   ->  오류

 

5. 다중상속

- 클래스가 둘 이상의 부모 클래스로부터 상속을 받는 기능을 의미
- 코드의 재사용성을 향상시킬 수 있지만, 동시에 복잡성이 높아지기 때문에 주의해야 함

# 기본 형태
class Parent1:
  pass

class Parent2:
  pass

class Child(Parent1, Parent2):
  pass

 

# Animal 클래스
class Animal:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def eat(self, food):
    print(f'{self.name}(는) {food}(을)를 먹습니다')

  def sleep(self, hour):
    print(f'{self.name}은(는) {hour}시간 동안 잠을 잡니다')

# Human 클래스
class Human:
  def __init__(self, name, age):
    self.name = name
    self.age = age
    
  def study(self, hour):
    print(f'{self.name}은(는) {hour}시간 동안 공부를 합니다')
    
  def sleep(self, hour):
    print(f'{self.name}은(는) {hour}시간 동안 잠을 푹~~~~ 잡니다')

# 다중 상속한 KimApple 클래스
class KimApple(Animal, Human):
  pass

kim = KimApple('김사과', 20)
kim.eat('사과')    # Animal
kim.study(3)      # Human 메서드
kim.sleep(8)      # Human이 아니고 Animal의 메서드 실행

 

 

C3 선형화 알고리즘

- 다중 상속에서 메서드 해결 순서를 계산하는 사용되는 알고리즘

- 복잡한 상속 구조에서 메서드 호출 순서를 명확하게 결정하기 위해 고안된 알고리즘

- 메서드 해석 순서 (Method Resolution Order, MRO)

print(KimApple.mro())   
# 메서드가 겹칠경우 자기자신을 1순위, Animal 2순위, Human 3순위

 

6. super() 함수

- 상속과 관련된 작업을 수행할 때 사용
- 특히, 자식 클래스에서 부모 클래스의 메서드를 호출할 때 사용
- 주요 목적은 자식 클래스에서 부모 클래스의 메서드를 오버라이드(재정의)하면서도

   오버라이드된 메서드 내에서 부모 클래스의 원본 메서드를 호출하는 것

# 기본 형태
class Parent:
  def hello(self):
    print('부모클래스의 hello 메서드')

class Child(Parent):
  def hello(self):
    super().hello()
    print('자식 클래스의 hello aptjem')

child = Child()
child.hello()    # 둘 다 호출됨

 

1) 매개변수 개수가 다를 때

class Parent:
  def __init__(self, value):
    self.value = value

class Child(Parent):
  def __init__(self, value, child_value):  # 매개변수 개수가 다름. 생성자는 1개. 메서드는 2개.
    self.child_value = child_value

child = Child(10, 20)       # 매개변수는 자식에 맞춰야함
print(child.child_value)    # 20
print(child.value)          # 에러, 따라서 super() 사용

class Parent:
  def __init__(self, value):
    self.value = value

class Child(Parent):
  def __init__(self, value, child_value):
    super().__init__(value)          # 부모의 생성자를 호출해야함
    self.child_value = child_value

child = Child(10, 20)
print(child.value)          # 10

 

2) 클래스 메서드 해석 순서

class Base:
  def hello(self):
    print('Base 클래스의 hello 메서드')

class A(Base):
  def hello(self):
    super().hello()
    print('A 클래스의 hello 메서드')

class B(Base):
  def hello(self):
    super().hello()
    print('B 클래스의 hello 메서드')

class Child(A, B):
  def hello(self):
    super().hello()
    print('Child 클래스의 hello 메서드')
    
Child.mro()     # child, A, B, Base 순

child = Child()
print(child.hello())  # Child의 hello 실행 -> A의 hello 실행 ->
                      # Base의 hello 실행 -> Base의 print 실행 ->
                      # B의 print 실행 -> A의 print 실행 -> Child의 print 실행