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)

animal = Animal('푸바오', 10) #객체 생성
animal.eat('대나무')
animal.sleep(10)

class Bear(Animal): # Animal 클래스를 상속
    pass
    
    
    
# Animal 클래스를 상속 받았기 때문에
# Animal 클래스의 생성자 매개변수(name, age)를 전달해야 한다.
#hui = Bear()

hui = Bear('후이바오', 1)
hui.eat('분유')
hui.sleep(10)

후이바오는 분유를 먹습니다.
후이바오는 10시간 동안 잠을 잡니다.

 

 

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

1. 자식 클래스(child class)의 생성자가 호출됩니다.
2. 자식 클래스의 생성자에서 부모 클래스(parent class)의 생성자를 호출해야 합니다. 이를 위해 super() 함수를 사용합니다. super() 함수는 현재 클래스의 부모 클래스를 참조하며, 부모 클래스의 생성자를 호출할 수 있습니다.
3. 부모 클래스의 생성자가 호출됩니다.
4. 부모 클래스의 생성자가 실행을 마치면 자식 클래스의 생성자로 돌아가 자식 클래스의 생성자 코드가 실행됩니다.

 

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

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

Child 클래스 생성자 호출
부모 클래스의 생성자 호출
자식 클래스 생성자 호출

 

3. ※ Object 클래스

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

class MyClass:
    pass

# 위 클래스는 아래 클래스와 동일
class MyClass(object):
    pass

 

 

4. 메서드 오버라이딩

메서드 오버라이딩(Method Overriding)은 객체 지향 프로그래밍에서 중요한 개념 중 하나로, 서브 클래스(자식 클래스)에서 슈퍼 클래스(부모 클래스)의 메서드를 재정의하는 것을 의미합니다. 오버라이딩을 사용하면, 서브 클래스에서 상속받은 메서드의 동작을 변경하거나 확장할 수 있습니다.

 

#부모 클래스
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 Bear(Animal):
    def run(self):
        print(f'{self.name}은/는 달립니다.')

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

    def superEat(self, food):
        super().eat(food)            
        
        
        
Fubao = Animal('Fubao', 3) #부모 클래스
Fubao.eat('대나무')		#부모 클래스 eat
Fubao.sleep(10)        	   #부모 클래스 sleep

Lebao = Bear('러바오', 13)
Lebao.eat('대나무') # 자식클래스의 eat이 출력
Lebao.run()			
Lebao.sleep(10)		 
Lebao.superEat('당근') #부모것을 호출

Fubao는 대나무를 먹습니다.
Fubao는 10시간 동안 잠을 잡니다.


러바오은/는 대나무를 많이 먹습니다.
러바오은/는 달립니다.
러바오는 10시간 동안 잠을 잡니다.
러바오는 당근를 먹습니다.

animal = Animal('판다', 10)
# 부모 클래스는 자식 클래스를 알 수 없음.
# 자식 클래스의 객체 메서드를 사용하지 못함
animal.eat('사과')
#animal.run() 
#AttributeError: 'Animal' object has no attribute 'run'

 

 

5. ※ super() 메소드

super()는 파이썬의 내장 함수로서, 상속과 관련된 작업을 수행할 때 사용됩니다. 특히, 자식 클래스에서 부모 클래스의 메서드를 호출할 때 사용됩니다. super()의 주요 목적은 자식 클래스에서 부모 클래스의 메서드를 오버라이드(재정의)하면서도 그 오버라이드된 메서드 내에서 부모 클래스의 원본 메서드를 호출하는 것입니다.

 

5-1. 기본적인 사용

class Parent:
    def hello(self):
        print('부모클래스의 hello 메서드')
        
class Child(Parent):
    def hello(self):
        super().hello()
        print('자식클래스의 hello 메서드')
        
        
c = Child() #자식객체 생성
c.hello()

부모클래스의 hello 메서드
자식클래스의 hello 메서드

 

 

5-2. __init__메서드의 사용

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        
        

c = Child(10, 20)
print(c.value)      #10
print(c.child_value)#20

 

5-3. 다중상속의 문제

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()
#Base가 최상
#왼쪽 A
#오른쪽 B
#맨아래 Child

[__main__.Child, __main__.A, __main__.B, __main__.Base, object]

c = Child()
c.hello()

Base 클래스의 hello 메서드 호출
B클래스의 hello 메서드 호출
A클래스의 hello 메서드 호출
Child 클래스의 hello 메서드 호출

 

순서 : Base → B →  A → Child

 

6. 다중 상속

다중 상속은 클래스가 둘 이상의 부모 클래스로부터 상속을 받는 기능을 의미합니다. 파이썬은 다른 많은 객체 지향 언어와 달리 다중 상속을 지원합니다. 다중 상속을 사용하면 코드의 재사용성을 향상시킬 수 있지만, 동시에 복잡성이 높아지기 때문에 주의해야 합니다.

 

#부모 클래스
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 Human:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def study(self, hour):
        print(f'{self.name}는 {hour}시간 동안 공부를 합니다.')
 
 
 
class Fubao(Animal, Human): # 두 클래스의 기능을 상속받아 두개의 기능을 사용가능
    pass 
    
    
Fu = Fubao('푸바오', 20)
Fu.eat('대나무')
Fu.study(2)

# 다이아몬드 문제 발생시 메서드가 실행되는 순서
Fubao.mro()

#[__main__.Fubao, > __main__.Animal,> __main__.Human,> object]
#Fubao가 다이아모양중 맨 아래

푸바오는 대나무를 먹습니다.
푸바오는 2시간 동안 공부를 합니다.
[__main__.Fubao, __main__.Animal, __main__.Human, object]