1. The complex number is widely used in circuit science. By using the sinusoidal nature of alternating current, the capacitance and reactance are given the resistance of the complex value, that is, the impedance. Then the calculation process only involves the four operations of the complex number, which greatly reduces the difficulty. Please define addition, subtraction, multiplication and division operator of complex. Write a program to realize + - * / operator overloading. The main functions are as follows: (1) Realize the addition, subtraction, multiplication and division of two complex numbers (C1 and C2). (2) Realize the addition, subtraction, multiplication and division of complex number C1 and integer num. (3) Realize the addition, subtraction, multiplication and division of integer number and complex number C1. Input format: Please write the input format here. For example： 1.0 2.0 3.0 4.0 5 Output format: Please describe the output format here. For example: c1+c2=(4.00,6.00i) c1-c2=(-2.00,-2.00i) c1*c2=(-5.00,10.00i) c1/c2=(0.44,0.08i) c1+num=(6.00,2.00i) c1-num=(-4.00,2.00i) c1*num=(5.00,10.00i) c1/num=(0.20,0.40i) num+c1=(6.00,2.00i) num-c1=(4.00,-2.00i) num*c1=(5.00,10.00i) num/c1=(1.00,-2.00i)

Sure, I can help you with that. Here's a Python program that defines a `Complex` class and overloads the `+`, `-`, `*`, and `/` operators to perform arithmetic operations on complex numbers:

class Complex:
    def __init__(self, real=0.0, imag=0.0):
        self.real = real
        self.imag = imag

    def __str__(self):
        return f"({self.real:.2f},{self.imag:.2f}i)"

    def __add__(self, other):
        return Complex(self.real + other.real, self.imag + other.imag)

    def __sub__(self, other):
        return Complex(self.real - other.real, self.imag - other.imag)

    def __mul__(self, other):
        return Complex(self.real * other.real - self.imag * other.imag,
                       self.real * other.imag + self.imag * other.real)

    def __truediv__(self, other):
        denom = other.real**2 + other.imag**2
        return Complex((self.real * other.real + self.imag * other.imag) / denom,
                       (self.imag * other.real - self.real * other.imag) / denom)

    def __radd__(self, other):
        return self.__add__(other)

    def __rsub__(self, other):
        return Complex(other.real - self.real, other.imag - self.imag)

    def __rmul__(self, other):
        return self.__mul__(other)

    def __rtruediv__(self, other):
        denom = self.real**2 + self.imag**2
        return Complex((other.real * self.real + other.imag * self.imag) / denom,
                       (other.imag * self.real - other.real * self.imag) / denom)

# test the Complex class
c1 = Complex(1.0, 2.0)
c2 = Complex(3.0, 4.0)
num = 5

print(f"c1+c2={c1+c2}")
print(f"c1-c2={c1-c2}")
print(f"c1*c2={c1*c2}")
print(f"c1/c2={c1/c2}")
print(f"c1+num={c1+Complex(num, 0)}")
print(f"c1-num={c1-Complex(num, 0)}")
print(f"c1*num={c1*Complex(num, 0)}")
print(f"c1/num={c1/Complex(num, 0)}")
print(f"num+c1={Complex(num, 0)+c1}")
print(f"num-c1={Complex(num, 0)-c1}")
print(f"num*c1={Complex(num, 0)*c1}")
print(f"num/c1={Complex(num, 0)/c1}")

The output of the program should be:

c1+c2=(4.00,6.00i)
c1-c2=(-2.00,-2.00i)
c1*c2=(-5.00,10.00i)
c1/c2=(0.44,0.08i)
c1+num=(6.00,2.00i)
c1-num=(-4.00,2.00i)
c1*num=(5.00,10.00i)
c1/num=(0.20,0.40i)
num+c1=(6.00,2.00i)
num-c1=(4.00,-2.00i)
num*c1=(5.00,10.00i)
num/c1=(1.00,-2.00i)

In terms of input format, you can prompt the user to enter the real and imaginary parts of the complex numbers and the integer, like this:

# prompt the user for input
re1, im1, re2, im2, num = map(float, input("Enter real and imaginary parts of c1, c2, and num: ").split())
c1 = Complex(re1, im1)
c2 = Complex(re2, im2)

And in terms of output format, you can use the `__str__` method of the `Complex` class to print the complex numbers in a nice format, like this:

print(f"c1+c2={c1+c2}")