有时将行或列向量"克隆"到矩阵很有用。 克隆是指将行向量转换为
[1,2,3]
入矩阵
[[1,2,3]
[1,2,3]
[1,2,3]
]
或列向量，例如
[1
2
3
]
进入
[[1,1,1]
[2,2,2]
[3,3,3]
]
在matlab或octave中，这很容易做到：
x = [1,2,3]
a = ones(3,1) * x
a =
1 2 3
1 2 3
1 2 3
b = (x') * ones(1,3)
b =
1 1 1
2 2 2
3 3 3
我想以numpy重复此操作，但未成功
In [14]: x = array([1,2,3])
In [14]: ones((3,1)) * x
Out[14]:
array([[ 1., 2., 3.],
[ 1., 2., 3.],
[ 1., 2., 3.]])
# so far so good
In [16]: x.transpose() * ones((1,3))
Out[16]: array([[ 1., 2., 3.]])
# DAMN
# I end up with
In [17]: (ones((3,1)) * x).transpose()
Out[17]:
array([[ 1., 1., 1.],
[ 2., 2., 2.],
[ 3., 3., 3.]])
为什么第一种方法(In [16])无效？ 有没有办法以更优雅的方式在python中完成此任务？
在Matlab中，请注意使用repmat：repmat([1 2 3],3,1)或repmat([1 2 3].,1,3)的速度要快得多。
八度也有repmat。
对于那些希望对pandas数据框进行类似检查的人，请点击此处的tile_df
使用numpy.tile：
>>> tile(array([1,2,3]), (3, 1))
array([[1, 2, 3],
[1, 2, 3],
[1, 2, 3]])
或重复列：
>>> tile(array([[1,2,3]]).transpose(), (1, 3))
array([[1, 1, 1],
[2, 2, 2],
[3, 3, 3]])
赞！在我的系统上，对于具有10000个元素的向量重复1000次，tile方法比当前接受的答案(使用乘法运算符方法)中的方法快19.5倍。
在第二部分("重复列")中，您能否解释第二组方括号的作用，即[[1,2,3]]
@Ant组成一个二维数组，其第一个轴的长度为1(在屏幕上垂直)，第二个轴的长度为3(在屏幕上水平)。换位然后使其在第一轴上的长度为3，在第二轴上的长度为1。切片形状(1, 3)会将此列复制三遍，这就是为什么结果行各包含一个不同元素的原因。
这应该是已接受的答案，因为您可以传递任何已经初始化的向量，而被接受的向量只能在初始化向量时添加逗号才能起作用。谢谢 ！
我无法将此用于2d到3d解决方案:(
这是一种优雅的Python方式：
>>> array([[1,2,3],]*3)
array([[1, 2, 3],
[1, 2, 3],
[1, 2, 3]])
>>> array([[1,2,3],]*3).transpose()
array([[1, 1, 1],
[2, 2, 2],
[3, 3, 3]])
[16]的问题似乎是转置对数组没有影响。您可能想要一个矩阵：
>>> x = array([1,2,3])
>>> x
array([1, 2, 3])
>>> x.transpose()
array([1, 2, 3])
>>> matrix([1,2,3])
matrix([[1, 2, 3]])
>>> matrix([1,2,3]).transpose()
matrix([[1],
[2],
[3]])
(转置适用于2D数组，例如示例中的正方形，或使用.reshape(-1, 1)转换为(N,1)形状的数组时)
这是非常低效的。使用numpy.tile，如pv.s答案所示。
首先请注意，使用numpy的广播操作，通常不必复制行和列。有关说明，请参见此内容。
但是要做到这一点，重复和换轴可能是最好的方法
In [12]: x = array([1,2,3])
In [13]: repeat(x[:,newaxis], 3, 1)
Out[13]:
array([[1, 1, 1],
[2, 2, 2],
[3, 3, 3]])
In [14]: repeat(x[newaxis,:], 3, 0)
Out[14]:
array([[1, 2, 3],
[1, 2, 3],
[1, 2, 3]])
此示例是针对行向量的，但希望将其应用于列向量是显而易见的。重复似乎很好地说明了这一点，但是您也可以像示例中那样通过乘法来实现
In [15]: x = array([[1, 2, 3]]) # note the double brackets
In [16]: (ones((3,1))*x).transpose()
Out[16]:
array([[ 1., 1., 1.],
[ 2., 2., 2.],
[ 3., 3., 3.]])
newaxis的另一个好处是，它直到需要时才真正复制数据。因此，如果执行此操作以将另一个3x3数组相乘或相加，则无需重复。阅读有关numpy广播的信息，以了解想法。
@AFoglia-好点。我更新了答案以指出这一点。
使用np.repeat与np.tile有什么好处？
@mrgloom：在这种情况下，大多数情况下没有。对于小型一维阵列，它们是相似的，并且没有明显的区别/好处/优点/等。就个人而言，我发现行克隆和列克隆之间的对称性更加直观，并且我不喜欢平铺所需的转置，但这只是一个问题。 Mateen Ulhaqs的回答还说重复更快，但这可能取决于所考虑的确切用例，尽管重复非常接近C功能，所以可能会保持更快的速度。在2D中，它们具有不同的行为，因此在那里很重要。
我认为使用numpy中的广播是最好的，而且速度更快
我做了如下比较
import numpy as np
b = np.random.randn(1000)
In [105]: %timeit c = np.tile(b[:, newaxis], (1,100))
1000 loops, best of 3: 354 μs per loop
In [106]: %timeit c = np.repeat(b[:, newaxis], 100, axis=1)
1000 loops, best of 3: 347 μs per loop
In [107]: %timeit c = np.array([b,]*100).transpose()
100 loops, best of 3: 5.56 ms per loop
使用广播大约快15倍
您可以使用None编制索引以执行相同的操作。
什么是newaxis ？！
np.newaxis是None的别名
np.broadcast_to甚至比np.tile快：
x = np.arange(9)
%timeit np.broadcast_to(x, (6,9))
100000 loops, best of 3: 3.6 μs per loop
%timeit np.tile(x, (6,1))
100000 loops, best of 3: 8.4 μs per loop
但是最快的是@ tom10的方法：
%timeit np.repeat(x[np.newaxis, :], 6, axis=0)
100000 loops, best of 3: 3.15 μs per loop
一种干净的解决方案是使用NumPy的外部乘积函数和一个矢量：
np.outer(np.ones(n), x)
给出n重复行。切换参数顺序以获取重复列。要获得相等数量的行和列，您可以执行
np.outer(np.ones_like(x), x)
您可以使用
np.tile(x,3).reshape((4,3))
瓷砖将生成矢量的代表
并重塑将使其具有您想要的形状
如果您拥有pandas数据框，并且想要保留dtypes(甚至是类别)，这是一种快速的方法：
import numpy as np
import pandas as pd
df = pd.DataFrame({1: [1, 2, 3], 2: [4, 5, 6]})
number_repeats = 50
new_df = df.reindex(np.tile(df.index, number_repeats))
import numpy as np
x=np.array([1,2,3])
y=np.multiply(np.ones((len(x),len(x))),x).T
print(y)
产量：
[[ 1. 1. 1.]
[ 2. 2. 2.]
[ 3. 3. 3.]]