Gibt es eine mehrdimensionale Version von arange / linspace in numpy?

Ich möchte eine Liste von 2d NumPy-Arrays (x, y), wobei jedes x in {-5, -4,5, -4, -3,5, ..., 3,5, 4, 4,5, 5} und dasselbe für y steht .

ich könnte

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

und dann alle möglichen Paare durchlaufen, aber ich bin sicher, es gibt einen schöneren Weg ...

Ich möchte etwas zurück, das aussieht wie:

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

aber die Reihenfolge spielt keine Rolle.

Sie können np.mgriddies verwenden, es ist oft bequemer als np.meshgridweil es die Arrays in einem Schritt erstellt:

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

Ersetzen Sie für linspaceähnliche Funktionen den Schritt (dh 0.5) durch eine komplexe Zahl, deren Größe die Anzahl der Punkte angibt, die Sie in der Reihe haben möchten. Mit dieser Syntax werden dieselben Arrays wie oben angegeben:

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

Sie können Ihre Paare dann wie folgt erstellen:

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

Wie von @ali_m vorgeschlagen, kann dies alles in einer Zeile erfolgen:

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

Viel Glück!

Dies ist genau das, wonach Sie suchen:

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

Das heisst:

Für die erste Spalte; Setzen Sie von 1 von (1,2) bis 10 von (10,20) die steigenden 10 Zahlen.

Für die zweite Spalte; Setzen Sie von 2 von (1,2) bis 20 von (10,20) die steigenden 10 Zahlen.

Und das Ergebnis wird sein:

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

Sie können auch die Werte einer Spalte erhöhen, wenn Sie beispielsweise Folgendes sagen:

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

Die erste Spalte wird 10 Mal von 1 von (1,2) bis 1 von (1,20) sein, was bedeutet, dass sie als 1 bleibt und das Ergebnis lautet:

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

Ich denke du willst np.meshgrid:

Koordinatenmatrizen von Koordinatenvektoren zurückgeben.

Erstellen Sie ND-Koordinatenarrays für vektorisierte Auswertungen von ND-Skalar- / Vektorfeldern über ND-Gittern mit gegebenen eindimensionalen Koordinatenarrays 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)

Sie können dies mit in Ihre gewünschte Ausgabe konvertieren

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

Wenn Sie nur Paare durchlaufen möchten (und nicht alle Punkte gleichzeitig berechnen möchten), sollten Sie am besten itertools.productalle möglichen Paare durchlaufen:

import itertools

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

Dies vermeidet die Erzeugung großer Matrizen über meshgrid.

Wir können die Arrangierfunktion verwenden als:

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

Ich bin mir nicht sicher, ob ich die Frage verstehe - um eine Liste von NumPy-Arrays mit zwei Elementen zu erstellen, funktioniert dies:

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 gibt Ihnen eine Liste von Tupeln, und das Listenverständnis erledigt den Rest.

Es ist keine superschnelle Lösung, funktioniert aber für jede Dimension

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

Ich habe es immer noch mit Linspace gemacht, weil ich mich lieber an diesen Befehl halte.

Sie können wie folgt formatieren: np.linspace (np.zeros ( Breite ) [0], np.full ((1, Breite ), - 1) [0], Höhe )

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

Geben Sie Folgendes aus:

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

Fügen Sie .tranpose () hinzu, dann erhalten Sie:

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

Anhand dieses Beispiels können Sie jede gewünschte Dimmung vornehmen

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