Question

让我们说有一个3行3列的numpy矩阵。找到第一个对角线很容易，这是一种方法。

使用以下矩阵：

[[0,3,6]

 [0,4,9]

 [0,1,9]]

使用此代码：

import numpy
matrix.diagonals()
[0, 4, 9]

如何获得相反的对角线？例如，对于上面的矩阵，我希望它返回：

[6, 4, 0]

Answer 1

实现这一目标的最快方法是使用步幅。您的数组有一个.strides属性，告诉您在内存中需要跳过多少字节才能到达每个维度中的下一个项目：

>>> a = np.array([[0, 3, 6], [0, 4, 9], [0, 1, 9]])
>>> a.strides
(24, 8)

对于正常的前向对角线，您必须向前跳过一行加一列，对于反向对角线，一行减去一列：

>>> a.strides[0] + a.strides[1]
32
>>> a.strides[0] - a.strides[1]
16

你现在可以construct一个与原始数组相同的内存缓冲区中的数组，但是使用新的步幅（并且在反向对角线情况下从第一行的最后一列开始非零偏移）：

>>> np.ndarray(shape=min(a.shape), dtype=a.dtype, buffer=a, 
...            offset=0, strides=a.strides[0]+a.strides[1])
array([0, 4, 9])
>>> np.ndarray(shape=min(a.shape), dtype=a.dtype, buffer=a, 
...            offset=a.strides[1] * (a.shape[1] - 1),
...            strides=a.strides[0]+a.strides[1])
array([6, 4, 0])

这些实际上是对原始数组内存的视图，即如果你修改它们的内容，原始数组也会改变，所以几乎没有内存分配或复制，只是包含对象的设置，所以它会快得多。

Answer 2

我想这会做到：

In [29]: mm
Out[29]:
matrix([[0, 3, 6],
        [0, 4, 9],
        [0, 1, 9]])

In [30]: np.fliplr(mm)
Out[30]:
matrix([[6, 3, 0],
        [9, 4, 0],
        [9, 1, 0]])

In [31]: mm.diagonal()
Out[31]: matrix([[0, 4, 9]])

In [33]: np.fliplr(mm).diagonal()
Out[33]: matrix([[6, 4, 0]])

Answer 3

您可以按以下步骤操作：
（1）反转矩阵，（2）得到对角线，（3）反转对角线

import numpy

a = numpy.matrix([[0, 3, 6], [0, 4, 9], [0, 1, 9]])
print(numpy.diag(a))
print(numpy.diag(a[::-1])[::-1])

<强>输出：

[0 4 9]
[6 4 0]

Answer 4

In [240]: M=np.arange(9).reshape(3,3)

主对角线是M[i,j] for i==j，我们可以通过高级索引获得i和j的相同数组

In [241]: i=np.arange(3)

In [242]: M[i,i]
Out[242]: array([0, 4, 8])

并且通过颠倒j的顺序，我们得到另一个对角线

In [243]: M[i,i[::-1]]
Out[243]: array([2, 4, 6])

我怀疑对于大型数组，像这样反转索引比翻转矩阵要快。但是我们必须做一些时间来确定。

===========

哎呀，我错了。 M.diagonal()比我的显式索引快一点。对于N=1000。

In [259]: timeit M.diagonal();np.fliplr(M).diagonal()
100000 loops, best of 3: 3.63 µs per loop

In [260]: timeit i=np.arange(N);mm=M[i,i],M[i,i[::-1]]
10000 loops, best of 3: 51.3 µs per loop

如何找到2D矩阵的两个对角线？

4 个答案: