如何在Python中创建复数矩阵

我正在尝试使用Python创建复数矩阵类。 我的第一个方法使用一个类和复杂类（self.real、self.imag）： 运算符重载+-*正常

class zcomplex:
def __init__(self,rows,real,imag):
    self.rows=rows
    self.real=real
    self.imag=imag
    self.tab=[[complex(self.real,self.imag)]*self.rows for i in range(rows)]
    
def __add__(self,other):
    tmp=zcomplex(self.rows,0,0)
    for i in range(self.rows):
        for j in range(self.rows):
            tmp.tab[i][j]= self.tab[i][j] + other.tab[i][j]
    return tmp

def __sub__(self,other):
    tmp=zcomplex(self.rows,0,0)
    for i in range(self.rows):
        for j in range(self.rows):
            tmp.tab[i][j]= self.tab[i][j] - other.tab[i][j]
    return tmp

def __mul__(self,other):
    tmp=zcomplex(self.rows,0,0)
    for i in range(self.rows):
        for j in range(self.rows):
            for k in range(self.rows):
                tmp.tab[i][j]+= self.tab[i][j] * other.tab[i][j]
    return tmp

def prm(self):
    for i in range(self.rows):
        print(self.tab[i])
    print('')


a=zcomplex(3,4,6)
a.prm()

b=zcomplex(3,1,2)
b.prm()

print('c+a+b')
c=a+b
c.prm()

print('d=a-b')
d=a-b
d.prm()

print('e=a*b')
e=a*b
e.prm()

但我希望继承类似于C++。< /P>

class zcomplex:
def __init__(self,real=1,imag=0):
    self.real=real
    self.imag=imag
def display(self):
    print((self.real,self.imag))

class zmatrix(zcomplex):
    def __init__(self, real=0,imag=0,rows=3):
        self.rows=rows
        zcomplex.__init__(self,real,imag)
        self.tab=[[(real,imag)]*self.rows for i in range(self.rows)]
    def display(self):
        for i in range(self.rows):
            print(self.tab[i])

a=zmatrix()
a.display()

b=zcomplex()
b.display()

但是不起作用。 在C++中，我可以使用Tab[i] [j]。 没有numpy我怎么能解决这个问题

感谢您的关注和帮助

对于tab[i][j].real，我的意思是如何重载运算符+，-和* 第二种情况

在C++中，我可以：

zmatrix zmatrix :: operator-(const zmatrix & zarray)

{ zmatrix温度（行、列）

{ zmatrix温度（行、列）

for（int i=0；i

---

}*/

如果你想

tab[i][j].real

成为一个有效的表达式，那么你必须创建

tab

作为

zcomplex

对象的矩阵。你没有这样做。但是你可以。下面是你的代码，其中有一个简单的更改：

class zcomplex:
    def __init__(self,real=1,imag=0):
        self.real=real
        self.imag=imag
    def display(self):
        print((self.real,self.imag))

class zmatrix(zcomplex):
    def __init__(self, real=0,imag=0,rows=3):
        self.rows=rows
        zcomplex.__init__(self,real,imag)
        self.tab=[[zcomplex(real,imag)]*self.rows for i in range(self.rows)]
    def display(self):
        for i in range(self.rows):
            print(self.tab[i])

a=zmatrix()

b=zcomplex()

# this now works...prints `0`
i = 2
j = 1
print(a.tab[i][j].real)

更新：

我不明白从

zcomplex

继承

zmatrix

会得到什么。毕竟，矩阵本身并不是一个复数。

zmatrix

是

zcomplex

对象的容器

你在构建矩阵的每一行时所做的一切都不起作用。

[（real，imag）]*self。行

将创建一个列表，其中包含对同一元组的3个引用，这不是你想要的，对吧？同样，

[zcomplex（real，imag）]*self.rows

将创建一个列表，其中包含对同一

zcomplex

对象的3个引用。因此，您需要以稍微不同的方式构建每一行

这是一个版本的代码，对我上面提到的两件事进行了更改。我还添加了

\uuuu repr\uuuu

方法，使您可以轻松打印每个类的实例内容。最后，我添加了一些代码来演示此代码是否有效：

class zcomplex:
    def __init__(self,real=1,imag=0):
        self.real=real
        self.imag=imag
    def __repr__(self):
        return f'<r:{self.real} i:{self.imag}>'
    def display(self):
        print(self)

class zmatrix:
    def __init__(self, real=0 ,imag=0, rows=3):
        self.rows=rows
        self.tab=[[zcomplex(real,imag) for _ in range(rows)] for _ in range(self.rows)]
    def __repr__(self):
        return '\n'.join(' '.join(str(c) for c in self.tab[i]) for i in range(self.rows))
    def display(self):
        print(self)

a=zmatrix()
print(a)

a.tab[0][0].real = 123
a.tab[1][1].real = 456
a.tab[2][2].real = 789

a.tab[0][2].imag = 999
a.tab[1][1].imag = 888
a.tab[2][0].imag = 777

print('\n', a, sep='')

zcomplex类：
定义初始化（self，real=1，imag=0）：
真实的
self.imag=imag
定义报告（自我）：
返回f“”
def显示（自）：
打印（自我）
zmatrix类：
定义初始化（self，real=0，imag=0，rows=3）：
self.rows=行
self.tab=[[zcomplex（real，imag）表示范围内（行）]表示范围内（self.rows）]
定义报告（自我）：
返回'\n'.join（''.join（str（c）表示self.tab[i]中的c）表示范围（self.rows）中的i）
def显示（自）：
打印（自我）
a=zmatrix（）
印刷品（a）
a、 制表符[0][0]。实数=123
a、 表[1][1]。实际值=456
a、 表[2][2]。实际值=789
a、 选项卡[0][2]。imag=999
a、 表[1][1]，imag=888
a、 表[2][0]，imag=777
打印（'\n'，a，sep=''）

结果:

<r:0 i:0> <r:0 i:0> <r:0 i:0>
<r:0 i:0> <r:0 i:0> <r:0 i:0>
<r:0 i:0> <r:0 i:0> <r:0 i:0>

<r:123 i:0> <r:0 i:0> <r:0 i:999>
<r:0 i:0> <r:456 i:888> <r:0 i:0>
<r:0 i:777> <r:0 i:0> <r:789 i:0>

---

这是一条错误的前进道路。Numpy具有本机复杂阵列，而且性能很高。有人花了数年时间构建了您正在尝试的内容，所以请使用它

class zcomplex:
    def __init__(self,real=1,imag=0):
        self.real=real
        self.imag=imag
    def display(self):
        print((self.real,self.imag))

class zmatrix(zcomplex):
    def __init__(self, real=0,imag=0,rows=3):
        self.rows=rows
        zcomplex.__init__(self,real,imag)
        self.tab=[[zcomplex(real,imag)]*self.rows for i in range(self.rows)]
    def display(self):
        for i in range(self.rows):
            print(self.tab[i])

a=zmatrix()

b=zcomplex()

# this now works...prints `0`
i = 2
j = 1
print(a.tab[i][j].real)

class zcomplex:
    def __init__(self,real=1,imag=0):
        self.real=real
        self.imag=imag
    def __repr__(self):
        return f'<r:{self.real} i:{self.imag}>'
    def display(self):
        print(self)

class zmatrix:
    def __init__(self, real=0 ,imag=0, rows=3):
        self.rows=rows
        self.tab=[[zcomplex(real,imag) for _ in range(rows)] for _ in range(self.rows)]
    def __repr__(self):
        return '\n'.join(' '.join(str(c) for c in self.tab[i]) for i in range(self.rows))
    def display(self):
        print(self)

a=zmatrix()
print(a)

a.tab[0][0].real = 123
a.tab[1][1].real = 456
a.tab[2][2].real = 789

a.tab[0][2].imag = 999
a.tab[1][1].imag = 888
a.tab[2][0].imag = 777

print('\n', a, sep='')

<r:0 i:0> <r:0 i:0> <r:0 i:0>
<r:0 i:0> <r:0 i:0> <r:0 i:0>
<r:0 i:0> <r:0 i:0> <r:0 i:0>

<r:123 i:0> <r:0 i:0> <r:0 i:999>
<r:0 i:0> <r:456 i:888> <r:0 i:0>
<r:0 i:777> <r:0 i:0> <r:789 i:0>