[Python] class, instance 속성, class 상속과 생성자

C++/Java에서의 Class와 차이점

• 클래스 instance 생성시 new 키워드가 없다. 함수호출과 같은 방식을 사용한다.
• 메소드 오버로딩이 없다.
  • 메소드 오버로딩: 하나의 클래스에서 메소드 이름은 같고, 인자를 다르게 하는 형태
  • 가변인자를 활용해 사용한다. 가변인자는 인자 앞에 *를 붙여서 사용 (함수참고)
  • def add(self, *num)
• class 속성과 instance 속성을 구분해서 정의해줘야한다
• C#, Java는 다중상속이 불가능하지만 python, c++은 다중상속이 가능하다.

class 속성과 instance 속성 구분하기

class 속성은 class를 import한 후 사용할 수 있다.

• class 변수는 class 내부에서 정의해준다.
• class method 정의시 @classmethod 데코레이터를 표시해준다.
• class method는 class 속성임을 의미하는 cls를 첫번째 매개변수로 받는다. (다른 이름도 가능하다.)

instance 속성은 class의 instance를 생성할 때 생성되며, 각 instance에서만 사용할 수 있다.

• instance 변수는 생성자 역할을 하는 __init__ 함수에서 정의해준다.
• instance method는 instance 속성임을 의미하는 self를 첫번째 매개변수로 받는다.

def __init__(self, argument) 는 C++에서의 생성자와 같다.

• 일반적으로는 __init__함수만 오버라이딩해서 instance 초기화에 이용한다.
• 자세히는 instance 생성시 __new__ 함수를 호출해 instance 생성할당을 한다. __new__ 함수가 __init__함수를 호출하고, instance에서 사용할 초기값들을 초기화한다.

class, instance 속성을 구분하기 위해 simpleClass.py 에 class C를 정의하고, 커맨드라인에서 class C, instance f, g의 속성들을 확인한다.

# simpleClass.py
class C:
        class_attr = [] # class 속성

        def __init__(self):
                self.instance_attr = [] # instance 속성

        def add_instance_attr(self, number): # instance method
                self.instance_attr.append(number)

        @classmethod
        def add_class_attr(cls, number): # class method
                C.class_attr.append(number)

class 속성 확인하기

>>> from simpleClass import C
>>> C.class_attr # 클래스 속성
[]
>>> C.add_class_attr(7) # 클래스 메소드
>>> C.class_attr
[7]
>>> C.add_instance_attr(5) # instance method를 불러올 경우 TypeError가 발생한다.
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unbound method add_instance_attr() must be called with C instance as first argument (got int instance instead)

instance 속성 확인하기

>>> f = C()
>>> g = C()
>>> f.add_instance_attr(5)
>>> f.add_class_attr(5) # instance는 class 함수를 사용할 수 있다.
>>> print f.instance_attr, f.class_attr # class_attr은 공유된다.
[5] [7, 5]
>>> g.add_instance_attr(3)
>>> g.add_class_attr(3)
>>> print g.instance_attr, g.class_attr
[3] [7, 5, 3]

 

Class 상속

상속은 Parent class의 내용을 바탕으로 추가적인 기능을 구현하기 위해 사용된다. 자식 클래스의 instance 생성시 상속받은 부모클래스의 class 변수, class method는 자식 클래스의 instance에서 바로 접근 가능하다. 이는 부모 클래스의 class 속성과 같은 값이다.

 

자식 클래스에서 생성자를 만들지 않은 경우와 새로 만들 경우에 차이가 발생한다. 자식 클래스에서 생성자를 만들지 않은 경우, 자식 클래스의 instance 생성시 부모 클래스의 생성자를 자동으로 호출한다.

 

자식 클래스에서 생성자를 새로 만든 경우, 부모 클래스의 생성자는 자동으로 호출되지 않는다. 부모 클래스의 생성자를 호출하기 위해서는 super() 함수를 통해서 호출하거나, 부모 클래스명을 이용해 직접 생성자를 호출해야한다. 두 함수의 차이는 아래와 같다.

• Parent.__init__(self)방식은 부모클래스의 생성자 메소드를 직접 참고하기 때문에, 부모클래스가 변경될 경우 Child(Parent), Parent.function() 둘 다 변경해줘야한다.
• super(Child, self).__init__방식은 부모클래스를 자동으로 인식하므로, 부모 클래스를 변경할 경우, Child(Parent) 부분만 변경해주면 된다.
• 생성자 초기화시 super()함수는 자동으로 self가 전달되지만, 직접 호출시에는 self도 전달해야한다.

---

아래 예시는 자식 클래스에서 생성자를 새로 만들고, 부모 클래스의 생성자를 호출하는 예제이다.

공통적으로 상속받은 class 변수, class 함수, instance 함수는 사용가능하다.

• 자식 클래스에서 생성자를 만들지 않을 경우
  • 자식 클래스 instance인 child의 instance 속성으로 instance_attr이 생성되어 사용가능하다.
• 자식 클래스에서 생성자를 만들고 부모 클래스의 생성자를 호출하지 않을 경우
  • 자식 클래스 instance인 child의 instance 속성으로 child_instance_attr만 생성된다.
  • 부모 클래스 instance 생성자가 호출되지 않았기 때문에 instance_attr은 생성되지 않는다.
• 자식 클래스에서 생성자를 만들고 부모 클래스의 생성자를 호출한 경우 (아래 예시와 같다)
  • 자식 클래스 instance인 child의 instance 속성으로 child_instance_attr, instance_attr이 생성된다.

class Parent(object):
    class_attr = []

    def __init__(self):
        self.instance_attr = []

    def add_instance_attr(self, number):
        print("parent instance function")
        self.instance_attr.append(number)

    @classmethod
    def add_class_attr(cls, number):
        Parent.class_attr.append(number)

class Child(Parent):
    child_attr = []

    def __init__(self):
    super(Child, self).__init__() # Parent.__init__(self) 와 같다.
        self.child_instance_attr = []

    def add_child_instance_attr(self, number):
        self.child_instance_attr.append(number)

    @classmethod
    def add_child_class_attr(cls, number):
        Child.child_attr.append(number)

>>> child = Child()
>>> child.add_child_class_attr(1)
>>> child.add_child_instance_attr(2)
>>> child.add_class_attr(3) # parent class function

>>> print "child class attr:", child.child_attr
child class attr: [1] [1]

>>> print "child instance attr:", child.child_instance_attr
child instance attr: [2]

>>> print "parent class attr:", child.class_attr, Parent.class_attr # parent class var
parent class attr: [3] [3]

>>> child.add_instance_attr(4) # parent instance function

>>> print "parent instance attr:", child.instance_attr
parent instance function
parent instance attr: [4]

>>> print child.__dict__
{'instance_attr': [4], 'child_instance_attr': [2]}

다중상속

Python 에서는 다중 상속을 지원한다. 다음과 같은 형태로 다중상속을 할 수 있다.
class DerivedClassName(Base1, Base2, Base3)

다중상속의 경우 super()를 이용하면 첫번째 부모만을 의미해, 각각의 부모를 사용할 수 없다. 부모의 클래스명을 이용해 직접 생성자를 호출해야한다.

다중상속을 받은 Parent들이 같은 이름의 함수를 갖고 있을 경우, 첫번째 부모의 메소드만 불러와지기 때문에 따로 정의해줘야한다.

class ParentOne(object):
        def __init__(self):
                self._one = 1

        def func(self):
                print('ParentOne.func')

class ParentTwo(object):
        def __init__(self):
                self.two = 2

        def func(self):
                print('ParentTwo.func')

class Child(ParentOne, ParentTwo):
        def __init__(self):
                ParentOne.__init__(self)
                ParentTwo.__init__(self)
                self._three = 3

        def oneFunc(self):
                ParentOne.func(self)

        def twoFunc(self):
                ParentTwo.func(self)

if __name__ == "__main__":
        child = Child()
        print(child.__dict__)
        child.oneFunc()
        child.twoFunc()

실행 결과 >
{'_one': 1, 'two': 2, '_three': 3}
ParentOne.func
ParentTwo.func

메소드 오버라이딩과 네임 맹글링

메소드 오버라이딩(method overriding)은 부모 클래스에 있는 method와 같은 이름의 method를 자식 클래스에서 새롭게 구현해서 사용하는 것이다.

하위 클래스에서 정의된 이름들과의 충돌을 피하기 위해서 name mangling을 사용한다. 정의한 함수가 클래스마다 이름이 겹치지 않게 자동으로 바꾸어준다.

아래 코드에서 class A, B에서 정의한 __double_method는 _A__double_method, _B__double_method로 변경된다.

• 이런 경우가 발생하는 코드를 작성하지 않는 것이 좋다,,

class A:
        def _single_method(self):
                pass
        def __double_method(self):
                print("A' double method")
class B(A):
        def __double_method(self):
                print("B' double method")

print(dir(A))
print(dir(B))

b = B()
b._A__double_method() # class A 에서 정의한 함수가 불러와진다.
b._B__double_method() # class B 에서 정의한 함수가 불러와진다.

실행 결과 >
['_A__double_method', '__doc__', '__module__', '_single_method']
['_A__double_method', '_B__double_method', '__doc__', '__module__', '_single_method']
A' double method
B' double method