Si vous souhaitez effectuer plusieurs recherches, vous pouvez les faire dans O (1) après une première traversée O (n) pour créer un dictionnaire de recherche.

>>> print('index of 8 is:', foo(8))
index of 8 is:  3

Et cela fonctionne pour votre test:

b = np.array([5, 4, 6, 8, 1, 2])
lookup_dict = {e:i for i,e in enumerate(b)}
def foo(element):
    return lookup_dict[element]

Notez que s'il y a une possibilité que b peut avoir changé depuis le dernier appel de foo () , nous devons recréer le dictionnaire.

Vous pouvez utiliser dict , zip et numpy.arrange pour créer votre recherche inversée:

{5: 0, 4: 1, 6: 2, 8: 3, 1: 4, 2: 5}

donne:

import numpy 

b = np.array([5, 4, 6, 8, 1, 2])
d = dict(zip(b, np.arange(0,len(b))))
print(d)

C'est plus simple que vous ne le pensez, en exploitant l'indexation avancée de numpy.

Ce que nous faisons est de créer notre tableau cible et d'attribuer simplement usign b comme index. Nous attribuerons les indices que nous voulons en utilisant arange.

h = np.int32(b * 100.0) % 101  # Typically some prime number
t = np.zeros((101,))
t[h] = np.arange(0, h.size)

# Retrieving a value v; keep in mind v can be an ndarray itself.
t[np.int32(v * 100.0) % 101]

Vous pouvez utiliser nan s ou -1 au lieu de zéros pour construire la cible vers aide à détecter les recherches non valides.

Utilisation de la mémoire : elle offre des performances optimales dans l'espace et dans le temps car elle est entièrement gérée par numpy.

Si vous pouvez tolérer les collisions , vous pouvez implémenter la table de hachage d'un pauvre homme. Supposons que nous ayons des devises, par exemple:

>>> t = np.zeros((np.max(b) + 1,))
>>> t[b] = np.arange(0, b.size)
>>> t
array([0., 4., 5., 0., 1., 0., 2., 0., 3.])

Vous pouvez effectuer d'autres étapes pour modifier l'adresse si vous savez à quoi ressemble votre ensemble de données.

Ceci est à peu près la limite de ce qui est utile à faire avec numpy.

Solution

Si vous voulez un temps constant (c'est-à-dire O (1) ), vous devrez précalculer une table de recherche d'une sorte. Si vous voulez créer votre table de recherche en utilisant un autre tableau Numpy, il faudra en fait un tableau clairsemé, dans lequel la plupart des valeurs sont «vides». Voici une approche pratique dans laquelle les valeurs vides sont marquées comme -1:

ix = {k:v for v,k in enumerate(b.flat)}

Test:

index of 8 is: [3]
index of 0,5,1,8 is: [-1  0  4  3]

Output:

print("index of 8 is: %s" % foo(8))
print("index of 0,5,1,8 is: %s" % foo(0,5,1,8))

Caveat

Dans le code de production, vous devez absolument utiliser un dictionnaire pour résoudre ce problème, comme d'autres répondants l'ont souligné. Pourquoi? Eh bien, pour une chose, disons que votre tableau b contient des valeurs float , ou toute valeur non- int . Ensuite, une table de recherche basée sur Numpy ne fonctionnera pas du tout.

Par conséquent, vous ne devriez utiliser la réponse ci-dessus que si vous avez une opposition philosophique profonde à l'utilisation d'un dictionnaire (par exemple, un dict a écrasé votre chat). Voici une bonne façon de générer un dict de recherche inversée:

b = np.array([5, 4, 6, 8, 1, 2])

_b_ix = np.array([-1]*(b.max() + 1))
_b_ix[b] = np.arange(b.size)
# _b_ix: array([-1,  4,  5, -1,  1,  0,  2, -1,  3])

def foo(*val):
    return _b_ix[list(val)]