Python 在复数计算器项目中使用类的问题

我是托马斯，我是一名计算机科学专业的学生。在我最新的Python OOP项目中，我一直在尝试做一个简单的复数计算器

我的任务是用Python制作一个2类项目

首先，该类有3种方法：

1-创建一个复数 第二个-显示复数 第三-删除复数

第二类有四种方法：加、减、乘和除。 我已经创建了第一个类及其方法，我认为它们在基本级别上工作得很好（当然，代码是原始的，需要大量工作：（）

---

我在第二节课上偶然发现了一个问题。我不能正确使用加法、减法、乘法和除法。 我希望数学方法能使用之前创建的两个复数，但我找不到正确完成任务的方法

谢谢您的帮助

我的代码：

class Complex (object):
    def __init__(self, real, imaginary):
        self.real = real
        self.imaginary = imaginary

    def create_number(self):
        self.real = (float(input("Enter a real part of the complex number")))
        self.imaginary = (float(input("Enter an imaginary part of the complex number")))
        return Complex(self.real, self.imaginary)

    def display_number(self):
        print(f"Your complex number is: {Complex(self.real, self.imaginary)}")

    def erase_number(self):
        (self.real, self.imaginary) = (0, 0)
        print(f"Number is erased: {(self.real, self.imaginary)}")

    def __str__(self):
        if type(self.real) == int and type(self.imaginary) == int:
            if self.imaginary >= 0:
                return '%d+%di' % (self.real, self.imaginary)
            elif self.imaginary < 0:
                return '%d%di' % (self.real, self.imaginary)
        else:
            if self.imaginary >= 0:
                return '%f+%fi' % (self.real, self.imaginary)
            elif self.imaginary < 0:
               return '%f%fi' % (self.real, self.imaginary)


class Calculator(object):
    def __init__(self, real, imaginary):
        self.real = real
        self.imaginary = imaginary

    def __add__(self, other):
        result_real = self.real+other.real
        result_imaginary = self.imaginary+other.imaginary
        result = Complex(result_real, result_imaginary)
        return result

    def __sub__(self, other):
        result_real = self.real-other.real
        result_imaginary = self.imaginary-other.imaginary
        result = Complex(result_real, result_imaginary)
        return result

    def __mul__(self, other):
        result_real = (self.real*other.real-self.imaginary*other.imaginary)
        result_imaginary = (self.real*other.imaginary+other.real*self.imaginary)
        result = Complex(result_real, result_imaginary)
        return result

    def __truediv__(self, other):
        result_real = float(float(self.real*other.real+self.imaginary*other.imaginary)/float(other.real*other.real+other.imaginary*other.imaginary))
        result_imaginary = float(float(other.real*self.imaginary-self.real*other.imaginary)/float(other.real*other.real+other.imaginary*other.imaginary))
        result = Complex(result_real, result_imaginary)
        return result


c1 = Complex(0, 0)
c2 = Complex(0, 0)

calc1 = Calculator(0, 0)
calc2= Calculator(0, 0)

choice = 1
while choice != 0:
    print("0. Exit")
    print("1. Construction of a complex number 1")
    print("2. Construction of a complex number 2")
    print("3. Display complex number 1")
    print("4. Display complex number 2")
    print("5. Erase complex number 1")
    print("6. Erase complex number 2")
    print("7. Addition")
    print("8. Subtraction")
    print("9. Multiplication")
    print("10. Division")
    choice = int(input("Enter choice: "))

    if choice == 1:
        print("Result: ", c1.create_number())
    elif choice == 2:
        print("Result: ", c2.create_number())
    elif choice == 3:
        print("Result: ", c1.display_number())
    elif choice == 4:
        print("Result: ", c2.display_number())
    elif choice == 5:
        print("Result: ", c1.erase_number())
    elif choice == 6:
        print("Result: ", c2.erase_number())
    elif choice == 7:
        print("Result: ", calc1.__add__(calc2))
    elif choice == 8:
        print("Result: ", calc1.__sub__(calc2))
    elif choice == 9:
        print("Result: ", calc1.__mul__(calc2))
    elif choice == 10:
        print("Result: ", calc1.__truediv__(calc2))
    elif choice == 0:
        print("Exiting!")
    else:
        print("Invalid choice!!")

类复合体（对象）：
定义初始（自、实、虚）：
self.real=real
自我想象的
def创建_编号（自身）：
self.real=（float（输入（“输入复数的实部”））
self.virginal=（float（输入（“输入复数的虚部”））
返回复合体（自实、自虚）
def显示_编号（自身）：
打印（f“您的复数为：{complex（self.real，self.virtual）}”）
def擦除_编号（自身）：
（自实、自虚）=（0,0）
打印（f“数字被删除：{（self.real，self.virtual）}”）
定义（自我）：
如果类型（self.real）==int，类型（self.virtual）==int：
如果self.virtual>=0：
返回“%d+%di%”（self.real，self.virtual）
elif self.virtual<0:
返回“%d%di%”（self.real，self.virtual）
其他：
如果self.virtual>=0：
返回“%f+%fi%”（self.real，self.virtual）
elif self.virtual<0:
返回“%f%fi%”（self.real，self.virtual）
类计算器（对象）：
定义初始（自、实、虚）：
self.real=real
自我想象的
定义添加（自身、其他）：
result\u real=self.real+other.real
结果_假想=自我假想+其他假想
结果=复数（结果为实，结果为虚）
返回结果
定义（自身、其他）：
结果_real=self.real-other.real
结果_virtual=自我想象-其他想象
结果=复数（结果为实，结果为虚）
返回结果
定义多个（自身、其他）：
结果_real=（self.real*other.real self.virtual*other.virtual）
结果_virtual=（self.real*other.virtual+other.real*self.virtual）
结果=复数（结果为实，结果为虚）
返回结果
def _uTrueDiv__;（自身、其他）：
result_real=float（float（self.real*other.real+self.virtual*other.virtual）/float（other.real*other.real+other.virtual*other.virtual））
result_virtual=float（float（other.real*self.virtual-self.real*other.virtual）/float（other.real*other.real+other.virtual*other.virtual））
结果=复数（结果为实，结果为虚）
返回结果
c1=复数（0，0）
c2=复数（0，0）
calc1=计算器（0，0）
calc2=计算器（0，0）
选择=1
而选项！=0:
打印（“0.退出”）
打印（“1.复数1的构造”）
打印（“2.复数2的构造”）
打印（“3.显示复数1”）
打印（“4.显示复数2”）
打印（“5.删除复数1”）
打印（“6.删除复数2”）
打印（“7.添加”）
打印（“8.减法”）
打印（“9.乘法”）
印刷品（“10.分部”）
choice=int（输入（“输入选项：”）
如果选项==1：
打印（“结果：”，c1.创建编号（）
elif选项==2：
打印（“结果：”，c2.create_number（））
elif选项==3：
打印（“结果：”，c1.显示编号（）
elif选项==4：
打印（“结果：”，c2.显示编号（）
elif选项==5：
打印（“结果：”，c1.擦除\u编号（）
elif选项==6：
打印（“结果：”，c2.删除编号（）
elif选项==7：
打印（“结果：，计算C1.\uuuuu添加\uuuuuuu（计算C2））
elif选项==8：
打印（“结果：，计算C1.\uuuuuuuuuuuuuuuu（计算C2））
elif选项==9：
打印（“结果：，计算C1.\uuuuuuuuuuuuuuuu（计算C2））
elif选项==10：
打印（“结果：，calc1.\uuu truediv\uuuu（calc2））
elif选项==0：
打印（“正在退出！”）
其他：
打印（“无效选择！！”）

这可能无法回答您的问题，但无论如何都是有效的知识

\uuuuuuuuuuuuuuuuuuuuuu

方法家族（“神奇方法”）仅用于python内部使用

当您编写

a+b

时，python将检查

a

是否碰巧有一个

\uuuuuuuuuuuu

方法，并使用该方法，如果没有，则使用

b

的

\uuuuuuuuu

方法

---

因此，我们应该简单地间接地“使用”这些方法：

print（“Result:”，calc1+calc2）

计算器和复杂对象之间目前没有关系。计算器的实/虚属性初始化为0，但从未更新

解决此问题的一种方法是使用对复杂对象的引用初始化计算器：

class Calculator(object):
    def __init__(self, complex_number):
        self.complex_number = complex_number

    def __add__(self, other):
        result_real = self.complex_number.real+other.complex_number.real
        result_imaginary = self.complex_number.imaginary+other.complex_number.imaginary
        result = Complex(result_real, result_imaginary)
        return result
    # other methods should be modified as appropriate..


c1 = Complex(0, 0)
c2 = Complex(0, 0)

calc1 = Calculator(c1)
calc2= Calculator(c2)

---

当用户调用create_number时，将更新

c1

，当用户调用

add

“我无法正确使用方法：add，…”时，计算器将引用（现在已更新）的复杂对象-您的问题到底是什么？例如，当我在if循环中使用选项7时，add方法返回的值为0.0。我找不到创建适当计算器对象的方法，或者可能代码需要更改，因为我找不到解决问题的方法。关于处理OOP的一些一般性建议：尝试对处于