Native Python Programing

파이썬에서 object 클래스를 상속하여 사용자 정의 데이터 타입을 만들 수 있습니다. 이를 통해 기본 데이터 타입(예: int, str, list)처럼 동작하는 객체를 만들거나, 특별한 동작을 가지는 데이터를 정의할 수 있습니다.

사용자 정의 데이터 타입 만들기

사용자 정의 데이터 타입을 만들기 위해서는 object 클래스를 상속받고, 필요한 속성(데이터)과 메서드(동작)를 정의합니다. 이때, 파이썬의 __init__, __repr__, __eq__, __lt__ 등과 같은 특수 메서드를 재정의하면, 객체 간 비교, 출력, 초기화 등을 정의할 수 있습니다.

예제: 사용자 정의 복소수 타입

다음은 파이썬의 object 클래스를 상속하여 복소수(Complex Number)를 표현하는 사용자 정의 데이터 타입을 만드는 예제입니다.

class ComplexNumber(object):
    def __init__(self, real, imag):
        """복소수의 실수부와 허수부를 초기화"""
        self.real = real
        self.imag = imag

    def __add__(self, other):
        """두 복소수의 덧셈"""
        return ComplexNumber(self.real + other.real, self.imag + other.imag)

    def __sub__(self, other):
        """두 복소수의 뺄셈"""
        return ComplexNumber(self.real - other.real, self.imag - other.imag)

    def __mul__(self, other):
        """두 복소수의 곱셈"""
        real_part = self.real * other.real - self.imag * other.imag
        imag_part = self.real * other.imag + self.imag * other.real
        return ComplexNumber(real_part, imag_part)

    def __eq__(self, other):
        """복소수의 동등성 비교"""
        return self.real == other.real and self.imag == other.imag

    def __repr__(self):
        """복소수의 표현"""
        return f"{self.real} + {self.imag}i"

    def conjugate(self):
        """복소수의 켤레 복소수 계산"""
        return ComplexNumber(self.real, -self.imag)

# 사용자 정의 복소수 클래스 사용 예제
z1 = ComplexNumber(3, 2)
z2 = ComplexNumber(1, 7)

# 덧셈
z3 = z1 + z2
print(f"z1 + z2 = {z3}")  # 출력: z1 + z2 = 4 + 9i

# 뺄셈
z4 = z1 - z2
print(f"z1 - z2 = {z4}")  # 출력: z1 - z2 = 2 - 5i

# 곱셈
z5 = z1 * z2
print(f"z1 * z2 = {z5}")  # 출력: z1 * z2 = -11 + 23i

# 켤레 복소수
z_conjugate = z1.conjugate()
print(f"z1의 켤레 복소수: {z_conjugate}")  # 출력: z1의 켤레 복소수: 3 - 2i

# 동등 비교
print(f"z1과 z2가 같은가? {z1 == z2}")  # 출력: z1과 z2가 같은가? False

설명:

• __init__(self, real, imag)는 클래스의 인스턴스가 생성될 때 호출되며, 복소수의 실수부와 허수부를 초기화합니다.
• __add__(self, other)는 두 복소수를 더하는 메서드로, + 연산자를 오버로드합니다.
• __sub__(self, other)는 두 복소수를 빼는 메서드로, - 연산자를 오버로드합니다.
• __mul__(self, other)는 두 복소수를 곱하는 메서드로, * 연산자를 오버로드합니다.
• __eq__(self, other)는 두 복소수가 같은지 비교하는 메서드로, == 연산자를 오버로드합니다.
• __repr__(self)는 객체를 문자열로 나타낼 때 사용되며, print() 함수나 인터프리터에서 출력될 때 호출됩니다.
• conjugate(self)는 복소수의 켤레 복소수를 반환하는 메서드입니다.

사용자 정의 타입의 장점

1. 데이터 모델링: 현실 세계의 개념을 더 잘 반영하는 데이터 타입을 정의할 수 있습니다.
2. 연산자 오버로딩: 기본 연산자(+, -, *, == 등)를 재정의하여 객체 간의 연산을 직관적으로 수행할 수 있습니다.
3. 메서드 추가: 필요한 메서드를 추가하여 데이터 처리나 계산을 간편하게 수행할 수 있습니다.

예제: 2D 벡터를 표현하는 사용자 정의 데이터 타입

다음은 2D 벡터를 표현하는 클래스입니다.

class Vector2D(object):
    def __init__(self, x, y):
        """2D 벡터의 x, y 좌표를 초기화"""
        self.x = x
        self.y = y

    def __add__(self, other):
        """두 벡터의 덧셈"""
        return Vector2D(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        """두 벡터의 뺄셈"""
        return Vector2D(self.x - other.x, self.y - other.y)

    def __mul__(self, scalar):
        """벡터의 스칼라 곱"""
        return Vector2D(self.x * scalar, self.y * scalar)

    def magnitude(self):
        """벡터의 크기 계산"""
        return (self.x ** 2 + self.y ** 2) ** 0.5

    def __repr__(self):
        """벡터의 표현"""
        return f"Vector2D({self.x}, {self.y})"

# 2D 벡터 클래스 사용 예제
v1 = Vector2D(3, 4)
v2 = Vector2D(1, 2)

# 벡터 덧셈
v3 = v1 + v2
print(f"v1 + v2 = {v3}")  # 출력: v1 + v2 = Vector2D(4, 6)

# 벡터 뺄셈
v4 = v1 - v2
print(f"v1 - v2 = {v4}")  # 출력: v1 - v2 = Vector2D(2, 2)

# 스칼라 곱
v5 = v1 * 3
print(f"v1 * 3 = {v5}")  # 출력: v1 * 3 = Vector2D(9, 12)

# 벡터의 크기
print(f"v1의 크기: {v1.magnitude()}")  # 출력: v1의 크기: 5.0

설명:

• Vector2D 클래스는 2차원 벡터를 나타냅니다.
• +, -, * 연산자를 오버로드하여 벡터 덧셈, 뺄셈, 스칼라 곱을 정의합니다.
• magnitude() 메서드는 벡터의 크기를 계산합니다.

이와 같이 Python의 object 클래스를 상속받아 사용자 정의 데이터 타입을 만들면, 데이터의 의미를 명확하게 정의하고, 관련된 연산을 직관적으로 처리할 수 있습니다.