Improved ComplexNumber Class - Python Programming Exercise

import math

class ComplexNumber:
    def __init__(self, real, imaginary):
        """
        Initializes a ComplexNumber object with real and imaginary parts.

        Parameters:
            real (float): The real part of the complex number.
            imaginary (float): The imaginary part of the complex number.
        """
        self.real = real
        self.imaginary = imaginary

    # Getter for the real part
    def get_real(self):
        return self.real

    # Setter for the real part
    def set_real(self, real):
        self.real = real

    # Getter for the imaginary part
    def get_imaginary(self):
        return self.imaginary

    # Setter for the imaginary part
    def set_imaginary(self, imaginary):
        self.imaginary = imaginary

    def __str__(self):
        """
        Returns the complex number in the format (a, b).
        """
        return f"({self.real}, {self.imaginary})"

    def get_magnitude(self):
        """
        Returns the magnitude of the complex number using the formula: sqrt(a^2 + b^2).
        """
        return math.sqrt(self.real ** 2 + self.imaginary ** 2)

    def add(self, other):
        """
        Adds two complex numbers together.

        Parameters:
            other (ComplexNumber): The other complex number to add.

        Returns:
            ComplexNumber: A new complex number that is the sum of the two.
        """
        real_part = self.real + other.real
        imaginary_part = self.imaginary + other.imaginary
        return ComplexNumber(real_part, imaginary_part)

    def subtract(self, other):
        """
        Subtracts another complex number from this one.

        Parameters:
            other (ComplexNumber): The complex number to subtract.

        Returns:
            ComplexNumber: A new complex number that is the result of the subtraction.
        """
        real_part = self.real - other.real
        imaginary_part = self.imaginary - other.imaginary
        return ComplexNumber(real_part, imaginary_part)

    # Overloading the addition operator (+)
    def __add__(self, other):
        """
        Overloads the + operator to add two complex numbers.
        """
        return self.add(other)

    # Overloading the subtraction operator (-)
    def __sub__(self, other):
        """
        Overloads the - operator to subtract two complex numbers.
        """
        return self.subtract(other)


# Test program to demonstrate the functionality of the overloaded operators
def main():
    # Create two complex numbers
    complex1 = ComplexNumber(2, 3)  # 2 + 3i
    complex2 = ComplexNumber(1, 1)  # 1 + 1i

    # Display the complex numbers
    print(f"Complex 1: {complex1}")
    print(f"Complex 2: {complex2}")

    # Add the two complex numbers using the overloaded + operator
    result_add = complex1 + complex2
    print(f"Addition Result: {result_add}")

    # Subtract the two complex numbers using the overloaded - operator
    result_subtract = complex1 - complex2
    print(f"Subtraction Result: {result_subtract}")

    # Display magnitudes
    print(f"Magnitude of Complex 1: {complex1.get_magnitude()}")
    print(f"Magnitude of Complex 2: {complex2.get_magnitude()}")


# Run the test program
if __name__ == "__main__":
    main()

 Output

Complex 1: (2, 3)
Complex 2: (1, 1)
Addition Result: (3, 4)
Subtraction Result: (1, 2)
Magnitude of Complex 1: 3.605551275463989
Magnitude of Complex 2: 1.4142135623730951