Native Python Programing

제너릭을 이용한 파이썬의 `Pair` 클래스를 구현하는 것은 타입 안전성을 높이는 좋은 방법입니다. 제너릭은 다양한 데이터 타입을 다룰 수 있는 클래스를 작성할 수 있게 해줍니다. 다음은 `Pair` 클래스를 구현하고, 이 클래스를 사용하는 예제입니다.

1. Pair 클래스 구현

from typing import Generic, TypeVar

# 제너릭 타입 변수 정의
T = TypeVar('T')
U = TypeVar('U')

class Pair(Generic[T, U]):
    def __init__(self, first: T, second: U):
        self.first = first
        self.second = second

    def get_first(self) -> T:
        """첫 번째 요소를 반환합니다."""
        return self.first

    def get_second(self) -> U:
        """두 번째 요소를 반환합니다."""
        return self.second

    def __repr__(self) -> str:
        """객체의 문자열 표현을 정의합니다."""
        return f"Pair({self.first}, {self.second})"

# 사용 예제
if __name__ == "__main__":
    # 서로 다른 타입의 Pair 객체 생성
    int_str_pair = Pair(1, "one")
    float_bool_pair = Pair(3.14, True)

    # 첫 번째 및 두 번째 요소 가져오기
    print(int_str_pair.get_first())  # 출력: 1
    print(int_str_pair.get_second())  # 출력: "one"
    print(float_bool_pair.get_first())  # 출력: 3.14
    print(float_bool_pair.get_second())  # 출력: True

    # Pair 객체의 문자열 표현 출력
    print(int_str_pair)  # 출력: Pair(1, one)
    print(float_bool_pair)  # 출력: Pair(3.14, True)

2. 코드 설명

• 제너릭 타입 변수: TypeVar를 사용하여 제너릭 타입 변수를 정의합니다. T와 U는 각각 Pair 클래스의 첫 번째와 두 번째 요소의 타입을 나타냅니다.
• 클래스 정의: Pair 클래스는 두 개의 제너릭 타입 변수를 사용하여 두 개의 요소를 가집니다.
• 생성자: __init__ 메서드는 첫 번째와 두 번째 요소를 초기화합니다.
• 메서드:
  • get_first: 첫 번째 요소를 반환합니다.
  • get_second: 두 번째 요소를 반환합니다.
• 문자열 표현: __repr__ 메서드는 Pair 객체의 문자열 표현을 정의하여, 객체를 쉽게 확인할 수 있도록 합니다.

3. 실행 예제

위 코드를 실행하면 다음과 같은 결과가 출력됩니다:

1
one
3.14
True
Pair(1, one)
Pair(3.14, True)

4. 장점

• 타입 안전성: 제너릭을 사용하면 각 요소의 타입을 명확히 정의할 수 있어, 타입 안전성을 높입니다. 잘못된 타입을 사용하면 컴파일 타임에 오류를 발생시키므로, 런타임 오류를 줄일 수 있습니다.
• 재사용성: 다양한 데이터 타입에 대해 `Pair` 클래스를 재사용할 수 있습니다. 필요에 따라 다른 타입의 쌍을 생성할 수 있습니다.

이러한 방식으로 제너릭을 활용하면, 다양한 데이터 타입을 다룰 수 있는 유연한 클래스를 쉽게 구현할 수 있습니다.

고정 키 집합을 가지는 딕셔너리 (FixedKeysDict)

이 예제에서는 초기화 시 정의된 키 집합 외에는 새로운 키를 추가할 수 없도록 제한하는 딕셔너리 클래스를 구현합니다.

코드 설명

• __init__: 초기 키 집합을 정의하고, 초기 데이터가 이 키 집합에 속하는지 확인합니다.
• __setitem__: 새로운 키를 추가하려 할 때 제한을 걸어 기존 키에 대해서만 값을 설정할 수 있도록 합니다.
• update: update 메서드를 오버라이드하여 새로운 키의 추가를 방지합니다.
• __repr__: 딕셔너리의 문자열 표현을 사용자 정의합니다.

class FixedKeysDict(dict):
    def __init__(self, *args, **kwargs):
        """
        초기 키 집합을 정의합니다.
        """
        # 초기 데이터 로드
        super().__init__(*args, **kwargs)
        # 초기 키 집합 저장
        self._fixed_keys = set(self.keys())

    def __setitem__(self, key, value):
        if key not in self._fixed_keys:
            raise KeyError(f"Cannot add new key '{key}'. Allowed keys: {self._fixed_keys}")
        super().__setitem__(key, value)

    def update(self, *args, **kwargs):
        """
        update 메서드도 새로운 키의 추가를 제한합니다.
        """
        if args:
            if isinstance(args[0], dict):
                for key in args[0]:
                    if key not in self._fixed_keys:
                        raise KeyError(f"Cannot add new key '{key}'. Allowed keys: {self._fixed_keys}")
            elif isinstance(args[0], (list, tuple)):
                for key, _ in args[0]:
                    if key not in self._fixed_keys:
                        raise KeyError(f"Cannot add new key '{key}'. Allowed keys: {self._fixed_keys}")
            else:
                raise TypeError("Invalid argument type for update")

        for key in kwargs:
            if key not in self._fixed_keys:
                raise KeyError(f"Cannot add new key '{key}'. Allowed keys: {self._fixed_keys}")
        
        super().update(*args, **kwargs)

    def __repr__(self):
        return f"{self.__class__.__name__}({dict.__repr__(self)})"

# 사용 예제
try:
    # 고정 키 'a', 'b'로 초기화
    my_dict = FixedKeysDict(a=1, b=2)
    print(my_dict)  # 출력: FixedKeysDict({'a': 1, 'b': 2})

    # 기존 키 수정
    my_dict['a'] = 10
    print(my_dict)  # 출력: FixedKeysDict({'a': 10, 'b': 2})

    # 새로운 키 추가 시도
    my_dict['c'] = 3  # KeyError 발생
except KeyError as e:
    print(e)  # 출력: Cannot add new key 'c'. Allowed keys: {'a', 'b'}

try:
    # update 메서드로 새로운 키 추가 시도
    my_dict.update({'a': 100, 'c': 300})  # KeyError 발생
except KeyError as e:
    print(e)  # 출력: Cannot add new key 'c'. Allowed keys: {'a', 'b'}

출력 결과

FixedKeysDict({'a': 1, 'b': 2})
FixedKeysDict({'a': 10, 'b': 2})
"Cannot add new key 'c'. Allowed keys: {'a', 'b'}"
"Cannot add new key 'c'. Allowed keys: {'a', 'b'}"