如何将非数字字符添加到numpy矩阵中的某个元素？

Question

假设我有一个像这样的 numpy 矩阵：

matrix = np.zeros((5,5))

# goes through code that changes value of matrix to get:

[[0. 4. 7. 1. 3.]
 [5. 6. 8. 0. 1.]
 [inf inf 5. 2. 5.]
 [4. 6. 2. 1. inf]]

打印此矩阵时，我想在某些元素的任一侧添加 2 个星号：

[[0. *4* 7. 1. 3.]
 [5. 6. *8* 0. 1.]
 [inf inf 5. 2. 5.]
 [4. *6* 2. *1* inf]]

我该怎么做呢？

我试过了：

 matrix_output = matrix
 matrix_output[i][j] = '*' + str(matrix_for_print[i][j]) + '*'

但我收到此错误：

 builtins.ValueError: could not convert string to float: '*4.0*'

（另外，附注，我如何让矩阵只有逗号而不是像这里的小数。所以理想情况下，我想：

[[0, *4*, 7, 1, 3]
 [5, 6, *8*, 0, 1]
 [inf, inf, 5, 2, 5]
 [4, *6*, 2, *1*, inf]]

Answer 1

我想知道这些调整是否真的值得？但首先要确保您了解在每个阶段您拥有哪些对象，以及它们为何如此显示。

从像你这样的简单数组开始：

In [163]: arr = np.array([[0, 4,7],[np.inf, 0,3]])                                                           
In [164]: arr                                                                                                
Out[164]: 
array([[ 0.,  4.,  7.],
       [inf,  0.,  3.]])
In [165]: arr.dtype                                                                                          
Out[165]: dtype('float64')

即使数字是整数，dtype 也是浮点数。 np.inf 是浮动的。 np.zeros 默认情况下也是浮点数。

您可以将其更改为列表列表：

In [166]: alist = arr.tolist()                                                                               
In [167]: alist                                                                                              
Out[167]: [[0.0, 4.0, 7.0], [inf, 0.0, 3.0]]

请注意，此显示包括逗号和 0。并且不会将其分成行。但是作为一个列表，我们可以将单个项目更改为字符串：

In [168]: alist[0][2] = '*7*'                                                                                
In [169]: alist                                                                                              
Out[169]: [[0.0, 4.0, '*7*'], [inf, 0.0, 3.0]]

甚至回到字符数组：

In [170]: np.array(alist)                                                                                    
Out[170]: 
array([['0.0', '4.0', '*7*'],
       ['inf', '0.0', '3.0']], dtype='<U32')

print 其中会省略逗号和数据类型，但仍显示引号。

我们也可以将其转换为字符数组：

In [171]: arr.astype(str)                                                                                    
Out[171]: 
array([['0.0', '4.0', '7.0'],
       ['inf', '0.0', '3.0']], dtype='<U32')

然后改变一个字符串。注意 dtype 的大小。这是 32 个字符宽。如果是 '<U3'，我们就无法添加额外的字符。

In [172]: _[0,2] = '*7*'                                                                                     
In [173]: _171                                                                                               
Out[173]: 
array([['0.0', '4.0', '*7*'],
       ['inf', '0.0', '3.0']], dtype='<U32')

为了去掉小数点，我们可以转换为 int dtype - 但这会弄乱 inf。

In [174]: arr.astype(int)                                                                                    
Out[174]: 
array([[                   0,                    4,                    7],
       [-9223372036854775808,                    0,                    3]])

因此，您可以对数组执行哪些操作，并且仍然以一致的方式显示所有元素。

但如果您足够挑剔，您可以使用标准 Python 格式化表达式显式格式化数组（或列表列表）。例如：

In [185]: astr = []                                                                                          
In [186]: for row in arr: 
     ...:     str1 = ['%s'%i for i in row] 
     ...:     astr.append(str1) 
     ...:                                                                                                    
In [187]: '\n'.join([', '.join(row) for row in astr])                                                        
Out[187]: '0.0, 4.0, 7.0\ninf, 0.0, 3.0'
In [188]: print(_)                                                                                           
0.0, 4.0, 7.0
inf, 0.0, 3.0

使用joins 我只生成一个字符串，而不是一个数组或字符串列表。这摆脱了引号。我会添加进一步的测试以将浮点数更改为 int，而不会损害inf。并且还以某种方式确定哪些元素获得了 *.您可以编写一个函数来获取一个元素，并处理所有整数与浮点（或 inf）细节以及添加突出显示。

自定义类的__str__ 或__repr__ 方法需要同样关注格式细节。当您的期望与常规做法有足够大的偏差时，就没有办法解决了。