Finde geordneten Vektor in numpy Array

Question

Ich muss einen Vektor in einem numpy.array finden. Zum Beispiel habe ich ein np.array namens e und ich möchte den Vektor [1, 2] in e finden (was bedeutet, dass ich gerne den Index des Vektors innerhalb der Matrix haben möchte), aber anscheinend sieht mein Programm den Vektor präsentieren, selbst wenn nicht:

der Code, den ich gebaut e verwenden im folgenden:

import numpy as np 
faces = np.array([[1,2,3,4],[5,6,2,1],[6,7,3,2],[7,8,4,3],[8,5,1,4],[8,7,6,5]]) 
e = np.zeros([6,4,2]) 
for k in range(len(faces)): 
    a = [faces[k][0], faces[k][1]] 
    b = [faces[k][1], faces[k][2]] 
    c = [faces[k][2], faces[k][3]] 
    d = [faces[k][3], faces[k][0]] 
    e[k] = np.array([a,b,c,d]) 
print('e: %s' %e) 

jede Ahnung, wie dieses Problem zu lösen?

Answer 1

Versuchen:

e[np.all((e-np.array([1,2]))==0, axis=2)] 

Kurze Erklärung. e-np.array([1,2]) gibt [0,0] zurück wo es [1,2] in Array e ist. np.all(..., axis=2 gibt das Boolesche Array zurück: True wenn [0,0]False ansonsten (so werden Dinge wie [1,1] zu False). Schließlich schneiden Sie es einfach von e.

Um den Index der [1,2] ‚s zu bekommen (es kann mehrere Untervektor [1,2] sein):

np.argwhere(np.all((e-array([1,2]))==0, axis=2)) 

Answer 2

nicht Python in mit numpy Arrays anwenden.

Es gibt 6 x 4 Paare in e.

In [32]: e.shape 
Out[32]: (6, 4, 2) 

Sie suchen ein Element, das die beiden übereinstimmt (das heißt all()) Einträge in dem Paar [1, 2].

In [33]: (e == np.array([1, 2])).all(-1) 
Out[33]: 
array([[ True, False, False, False], 
     [False, False, False, False], 
     [False, False, False, False], 
     [False, False, False, False], 
     [False, False, False, False], 
     [False, False, False, False]], dtype=bool) 

Die -1 in all(-1) bezieht sich die letzte Dimension in der Anordnung, die Teil der Form, die Paare bildet. Die Verwendung von -1 ist wahrscheinlich allgemeiner als die Verwendung von 2, was auch in diesem Fall funktionieren würde.

Es fand die richtige Übereinstimmung - die einzige True Wert. Sie können sehen, dass die Form dieses Ergebnisses sinnvoll ist.

In [34]: (e == np.array([1, 2])).all(-1).shape 
Out[34]: (6, 4) 

Um der Index des ersten Spiels erhalten Sie

x, y = (e == np.array([1, 2])).all(-1).argmax(1).argmax(), (e == np.array([1, 2])).all(-1).argmax(0).argmax() 

tun konnte, aber unter Verwendung von np.argwhere in CT Zhu Antwort vorgeschlagen ist auf jeden Fall besser.

Answer 3

Dies wird alle Indizes von e ausdrucken und ob es gleich [1,2] ist. Wenn Sie die Indizes zurückgeben möchten, anstatt sie zu drucken, können Sie (num, num2) zu einer anderen Liste hinzufügen, und das würde Ihnen alle Standorte von [1,2] geben. Müsste erweitert werden, um mit Arrays aus mehreren Ebenen zu arbeiten.

for num, item in enumerate(e): 
    for num2, item2 in enumerate(item):          
     print ('e[{i}][{j}]: {truth}'.format(i=num, 
              j=num2, 
              truth = (item2 == [1,2]).all())) 

Ausgang:

e[0][0]: True                           
e[0][1]: False                           
e[0][2]: False                           
e[0][3]: False                           
e[1][0]: False                           
e[1][1]: False                           
e[1][2]: False                           
e[1][3]: False                           
e[2][0]: False                           
e[2][1]: False                           
e[2][2]: False                           
e[2][3]: False                           
e[3][0]: False                           
e[3][1]: False                           
e[3][2]: False                           
e[3][3]: False                           
e[4][0]: False                           
e[4][1]: False                           
e[4][2]: False                           
e[4][3]: False                           
e[5][0]: False                           
e[5][1]: False                           
e[5][2]: False                           
e[5][3]: False 

Answer 4

Sie können auch die folgenden Trick verwenden, um Ihre Vektoren als Einzelstücke von np.void dtype anzuzeigen:

e = np.ascontiguousarray(e) 
dt = np.dtype((np.void, e.dtype.itemsize * e.shape[-1])) 
e_view = e.view(dt) 
search = np.array([1, 2], dtype=e.dtype).view(dt) 

Sie können nun die Positionen mit np.in1d extrahieren:

mask = np.in1d(e_view, search) 
indices = np.unravel_index(np.where(mask), e.shape[:-1]) 

>>> indices 
(array([[0]], dtype=int64), array([[0]], dtype=int64)) 

Die Rückgabearrays ist ein Tupel mit den Zeilen und Spalten des Auftretens von search, in diesem Fall gibt es nur einen, bei (0, 0).