python两个数组成二维_Numpy：x和y数组点的笛卡儿乘积成二维点的单个数组

典范cartesian_product(几乎)

对于这个问题，有许多不同性质的解决方法。有些比另一些更快，有些则更通用。经过大量的测试和调整，我发现下面的函数计算了一个n维cartesian_product，在许多输入方面比大多数其他的更快。对于两种稍微复杂但在许多情况下甚至更快的方法，请参见保罗·潘泽.

给出这个答案，这不再是最快笛卡尔积的实现numpy据我所知。然而，我认为它的简单性将继续使它成为今后改进的一个有用的基准：

def cartesian_product(*arrays):

la = len(arrays)

dtype = numpy.result_type(*arrays)

arr = numpy.empty([len(a) for a in arrays] + [la], dtype=dtype)

for i, a in enumerate(numpy.ix_(*arrays)):

arr[...,i] = a

return arr.reshape(-1, la)

值得一提的是，这个函数使用ix_以一种不寻常的方式；而ix_是为了生成指数 进作为一个数组，恰好相同形状的数组可以用于广播赋值。感谢姆吉尔森，他激励我尝试使用ix_这条路，还有.乌图布，他就这个答案提供了一些非常有用的反馈，包括建议使用numpy.result_type.

值得注意的替代方案

按Fortran顺序编写连续内存块有时更快。这就是这种选择的基础，cartesian_product_transpose，这在某些硬件上被证明比cartesian_product(见下文)。然而，保罗·潘泽的答案-使用同样的原则-甚至更快。尽管如此，我还是在此为感兴趣的读者提供以下内容：

def cartesian_product_transpose(*arrays):

broadcastable = numpy.ix_(*arrays)

broadcasted = numpy.broadcast_arrays(*broadcastable)

rows, cols = numpy.prod(broadcasted[0].shape), len(broadcasted)

dtype = numpy.result_type(*arrays)

out = numpy.empty(rows * cols, dtype=dtype)

start, end = 0, rows

for a in broadcasted:

out[start:end] = a.reshape(-1)

start, end = end, end + rows

return out.reshape(cols, rows).T

在理解了Panzer的方法之后，我写了一个新版本，它几乎和他的一样快，而且几乎和他的一样简单cartesian_product:

def cartesian_product_simple_transpose(arrays):

la = len(arrays)

dtype = numpy.result_type(*arrays)

arr = numpy.empty([la] + [len(a) for a in arrays], dtype=dtype)

for i, a in enumerate(numpy.ix_(*arrays)):

arr[i, ...] = a

return arr.reshape(la, -1).T

这似乎有一些固定的时间开销，使其运行速度慢于装甲的小输入。但是对于更大的输入，在我运行的所有测试中，它的性能与他最快的实现一样好(cartesian_product_transpose_pp).

在下面的部分中，我将介绍一些其他替代方案的测试。现在这些都有点过时了，但我决定把它们放在这里，而不是重复的工作，这是出于历史的考虑。关于最新的测试，请参阅Panzer的答案以及尼科·施勒默他的。

对替代品的测试

下面是一系列测试，这些测试显示了其中一些功能相对于许多替代功能提供的性能提升。这里显示的所有测试都是在运行MacOS10.12.5、Python3.6.1和numpy1.12.1.众所周知，硬件和软件的变化会产生不同的结果，因此YMMV。运行这些测试为您自己，以确保！

定义：

import numpy

import itertools

from functools import reduce

### Two-dimensional products ###

def repeat_product(x, y):

return numpy.transpose([numpy.tile(x, len(y)),

numpy.repeat(y, len(x))])

def dstack_product(x, y):

return numpy.dstack(numpy.meshgrid(x, y)).reshape(-1, 2)

### Generalized N-dimensional products ###

def cartesian_product(*arrays):

la = len(arrays)

dtype = numpy.result_type(*arrays)

arr = numpy.empty([len(a) for a in arrays] + [la], dtype=dtype)

for i, a in enumerate(numpy.ix_(*arrays)):

arr[...,i] = a

return arr.reshape(-1, la)

def cartesian_product_transpose(*arrays):

broadcastable = numpy.ix_(*arrays)

broadcasted = numpy.broadcast_arrays(*broadcastable)

rows, cols = numpy.prod(broadcasted[0].shape), len(broadcasted)

dtype = numpy.result_type(*arrays)

out = numpy.empty(rows * cols, dtype=dtype)

start, end = 0, rows

for a in broadcasted:

out[start:end] = a.reshape(-1)

start, end = end, end + rows

return out.reshape(cols, rows).T

# from https://stackoverflow.com/a/1235363/577088

def cartesian_product_recursive(*arrays, out=None):

arrays = [numpy.asarray(x) for x in arrays]

dtype = arrays[0].dtype

n = numpy.prod([x.size for x in arrays])

if out is None:

out = numpy.zeros([n, len(arrays)], dtype=dtype)

m = n // arrays[0].size

out[:,0] = numpy.repeat(arrays[0], m)

if arrays[1:]:

cartesian_product_recursive(arrays[1:], out=out[0:m,1:])

for j in range(1, arrays[0].size):

out[j*m:(j+1)*m,1:] = out[0:m,1:]

return out

def cartesian_product_itertools(*arrays):

return numpy.array(list(itertools.product(*arrays)))

### Test code ###

name_func = [('repeat_product',

repeat_product),

('dstack_product',

dstack_product),

('cartesian_product',

cartesian_product),

('cartesian_product_transpose',

cartesian_product_transpose),

('cartesian_product_recursive',

cartesian_product_recursive),

('cartesian_product_itertools',

cartesian_product_itertools)]

def test(in_arrays, test_funcs):

global func

global arrays

arrays = in_arrays

for name, func in test_funcs:

print('{}:'.format(name))

%timeit func(*arrays)

def test_all(*in_arrays):

test(in_arrays, name_func)

# `cartesian_product_recursive` throws an

# unexpected error when used on more than

# two input arrays, so for now I've removed

# it from these tests.

def test_cartesian(*in_arrays):

test(in_arrays, name_func[2:4] + name_func[-1:])

x10 = [numpy.arange(10)]

x50 = [numpy.arange(50)]

x100 = [numpy.arange(100)]

x500 = [numpy.arange(500)]

x1000 = [numpy.arange(1000)]

测试结果：

In [2]: test_all(*(x100 * 2))

repeat_product:

67.5 µs ± 633 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

dstack_product:

67.7 µs ± 1.09 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

cartesian_product:

33.4 µs ± 558 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

cartesian_product_transpose:

67.7 µs ± 932 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

cartesian_product_recursive:

215 µs ± 6.01 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

cartesian_product_itertools:

3.65 ms ± 38.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [3]: test_all(*(x500 * 2))

repeat_product:

1.31 ms ± 9.28 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

dstack_product:

1.27 ms ± 7.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

cartesian_product:

375 µs ± 4.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

cartesian_product_transpose:

488 µs ± 8.88 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

cartesian_product_recursive:

2.21 ms ± 38.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

cartesian_product_itertools:

105 ms ± 1.17 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [4]: test_all(*(x1000 * 2))

repeat_product:

10.2 ms ± 132 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

dstack_product:

12 ms ± 120 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

cartesian_product:

4.75 ms ± 57.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

cartesian_product_transpose:

7.76 ms ± 52.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

cartesian_product_recursive:

13 ms ± 209 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

cartesian_product_itertools:

422 ms ± 7.77 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

在所有情况下，cartesian_product正如在这个答案的开头所定义的那样，速度是最快的。

对于那些接受任意数目输入数组的函数，值得在len(arrays) > 2也是。(直到我确定为什么cartesian_product_recursive在本例中抛出一个错误，我已经从这些测试中删除了它。)

In [5]: test_cartesian(*(x100 * 3))

cartesian_product:

8.8 ms ± 138 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

cartesian_product_transpose:

7.87 ms ± 91.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

cartesian_product_itertools:

518 ms ± 5.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [6]: test_cartesian(*(x50 * 4))

cartesian_product:

169 ms ± 5.1 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

cartesian_product_transpose:

184 ms ± 4.32 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

cartesian_product_itertools:

3.69 s ± 73.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [7]: test_cartesian(*(x10 * 6))

cartesian_product:

26.5 ms ± 449 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

cartesian_product_transpose:

16 ms ± 133 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

cartesian_product_itertools:

728 ms ± 16 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [8]: test_cartesian(*(x10 * 7))

cartesian_product:

650 ms ± 8.14 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

cartesian_product_transpose:

518 ms ± 7.09 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

cartesian_product_itertools:

8.13 s ± 122 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

正如这些测试所显示的，cartesian_product保持竞争力，直到输入数组的数量超过(大致)四个。在那之后,cartesian_product_transpose确实有一点点优势。

值得重申的是，使用其他硬件和操作系统的用户可能会看到不同的结果。例如，unutbu报告使用Ubuntu14.04、Python3.4.3和numpy1.14.0.dev0+b7050a9：

>>> %timeit cartesian_product_transpose(x500, y500)

1000 loops, best of 3: 682 µs per loop

>>> %timeit cartesian_product(x500, y500)

1000 loops, best of 3: 1.55 ms per loop

下面，我将详细介绍一下我沿着这些路线运行的早期测试。这些方法的相对性能随着时间的推移而变化，对于不同的硬件和不同版本的Python和numpy..虽然它对使用最新版本的numpy，它说明了自从这个答案的第一个版本以来，事情发生了怎样的变化。

一个简单的备选方案：meshgrid + dstack

当前接受的答案使用tile和repeat将两个数组广播到一起。但meshgrid函数实际上也是这样做的。这是…的输出tile和repeat在被传递到转位之前：

In [1]: import numpy

In [2]: x = numpy.array([1,2,3])

...: y = numpy.array([4,5])

...:

In [3]: [numpy.tile(x, len(y)), numpy.repeat(y, len(x))]

Out[3]: [array([1, 2, 3, 1, 2, 3]), array([4, 4, 4, 5, 5, 5])]

这是meshgrid:

In [4]: numpy.meshgrid(x, y)

Out[4]:

[array([[1, 2, 3],

[1, 2, 3]]), array([[4, 4, 4],

[5, 5, 5]])]

正如你所看到的，它几乎是一样的。我们只需要重塑结果就能得到完全相同的结果。

In [5]: xt, xr = numpy.meshgrid(x, y)

...: [xt.ravel(), xr.ravel()]

Out[5]: [array([1, 2, 3, 1, 2, 3]), array([4, 4, 4, 5, 5, 5])]

不过，与其在此时进行整形，不如将输出传递给meshgrid到dstack然后再重新塑造，这就省去了一些工作：

In [6]: numpy.dstack(numpy.meshgrid(x, y)).reshape(-1, 2)

Out[6]:

array([[1, 4],

[2, 4],

[3, 4],

[1, 5],

[2, 5],

[3, 5]])

与本评论我没有看到任何证据表明不同的输入会产生不同形状的输出，正如上面所演示的，它们所做的事情非常相似，所以如果它们这样做了，那将是相当奇怪的。如果你找到反例，请告诉我。

测试meshgrid + dstackv.V.repeat + transpose

随着时间的推移，这两种方法的相对性能发生了变化。在早期版本的Python(2.7)中，使用meshgrid + dstack对于小的投入来说，速度要快得多。(请注意，这些测试来自这个答案的旧版本。)定义：

>>> def repeat_product(x, y):

...     return numpy.transpose([numpy.tile(x, len(y)),

numpy.repeat(y, len(x))])

...

>>> def dstack_product(x, y):

...     return numpy.dstack(numpy.meshgrid(x, y)).reshape(-1, 2)

...

对于中等大小的输入，我看到了一个显著的加速。但是我用Python的最新版本(3.6.1)和numpy(1.12.1)，在较新的机器上。这两种方法现在几乎是相同的。

旧测验

>>> x, y = numpy.arange(500), numpy.arange(500)

>>> %timeit repeat_product(x, y)

10 loops, best of 3: 62 ms per loop

>>> %timeit dstack_product(x, y)

100 loops, best of 3: 12.2 ms per loop

新测试

In [7]: x, y = numpy.arange(500), numpy.arange(500)

In [8]: %timeit repeat_product(x, y)

1.32 ms ± 24.7 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [9]: %timeit dstack_product(x, y)

1.26 ms ± 8.47 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

和往常一样，YMMV，但这表明在Python和Numpy的最新版本中，它们是可互换的。

广义乘积函数

一般来说，我们可能会期望，对于小输入，使用内置函数会更快，而对于大型输入，目的内置函数可能会更快。此外，对于一个广义n维乘积，tile和repeat不会有帮助，因为它们没有清晰的高维类似物。因此，研究目的函数的行为也是值得的。

大多数相关测试都出现在这个答案的开头，但是下面是在早期版本的Python和numpy为了比较。

这个cartesian中定义的函数另一个答案用于较大的输入时表现很好。(与调用的函数相同)cartesian_product_recursive)为了比较cartesian到dstack_prodct我们只使用二维。

在这里，旧的测试显示了一个显着的差异，而新的测试显示几乎没有。

旧测验

>>> x, y = numpy.arange(1000), numpy.arange(1000)

>>> %timeit cartesian([x, y])

10 loops, best of 3: 25.4 ms per loop

>>> %timeit dstack_product(x, y)

10 loops, best of 3: 66.6 ms per loop

新测试

In [10]: x, y = numpy.arange(1000), numpy.arange(1000)

In [11]: %timeit cartesian([x, y])

12.1 ms ± 199 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [12]: %timeit dstack_product(x, y)

12.7 ms ± 334 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

和以前一样，dstack_product仍拍cartesian在更小的尺度上。

新测试 (冗余旧测试未显示)

In [13]: x, y = numpy.arange(100), numpy.arange(100)

In [14]: %timeit cartesian([x, y])

215 µs ± 4.75 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [15]: %timeit dstack_product(x, y)

65.7 µs ± 1.15 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

我认为，这些区别是有趣和值得记录的，但它们最终都是学术性的。正如这个答案开始时的测试所显示的那样，所有这些版本几乎总是比cartesian_product在这个答案的一开始就定义了-它本身比这个问题答案中最快的实现要慢一些。