Как рассчитать декартово произведение двух массивов в NumPy?

Ответ 1

Для этого вы можете использовать np.mgrid, он часто более удобен, чем np.meshgrid потому что он создает массивы за один шаг:

import numpy as np
X,Y = np.mgrid[-5:5.1:0.5, -5:5.1:0.5]

Для функциональности, подобной linspace, замените шаг (то есть 0.5) комплексным числом, величина которого указывает количество точек, которые вы хотите в серии. Используя этот синтаксис, определяются те же массивы, что и выше:

X, Y = np.mgrid[-5:5:21j, -5:5:21j]

Затем вы можете создать свои пары как:

xy = np.vstack((X.flatten(), Y.flatten())).T

Как предложил @ali_m, все это можно сделать в одну строку:

xy = np.mgrid[-5:5.1:0.5, -5:5.1:0.5].reshape(2,-1).T

Удачи!

Ответ 2

Я думаю, вы хотите np.meshgrid:

Обратные координатные матрицы из векторов координат.

Сделать N-D координатные массивы для векторизованных оценок N-D скалярных/векторных полей над сетками N-D, учитывая одномерные координатные массивы x1, x2,..., xn.

import numpy as np
x = np.arange(-5, 5.1, 0.5)
y = np.arange(-5, 5.1, 0.5)
X,Y = np.meshgrid(x,y)

вы можете преобразовать его в желаемый результат с помощью

XY=np.array([X.flatten(),Y.flatten()]).T

print XY
array([[-5. , -5. ],
       [-4.5, -5. ],
       [-4. , -5. ],
       [-3.5, -5. ],
       [-3. , -5. ],
       [-2.5, -5. ],
       ....
       [ 3. ,  5. ],
       [ 3.5,  5. ],
       [ 4. ,  5. ],
       [ 4.5,  5. ],
       [ 5. ,  5. ]])

Ответ 3

Мы можем использовать функцию аранжировки как:

z1 = np.array([np.array(np.arange(1,5)),np.array(np.arange(1,5))])
print(z1)
o/p=> [[1 2 3 4]
       [1 2 3 4]]

Ответ 4

Если вы просто хотите итерации по парам (а не выполнять вычисления всего набора точек сразу), вам может быть лучше всего itertools.product выполнить итерацию по всем возможным парам:

import itertools

for (xi, yi) in itertools.product(x, y):
    print(xi, yi)

Это позволяет избежать генерации больших матриц через meshgrid.

Ответ 5

Это именно то, что вы ищете:

matr = np.linspace((1,2),(10,20),10)

Это означает:

Для первого столбца; от 1 из (1,2) до 10 из (10,20), положите увеличивающиеся 10 чисел.

Для второго столбца; от 2 из (1,2) до 20 из (10,20), вставьте 10 чисел.

И результат будет:

[[ 1.  2.]
 [ 2.  4.]
 [ 3.  6.]
 [ 4.  8.]
 [ 5. 10.]
 [ 6. 12.]
 [ 7. 14.]
 [ 8. 16.]
 [ 9. 18.]
 [10. 20.]]

Вы также можете сохранить увеличение только одного значения столбца, например, если вы скажете, что:

matr = np.linspace((1,2),(1,20),10)

Первый столбец будет от 1 из (1,2) до 1 из (1,20) в течение 10 раз, что означает, что он останется как 1, и результат будет:

[[ 1.  2.]
 [ 1.  4.]
 [ 1.  6.]
 [ 1.  8.]
 [ 1. 10.]
 [ 1. 12.]
 [ 1. 14.]
 [ 1. 16.]
 [ 1. 18.]
 [ 1. 20.]]

Ответ 6

Не уверен, что я понимаю вопрос - чтобы составить список 2-элементных массивов NumPy, это работает:

import numpy as np
x = np.arange(-5, 5.1, 0.5)
X, Y = np.meshgrid(x, x)
Liszt = [np.array(thing) for thing in zip(X.flatten(), Y.flatten())] # for python 2.7

zip дает вам список кортежей, а остальное - все остальные.

Ответ 7

На основе этого примера вы можете сделать любой тусклый

def linspace3D(point1,point2,length):
    v1 = np.linspace(point1[0],point2[0],length)
    v2 = np.linspace(point1[1],point2[1],length)
    v3 = np.linspace(point1[2],point2[2],length)
    line = np.zeros(shape=[length,3])
    line[:,0]=v1
    line[:,1]=v2
    line[:,2]=v3
    return line