Native Python Programing

파이썬에서는 제너릭(Generic) 타입을 사용하여 여러 가지 자료형에 대해 동작할 수 있는 유연한 데이터 구조를 만들 수 있습니다. 제너릭 타입은 주로 typing 모듈을 사용하여 구현합니다. 여기서는 제너릭을 이용해 세 개의 요소를 저장하는 Triple 자료구조를 만들어 보겠습니다.

제너릭을 이용한 Triple 자료구조

Triple 클래스는 세 개의 요소를 저장할 수 있으며, 각 요소의 타입은 유연하게 설정될 수 있습니다. 이를 위해 typing 모듈의 Generic과 TypeVar를 사용합니다. Triple의 각 요소는 서로 다른 타입일 수 있으며, 이를 안전하게 다루기 위해 제너릭을 도입합니다.

예제 코드:

from typing import Generic, TypeVar

# 세 개의 서로 다른 타입을 위한 제너릭 타입 변수 정의
T1 = TypeVar('T1')
T2 = TypeVar('T2')
T3 = TypeVar('T3')

# 제너릭을 이용한 Triple 클래스 정의
class Triple(Generic[T1, T2, T3]):
    def __init__(self, first: T1, second: T2, third: T3):
        self.first = first
        self.second = second
        self.third = third

    # 각 요소에 접근하는 메서드
    def get_first(self) -> T1:
        return self.first

    def get_second(self) -> T2:
        return self.second

    def get_third(self) -> T3:
        return self.third

    # Triple 객체 출력 메서드
    def display(self):
        print(f"First: {self.first}, Second: {self.second}, Third: {self.third}")

# 사용 예제
# Triple 객체 생성 (타입: str, int, float)
triple = Triple("Python", 3, 3.14)

# 요소 출력
triple.display()

# 각 요소에 접근
print(f"First Element: {triple.get_first()}")
print(f"Second Element: {triple.get_second()}")
print(f"Third Element: {triple.get_third()}")

설명:

1. 제너릭 타입 변수(T1, T2, T3):

   • TypeVar('T1'), TypeVar('T2'), TypeVar('T3')는 각각 Triple 클래스에서 첫 번째, 두 번째, 세 번째 요소의 타입을 나타냅니다.
   • 이들은 제너릭 타입 변수로, Triple 객체가 생성될 때 각 요소에 대해 타입을 지정할 수 있습니다.

2. Triple 클래스:

   • Generic[T1, T2, T3]을 상속받아 제너릭을 사용합니다.
   • 생성자 __init__()는 세 개의 요소 first, second, third를 받아서 해당 객체의 속성으로 저장합니다.
   • get_first(), get_second(), get_third() 메서드를 통해 각 요소에 안전하게 접근할 수 있습니다.
   • display() 메서드는 세 요소를 출력합니다.

실행 결과:

First: Python, Second: 3, Third: 3.14
First Element: Python
Second Element: 3
Third Element: 3.14

주요 포인트:

• 제너릭의 유연성: Triple 클래스는 각 요소에 대해 제너릭 타입을 적용하여, 다양한 타입의 데이터를 저장하고 처리할 수 있습니다. 즉, 동일한 구조의 클래스를 여러 가지 데이터 타입에 대해 재사용할 수 있습니다.
• 타입 안정성: 각 요소에 대해 명확한 타입을 지정함으로써, 잘못된 타입의 데이터를 사용하지 않도록 도와줍니다.
• 실제 사용 예: 이 구조는 세 개의 서로 다른 데이터를 하나의 구조로 묶고, 각 데이터를 안전하게 다룰 수 있는 상황에서 유용하게 사용할 수 있습니다. 예를 들어, 좌표값, 다양한 설정값, 또는 관련 있는 세 개의 데이터를 다룰 때 활용할 수 있습니다.

이 Triple 자료구조는 다양한 데이터 타입을 다룰 수 있는 강력한 도구가 될 수 있으며, 파이썬의 제너릭 기능을 잘 활용한 예입니다.

제너릭을 이용한 파이썬의 `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` 클래스를 재사용할 수 있습니다. 필요에 따라 다른 타입의 쌍을 생성할 수 있습니다.

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