파이썬 기초 6. 클래스와 상속

🎯 파이썬 클래스와 상속을 알아본다.

 

 

 

 

클래스

프로그램이 커지면 유지보수를 위해 클래스로 코드를 구조화하고 서로간의 결합을 느슨하게 해야한다. 클래스를 이해하기 위해서 객체지향 프로그래밍을 설명한 글을 먼저 참고하는 게 좋다.

 

클래스 선언

class UserInfo:
    pass

사용자 정보(객체)를 찍어낼 큰 틀(클래스)를 먼저 만든다. 이 틀 하나만 있으면 아주 다양한 사용자를 쉽게 생성할 수 있다.

클래스 이름의 첫 글자는 대문자로 선언한다. 어떤 내용도 작성하지 않고 pass 키워드를 쓰면 일단 에러없이 코드를 실행할 수 있다.

 

 

클래스 최초 초기화

class UserInfo:
    def __init__(self):
        print("초기화")

user1 = UserInfo()

클래스는 속성과 메소드로 구성된다. 속성은 객체의 특징을, 메소드는 수행할 동작을 나타낸다.

__init__() 메소드는 클래스로 객체를 처음 찍어낼 때 사용된다. 클래스 선언은 틀만 만든 것이므로 이 틀로 객체를 찍어내야 메모리에 올려서 사용할 수 있다. 틀로 객체를 찍어내는 작업을 인스턴스화 한다고 표현하는데, 어떤 변수에 이 클래스를 할당해서 메모리에 생성하는 작업이다. 클래스로 코딩하고 변수에 할당시켜서 인스턴스화한다.

자바와 달리 파이썬은 메소드의 첫번째 매개변수에 self를 명시한다. 객체를 호출할 때 호출한 객체 자신이 전달되기 때문이다. 호출할 땐 self를 생략한다.

class UserInfo:
    def __init__(self, name):
        self.name = name
    def user_info_p(self)
        print("name : ", self.name)

user1 = UserInfo("Kim")
user1.user_info_p()

init메소드 인자에 name이라는 유저의 속성을 넣어본다. self라는 유저인포의 인스턴스 변수 안의 name속성에 name을 넣어준다.

이제 UserInfo 클래스는 인스턴스화 될 때마다 이름을 인자로 받아야한다. user1을 객체생성할 때 Kim을 넣고 user1 객체의 메소드인 user_info_p()를 호출하면 user_info_p()함수 실행해서 저장된 네임을 출력하게된다.

 

 

네임스페이스

인스턴스가 갖고있는 자기자신의 저장공간.

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

id() 메소드를 사용해 같은 클래스로 찍어낸 서로 다른 객체의 주소를 찍어보면 역시 다른 값이 나온다. 모든 인스턴스는 각자 독립적인 네임스페이스를 갖고있다.

 

 

self의 이해

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

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

f = SelfTest()
# f.function1()
f.function2()
SelfTest.function1()

function1()은 self 인자가 없다. 누구의 함수인지 모르는 상태다. 그래서 인스턴스를 통해 호출할 수 없고 클래스에서 호출해야한다. function2() 메소드는 자기자신을 가리키는 self 인자를 가졌기 때문에 객체생성 후 변수를 통해 자기자신의 메소드에 접근할 수 있다.

클래스변수는 객체보다 먼저 생성되고 여러 인스턴스에서 공통으로 공유하게 되며 클래스에서 직접 호출할 수 있다. 인스턴스 함수는 클래스를 직접 사용할 수 있지만 객체생성할 때 인자로 클래스이름을 넣어줘야한다.

 

 

class Warehouse:
    # 클래스 변수
    stock_num = 0

    def __init__(self, name):
        # 인스턴스 변수
        self.name = name
        Warehouse.stock_num += 1

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

클래스 변수 stock_num = 0 을 선언하고 값을 초기화했다. __del__()은 인스턴스가 종료될때 호출되는 함수이다.

 

user1 = Warehouse('Kim')
user2 = Warehouse('Park')

2명의 객체를 생성한다.

 

print(user1.name)
print(user2.name)
print(user1.__dict__)
print(user2.__dict__)
print(Warehouse.__dict__)

__dict__() 메소드로 네임스페이스를 확인해보면 각각 이름만 출력된다. 클래스명으로 네임스페이스를 찍어보면 클래스 변수stock_num=2 도 출력된다. 2개의 인스턴스가 클래스변수를 공유하고 있다는 걸 알 수 있다.

 

print(user1.stock_num)
print(user2.stock_num)

인스턴스의 네임스페이스에는 저 클래스 변수가 출력되지 않았다. 하지만 인스턴스에서 클래스 변수를 찍어보면 값이 출력된다. 클래스변수는 모든 인스턴스에서 공유되는 변수이기 때문이다. 자기 네임스페이스에 없으면 클래스 네임스페이스에서 찾는다. 거기에도 없으면 에러가 발생한다.

나중에 배우겠지만 del user1 을 사용하면 인스턴스를 메모리에서 지울 수 있다. user1 인스턴스를 하나 지우고 print(user2.stock_num) 출력해보면 숫자가 1로 줄어든걸 볼수있다. 지웠을 땐 def __del__(self) 함수가 실행되어서 stock_num을 하나 감소했기 때문이다.

 

 

객체와 인스턴스의 차이 (점프 투 파이썬)

클래스로 만든 객체를 인스턴스라고도 한다. a = Cookie() 에서 a는 객체. a객체는 Cookie() 클래스의 인스턴스이다. 인스턴스는 특정 객체가 어떤 클래스의 객체인지 관계 위주로 설명할 때 사용한다. `a는 인스턴스다` 보다는 `a는 객체다` 라는 표현이 어울리며 `a는 쿠키의 객체` 보다는 `a는 쿠키의 인스턴스`라는 표현이 어울린다.

 

 

 

상속

파이썬은 자바와 다르게 다중상속을 허용한다. 상속을 사용하면 코드를 재사용할 수 있다. 부모클래스에서 공통 속성을 정의하고 상속받는 서브클래스에서 그걸 사용한다.

 

class Car:
    """Parent Class"""  #보통 이렇게 표시해준다
    def __init__(self, tp, color):
        self.tp = tp
        self.color = color
    def show(self):
        return 'car class show method'

class BmwCar(Car):

서브클래스의 인자에 부모클래스를 넣어주면 상속표시가 되고 사용가능해진다.

 

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

부모에서 상속받은 메소드는 super()로 초기화하고 자신의 메소드는 self로 초기화를 한다. -> None 은 리턴할 게 없다는 뜻이다.

 

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

print(model1.color) #super
print(model1.tp) #super
print(model1.car_name) #sub
print(model1.show()) #super
print(model1.show_model()) #sub
print(model1.__dict__)

인스턴스 생성하고 메소드 사용해보기

 

 

오버라이딩

#벤츠에 메소드 추가

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

# Method Overriding
model2 = BenzCar("220d", "suv", "black")
print(model2.show())

부모의 모든 메소드를 사용하는게 아니라 상속받을 건 받고 내용을 재정의해서 사용한다.

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

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

부모의 show 메소드를 출력하고 싶을 때, super 키워드로 접근하면 된다.

# Inheritance Info
print(BmwCar.mro())

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

mro() 메소드는 상속관계를 리스트 형태로 보여준다. 모든 클래스는 오브젝트 클래스를 상속받는다.

 

 

다중상속

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

print(M.mro())

클래스 M은 위에 있는 모든 클래스를 상속받은 거라 다중상속된 상태이다.

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

M의 상속관계는 이러하다. 하지만 너무 복잡하고 깊은 관계는 좋지 않다.

 

 

 

😜 NEXT : 파이썬 모듈과 패키지 공부하기