Чи існує багатовимірна версія arange / linspace у numpy?

Question 1

Я хотів би отримати список 2d масивів NumPy (x, y), де кожне x знаходиться в {-5, -4,5, -4, -3,5, ..., 3,5, 4, 4,5, 5} і однакове для y .

Я міг би це зробити

x = np.arange(-5, 5.1, 0.5)
y = np.arange(-5, 5.1, 0.5)

а потім перебирати всі можливі пари, але я впевнений, що є кращий спосіб ...

Я хотів би повернути щось, що виглядає так:

[[-5, -5],
 [-5, -4.5],
 [-5, -4],
 ...
 [5, 5]]

але порядок не має значення.

Question 2

Ви можете використовувати np.mgridдля цього, це часто зручніше, ніж np.meshgridтому, що створює масиви в один крок:

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

Для функціональності, подібної до лінзового простору, замініть крок (тобто 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

Удачі!

Question 3

Це саме те, що ви шукаєте:

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.]]

Question 4

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

Повернути координатні матриці з координатних векторів.

Складіть координатні масиви ND для векторизованих оцінок скалярних / векторних полів ND над сітками ND, враховуючи одновимірні масиви координат 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. ]])

Question 5

Якщо ви просто хочете перебирати пари (а не робити обчислення по всій сукупності точок одночасно), вам може бути найкраще itertools.productвиконати перебір усіх можливих пар:

import itertools

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

Це дозволяє уникнути генерації великих матриць через meshgrid.

Question 6

Ми можемо використовувати функцію упорядкування як:

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]]

Question 7

Не впевнений, що я розумію питання - скласти список двоелементних масивів 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 дає вам список кортежів, а розуміння списку робить все інше.

Question 8

Це не надшвидке рішення, але працює для будь-якого виміру

import numpy as np
def linspace_md(v_min,v_max,dim,num):
    output = np.empty( (num**dim,dim)  )
    values = np.linspace(v_min,v_max,num)
    for i in range(output.shape[0]):
        for d in range(dim):
            output[i][d] = values[( i//(dim**d) )%num]
    return output

Question 9

Я все-таки зробив це з Linspace, бо вважаю за краще дотримуватися цієї команди.

Ви можете створити такий формат: np.linspace (np.zeros ( width ) [0], np.full ((1, width ), - 1) [0], height )

np.linspace(np.zeros(5)[0],np.full((1,5),-1)[0],5)

Виведіть наступне:

array([[ 0.  ,  0.  ,  0.  ,  0.  ,  0.  ],
       [-0.25, -0.25, -0.25, -0.25, -0.25],
       [-0.5 , -0.5 , -0.5 , -0.5 , -0.5 ],
       [-0.75, -0.75, -0.75, -0.75, -0.75],
       [-1.  , -1.  , -1.  , -1.  , -1.  ]])

Додайте .tranpose (), тоді ви отримаєте:

array([[ 0.  , -0.25, -0.5 , -0.75, -1.  ],
      [ 0.  , -0.25, -0.5 , -0.75, -1.  ],
      [ 0.  , -0.25, -0.5 , -0.75, -1.  ],
      [ 0.  , -0.25, -0.5 , -0.75, -1.  ],
      [ 0.  , -0.25, -0.5 , -0.75, -1.  ]])

Question 10

На основі цього прикладу ви можете зробити будь-який тьмяний, який хочете

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