MATLAB-style find() en Python

Dans MATLAB, il est facile de trouver les indices des valeurs qui satisfont à une condition particulière:

>> a = [1,2,3,1,2,3,1,2,3];
>> find(a > 2)     % find the indecies where this condition is true
[3, 6, 9]          % (MATLAB uses 1-based indexing)
>> a(find(a > 2))  % get the values at those locations
[3, 3, 3]

Quelle serait la meilleure façon de le faire en Python?

Jusqu'à présent, je suis venu avec la suivante. Juste obtenir les valeurs:

>>> a = [1,2,3,1,2,3,1,2,3]
>>> [val for val in a if val > 2]
[3, 3, 3]

Mais si je veux l'index de chacune de ces valeurs, il est un peu plus compliqué:

>>> a = [1,2,3,1,2,3,1,2,3]
>>> inds = [i for (i, val) in enumerate(a) if val > 2]
>>> inds
[2, 5, 8]
>>> [val for (i, val) in enumerate(a) if i in inds]
[3, 3, 3]

Est-il une meilleure façon de le faire en Python, en particulier pour arbitraire conditions (pas juste "val > 2')?

J'ai trouvé des fonctions équivalentes à MATLAB "trouver" dans NumPy mais je n'ont pas actuellement accès à ces bibliothèques.

Votre dernier exemple pourrait être [a[i] for i in inds], ce qui est un peu plus simple.

InformationsquelleAutor user344226 | 2011-05-10

26

Vous pouvez faire une fonction qui prend un callable paramètre qui sera utilisé dans la partie conditions de votre compréhension de liste. Ensuite, vous pouvez utiliser un lambda ou une autre fonction de l'objet de transmettre à l'arbitraire de l'état:
```
def indices(a, func):
    return [i for (i, val) in enumerate(a) if func(val)]

a = [1, 2, 3, 1, 2, 3, 1, 2, 3]

inds = indices(a, lambda x: x > 2)

>>> inds
[2, 5, 8]
```
C'est un peu plus près à vos Matlab exemple, sans avoir à charger tout de numpy.
- Pense que la question contient le code mieux que cette version: inds = [i for (i, val) in enumerate(a) if val > 2] qui est une solution en ligne.
InformationsquelleAutor John
81

dans numpy vous avez where :
```
>> import numpy as np
>> x = np.random.randint(0, 20, 10)
>> x
array([14, 13,  1, 15,  8,  0, 17, 11, 19, 13])
>> np.where(x > 10)
(array([0, 1, 3, 6, 7, 8, 9], dtype=int64),)
```
- +1 Vous pouvez également mentionner que vous pouvez index des tableaux numpy avec l'opérateur booléen tableaux, le même que vous pouvez dans matlab. (par exemple, x[x>3] au lieu de np.where(x>3)) (Pas qu'il y ait quelque chose de mal avec where! L'indexation directe est peut-être une plus forme familière aux personnes familières avec Matlab.)
- C'est un bon moyen, mais le demandeur a précisé qu'il ou elle ne peut pas utiliser numpy.
- vous avez raison. Je n'ai pas eu lors de la lecture de la question. J'ai été aveuglé par l'idée que l'OP voulait trouver l'équivalent d'une fonction matlab (et matlab est aussi gros). Par la façon dont, dans lequel la situation, pourriez-vous avoir accès à numpy?
- Seule façon que je peux voir, c'est si votre patron ne vous laisseront pas de les utiliser, ou vous êtes sur un étrange système d'exploitation ou de l'architecture.
- Il ressemble à where renvoie en fait des indices, au moins dans la version 1.6.1. Il peut renvoyer des valeurs si vous spécifier que c'est le deuxième argument. De docs sur argwhere: "La sortie de argwhere n'est pas adapté pour l'indexation des tableaux. Pour cela, où(a) à la place."
- J'ai reproduit mes exemples avec 1.7.1 et a obtenu le même résultat. Va vérifier docs en ayant un peu de temps.
- Ah, je pense que ça pourrait être parce que vous étiez à l'aide de x = np.arange(9), ce qui en soi est un ensemble d'indices. Si vous modifiez le tableau (décalage, mise à l'échelle, l'inverser, etc.), la sortie de where sera toujours indices: >>> x = np.arange(9)[::-1] * 10 + 33; print(x); print(np.où(x > 53)); [113 103 93 83 73 63 53 43 33] (tableau([0, 1, 2, 3, 4, 5]),)
- Vous êtes à la droite!. where est en fait de donner des indices, et non des valeurs. L'exemple n'était pas approprié. Je vais modifier la question pour résoudre le problème dès que possible. Personne ne l'avait vu qu'avant. Incroyable.
InformationsquelleAutor joaquin

Ou utiliser numpy est différente de zéro de la fonction:

import numpy as np
a    = np.array([1,2,3,4,5])
inds = np.nonzero(a>2)
a[inds] 
array([3, 4, 5])

InformationsquelleAutor vincentv

5

Pourquoi ne pas simplement utiliser ce:
```
[i for i in range(len(a)) if a[i] > 2]
```
ou arbitraires conditions, de définir une fonction f de votre condition et de faire:
```
[i for i in range(len(a)) if f(a[i])]
```
InformationsquelleAutor JasonFruit
4

La numpy routine plus couramment utilisé pour cette application est numpy.où(); cependant, je crois qu'il fonctionne de la même comme numpy.différent de zéro().
```
import numpy
a    = numpy.array([1,2,3,4,5])
inds = numpy.where(a>2)
```
Pour obtenir les valeurs, vous pouvez stocker les indices et tranche avec eux:
```
a[inds]
```
ou vous pouvez passer le tableau comme paramètre facultatif:
```
numpy.where(a>2, a)
```
ou plusieurs tableaux:
```
b = numpy.array([11,22,33,44,55])
numpy.where(a>2, a, b)
```
InformationsquelleAutor ryanjdillon
3

Pour obtenir des valeurs arbitraires conditions, vous pouvez utiliser filter() avec une fonction lambda:
```
>>> a = [1,2,3,1,2,3,1,2,3]
>>> filter(lambda x: x > 2, a)
[3, 3, 3]
```
L'une des voies possibles pour obtenir les indices serait d'utiliser enumerate() de construire un n-uplet avec à la fois des indices et des valeurs, et puis filtre:
```
>>> a = [1,2,3,1,2,3,1,2,3]
>>> aind = tuple(enumerate(a))
>>> print aind
((0, 1), (1, 2), (2, 3), (3, 1), (4, 2), (5, 3), (6, 1), (7, 2), (8, 3))
>>> filter(lambda x: x[1] > 2, aind)
((2, 3), (5, 3), (8, 3))
```
- Vous pouvez utiliser filter, mais en utilisant des interprétations de la liste est préférable et plus hautement optimisé.
InformationsquelleAutor Blair
3

J'ai essayé de trouver un moyen rapide de faire cette chose exacte, et voici ce que je suis tombé sur une (utilisation de numpy pour la rapidité de vecteur de comparaison):
```
a_bool = numpy.array(a) > 2
inds = [i for (i, val) in enumerate(a_bool) if val]
```
Il s'avère que c'est beaucoup plus rapide que:
```
inds = [i for (i, val) in enumerate(a) if val > 2]
```
Il semble que Python est plus rapide en comparaison lorsqu'il est effectué dans un tableau numpy, et/ou plus rapides à faire des interprétations de la liste lors de la simple vérification de la vérité plutôt que de la comparaison.

Edit:

J'ai été revoir mon code et je suis tombé sur un peut-être moins gourmande en mémoire, peu plus rapide, et super-concise façon de le faire en une seule ligne:
```
inds = np.arange( len(a) )[ a < 2 ]
```
InformationsquelleAutor Nate
2

Je pense que j'ai peut-être trouvé un moyen rapide et simple de substitution.
BTW, j'ai senti que le np.où() la fonction n'est pas très satisfaisante, en un sens, que quelque part, il contient un ennuyeux ligne de zéro-élément.
```
import matplotlib.mlab as mlab
a = np.random.randn(1,5)
print a

>> [[ 1.36406736  1.45217257 -0.06896245  0.98429727 -0.59281957]]

idx = mlab.find(a<0)
print idx
type(idx)

>> [2 4]
>> np.ndarray
```
Meilleur,
Da

InformationsquelleAutor DidasW
0

Matlab trouver le code a deux arguments. Jean du code de comptes pour le premier argument, mais pas le second. Par exemple, si vous voulez savoir où l'indice de la condition est satisfaite: Mtlab de la fonction:
```
find(x>2,1)
```
L'aide de Jean-code, tout ce que vous avez à faire est d'ajouter un [x] à la fin des indices de la fonction, où x est le numéro d'index que vous cherchez.
```
def indices(a, func):
    return [i for (i, val) in enumerate(a) if func(val)]

a = [1, 2, 3, 1, 2, 3, 1, 2, 3]

inds = indices(a, lambda x: x > 2)[0] #[0] being the 2nd matlab argument
```
qui renvoie >>> 2, le premier indice de dépasser de plus de 2.

InformationsquelleAutor Clayton Pipkin

Vous devez vous connecter pour publier un commentaire.