Python 按元素相乘1D numpy数组（形状（k，1）或（k，）并使结果具有第一个数组的形状

我想实现一个对角线矩阵应用函数，该函数是通过首先提供对角线

d

，然后使用

x

执行一系列矩阵向量乘法而创建的。当然，我不想创建一个实际的矩阵，因为所需要的只是元素向量乘法

现在，一些用户将提供形状

（k，）

的对角线

d

，一些形状

（k，1）

。另外，

x

可以具有形状

（k，）

和

（k，1）

。我希望apply（）方法的行为与numpy矩阵的

*

类似，因为结果与输入

x

的形状相同

因此问题就来了：在Python/Numpy中，是否有一种简单的方法可以将两个np.array

x

和

y

的形状

（k，）

或

（k，1）

（任意组合）相乘，从而得到的数组的形状为

x

我用

[：，None]

做了一些实验

x = np.empty((4,1))
y = np.empty(4)
(x * y).shape         # (4,4)  -- nope
(y * y).shape         # (4,)   -- yes
(x * y[:,None]).shape # (4, 1) -- yes
(y * y[:,None]).shape # (4,4)  -- nope

如果len（x.shape）=……：，我当然可以用

来包装我的代码，但这感觉不太像Python

建议？
如果您可以假设
x
和
y
基本上都是1D数组，那么使用numpy的
.flant（）
数组方法：

>>> result=x.flatten()*y.flatten()

应返回1D数组：

>>> result.shape
(4,)

要保留
x
的形状，可以执行以下操作：

>>> result = x*y.reshape(x.shape)
>>> result.shape
(4,1)

既然我理解了你的问题，我的建议就是重塑。调用
重塑
返回一个视图，因此不会产生任何大的复制成本或类似的费用。只需重新调整阵列形状、乘法，然后再次重新调整形状：

>>> def shape_preserving_mult(x, y):
...     return (x.reshape((-1,)) * y.reshape((-1))).reshape(x.shape)
... 

或者更简洁地说，正如你和罗沃兰德所指出的：

>>> def shape_preserving_mult(x, y):
...     return x * y.reshape(x.shape)
... 
>>> shape_preserving_mult(x, y)
array([[ 0],
       [ 1],
       [ 4],
       [ 9],
       [16]])
>>> shape_preserving_mult(x, y.T)
array([[ 0],
       [ 1],
       [ 4],
       [ 9],
       [16]])
>>> shape_preserving_mult(x.T, y)
array([[ 0,  1,  4,  9, 16]])
>>> shape_preserving_mult(x.T, y.T)
array([[ 0,  1,  4,  9, 16]])

我先前建议的实质内容如下

值得注意的是，如果将一个numpy数组的shape
（1，4）
与一个shape数组的shape
（4，）
相乘，则得到的结果与您想要的结果非常接近

>>> x = numpy.arange(5).reshape((5, 1))
>>> y = numpy.arange(5)
>>> x.shape
(5, 1)
>>> x.T.shape
(1, 5)
>>> y * x.T
array([[ 0,  1,  4,  9, 16]])

它的形状不是
a
，而是
a.t
。您可以随时对结果再次调用
T
。这也适用于形状
（5，）
的数组，因为一维数组上的转置操作不会导致任何更改。所以也许你可以这样做：

>>> def transposed_mult(x, y):
...     return (x.T * y).T
... 
>>> transposed_mult(x, y)
array([[ 0],
       [ 1],
       [ 4],
       [ 9],
       [16]])

当然，如果传递一个shape数组
（1，5）
，则会产生相反的问题：

因此，
transposed\u mult
完全符合您在原始帖子中的要求，但如果您需要进一步的灵活性，它将无法按预期工作。事实上，你似乎需要更多的灵活性
 这总是导致形状
（4，）
。不过，我想要的是一个保持第一个因子形状的乘法。好的，非常清楚，谢谢！看我的。整形似乎是个好主意。像
returnx*y.reforme（x.shape）
这样简单的方法似乎可以奏效。
>>> transposed_mult(x.T, y)
array([[ 0,  0,  0,  0,  0],
       [ 0,  1,  2,  3,  4],
       [ 0,  2,  4,  6,  8],
       [ 0,  3,  6,  9, 12],
       [ 0,  4,  8, 12, 16]])