Wie wähle ich Elemente eines Arrays unter bestimmten Bedingungen aus?

Angenommen , ich eine numpy Array haben x = [5, 2, 3, 1, 4, 5], y = ['f', 'o', 'o', 'b', 'a', 'r']. Ich möchte die Elemente auswählen, die Elementen yentsprechen x, die größer als 1 und kleiner als 5 sind.

Ich habe es versucht

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

aber das funktioniert nicht. Wie würde ich das machen?

Ihr Ausdruck funktioniert, wenn Sie Klammern hinzufügen:

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

IMO OP will eigentlich nicht np.bitwise_and()(aka &), sondern eigentlich, np.logical_and()weil sie logische Werte wie Trueund vergleichen False- siehe diesen SO-Beitrag auf logisch vs. bitweise , um den Unterschied zu sehen.

>>> 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')

Ein gleichwertiger Weg, dies zu tun, besteht darin np.all(), das axisArgument entsprechend festzulegen.

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

durch die Zahlen:

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

so mit np.all()langsamer, aber &und logical_andsind in etwa gleich.

Fügen Sie den Antworten von @JF Sebastian und @Mark Mikofski ein Detail hinzu:
Wenn Sie die entsprechenden Indizes (anstelle der tatsächlichen Werte des Arrays) erhalten möchten , reicht der folgende Code aus:

Zur Erfüllung mehrerer (aller) Bedingungen:

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

Zur Erfüllung mehrerer (oder) Bedingungen:

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

Ich benutze es gerne np.vectorizefür solche Aufgaben. Folgendes berücksichtigen:

>>> # 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')

Der Vorteil ist, dass Sie der vektorisierten Funktion viele weitere Arten von Einschränkungen hinzufügen können.

Ich hoffe es hilft.

Eigentlich würde ich es so machen:

L1 ist die Indexliste der Elemente, die die Bedingung 1 erfüllen (möglicherweise können Sie L1 verwenden somelist.index(condition1)oder np.where(condition1)erhalten.)

In ähnlicher Weise erhalten Sie L2, eine Liste von Elementen, die Bedingung 2 erfüllen;

Dann finden Sie die Kreuzung mit intersect(L1,L2).

Sie können auch Schnittpunkte mehrerer Listen finden, wenn Sie mehrere Bedingungen erfüllen müssen.

Dann können Sie den Index in jedem anderen Array anwenden, z. B. x.

Bei 2D-Arrays können Sie dies tun. Erstellen Sie unter Verwendung der Bedingung eine 2D-Maske. Geben Sie die Bedingungsmaske je nach Array in int oder float ein und multiplizieren Sie sie mit dem ursprünglichen Array.

In [8]: arr
Out[8]: 
array([[ 1.,  2.,  3.,  4.,  5.],
       [ 6.,  7.,  8.,  9., 10.]])

In [9]: arr*(arr % 2 == 0).astype(np.int) 
Out[9]: 
array([[ 0.,  2.,  0.,  4.,  0.],
       [ 6.,  0.,  8.,  0., 10.]])