python - empty - numpy array index

Numpy array, ¿cómo seleccionar índices que satisfagan múltiples condiciones?

Question

Supongamos que tengo una matriz numpy x = [5, 2, 3, 1, 4, 5] , y = [''f'', ''o'', ''o'', ''b'', ''a'', ''r''] . Quiero seleccionar los elementos en y corresponden a elementos en x que son mayores que 1 y menores que 5.

Lo intenté

x = array([5, 2, 3, 1, 4, 5])
y = array([''f'',''o'',''o'',''b'',''a'',''r''])
output = y[x > 1 & x < 5] # desired output is [''o'',''o'',''a'']

pero esto no funciona ¿Cómo haría esto?

Answer 1

Agregue un detalle a las respuestas de @JF Sebastian y @Mark Mikofski:
Si uno quiere obtener los índices correspondientes (en lugar de los valores reales de la matriz), el siguiente código hará:

Para satisfacer múltiples (todas) condiciones:

select_indices = np.where( np.logical_and( x > 1, x < 5) ) #   1 < x <5

Para satisfacer múltiples (o) condiciones:

select_indices = np.where( np.logical_or( x < 1, x > 5 ) ) # x <1 or x >5

Answer 2

En realidad, lo haría de esta manera:

L1 es la lista de índice de elementos que satisfacen la condición 1; (tal vez puede usar somelist.index(condition1) o np.where(condition1) para obtener L1).

Del mismo modo, obtienes L2, una lista de elementos que cumplen la condición 2;

Luego encuentras la intersección usando intersect(L1,L2) .

También puede encontrar la intersección de múltiples listas si obtiene múltiples condiciones para satisfacer.

Luego puede aplicar el índice en cualquier otra matriz, por ejemplo, x.

Answer 3

IMO OP en realidad no quiere np.bitwise_and() (aka & ) pero en realidad quiere np.logical_and() porque están comparando valores lógicos como True y False : vea esta publicación de SO en lógica vs. bit a bit para ver la diferencia.

>>> x = array([5, 2, 3, 1, 4, 5])
>>> y = array([''f'',''o'',''o'',''b'',''a'',''r''])
>>> output = y[np.logical_and(x > 1, x < 5)] # desired output is [''o'',''o'',''a'']
>>> output
array([''o'', ''o'', ''a''],
      dtype=''|S1'')

Y una forma equivalente de hacer esto es con np.all() estableciendo el argumento del axis apropiadamente.

>>> output = y[np.all([x > 1, x < 5], axis=0)] # desired output is [''o'',''o'',''a'']
>>> output
array([''o'', ''o'', ''a''],
      dtype=''|S1'')

Por los números:

>>> %timeit (a < b) & (b < c)
The slowest run took 32.97 times longer than the fastest. This could mean that an intermediate result is being cached.
100000 loops, best of 3: 1.15 µs per loop

>>> %timeit np.logical_and(a < b, b < c)
The slowest run took 32.59 times longer than the fastest. This could mean that an intermediate result is being cached.
1000000 loops, best of 3: 1.17 µs per loop

>>> %timeit np.all([a < b, b < c], 0)
The slowest run took 67.47 times longer than the fastest. This could mean that an intermediate result is being cached.
100000 loops, best of 3: 5.06 µs per loop

así que usar np.all() es más lento, pero & y logical_and son más o menos lo mismo.

Answer 4

Me gusta usar np.vectorize para tales tareas. Considera lo siguiente:

>>> # Arrays
>>> x = np.array([5, 2, 3, 1, 4, 5])
>>> y = np.array([''f'',''o'',''o'',''b'',''a'',''r''])

>>> # Function containing the constraints
>>> func = np.vectorize(lambda t: t>1 and t<5)

>>> # Call function on x
>>> y[func(x)]
>>> array([''o'', ''o'', ''a''], dtype=''<U1'')

La ventaja es que puede agregar muchos más tipos de restricciones en la función vectorizada.

Espero eso ayude.

Answer 5

Tu expresión funciona si agregas paréntesis:

>>> y[(1 < x) & (x < 5)]
array([''o'', ''o'', ''a''], 
      dtype=''|S1'')