2 [问答]设计一个三维向量类，并实现向量的加法、减法以及向

class Vector
{    
    private:

    public:
        double x,y,z;

        Vector(double x,double y,double z):
            x(x),
            y(y),
            z(z){}

        ~Vector(){}

        Vector operator+(const Vector &other)const
        {
            return (Vector){x+other.x,y+other.y,z+other.z};
        }

        Vector operator-(const Vector &other)const
        {
            return (Vector){x-other.x,y-other.y,z-other.z};
        }

        Vector operator*(const double &k)const
        {
            return (Vector){k*x,k*y,k*z};
        }

        Vector operator/(const double &k)const
        {
            return *this*(1/k);
        }
};

class Vector():
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z
    def __add__(self, n):      
        x = self.x + n.x
        y = self.y + n.y
        z = self.z + n.z
        r = Vector(x, y, z)
        return r
    def __sub__(self, n):
        x = self.x - n.x
        y = self.y - n.y
        z = self.z - n.z
        r = Vector(x, y, z)
        return r
    def __mul__(self, k):
        x = self.x * k
        y = self.y * k
        z = self.z * k
        r = Vector(x, y, z)
        return r
    def __truediv__(self, k):
        try:
            x = self.x / k
            y = self.y / k
            z = self.z / k
        except:
            print('k is zero!')
            return Vector(0, 0, 0)
        else:
            return Vector(x, y, z)
    def __floordiv__(self, k):
        try:
            x = self.x // k
            y = self.y // k
            z = self.z // k
        except:
            print('k is zero!')
            return Vector(0, 0, 0)
        else:
            return Vector(x, y, z)
    def showVector(self):
        print(self.x, self.y, self.z)
v1 = Vector(1,2,3)
v2 = Vector(4,5,6)
k = 2
(v1 + v2).showVector()
(v1 - v2).showVector()
(v1 * k).showVector()
(v2 // k).showVector()
(v2 / k).showVector()

def vectorSum(Vector1, Vector2, Vector3):
    for i in range(3):
        Vector3[i] = eval(Vector1[i])+eval(Vector2[i])
    return Vector3

def vectorSub(Vector1, Vector2, Vector4):
    for i in range(3):
        Vector4[i] = eval(Vector1[i])-eval(Vector2[i])
    return Vector4

def vectorPro(Vector1, Vector2, Vector5):
    for i in range(3):
        Vector5[i] = eval(Vector1[i])*eval(Vector2[i])
    return Vector5

def vectorDiv(Vector1, Vector2, Vector6):
    for i in range(3):
        Vector6[i] = eval(Vector1[i])/eval(Vector2[i])
    return Vector6

list1 = []
list2 = []
list3 = [0, 0, 0]
list4 = [0, 0, 0]
list5 = [0, 0, 0]
list6 = [0, 0, 0]
list1 = input("请输入第一个三维向量(用逗号隔开)：").split("，")
list2 = input("请输入第二个三维向量(用逗号隔开)：").split("，")
Vector1 = list1
Vector2 = list2
Vector3 = list3
Vector4 = list4
Vector5 = list5
Vector6 = list6
print(vectorSum(Vector1, Vector2, Vector3))
print(vectorSub(Vector1, Vector2, Vector4))
print(vectorPro(Vector1, Vector2, Vector5))
print(vectorDiv(Vector1, Vector2, Vector6))

class Vecter3: def __init__(self,x=0,y=0,z=0): self.X=x self.Y=y self.Z=z def __add__(self, n):
        r=Vecter3()
        r.X=self.X+n.X
        r.Y=self.Y+n.Y
        r.Z=self.Z+n.Z return r def __sub__(self,n):
        r=Vecter3()
        r.X=self.X-n.X
        r.Y=self.Y-n.Y
        r.Z=self.Z-n.Z return r def __mul__(self, n):
        r=Vecter3()
        r.X=self.X*n
        r.Y=self.Y*n
        r.Z=self.Z*n return r def __truediv__(self,n):
        r=Vecter3()
        r.X=self.X/n
        r.Y=self.Y/n
        r.Z=self.Z/n return r def __floordiv__(self,n):
        r=Vecter3()
        r.X=self.X//n
        r.Y=self.Y//n
        r.Z=self.Z//n return r def show(self): print(self.X,self.Y,self.Z)

class Vector():
    
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z
    
    def __add__(self, b):
        x = self.x + b.x
        y = self.y + b.y
        z = self.z + b.z
        return Vector(x, y, z)
        
    def __sub__(self, b):
        x = self.x - b.x
        y = self.y - b.y
        z = self.z - b.z
        return Vector(x, y, z)
    
    def __mul__(self, k):
        x = self.x * k
        y = self.y * k
        z = self.z * k
        return Vector(x, y, z)
    
    def __truediv__(self, k):
        try:
            x = self.x / k
            y = self.y / k
            z = self.z / k
        except:
            print('k is zero!!')
            return Vector(0,0,0)
        else:
            return Vector(x, y, z)
    
    def sp(self):
        print(self.x, self.y, self.z)
        

v1 = Vector(1,2,3)
v2 = Vector(3,4,5)
k = 2

(v1+v2).sp()
(v1-v2).sp()
(v1*k).sp()
(v1/k).sp()