在蟒蛇中处理矩阵

Question

我是python的新手，在处理矩阵时遇到了一个问题。

我有一个矩阵，比方说

A = [1 0 0 2; 3 3 3 2; 3 3 0 2; 3 4 4 4]

现在，我想让矩阵中的所有元素都等于零，除了在矩阵中重复最多次的元素。（在这种情况下，它是3）。

所以预期的结果是，

B = [0 0 0 0; 3 3 3 0; 3 3 0 0;3 0 0 0]

如果有人能帮我做这个的python代码，那真的很有帮助。

Answer 1

 ----------------------------------------------------

Answer 2

这是 MATLAB 语法，不是笨拙的：

A = [1 0 0 2; 3 3 3 2; 3 3 0 2; 3 4 4 4]

尽管np。matrix通过以下方式模拟它：

In [172]: A = np.matrix('1 0 0 2; 3 3 3 2; 3 3 0 2; 3 4 4 4')
In [173]: A
Out[173]: 
matrix([[1, 0, 0, 2],
        [3, 3, 3, 2],
        [3, 3, 0, 2],
        [3, 4, 4, 4]])

您的任务是2倍，找到最常见的元素，然后替换所有其他元素。这两个动作都不依赖于矩阵是2d，或者是矩阵而不是数组。

In [174]: A1=A.A1
In [175]: A1
Out[175]: array([1, 0, 0, 2, 3, 3, 3, 2, 3, 3, 0, 2, 3, 4, 4, 4])

np.unique可以给我们频率计数，所以我们可以用（唯一需要1d）精细最频繁的值：

In [179]: u,c = np.unique(A1, return_counts=True)
In [180]: u
Out[180]: array([0, 1, 2, 3, 4])
In [181]: c
Out[181]: array([3, 1, 3, 6, 3])
In [182]: np.argmax(c)
Out[182]: 3
In [183]: u[np.argmax(c)]
Out[183]: 3

我很惊讶Divakar使用sache y模式而不是唯一。他是使用唯一的专家。：）

Divakar使用np.where可能是执行替换的最简单方法。

为了好玩，这里有一种屏蔽数组方法：

In [196]: np.ma.MaskedArray(A, A!=3)
Out[196]: 
masked_matrix(data =
 [[-- -- -- --]
 [3 3 3 --]
 [3 3 -- --]
 [3 -- -- --]],
              mask =
 [[ True  True  True  True]
 [False False False  True]
 [False False  True  True]
 [False  True  True  True]],
        fill_value = 999999)
In [197]: _.filled(0)
Out[197]: 
matrix([[0, 0, 0, 0],
        [3, 3, 3, 0],
        [3, 3, 0, 0],
        [3, 0, 0, 0]])

或就地更改：

In [199]: A[A!=3] = 0
In [200]: A
Out[200]: 
matrix([[0, 0, 0, 0],
        [3, 3, 3, 0],
        [3, 3, 0, 0],
        [3, 0, 0, 0]])

Answer 3

在轴设置为None的情况下，使用 >在整个数组中获取最常见的数字。将该数字与输入数组进行比较，得到一个掩码，该掩码可用于通过与输入数组/最常出现的数字进行元素相乘或使用 np将余数设置为零。其中进行选择。

因此，一种方法是-

from scipy.stats import mode

most_occ_num = mode(A, axis=None)[0][0]
out = most_occ_num*(A==most_occ_num)

np.where用于数组输出-

out = np.where(A==most_occ_num,A,0)

样本运行-

In [129]: A = np.matrix([[1, 0 ,0 ,2],[ 3, 3, 3, 2],[ 3 ,3 ,0 ,2],[ 3 ,4 ,4 ,4]])
In [140]: A
Out[140]: 
matrix([[1, 0, 0, 2],
        [3, 3, 3, 2],
        [3, 3, 0, 2],
        [3, 4, 4, 4]])

In [141]: most_occ_num = mode(A, axis=None)[0][0]

In [142]: most_occ_num*(A==most_occ_num)
Out[142]: 
matrix([[0, 0, 0, 0],
        [3, 3, 3, 0],
        [3, 3, 0, 0],
        [3, 0, 0, 0]])

In [143]: np.where(A==most_occ_num,A,0)
Out[143]: 
array([[0, 0, 0, 0],
       [3, 3, 3, 0],
       [3, 3, 0, 0],
       [3, 0, 0, 0]])