如何在numpy中用一个数组除以另一个数组的元素？

Question

我有两个数组，我想让其中一个数组的所有元素除以第二个数组。例如，我有两个数组，我想让其中一个数组的所有元素除以第二个数组。

In [24]: a = np.array([1,2,3])                                                      

In [25]: b = np.array([1,2,3])                                                      

In [26]: a/b                                                                        
Out[26]: array([1., 1., 1.])

In [27]: 1/b                                                                        
Out[27]: array([1.        , 0.5       , 0.33333333])

这不是我想要的答案，我想要的输出是这样的(我们可以看到a的所有元素都被b除掉)

In [28]: c = []                                                                     

In [29]: for i in a: 
    ...:     c.append(i/b) 
    ...:                                                                            

In [30]: c                                                                          
Out[30]: 
[array([1.        , 0.5       , 0.33333333]),
 array([2.        , 1.        , 0.66666667]),
In [34]: np.array(c)                                                                
Out[34]: 
array([[1.        , 0.5       , 0.33333333],
       [2.        , 1.        , 0.66666667],
       [3.        , 1.5       , 1.        ]])

但是我不喜欢for循环，对于大数据来说太慢了，那么有没有一个函数包含在numpy包里，或者有什么好的（更快的）方法来解决这个问题？

Answer 1

首先你需要将 a 成一个二维数组（与输出的形状相同），然后对你想循环的维度重复。然后矢量化除法就可以了。

>>> a.reshape(-1,1)
array([[1],
       [2],
       [3]])

>>> a.reshape(-1,1).repeat(b.shape[0], axis=1) 
array([[1, 1, 1],
       [2, 2, 2],
       [3, 3, 3]])


>>> a.reshape(-1,1).repeat(b.shape[0], axis=1) / b
array([[1.        , 0.5       , 0.33333333],
       [2.        , 1.        , 0.66666667],
       [3.        , 1.5       , 1.        ]])


# Transpose will let you do it the other way around, but then you just get 1 for everything
>>> a.reshape(-1,1).repeat(b.shape[0], axis=1).T
array([[1, 2, 3],
       [1, 2, 3],
       [1, 2, 3]])

>>> a.reshape(-1,1).repeat(b.shape[0], axis=1).T / b
array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])

Answer 2

在纯numpy中做起来很简单，你可以使用 广播 来计算 外品 (或任何其他外部运算)的两个向量。

import numpy as np

a = np.arange(1, 4)
b = np.arange(1, 4)

c = a[:,np.newaxis] / b

# array([[1.        , 0.5       , 0.33333333],
#        [2.        , 1.        , 0.66666667],
#        [3.        , 1.5       , 1.        ]])

这很有效，因为 a[:,np.newaxis] 增加的尺寸 (3,) 异形阵 a 变成 (3, 1) 形状的阵列，可用于所需的广播操作。

Answer 3

这应该可以完成工作。

import numpy as np

a = np.array([1, 2, 3])
b = np.array([1, 2, 3])

print(a.reshape(-1, 1) / b)

输出。

[[ 1.          0.5         0.33333333]
 [ 2.          1.          0.66666667]
 [ 3.          1.5         1.        ]]

Answer 4

谢谢大家回答这个问题 到目前为止，我认为'reshape'看起来不错。以下是我的回答。

In [39]: a                                                                          
Out[39]: array([1, 2, 3])

In [40]: a_r = a.reshape(3,1)                                                       

In [41]: b                                                                          
Out[41]: array([1, 2, 3])

In [42]: a_r/b                                                                      
Out[42]: 
array([[1.        , 0.5       , 0.33333333],
       [2.        , 1.        , 0.66666667],
       [3.        , 1.5       , 1.        ]])