[python 심화] 11. 클래스 Getter, Setter, 추상클래스 , class ABC

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

 

 

<이전 글>

https://silvercoding.tistory.com/27

[python 심화] 10. copy & deep copy

 

 

 

- Class  Getter & Setter 

* 클래스 선언 

class VectorP(object):
    def __init__(self, x, y):
        self.__x = float(x)
        self.__y = float(y)

    def __iter__(self):
        return (i for i in (self.__x, self.__y)) # Generator

 

 

* 객체 선언 

v = VectorP(20, 40)

 

* 오류

print('EX1-1 - ', v.__x, v.__y)  # ---> 직접 접근 불가

 AttributeError: 'VectorP' object has no attribute '__x' 

 언더바 2개로 선언한 인스턴스 변수는 객체를 통한 직접 접근이 불가능 하다. 

 

 

 

 

- Getter & Setter 

: 더 안전한 프로그래밍을 할 수 있다. 

class VectorP(object):
    def __init__(self, x, y):
        self.__x = float(x)
        self.__y = float(y)

    def __iter__(self):
        return (i for i in (self.__x, self.__y)) # Generator

    @property
    def x(self):
        print('Called Property X')
        return self.__x

    @x.setter
    def x(self, v):
        print('Called Property X setter')
        self.__x = float(v)
    
    @property
    def y(self):
        print('Called Property Y')
        return self.__y

    @y.setter
    def y(self, v):
        print('Called Property Y setter')        
        if v < 30: 
            raise ValueError('30 Below is not possible')
        self.__y = float(v)

데코레이터를 사용하여 @property, @x.setter @y.setter 밑에 x와 y를 정의해 준다. 

 

 

print('EX1-2 - ', dir(v), v.__dict__)
v.x = 10
print('EX1-3 - ', v.x, v.y)

 EX1-2 -  ['_VectorP__x', '_VectorP__y', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'x', 'y'] {'_VectorP__x': 20.0, '_VectorP__y': 40.0} 
 Called Property X 
 Called Property Y 
 EX1-3 -  10.0 40.0 

Getter와 Setter를 이용하여 self.__x 변수에 self.x 의 형태로 접근이 가능해 졌다. v.x=10 을 이용하여 값을 바꿀 수 있는 것 또한 볼 수 있다. 

 

# Iter 확인 
for val in v:
    print('EX1-4 - ', val)

 EX1-4 -  10.0 
 EX1-4 -  40.0 

구현해 놓은 __iter__ 메소드를 확인하였다. 

 

 

 

- __slot__ 

: 파이썬 인터프리터에게 통보 , 해당 클래스가 가지는 속성을 제한 

* __dict__ 

: 속성 최적화 -> 다수 객체 생성 시 메모리 사용 공간 대폭 감소 

: 해당 클래스에 만들어진 인스턴스 속성 관리에 딕셔너리 대신 set 형태를 사용 

 

class TestA(object):
    __slots__ = ('a', )

class TestB(object):
    pass

 

 

* 객체 생성 

use_slot = TestA()
no_slot = TestB()

 

* 사용

print('EX2-1 - ', use_slot)
# print('EX2-2 - ', use_slot.__dict__)  # 속성 값 확인 --> dictionary이기 때문에 안됨 
print('EX2-3 - ', no_slot)
print('EX2-3 - ', no_slot.__dict__)

 EX2-1 -  <__main__.TestA object at 0x000001BE68801C78> 
 EX2-3 -  <__main__.TestB object at 0x000001BE68A4D6A0> 
 EX2-3 -  {} 

 

 

* 메모리 사용량 비교

import timeit

# 측정을 위한 함수 선언 
def repeat_outer(obj):
    def repeat_inner():
        obj.a = 'TEST'
        del obj.a
    return repeat_inner

obj.a = 'TEST' 를 선언하고 obj.a를 삭제하는 시간을 측정하기 위한 함수를 생성한다. 

 

print(min(timeit.repeat(repeat_outer(use_slot), number=100000))) 
print(min(timeit.repeat(repeat_outer(no_slot), number=100000)))

 0.015717999999999982 
 0.018735899999999972 

100000번을 반복하여 가장 작은 시간을 출력해 보았을 때, slot을 사용한 클래스의 객체가 더 빠른 것을 알 수 있다. 

 

 

 

- 객체 슬라이싱

class ObjectS:
    def __init__(self):
        self._numbers = [n for n in range(1, 100, 3)]

    def __len__(self):
        return len(self._numbers)

    def __getitem__(self, idx):
        return self._numbers[idx]

인스턴스 변수를 리스트 타입으로 생성하고, __len__, __getitem__ 메소드를 선언해 놓은 ObjectS 클래스를 생성한다. 

 

* 객체 생성

s = ObjectS()

 

print('EX3-1 - ', s.__dict__)    
print('EX3-2 - ', len(s))
print('EX3-3 - ', len(s._numbers))  # __len__ 이 없으면 . 
print('EX3-4 - ', s[1:100])
print('EX3-5 - ', s[-1])
print('EX3-6 - ', s[::10])

 EX3-1 -  {'_numbers': [1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49,  
 52, 55, 58, 61, 64, 67, 70, 73, 76, 79, 82, 85, 88, 91, 94, 97]} 

 EX3-2 -  33 
 EX3-3 -  33 

__len__ 메소드를 선언해 놓지 않는다면 EX3-3과 같이 작성하여 리스트의 길이를 확인할 수 있다. 
 EX3-4 -  [4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49, 52, 55, 58, 61,  
 64, 67, 70, 73, 76, 79, 82, 85, 88, 91, 94, 97] 
 EX3-5 -  97 
 EX3-6 -  [1, 31, 61, 91] 

 

__getitem__ 메소드를 사용하여 객체 자체에서 인덱싱과 슬라이싱을 가능하게 만들었다. 만약 __getitem__ 메소드를 생성하지 않았다면 다음과 같은 에러가 난다.

 

 Traceback (most recent call last): 
  File "c:/Users/sooki/Desktop/python_high/chapter05_02.py", line 114, in <module>      
    print('EX3-4 - ', s[1:100])
 TypeError: 'ObjectS' object is not subscriptable 

 

 

 

 

- 파이썬 추상 클래스 

https://docs.python.org/3/library/collections.abc.html

collections.abc — Abstract Base Classes for Containers — Python 3.9.6 documentation

1. 자체적으로 객체 생성 불가 

2. 상속을 통해서 '자식 클래스' 에서 생성해야 함 

3. 개발과 관련된 공통된 내용 (필드, 메소드) 추출 및 통합해서 공통된 내용으로 작성하게 하는 것

 

 

 

** Sequence 상속 받지 않았지만, 자동으로 __iter__, __contain__ 기능 작동 

** 객체 전체를 자동으로 조사 -> 시퀀스 프로토콜 

class IterTestA():
    def __getitem__(self, idx):
        return range(1, 50, 2)[idx] # range(1, 50, 2)

__getitem__ 메소드를 선언한 IterTestA 클래스를 생성한다. 

 

 

* 객체 생성

i1 = IterTestA()

 

print('EX4-1 - ', i1[4])
print('EX4-2 - ', i1[4:10])
print('EX4-3 - ', 3 in i1[1:10])  # __contain__ 구현하지 않아도 사용됨 
print('EX4-4 - ', [i for i in i1]) # 구현하지 않은 __iter__ 실행

 EX4-1 -  9 
 EX4-2 -  range(9, 21, 2) 
 EX4-3 -  True 
 EX4-4 -  [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49] 

인덱싱과 슬라이싱이 가능하도록 __getitem__ 메소드만 생성을 해 놓았지만 , 4-3, 4-4 가 실행이 되는 것을 볼 수 있다. __contain__과 __iter__메소드를 클래스 내에 생성하지 않았어도 실행이 된 것이다. 

 

 

 

 

- Sequence 상속 

: 요구사항인 추상메소드를 모두 구현해야 동작 

from collections.abc import Sequence

class IterTestB(Sequence):
    def __getitem__(self, idx):
        return range(1, 50, 2)[idx] # range(1, 50, 2)

    def __len__(self, idx):
        return len(range(1, 50, 2)[idx])

Sequence를 상속 받는 IterTestB 클래스를 생성한다.  __getitem__, __len__ <--- 이 두개의 메소드를 구현하지 않으면 동작하지 않는다. 

i2 = IterTestB()  # ---> __getitem__, __len__ 함수가 없으면 객체 생성 불가. (강제성을 띈다.)

두개의 메소드를 하나라도 구현하지 않으면 다음과 같은 에러가 난다. 

TypeError: Can't instantiate abstract class IterTestB with abstract methods __len__  

 

print('EX4-5 - ', i2[4])
print('EX4-6 - ', i2[4:10])
print('EX4-7 - ', 3 in i2[1:10])

 EX4-5 -  9 
 EX4-6 -  range(9, 21, 2) 
 EX4-7 -  True 

 

 

 

 

 

 

- abc 활용 예제 

https://docs.python.org/ko/3/library/abc.html

abc — 추상 베이스 클래스 — Python 3.9.6 문서

import abc

class RandomMachine(abc.ABC): # metaclass=abc.ABCMeta(3.4 이하)
    # __metaclass__ = abc.ABCMeta

    #추상 메소드  ---> 데코레이터가 붙은 건 무조건 자식 클래스에서 구현해주어야 한다.
    @abc.abstractmethod
    def load(self, iterobj):
        '''Iterable 항목 추가'''

    # 추상 메소드 
    @abc.abstractmethod
    def pick(self, iterobj):
        '''무작위 항목 뽑기'''

    def inspect(self):
        items = []
        while True:
            try:
                items.append(self.pick())
            except LookupError:
                break
            return tuple(sorted(items))

데코레이터로 @abc.abstractmethod 가 붙은 메소드는 무조건 자식 클래스에서 구현 해주어야 하는 메소드이다 . load와 pick 메소드에 데코레이터가 달려있다. 위와 같이 abc를 상속받는 추상클래스에 데코레이터 메소드를 구현하고, 메소드에 주석 설명을 달아 놓으면 자식 클래스에서 자세한 구현을 하게되는 방식이다. 

 

import random

class CraneMachine(RandomMachine):
    def __init__(self, items):
        self._randomizer = random.SystemRandom()
        self._items = []
        self.load(items)
        
    def load(self, items):
        self._items.extend(items)
        self._randomizer.shuffle(self._items)

    def pick(self):
        try:
            return self._items.pop()
        except IndexError:
            raise LookupError('Empty Crane Box')

    def __call__(self):
        return self.pick()

이와 같이 abc를 상속받았던 RandomMachine 클래스를 상속받는 CraneMachine 을 생성한다. 입력한 아이템 리스트 중에서 랜덤 뽑기를 하는 클래스이다. RandomMachine에서 구현해놓았던 추상 메소드 load, pick 함수는 필수로 구현해주어야 한다. 

 

 

* 서브 클래스 확인 

print('EX5-1 - ', issubclass(RandomMachine, CraneMachine))
print('EX5-2 - ', issubclass(CraneMachine, RandomMachine))

 EX5-1 -  False 
 EX5-2 -  True 

issubclass를 사용하여 서브클래스인지 확인 해본다. issubclass(RandomMachine, CraneMachine)은 RandomMachine이 CraneMachine의 서브클래스냐? 라는 뜻이다. 

 

 

* 상속 구조 확인 

print('EX5-3 - ', CraneMachine.__mro__)  # 가계도를 보여준다. 상속을 받은 순서를 보여줌

 EX5-3 -  (<class '__main__.CraneMachine'>, <class '__main__.RandomMachine'>, <class 'abc.ABC'>, <class 'object'>) 

 

 

* 객체 생성

cm = CraneMachine(range(1, 100)) # 추상 메소드 구현 안하면 에러

Sequence를 상속했을 때 __getitem__, __len__ 메소드가 필수였다면, abc를 상속할 때는 추상 메소드를 필수로 구현해 주어야 한다는 강제성을 띈다. 

 

print('EX5-4 - ', cm._items)
print('EX5-5 - ', cm.pick())
print('EX5-6 - ', cm())
print('EX5-7 - ', cm.inspect()) # --> 부모의 메소드가 실행된다.

 EX5-4 -  [53, 83, 95, 24, 97, 2, 43, 89, 85, 3, 59, 15, 78, 12, 46, 11, 29, 72, 6, 60, 41, 51, 1, 67, 10, 88, 5, 62, 33, 18, 55, 61, 13, 63, 90, 81, 32, 65, 86, 75, 94, 71, 93, 70, 26, 54, 31, 20, 91, 35, 34, 68, 57, 42, 23, 8, 77, 69, 36, 28, 99, 17, 98, 56, 44, 22, 14, 27, 30, 48, 37, 80, 87, 52, 49, 50, 40, 74, 25, 47, 96, 9, 45, 73, 4, 16, 21, 7, 82, 39, 58, 66, 84, 19, 79, 76, 38, 64, 92] 
 EX5-5 -  92 
 EX5-6 -  64 
 EX5-7 -  (38,) 

inspect메소드는 자식클래스에서 구현해주지 않아도 부모의 클래스의 메소드가 실행된다.