§ 클래스와 객체

1. 인스턴스의 문자열 표현식

• 인스턴스의 문자열 표현식을 바꾸려면 str() 와 repr() 메소드를 정의한다.
  • 객체를 출력할 경우 기본적으로는 str() 함수가 호출된다.
  • !r 은 기본값으로 repr() 함수가 호출된다.
  • { } 기본값으로 str() 함수가 호출된다.
  • repr() 함수는 객체를 선언했을 때 형태 그대로를 만들어야 함.
  • 형태 그대로 라는건, 예를 들어 아래에서 Pair(A, B) 라고 하면 repr 도 그대로 출력되도록 해야한다.
  • 나중에 eval(repr(x)) == x 와 같은 text를 만드는 것이 표준이다.
  • repr(x) 를 eval 에 넣으면 실제 객체가 생성된다.

  1 class Pair:
  2     def __init__(self, x, y):
  3         self.x = x
  4         self.y = y
  5  
  6     def __repr__(self):
  7         return f'Pair ({self.x!r}, {self.y!r})'
  8  
  9     def __str__(self):
 10         return f'({self.x}, {self.y})'
 11  
 12 p = Pair(3, 4)
 13 print (p)  

2. 객체의 콘텍스트 관리 프로토콜 (with) 지원

• 객체가 context management protocol (with) 을 지원하게 구현
  • 쌍으로 만드는 과정을 자동화 할 때 편리하다.
  • with 문 만나면 enter() 메소드가 호출
  • with 문 빠져 나갈때는 exit() 메소드가 호출
  • 객체에 내부 함수로 구현해두자 !

c = LazeConnection(('www.python.org', 80))
with c as s:   # ← c 의 __enter__() 호출
   ...
               # ← c 의 __exit__() 호출
print ("End")

• user 가 필요할 때만 socket을 만들기 위해 LazyConnection class를 만들어보자.
  • with c as s : 를 하면 enter() 의 return 값이 as s 로 return 된다.
  • with 내부의 코드 (context) 가 정상 종료 되었거나 비정상 종료 되었더라도 exit() 이 반드시 실행되어야 하는 경우에는 with 로 하면 된다.

3. 인스턴스를 많이 생성할 때 메모리 절약

• 객체 인스턴스마다 내부에 멤버를 저장할 목적으로 딕셔너리 (알파벳 순으로 구성) 를 구성한다.

  • 이는 메모리 낭비의 원인이 된다.
  • 내부 구조는 dict 이 root 만 가리키고 있음
  • 나머지는 실시간 정렬 및 빠른 검색을 위한 RB tree로 되어있다. 메모리 낭비가 심하다.
  • RB tree 이기 때문에 객체에 member가 없더라도 동적으로 생성 / 제거가 가능하다.
    . 즉, d1.name = "kim" 이런 식으로 d1 이라는 객체의 member에 name 이 없어도 중간에 추가 가능하다.
    . 또한 del d1.name 을 사용하여 member 를 삭제할 수도 있다.
  • 하지만 모든 객체에서 이런 기능을 꼭 필요로 하지 않는다..
  • 이런 경우에는 RB tree 기능을 없애고 compact 한 배열로 관리하는 방법이 있는데, 바로 slots 을 쓰면 된다.

• __slots__을 정의하면 파이썬은 인스턴스에 훨씬 더 압축된 내부 표현식을 사용한다.

  • 인스턴스 마다 딕셔너리를 구성하지 않고 튜플이나 리스트 값은 부피가 작은 고정 배열로 인스턴스가 만들어진다.
  • 이렇게 하면 dict 이 사라지게 된다.
  • 또한, 멤버 생성 / 제거가 불가능하다.

  1 class Date:
  2     __slots__ = ['year', 'month', 'day']
  3
 10 print (dir(d1)) 

• special member : dict
  • d1.dir (혹은 dir(d1)) 이라고 실행하면 내부 member 에도 dict 가 존재한다.

4. 관리 속성 만들기 #except #exception #setter #TypeError

• 인스턴스 속성을 얻거나 설정할 때 추가적인 처리 (type check, 검증 등)을 하고 싶을때 @property 이용한다.
  • 함수 내부에서 사용되는 변수에는 _를 붙여서 사용한다.
  • python 에서는 접근 지정자 (private, public) 이 없기 때문에 getter setter 을 사용할 필요가 없음.
  • 사실은 객체 member 의 값을 변경하는게 문제가 없지만, 예외 처리를 넣기 위해 getter, setter 를 넣어준 아래 코드로도 충분히 가능.
  • 그런데 get_X, set_X 함수를 만들고 set_X 에 예외 처리를 넣어주는 것도 되는데 왜 decorator 을 쓸까?

class Person:
   def __init__(self, first_name):
      self.first_name = first_name
   
   def get_first_name(self):
      return self.first_name

   def set_first_name(self, value):
      if not isinstance(value, str):
         raise TypeError('Expected a string')
      self.first_name = value

if __name__ == '__main__':
   a = Person('Guido')
   print (a.get_first_name())
   a.set_first_name('Dave')
   print (a.get_first_name())

   try:
      a.set_first_name(42)
   except TypeError as e:
      print (e)

(20.08.04 06:20 부터 다시 보기)

• @는 decorator 이고 property 함수에 getter, setter를 넘겨주면 된다.
• property 라는 객체가 존재하고, 여기에 first_name 을 넣어서 다시 first_name 으로 받아온 것을 first_name.setter에 집어넣은 걸 다시 first_name 으로 넣어줌

• property 객체 이름에다가 setter를 집어 넣어주면 된다.
  • @first_name.setter 로 데코레이터를 지정하면 해당 속성을 변경하려 할 때 자동으로 호출된다.
  • 이 때 타입을 검사할 수 있고 문자열이 아닌 경우 예외를 던진다.

  1 class Person:
  2     def __init__(self, first_name):
  3         self.first_name = first_name
  4      
  5     @property
  6     def first_name(self):
  7         return self._first_name
  8      
  9     '''
 10     def first_name(self):
 11         return self._first_name
 12      
 13     first_name = property(get_first_name)
 14     '''
 15      
 16     @first_name.setter
 17     def first_name(self, value):
 18         if not isinstance(value, str):
 19             raise TypeError('Expected a string')
 20         self._first_name = value
 21      
 22     '''
 23     first_name = first_name.setter(set_first_name)
 24     '''  
 25      
 27 if __name__ == '__main__':
 28     a = Person('Guido')
 29     print(a.first_name)
 30      
 31     a.first_name = 'Dave'
 32     print(a.first_name)
 33      
 34     try:
 35         a.first_name = 42
 36     except TypeError as e:
 37         print (e)                                             

5. 부모 클래스의 메소드 호출

• 부모의 메소드를 호출하려면 super() 함수를 사용한다.

  1 class A:
  2     def spam(self):
  3         print ('A.spam')
  4         
  5 class B(A):
  6     def spam(self):
  7         print ('B.spam')
  8         super().spam()    
  9         
 10         
 11 if __name__ == '__main__':
 12     b = B()
 13     b.spam()

• super()는 일반적으로 init() 메소드에서 부모를 제대로 초기화 하기 위해 사용된다.

 16 class A: 
 17     def __init__(self):
 18         print ('\nA.__init__() : ', end='')
 19         self.x = 0
 20          
 21 class B(A):
 22     def __init__(self):
 23         super().__init__()
 24         print ('\nB.__init__() : ', end='')
 25         self.y = 1     
 26          
 27 if __name__ == '__main__':
 28     b = B()
 29     print (b.x, b.y)

• proxy 대리자 디자인 pattern ...

  • python 의 특별 메소드를 오버라이드한 코드에서 super()를 사용하기도 한다.

  • getattr(self, name): 자신에게 없는 속성을 접근 했을 때 호출됨. 그 때 그 속성 (변수) 이름이 name 으로 전달된다.

  • 자신에게 있는 속성에 접근했을 때에는 __getattr__에는 접근하지 않음. 자기가 포함하고 있는 멤버인 _obj 에 접근할때에는 호출되지 않음.

  • 아래 코드에서 p는 a와 똑같은 역할을 하고 있게 된다.

  • get 으로 꺼내오는 건 Proxy 가 할 수 있는데 과연 set 도 가능할까 ?

  • setattr(self, name, value): 자신에게 있거나 없는 경우 호출됨. 즉 무조건 호출됨 !

  • setattr() 구현에 이름 확인이 들어 있다. 만약 이름이 밑줄로 시작하면 super()를 사용해서 setattr() 의 원래 구현을 호출한다.

  1 class Proxy:
  2     def __init__(self, obj):
  3         self._obj = obj
  4      
  5     def __getattr__(self, name):
  6         print (f"Proxy.__getattr__(name = {name})")
  7         return getattr(self._obj, name)
  8      
  9     def __setattr__(self, name, value):
 10         print (f"Proxy.__setattr__(name = {name}, value = {value})")
 11         if name.startswith('_'):
 12             # 내 함수는 이미 오버라이딩 되었기 때문에 부모쪽에 있는 __setattr__ 을 사용해주면 된다. 
 13             super().__setattr__(name, value)
 14         else:
 15             setattr(self._obj, name, value)
 16      
 17 if __name__ == '__main__':
 18     class A:
 19         def __init__(self, x):
 20             self.x = x
 21         def spam(self):
 22             print ("A.spam")
 25     a = A(42)
 26     p = Proxy(a)
 27      
 28     print (p.x)
 29     print (p._obj)
 30     print (p.spam())
 31      
 32     p.x = 37
 33     print ('should be 37 : ', p.x)
 34     print ('should be 37 : ', a.x)          

# output
''' 맨 처음에 __init__ 함수에서 _obj 를 set 할 때에도 __setattr__ 이 호출된다. 
Proxy.__setattr__(name = _obj, value = <__main__.A object at 0x7f863c9e4668>)
Proxy.__getattr__(name = x)
42
<__main__.A object at 0x7f863c9e4668>
Proxy.__getattr__(name = spam)
A.spam
None
Proxy.__setattr__(name = x, value = 37)
Proxy.__getattr__(name = x)
should be 37 :  37
should be 37 :  37

• 다이아몬드 상속
  • 아래 코드처럼 C 에서 부모를 각각 호출하면 base 의 초기화가 2번 초기화 되어버린다.

  1 class Base:
  2     def __init__(self):
  3         print ('Base.__init__')
  4      
  5 class A(Base):
  6     def __init__(self):
  7         Base.__init__(self)
  8         print ('A.__init__')
 10 class B(Base):
 11     def __init__(self):
 12         Base.__init__(self)
 13         print ('B.__init__')
 14      
 15 class C(A,B):
 16     def __init__(self):
 17         A.__init__(self)
 18         B.__init__(self)
 19         print ('C.__init__')
 20      
 21 if __name__ == '__main__':
 22     c = C() 

• C.mro 라는 멤버가 있다. (method resolution order)
  • super가 부모쪽을 호출을 할 때 어떤 경로로 호출할지에 대한 order
  • python 에서는 base를 한번만 호출해주기 위한 방법이 필요한데, 바로 super()를 사용하면 된다.

  1 class Base:
  2     def __init__(self):
  3         print ('Base.__init__')
  4          
  5 class A(Base):
  6     def __init__(self):
  7         #Base.__init__(self)
  8         super().__init__()
  9         print ('A.__init__')
 10          
 11 class B(Base):
 12     def __init__(self):
 13         #Base.__init__(self)
 14         super().__init__()
 15         print ('B.__init__')
 16          
 17 class C(A,B):
 18     def __init__(self):
 19         #A.__init__(self)
 20         #B.__init__(self)
 21         super().__init__()     
 22         print ('C.__init__')
 23    
 24          
 25 if __name__ == '__main__':
 26     c = C()
 27     print (C.__mro__)

• C 위에 부모가 A 위에 부모가 B 위에 부모가 Base 인 것.
• 왜 A 위에 부모가 B 이지 ?
• C 가 상속된 순서대로 super 를 결정한다. (class C(A, B) : 라고 했기 때문에 C의 부모는 A, B)
• 함수를 찾는 순서가 C.mro

# output
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.Base'>, <class 'object'>)

6. 서브클래스에서 프로퍼티 확장

• deleter

  • property 가 del 로 지워지려고 할 때 호출되는 함수

• 서브 클래스에서, 부모 클래스에 정의한 프로퍼티의 기능을 확장 하고 싶을 때

  • super() 괄호 안에는 사실 self 로 호출된다.
  • getter 에서는 생략해도 되는데 setter 와 deleter 에서는 생략하면 에러가 발생한다.
  • super(SubPerson, XX) XX 자리에는 자식 클래스의 타입이나 인스턴스 타입을 넣을 수 있다.
  • XX 자리에 넣는 값은, 부모에 있는 class 변수인지, instance 변수인지에 따라 다르다.
  • class 변수에 접근하려고 할 때에는 class type을 반드시 지정해야 한다. (???)
  • 부모 메소드에 도달하기 위한 유일한 방법은, 인스턴스 변수가 아닌 클래스 변수로 접근해야 한다.
  • super(SubPerson, SubPerson) 이런 식으로 ...

• property 를 보면,

  • name = property(name) <- property 의 객체일 뿐, self.name 이 아니다.
  • 즉 name 은 class 변수이다.

  1 class Person:                                         
  2     def __init__(self, name):                         
  3         self.name = name                              
  4                                                       
  5     # getter                                          
  6     @property                                         
  7     def name(self):                                   
  8         return self._name           
  9      
 10     # setter                                          
 11     @name.setter                                      
 12     def name(self, value):                            
 13         if not isinstance(value, str):                
 14             raise TypeError("Expected a string")      
 15         self._name = value                            
 16                                                       
 17     # deleter                                         
 18     @name.deleter                                     
 19     def name(self):                                   
 20         raise AttributeError("Can't delete attribute")            

7. 새로운 클래스나 인스턴스 속성 만들기

• descriptor

  • get set delete 를 재정의한 class 를 descriptor 라고 한다.
  • 완전히 새로운 종류의 인스턴스 속성을 만들려면, 그 기능을 디스크립터 클래스 형태로 정의해야 한다.
  • property 도 dscriptor 구현체 중 하나이다.

• https://docs.python.org/ko/3/howto/descriptor.html

class Integer:
    def __init__(self, name):
        self.name = name

    def __get__(self, instance, cls):
        if instance is None:
            return self
        else:
            return instance.__dict__[self.name]

    def __set__(self, instance, value):
        if not isinstance(value, int):
            raise TypeError('Expected an int')
        instance.__dict__[self.name] = value

    def __delete__(self, instance):
        del instance.__dict__[self.name]

class Point:
    x = Integer('x')
    y = Integer('y')
    def __init__(self, x, y):
        self.x = x
        self.y = y

if __name__ == '__main__':
    p = Point(2, 3)
    print(p.x)
    p.y = 5
    try:
        p.x = 2.3
    except TypeError as e:
        print(e)

8. 자료 구조 초기화 단순화하기

• 자료 구조로 사용하는 클래스를 작성하고 있는데, 반복적으로 비슷한 init() 함수를 매번 작성해야 한다.
  • Struct 라는 부모 클래스에서 init 을 한번 해주면 자식 class 에서 오버라이딩 하지 않는 한, 부모의 init 이 호출된다.

class Structure:
    _fields= []
    def __init__(self, *args):
        # argument 수가 각 class의 field 수와 같은지 check 
        if len(args) != len(self._fields):
            raise TypeError('Expected {} arguments'.format(len(self._fields)))

        for name, value in zip(self._fields, args):
            setattr(self, name, value)
        
# 각 class 마다 자신의 field 를 정의하고 그에 맞게 init 되도록 한다. 
if __name__ == '__main__':
    class Stock(Structure):
        _fields = ['name', 'shares', 'price']

    class Point(Structure):
        _fields = ['x','y']

    class Circle(Structure):
        _fields = ['radius']
        def area(self):
            return math.pi * self.radius ** 2

if __name__ == '__main__':
    s = Stock('ACME', 50, 91.1)
    print(s.name, s.shares, s.price)

    p = Point(2,3)
    print(p.x, p.y)

    c = Circle(4.5)
    print(c.radius)

    try:
        s2 = Stock('ACME', 50)
    except TypeError as e:
        print(e)

• 가변인자 뿐만 아니라 키워드 가변인자도 받기 위해서는 아래와 같이 구현한다.
  • args 가 field 보다 작기만 하면 됨

class Structure:
    _fields= []
    def __init__(self, *args, **kwargs):
        if len(args) > len(self._fields):
            raise TypeError('Expected {} arguments'.format(len(self._fields)))

        for name, value in zip(self._fields, args):
            setattr(self, name, value)

        # args 다음부터는 키워드 인자를 받아주면 된다. 
        for name in self._fields[len(args):]:
            setattr(self, name, kwargs.pop(name))

        if kwargs:
            raise TypeError('Invalid argument(s): {}'.format(','.join(kwargs)))
        
if __name__ == '__main__':
    class Stock(Structure):
        _fields = ['name', 'shares', 'price']

    s1 = Stock('ACME', 50, 91.1)
    s2 = Stock('ACME', 50, price=91.1)
    s3 = Stock('ACME', shares=50, price=91.1)

• 또는 extra_args 이용해서 아래와 같이 구현도 가능

    _fields= []
    def __init__(self, *args, **kwargs):
        if len(args) != len(self._fields):
            raise TypeError('Expected {} arguments'.format(len(self._fields)))
       
        for name, value in zip(self._fields, args):
            setattr(self, name, value)

        print (f"[TEST] kwargs.keys() - self._fields")
        extra_args = kwargs.keys() - self._fields
        for name in extra_args:
            setattr(self, name, kwargs.pop(name))
        if kwargs:
            raise TypeError('Duplicate values for {}'.format(','.join(kwargs)))
        
if __name__ == '__main__':
    class Stock(Structure):
        _fields = ['name', 'shares', 'price']

    s1 = Stock('ACME', 50, 91.1)
    s2 = Stock('ACME', 50, 91.1, date='6/1/2020')

10. 인터페이스, 추상 베이스 클래스 정의

• body 가 없는 추상 함수를 만들어 보자
• module : ABCMeta, abstractmethod (추상 클래스, 추상 메소드) ※ ABC : ABstraCt
• 기본적으로 추상 함수가 하나라도 있는 클래스는 객체가 될 수 없음
• abstractmethod 를 데코레이터는 해당 함수를 추상 메서드로 만들어준다.
• a = IStream() 을 하면 에러 발생
  • 추상 메서드 이기 때문에 반드시 read write 를 구현해야 함.
  • IStream 클래스는 상속한 클래스에게 spec에 구성되어있는 모든 함수 (여기서는, read함수와 write함수)를 구현하도록 강제한다.

from abc import ABCMeta, abstractmethod

class IStream(metaclass=ABCMeta):
    @abstractmethod
    def read(self, maxbytes=-1):
        pass
    @abstractmethod
    def write(self, data):
        pass

class SocketStream(IStream):
    def read(self, maxbytes=-1):
        print('reading')
    def write(self, data):
        print('writing')

def serialize(obj, stream):
    if not isinstance(stream, IStream):
        raise TypeError('Expected an IStream')
    print('serializing')

if __name__ == '__main__':
    try:
        a = IStream()
    except TypeError as e:
        print(e)

    a = SocketStream()
    a.read()
    a.write('data')

    serialize(None, a)

    import sys

    try:
        serialize(None, sys.stdout)
    except TypeError as e:
        print(e)

    import io
    IStream.register(io.IOBase)

    serialize(None, sys.stdout)

from abc import ABCMeta, abstractmethod

class A(metaclass=ABCMeta):
    # 가상 함수로 먼저 만들고 property 든 다른 decorator 를 써준다. 
    @property
    @abstractmethod
    def name(self):
        pass

    @name.setter
    @abstractmethod
    def name(self, value):
        pass

    @classmethod
    @abstractmethod
    def method1(cls):
        pass

    @staticmethod
    @abstractmethod
    def method2():
        pass

10 의 04:10 부터 다시 보기

11 부터 다시 보기

13. 순환 자료 구조에서 메모리 관리

• 순환이 있는 자료 구조를 생성하는 프로그램에서 메모리 관리의 문제가 있음

• 상호 참초가 있는 구조에서는 weakref 라이브러리를 사용하는 약한 참조로 만드는 것을 고려한다.

• ref count 은, root = Node ('parent') 를 하는 순간, 자기 자신이 가리키기 때문에, ref = 1 이 되고, 자식과 상호 참초 되는 순간, (root.add_child(c1)) ref = 2 가 된다.

• 따라서 del root 만 하게 되면 root 가 자기 자신을 가리키지 않게 되서 ref = 1 이 될 뿐, Node 자체는 남아있어 memory leak 이 발생한다.

class Data:
   def __del__(self):
      print('Data.__del__')

class Node: 
   def __init__(self):
      self.data = Data()
      self.parent = None
      self.children = []

   def add_child(self, child):
      self.children.append(child)
      child.parent = self

if __name__ = "__main__":
   a = Data()
   del a
   a = Node()
   a.add_child(Node())

• 이를 위해서 gc (garbage collector) 를 지울 수 있다.

import gc
gc.collect()

• 하지만 계속 이를 수행해 줄 수 없기 때문에, weak pointer 를 사용하자 !