이펙티브 파이썬 5장 - 클래스와 인터페이스

Better way 38 간단한 인터페이스의 경우 클래스 대신 함수를 받아라

훅(hook)

• Python 내장 API 사용할 때, 함수를 전달하여 실행하는 경우
• Python은 함수를 일급 시민 객체로 취급하기에 가능 

일급 시민 (first-class citizen)

• 아무런 제약 없이 사용할 수 있는 데이터 값
• 함수 인자로 넘기기 가능
• 함수 반환 값으로 사용 가능
• 변수나 데이터 구조에 저장 가능

 

languages = ['python', 'swift', 'java']
languages.sort(key=len) # hook
print(languages)
>>>
['java', 'swift', 'python']

 

 

딕셔너리에 키가 추가 여부를 추적하는 내용이 필요하다고 하자.

defaultdict 인자에 log_missing 을 구현하여, 키 추가를 추적할 수 있다.

def log_missing():
    print('키 추가') # 키가 추가되면 출력
    return 0 # 기본값 0 


from collections import defaultdict

colors = {'초록': 1, '파랑': 2} # 기존
increments = [('초록',3), ('빨강',4), ('노랑',5)] # 업데이트 내용
result = defaultdict(log_missing, colors)
print(f'이전 : {dict(result)}')
for color, count in increments:
    result[color] += count
print(f'이후 : {dict(result)}')

>>>
이전 : {'초록': 1, '파랑': 2}
키 추가
키 추가
이후 : {'초록': 4, '파랑': 2, '빨강': 4, '노랑': 5}

 

 

__call__ 메소드를 구현해, 클래스로 관리 할 수 있다.

class BetterCountMissing:
    def __init__(self):
        self.added = 0

    def __call__(self): # 객체를 함수처럼 호출이 가능
        self.added += 1
        return 0

from collections import defaultdict
counter = BetterCountMissing()

colors = {'초록': 1, '파랑': 2}
increments = [('초록',3), ('빨강',4), ('노랑',5)]
result = defaultdict(counter, colors)  # __call__ 를 호출함
print(f'이전 : {dict(result)}')
for color, count in increments:
    result[color] += count
print(f"키가 추가된 횟수 : {counter.added}")
print(f'이후 : {dict(result)}')

>>>
이전 : {'초록': 1, '파랑': 2}
키가 추가된 횟수 : 2
이후 : {'초록': 4, '파랑': 2, '빨강': 4, '노랑': 5}

 

 

Better way 40 super로 부모 클래스를 초기화하라

# 안 좋은 예시 - 부모 클래스를 직접 호출하여 초기화
class Base:
    def __init__(self, value):
        self.value = value

class Child(Base):
    def __init__(self):
        Base.__init__(self, 5) # 잘 작동한다.

 

문제점

• 다중 상속을 할 때, 호출의 순서가 인자의 순서와 무관
• 다이아몬드 상속을 할 때, 문제가 발생할 수도 있다.

class Base:
    def __init__(self, value):
        self.value = value

class TimesSeven(Base):
    def __init__(self, value):
        Base.__init__(self, value)
        self.value *= 7

class PlusNine(Base):
    def __init__(self, value):
        Base.__init__(self, value)
        self.value += 9


class Diamond(TimesSeven, PlusNine):
    def __init__(self, value):
        TimesSeven.__init__(self, value)
        PlusNine.__init__(self, value)

diamond = Diamond(5)
print(f'(5 * 7) + 9 = 44 를 기대하지만, 실제 값 {diamond.value}')
>>>
(5 * 7) + 9 = 44 를 기대하지만, 실제 값 14

 

왜냐하면 의 TimesSenve.__init__ 끝난 후, value 는 35 이지만, PlusNine에서 Base.__init__ 을 다시 한번 더 호출하여 value가 5로 다시 초기화 된후 5+9를 실행하여 14가 되기 때문이다.

 

이를 해결하기 위해 super()을 사용하자. super()는 다이아몬드 계층에서 공통 상위 클래스를 단 한번만 호출하도록 보장한다.

• 표준 메서드 결정 순서 (Method Resolution Order, MRO) - C3 선형화 알고리즘 사용

class Base:
    def __init__(self, value):
        self.value = value

class TimesSeven(Base):
    def __init__(self, value):
        super().__init__(value)
        self.value *= 7

class PlusNine(Base):
    def __init__(self, value):
        super().__init__(value)
        self.value += 9


class Diamond(PlusNine, TimesSeven):
    def __init__(self, value):
        super().__init__(value)

diamond = Diamond(5)
print(f'(5 * 7) + 9 = 44 를 기대하지만, 실제 값 {diamond.value}')
>>>
(5 * 7) + 9 = 44 를 기대하지만, 실제 값 44

 

Better way 41 기능을 합성할 때는 믹스인 클래스를 사용하라

믹스인(mix-in)

• 자식 클래스가 사용할 메서드 몇 개만 정의하는 클래스
• 자체 애트리뷰트 정의가 없으므로 자식이 부모 믹스인 클래스 __init__ 을 호출할 필요도 없다.

class LogMixin:
    def log(self, message):
        print(f"[LOG]: {message}")

class TimestampMixin:
    def timestamp(self):
        from datetime import datetime
        return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

class App(LogMixin, TimestampMixin):
    def run(self):
        self.log("앱이 실행되었습니다.")
        print(f"현재 시간: {self.timestamp()}")

app = App()
app.run()

Better way 42 비공개 애트리뷰트보다는 공개 애트리뷰트를 사용하라

파이썬 클래스의 어트리뷰트 가시성

• 공개 (public)
• 비공개 (private)

class MyClass:
    def __init__(self):
        self.public_field = 5 # public
        self.__private_field = 10 # private


    def get_private_field(self):
        return self.__private_field


my_class = MyClass()
print(my_class.public_field) # 5
print(my_class.get_private_field()) # 10
print(my_class.__private_field) # AttributeError: 'MyClass' object has no attribute

 

비공개 어트리뷰트인 __private_field를 외부에서 접근하면 예외가 발생한다.

파이썬에서 비공개 어트리뷰트의 동작은 그저 이름을 바꾸는 단순한 방식으로 구현된다.

예를 들면 MyClass 내의 __private_field 어트리뷰트는  _MyClass__private_field 으로 변경되어 동작한다.

그래서 해당 이름으로 외부에서 접근하면, 접근이 가능하다.

print(my_class._MyClass__private_field) # 10

 

 

왜 파이썬에서는 가시성을 엄격하게 제한하지 않았을까? 

"우리는 모두 책임질줄 알는 성인이다" 라는 모토로 정말 굳이굳이 위험을 택할 필요성이 있다면, 개발자에게 선택을 존중하는 것이다.

 

관례적으로는 _ 1개만 있는 경우 protect 의미로 조심히 사용해야 한다는 뜻이다.

 

Better way 43 커스텀 컨테이너 타입은 collections.abc를 상속하라

장점 1. 필요한 메소드가 구현되지 않은 경우, 실수한 부분을 알려준다.

from collections.abc import  Sequence

class BadType(Sequence):
    pass

foo = BadType()

>>>
    foo = BadType()
          ^^^^^^^^^
TypeError: Can't instantiate abstract class BadType with abstract methods __getitem__, __len__

 

장점 2. 요구하는 메서드를 구현하면 나머지 메소드 - Sequence의 경우 (index, count)

# 직접 구현하는 경우 
class IndexableNode:
    def __init__(self, value, next_node=None):
        self.value = value
        self.next_node = next_node

    def __getitem__(self, index):
        current = self
        for _ in range(index):
            if current.next_node is None:
                raise IndexError("Index out of range")
            current = current.next_node
        return current.value

    def __len__(self):
        count = 0
        current = self
        while current:
            count += 1
            current = current.next_node
        return count

    def __contains__(self, item):
        current = self
        while current:
            if current.value == item:
                return True
            current = current.next_node
        return False

    def index(self, item):
        current = self
        idx = 0
        while current:
            if current.value == item:
                return idx
            current = current.next_node
            idx += 1
        raise ValueError(f"{item} is not in list")

    def count(self, item):
        current = self
        count = 0
        while current:
            if current.value == item:
                count += 1
            current = current.next_node
        return count

 

from collections.abc import Sequence

# ✅ collections.abc Sequence를 사용하는 경우 (더 간결하고 유지보수 용이)
class IndexableNode(Sequence):
    def __init__(self, value, next_node=None):
        self.value = value
        self.next_node = next_node

    def __getitem__(self, index):
        current = self
        for _ in range(index):
            if current.next_node is None:
                raise IndexError("Index out of range")
            current = current.next_node
        return current.value

    def __len__(self):
        count = 0
        current = self
        while current:
            count += 1
            current = current.next_node
        return count

 

# 사용 예시는 동일하다
node3 = IndexableNode(3)
node2 = IndexableNode(2, node3)
node1 = IndexableNode(1, node2)

print(node1[1])  # 2
print(len(node1))  # 3
print(3 in node1)  # True  (자동 지원)
print(node1.index(2))  # 1  (자동 지원)
print(node1.count(3))  # 1  (자동 지원)