你想要meshgrid()。这是一个简单的例子：

In [14]: a = arange(5)

In [18]: r = array(meshgrid(a,a))

In [20]: r.shape
Out[20]: (2, 5, 5)

In [21]: r
Out[21]: 
array([[[0, 1, 2, 3, 4],
        [0, 1, 2, 3, 4],
        [0, 1, 2, 3, 4],
        [0, 1, 2, 3, 4],
        [0, 1, 2, 3, 4]],

       [[0, 0, 0, 0, 0],
        [1, 1, 1, 1, 1],
        [2, 2, 2, 2, 2],
        [3, 3, 3, 3, 3],
        [4, 4, 4, 4, 4]]])

由于那里有很多重复值，您可以使用 sparse=True 命令调用它来保存 mem 并利用一些 ndarray 技巧。

如果你真的想要 (i,j) 的一些简单函数，你可以使用以下技巧来避免形成 immidiate。我一直在使用它，但在其他任何链接中都没有看到：

In [3]: a = arange(5)

In [4]: a[:,newaxis] * a[newaxis,:]
Out[4]: 
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]])

该示例使用乘法，但任何数量的二进制函数都可以放在那个地方。由于广播规则，这个技巧也适用于更高的维度：

In [6]: a = ones((2,5))

In [7]: a[:,newaxis] * a[newaxis,:]
Out[7]: 
array([[[ 1.,  1.,  1.,  1.,  1.],
        [ 1.,  1.,  1.,  1.,  1.]],

       [[ 1.,  1.,  1.,  1.,  1.],
        [ 1.,  1.,  1.,  1.,  1.]]])

In [8]: a.shape
Out[8]: (2, 5)

In [9]: b = a[:,newaxis] * a[newaxis,:]

In [10]: b.shape
Out[10]: (2, 2, 5)

您可以使用 itertools.product：

>>> from numpy import *
>>> import itertools
>>> array([x for x in itertools.product(arange(2), arange(3))])
array([[0, 0],
       [0, 1],
       [0, 2],
       [1, 0],
       [1, 1],
       [1, 2]])

有一种可能会被广播为x

xx = numpy.zeros(n) + x.reshape(n,1)

获得'x-grid'。对第二个组件执行相同的操作，然后使用 numpy 的dstack 函数将它们平铺在第三维中。

import numpy as np

def cartesian_cross_product(x,y):
    cross_product = np.transpose([np.tile(x, len(y)),np.repeat(y,len(x))])
    return cross_product