[python 기초] 8. 클래스 , 상속 , 다중상속

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

 

 

<이전 글>

https://silvercoding.tistory.com/39

[python 기초] 7. 함수 및 람다 (lambda)

 

 

- 본 포스팅에서 다룰 내용 요약 

* 클래스 변수 & 인스턴스 변수 차이 (중요)

* 클래스 변수 : 직접 사용 가능, 객체보다 먼저 생성 

* 인스턴스 변수 : 객체 마다 별도로 존재, 인스턴스 생성 후 사용 

* 네임스페이스 : 객체를 인스턴스화 할 때 저장된 공간 ( (ex)이름, 주소, .... -> 독립적인 공간 )   

* 클래스 상속과 다중 상속 

 

 

* 클래스 선언

class 클래스명:

    함수

    함수

    함수 

 

 

 

 

 [클래스 기본 사용] 

- 예제 1 

class UserInfo:
    # 속성, 메소드 
    def __init__(self, name):
        self.name = name
        print("초기화", name)

    def user_info_p(self):
        print('Name : ', self.name)

초기에 name을 받는 클래스 UserInfo를 선언한다. user_info_p메소드를 호출하면 self.name이 출력된다. 

user1 = UserInfo('Silver')
print(user1.name)
user1.user_info_p()

 초기화 Silver 
 Silver 
 Name :  Silver 

user2 = UserInfo('Park')
print(user1.name)
user2.user_info_p()

 초기화 Park 
 Park 
 Name :  Park 

print(id(user1))
print(id(user2))

 2535817860096 
 2535817860544 

같은 클래스에서 나왔지만 user1과 user2 는 서로 다르다. id값이 다르다는 것으로 증명할 수 있다. 

 

 

 

* 네임스페이스 확인 

print(user1.__dict__)
print(user2.__dict__)

 {'name': 'Silver'} 
 {'name': 'Park'} 

 __dict__ 메서드를 사용하여 인스턴스의 네임스페이스를 확인할 수 있다. 저장된 변수와 값이 key, value형식인 dictionary로 출력된다. 

 

 

 

 

 

 

 

- 예제 2 

* self 의 이해 (클래스 메소드 vs 인스턴스 메소드) 

<참고 포스팅> 

https://silvercoding.tistory.com/20?category=957523 

[python 심화] 3. 클래스 메소드, 인스턴스 메소드, 스테이틱 메소드

class SelfTest():
    def function1():
        print('function1 called ! ')

    def function2(self):
        print(id(self))
        print('function2 called ! ')

메서드를 2개 생성해 준다. functionn1은 self를 인자로 받지 않고, function2는 self를 인자로 받는다. 이 경우에 각 두개의 메서드에 어떻게 접근하는지 실험해 본다. 

self_test = SelfTest()

self_test.function1()

 TypeError: function1() takes 0 positional arguments but 1 was given 

function1 함수에 인스턴스로 접근했더니 TypeError가 발생하게 된다. self를 인자로 받지 않기 때문에 클래스 메소드이고, 누구(어떤 인스턴스)의 function1 함수인지 모르는 것이다. 

SelfTest.function1() # 클래스 메소드

 function1 called ! 

따라서 이렇게 클래스 자체로 접근해 주어야 호출이 가능하다. 

self_test.function2() # 인스턴스 메소드 
print(id(self_test))

 1805035034104 
 function2 called ! 
 1805035034104 

반면 self를 인자로 받았던 function2 메소드는 인스턴스를 통해 호출 가능하다. self의 id를 출력하도록 생성 했었는데, self_test 인스턴스와 id값이 같은 것을 볼 수 있다. 따라서 self를 인자로 받는 클래스의 메소드의 인자인 self에는 인스턴스가 들어가게 되는 것이다. 

SelfTest.function2() # -> 예외

 TypeError: function2() missing 1 required positional argument: 'self' 

이처럼 인스턴스가 아닌 클래스 자체로 접근하면 똑같이 TypeError가 나게 된다. 오류 내용에 따르면 인스턴스를 인자에 넣어주면 실행될 것이다. 

SelfTest.function2(self_test)  # 인자에 인스턴스 넣어주면 클래스자체로 호출 가능

 2385469756864 
 function2 called ! 

 

 

 

 

 

 

 

 

- 예제 3 

: 클래스 변수 vs 인스턴스 변수 

<참고 포스팅> 

https://silvercoding.tistory.com/19?category=957523 

[python 심화] 2. 클래스 기초, 클래스 변수 , 인스턴스 변수

class WareHouse: 
    # 클래스 변수 
    stock_num = 0 
    def __init__(self, name): 
    	# 인스턴스 변수
        self.name = name 
        WareHouse.stock_num += 1 

    def __del__ (self):
        WareHouse.stock_num -= 1

클래스 변수와 인스턴스 변수를 각각 생성해 주었다. 

user1 = WareHouse('Kim')
user2 = WareHouse("Park")
user3 = WareHouse("Lee")

인스턴스를 3개 만들어 준다. 

 

 

* 인스턴스 네임스페이스, 클래스 변수 (모든 인스턴스에 공유) 

print(user1.__dict__)
print(user2.__dict__)
print(user3.__dict__)

 {'name': 'Kim'} 
 {'name': 'Park'} 
 {'name': 'Lee'} 

위와 같이 인스턴스의 네임스페이스를 출력하면 name이 제대로 나오는 것을 볼 수 있다. 

print(user1.name)
print(user2.name)
print(user3.name)

 Kim 
 Park 
 Lee 

 

 

* 클래스 네임스페이스, 클래스 변수 (모든 인스턴스에 공유) 

print(WareHouse.__dict__)  # ---> 클래스 자체의 네임 스페이스에서 클래스변수 확인 가능

 {'__module__': '__main__', 'stock_num': 3, '__init__': <function WareHouse.__init__  
 at 0x0000022B69124510>, '__del__': <function WareHouse.__del__ at 0x0000022B69124598>, '__dict__': <attribute  '__di ct__' of 'WareHouse' objects>, '__weakref__': <attribute '__weakref__' of 'WareHouse' objects>, '__doc__': None} 

이렇게 클래스 변수는 클래스의 네임스페이스를 찍어보면 확인할 수 있다. 

 

print(user1.stock_num) # 자신의 네임스페이스에 없으면 클래스의 네임스페이스에서 찾고, 클래스의 네임스페이스에도 없으면 그때 에러가 난다. 
print(user2.stock_num)
print(user3.stock_num)

 3 
 3 
 3 

클래스 변수는 인스턴스를 통하여 접근할 수도 있다. 자기 자신의 인스턴스 네임스페이스에 찾는 변수가 없으면 클래스의 네임스페이스에서 찾고 , 클래스의 네임스페이스에도 해당 변수가 없으면 그때 오류가 나게 되는 것이다. 

 

del user1

del로 user1을 지우면, 위에 선언해 놓은 대로 sock_num 도 -1이 될 것이다. 

# print(user1.stock_num)
print(user2.stock_num)
print(user3.stock_num)

 2 
 2 

 

 

 

 

 

 

 

 

 

 

 

 

 [클래스 상속] 

- 예제 1 

* Car : 부모 클래스 

class Car: 
    """"Parent Class"""
    def __init__(self, tp, color):
        self.type = tp
        self.color = color

    def show(self):
        return 'Car Class "Show Method!"'

* BmwCar : 자식 클래스 1

class BmwCar(Car):
    """Sub Class"""
    def __init__(self, car_name, tp, color):
        super().__init__(tp, color)
        self.car_name = car_name

    def show_model(self) -> None:
        return "Your Car Name : %s" % self.car_name

* BenzCar : 자식 클래스 2

class BenzCar(Car):
    """Sub Class"""
    def __init__(self, car_name, tp, color):
        super().__init__(tp, color)
        self.car_name = car_name

    def show_model(self) -> None:
        return "Your Car Name : %s" % self.car_name

    def show(self):
        print(super().show())
        return 'Car Info: %s %s %s' % (self.car_name, self.type, self.color)

 

* 사용 

model1 = BmwCar('520d', 'sedan', 'red')

우선 객체를 생성해 준다. 

print(model1.color) # Super 
print(model1.type)  # Super
print(model1.car_name) # Sub
print(model1.show()) # Super    
print(model1.show_model()) # Sub
print(model1.__dict__)

 red 
 sedan 
 520d 
 Car Class "Show Method!" 
 Your Car Name : 520d 
 {'type': 'sedan', 'color': 'red', 'car_name': '520d'} 

부모클래스에서 선언해 놓았던 color, type변수와 show() 메소드가 정상적으로 출력된 것을 볼 수 있다. 인스턴스의 네임스페이스에도 변수가 들어 가 있다. 

 

 

# Method Overriding (오버라이드 : 올라타다)

model2 = BenzCar("220d", 'suv', 'black')
print(model2.show())

 Car Class "Show Method!" 
 Car Info: 220d suv black 

# Parent Method Call 
model3 = BenzCar('350s', 'sedan', 'silver')
print(model3.show())

 Car Class "Show Method!" 
 Car Info: 350s sedan silver 

BenzCar 클래스의 show() 메소드에서 super.show()를 사용하여 부모클래스의 메소드를 오버라이딩 하였다. 따라서 부모 클래스에서 선언하였던 내용도 함께 출력된 것을 볼 수 있다. 

 

 

# Inheritance Info (상속정보 리스트 형태로 나옴)

print(BmwCar.mro())  # 상속 관계를 보여준다. 
print(BenzCar.mro())
# 모든 클래스는 object를 상속받는다.

 [<class '__main__.BmwCar'>, <class '__main__.Car'>, <class 'object'>] 
 [<class '__main__.BenzCar'>, <class '__main__.Car'>, <class 'object'>] 

mro 함수를 사용하여 상속 관계를 리스트로 출력해볼 수 있다. 모든 클래스는 object를 상속 받는 것 또한 알아두기 ! 

 

 

 

 

 

 

- 예제 2 : 다중 상속 

class X:
    pass

class Y:
    pass

class Z:
    pass

class A(X, Y):
    pass

class B(Y, Z):
    pass

class M(B, A, Z):
    pass

우선 클래스 X, Y, Z를 선언하고, A는 X, Y를 , B는 Y, Z 를 , M은 B, A, Z 를 다중상속 받는다. 이 때의 Inheritance Info를 출력해 보자. 

print(M.mro())
print(A.mro())

 [<class '__main__.M'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.X'>, <class '__main__.Y'>, <class '__main__.Z'>, <class 'object'>] 
 [<class '__main__.A'>, <class '__main__.X'>, <class '__main__.Y'>, <class 'object'>] 

이처럼 다중상속이 가능하지만 , 너무 많이 상속 받게 되면 코드를 해석하기 어렵게 만들어질 수도 있으므로 주의하여 사용하는 것이 권장된다.