finde die Position des letzten Elements vor dem spezifischen Wert in python numpy

Question

Ich habe die folgenden. Python numpy Array, arr:

([1L, 1L, 1L, 1L, 1L, 1L, 1L, 0L, 0L, 0L, 0L, 3L, 3L, 3L, 2L, 2L, 2L, 
     2L, 2L, 2L, 1L, 1L, 1L, 1L]) 

kann ich das erste Vorkommen von 1 wie diese finden:

np.where(arr.squeeze() == 1)[0] 

Wie finde ich die Position der letzten 1, bevor entweder eine 0 oder 3

Answer 1

Hier ist ein Ansatz mit np.where und np.in1d -

# Get the indices of places with 0s or 3s and this 
# decides the last index where we need to look for 1s later on 
last_idx = np.where(np.in1d(arr,[0,3]))[0][-1] 

# Get all indices of 1s within the range of last_idx and choose the last one 
out = np.where(arr[:last_idx]==1)[0][-1] 

Bitte beachten Sie, dass für Fälle, in denen keine Indizes gefunden werden, so etwas wie [0][-1] mit etwa würden sich beschweren keine Elemente aufweist, so die Fehlerprüfungscodes erforderlich sein um diese Zeilen gewickelt.

Probelauf -

In [118]: arr 
Out[118]: array([1, 1, 3, 0, 3, 2, 0, 1, 2, 1, 0, 2, 2, 3, 2]) 

In [119]: last_idx = np.where(np.in1d(arr,[0,3]))[0][-1] 

In [120]: np.where(arr[:last_idx]==1)[0][-1] 
Out[120]: 9 

Answer 2

können Sie einen rolling window verwenden und dass Sie für die Werte gesucht werden soll:

import numpy as np 
arr = np.array([1L, 1L, 1L, 1L, 1L, 1L, 1L, 0L, 0L, 0L, 0L, 3L, 3L, 3L, 2L, 2L, 2L, 
     2L, 2L, 2L, 1L, 1L, 1L, 1L]) 

def rolling_window(a, window): 
    shape = a.shape[:-1] + (a.shape[-1] - window + 1, window) 
    strides = a.strides + (a.strides[-1],) 
    return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides) 

match_1_0 = np.all(rolling_window(arr, 2) == [1, 0], axis=1) 
match_1_3 = np.all(rolling_window(arr, 2) == [1, 3], axis=1) 
all_matches = np.logical_or(match_1_0, match_1_3) 
print(np.flatnonzero(all_matches)[-1]) 

abhängi Auf Ihren Arrays kann dies leistungsmäßig gut genug sein. Mit dieser sagte, eine weniger flexibel (aber einfacher) Lösung könnte eine bessere Leistung, auch wenn es sich um eine Schleife über Indizes ist, dass Sie in der Regel mit numpy vermeiden wollen ...:

for ix in xrange(len(arr) - 2, -1, -1): # range in python3.x 
    if arr[ix] == 1 and (arr[ix + 1] == 0 or arr[ix + 1] == 3): 
     return ix 

Vielleicht haben Sie sogar sein so etwas wie die in der Lage zu tun, ist wahrscheinlich ein bisschen flexibler als die hartcodierte Lösung oben und nach wie vor wahrscheinlich würde (ich würde vermuten) aus-führen die Rollfensterlösung:

def rfind(haystack, needle): 
    len_needle = len(needle) 
    for ix in xrange(len(haystack) - len_needle, -1, -1): # range in python3.x 
     if (haystack[ix:ix + len_needle] == needle).all(): 
      return ix 

Hier würden Sie etwas tun wie:

max(rfind(arr, np.array([1, 0])), rfind(arr, np.array([1, 3]))) 

Und natürlich, mit all diesen Antworten habe ich nicht wirklich den Fall behandelt, wo die Sache, die Sie suchen, nicht vorhanden ist, da Sie nicht angegeben haben, was Sie für diesen Fall wollen ...