Question

使用numpy，我希望通过列数组x将矩阵y复用，元素：

   x = numpy.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
   y = numpy.array([1, 2, 3])
   z = numpy.multiply(x, y)
   print z

这给出了输出，好像y是一个行数组：

   [[ 1  4  9]
    [ 4 10 18]
    [ 7 16 27]]

但是，我希望输出好像y是一个列数组：

   [[ 1  2  3]
    [ 8 10 12]
    [21 24 27]]

那么如何操纵y来实现这一目标呢？如果我使用：

y = numpy.transpose(y)

然后y保持相同的形状。

Answer 1

您可以使用reshape：

y = y.reshape(-1,1)

Answer 2

将其封入另一个列表中以使其成为2D：

>>> y2 = numpy.transpose([y])
>>> y2
array([[1],
       [2],
       [3]])
>>> numpy.multiply(x, y2)
array([[ 1,  2,  3],
       [ 8, 10, 12],
       [21, 24, 27]])

Answer 3

您无法转置y的原因是因为它已初始化为1-D数组。只在两个（或更多）维度中转置数组才有意义。

为了解决这些混合维度问题，numpy实际上提供了一组便利功能来清理您的输入：

y = np.array([1, 2, 3])
y1 = np.atleast_1d(y)  # Converts array to 1-D if less than that
y2 = np.atleast_2d(y)  # Converts array to 2-D if less than that
y3 = np.atleast_3d(y)  # Converts array to 3-D if less than that

我还认为np.column_stack属于这个便利类别，因为它将1-D和2-D数组放在一起就像你期望的那样，而不是必须找出正确的重塑和堆栈系列。

y1 = np.array([1, 2, 3])
y2 = np.array([2, 4, 6])
y3 = np.array([[2, 6], [2, 4], [7, 7]])
y = np.column_stack((y1, y2, y3))

我认为这些功能并不像它们应该的那样众所周知，而且我发现它们比重塑或数组尺寸手动摆弄更容易，更灵活，更安全。他们也尽可能避免复制，这可能是一个小的性能加速。

要回答您的问题，您应该使用np.atleast_2d将数组转换为二维数组，然后转置它。

y = np.atleast_2d(y).T

快速执行此操作而不用担心y的另一种方法是转置x，然后将结果转置回来。

z = (x.T * y).T

虽然这可能会混淆代码的意图。如果性能很重要，它可能会更快。

如果性能很重要，那么可以告知您要使用哪种方法。我的电脑上有一些时间：

%timeit x * np.atleast_2d(y).T
100000 loops, best of 3: 7.98 us per loop

%timeit (x.T*y).T
100000 loops, best of 3: 3.27 us per loop

%timeit x * np.transpose([y])
10000 loops, best of 3: 20.2 us per loop

%timeit x * y.reshape(-1, 1)
100000 loops, best of 3: 3.66 us per loop

Answer 4

y变量的形状为（3，）。如果你用这种方式构建它：

y = numpy.array（[1,2,3]，ndmin = 2）

...它的形状为（1,3），你可以调换它以获得你想要的结果：

y = numpy.array（[1,2,3]，ndmin = 2）.T z = numpy.multiply（x，y）

numpy矩阵和列数组的元素乘法

4 个答案: