Native Python Programing

파이썬에서 기본 dict 자료형을 확장하면서도 특정한 제한을 두고 싶을 때, dict를 상속받아 사용자 정의 클래스를 만드는 것이 일반적입니다. 예를 들어, 딕셔너리에 새로운 키의 추가를 제한하거나, 특정 키만 수정할 수 있도록 제한할 수 있습니다.

아래에서는 딕셔너리의 확장을 제한하는 다양한 방법과 그에 해당하는 코드 샘플을 소개하겠습니다.

읽기 전용 딕셔너리 (ReadOnlyDict)

이 예제에서는 딕셔너리를 읽기 전용으로 만들어, 어떤 수정도 불가능하게 합니다.

코드 설명

• __setitem__, __delitem__, clear, pop, popitem, setdefault, update: 모든 수정 메서드를 오버라이드하여 예외를 발생시킵니다.

코드 샘플

class ReadOnlyDict(dict):
    def __readonly__(self, *args, **kwargs):
        raise TypeError("This dictionary is read-only")

    __setitem__ = __readonly__
    __delitem__ = __readonly__
    clear = __readonly__
    pop = __readonly__
    popitem = __readonly__
    setdefault = __readonly__
    update = __readonly__

# 사용 예제
try:
    readonly_dict = ReadOnlyDict(a=1, b=2)
    print(readonly_dict)  # 출력: {'a': 1, 'b': 2}

    # 값 수정 시도
    readonly_dict['a'] = 10  # TypeError 발생
except TypeError as e:
    print(e)  # 출력: This dictionary is read-only

try:
    # 키 삭제 시도
    del readonly_dict['a']  # TypeError 발생
except TypeError as e:
    print(e)  # 출력: This dictionary is read-only

try:
    # update 메서드 사용 시도
    readonly_dict.update({'c': 3})  # TypeError 발생
except TypeError as e:
    print(e)  # 출력: This dictionary is read-only

출력 결과

{'a': 1, 'b': 2}
This dictionary is read-only
This dictionary is read-only
This dictionary is read-only

결론

파이썬의 dict 자료형을 상속받아 사용자 정의 클래스를 만드는 것은 매우 유용하며, 다양한 방식으로 딕셔너리의 동작을 확장하거나 제한할 수 있습니다. 위의 예제들을 통해 다음과 같은 기능을 구현할 수 있습니다:

1. 고정 키 집합: 특정 키만 수정 가능하게 하고, 새로운 키의 추가를 제한.
2. 읽기 전용 딕셔너리: 딕셔너리를 수정 불가능하게 만들어 데이터의 무결성을 유지.
3. 최대 크기 제한: 딕셔너리에 추가할 수 있는 항목의 수를 제한.
4. 타입 제한: 키와 값의 타입을 제한하여 데이터의 일관성을 유지.

이러한 사용자 정의 딕셔너리를 활용하면, 애플리케이션의 요구사항에 맞게 데이터 구조를 더욱 정교하게 제어할 수 있습니다.

제너릭을 이용한 파이썬의 `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'}"