Python: restituisce l'indice del primo elemento di una lista che rende una funzione passata true

Question

la funzione list.index(x) restituisce l'indice nell'elenco del primo elemento il cui valore è x.

c'è una funzione, list_func_index(), simile alla funzione index() che ha una funzione, f(), come parametro. la funzione, f(), viene eseguita su ogni elemento, e, dell'elenco fino a f(e) restituisce True. quindi list_func_index() restituisce l'indice di e.

codewise:

>>> def list_func_index(lst, func): 
     for i in range(len(lst)): 
     if func(lst[i]): 
      return i 
     raise ValueError('no element making func True') 

>>> l = [8,10,4,5,7] 
>>> def is_odd(x): return x % 2 != 0 
>>> list_func_index(l,is_odd) 
3 

c'è una soluzione più elegante? (E un nome migliore per la funzione)

Answer 1

si potrebbe fare in una battuta che utilizzano generatori:

(i for i,v in enumerate(l) if is_odd(v)).next() 

La cosa bella di generatori è che si calcolano solo fino all'importo richiesto. Quindi richiedere i primi due indici è (quasi) altrettanto facile:

y = (i for i,v in enumerate(l) if is_odd(v)) 
x1 = y.next() 
x2 = y.next() 

Anche se, si aspettano un'eccezione StopIteration dopo l'ultimo indice (cioè come funzionano i generatori). Questo è anche conveniente nel tuo approccio "take-first", per sapere che non è stato trovato alcun valore --- la funzione list.index() genererebbe ValueError qui.

più Un commento degno di nota da Alex Martelli: In Python 2.6 e fino, next(someiterator) è il modo nuovo e preferito su someiterator.next().

Answer 2

Una possibilità è il built-in funzione di enumerate:

def index_of_first(lst, pred): 
    for i,v in enumerate(lst): 
     if pred(v): 
      return i 
    return None 

E 'tipico per indicare una funzione come quella che lei descrive come un "predicato"; restituisce vero o falso per qualche domanda. Ecco perché lo chiamo pred nel mio esempio.

Penso anche che sarebbe stato meglio restituire None, poiché questa è la vera risposta alla domanda. Il chiamante può scegliere di esplodere su None, se necessario.

Answer 3

si potrebbe fare questo con una lista-di comprensione:

l = [8,10,4,5,7] 
filterl = [a for a in l if a % 2 != 0] 

Poi filterl torneranno tutti i membri della lista che soddisfano l'espressione a 2% = 0. direi un metodo più elegante ...!

Answer 4

non una sola funzione, ma si può fare abbastanza facilmente:

>>> test = lambda c: c == 'x' 
>>> data = ['a', 'b', 'c', 'x', 'y', 'z', 'x'] 
>>> map(test, data).index(True) 
3 
>>> 

Se non si desidera valutare l'intero elenco in una sola volta è possibile utilizzare itertools, ma non è così bella:

>>> from itertools import imap, ifilter 
>>> from operator import itemgetter 
>>> test = lambda c: c == 'x' 
>>> data = ['a', 'b', 'c', 'x', 'y', 'z'] 
>>> ifilter(itemgetter(1), enumerate(imap(test, data))).next()[0] 
3 
>>> 

L'uso di un'espressione di generatore è probabilmente più leggibile di itertools.

Answer 5

@ risposta accettato di Paolo è migliore, ma qui è un po 'variante latero-pensiero, per lo più per scopi di divertimento e istruzione ...:

>>> class X(object): 
... def __init__(self, pred): self.pred = pred 
... def __eq__(self, other): return self.pred(other) 
... 
>>> l = [8,10,4,5,7] 
>>> def is_odd(x): return x % 2 != 0 
... 
>>> l.index(X(is_odd)) 
3 

sostanza, lo scopo X s' è quello di cambiare il significato di " l'uguaglianza "da quella normale a" soddisfa questo predicato ", consentendo in tal modo l'uso di predicati in tutti i tipi di situazioni che sono definite come controllo dell'uguaglianza - ad esempio, ti consentirebbe anche di codificare, invece di if X(is_odd) in l:if X(is_odd) in l: , e così via.

Vale la pena utilizzare? Non quando un approccio più esplicito come quello preso da @Paul è altrettanto utile (specialmente quando si cambia la funzione nuova, lucida integrata next anziché quella precedente, meno appropriata, .next, come suggerisco in un commento a quella risposta), ma ci sono altre situazioni in cui (o altre varianti dell'idea "modificare il significato di uguaglianza", e forse altri comparatori e/o hashing) possono essere appropriati. Soprattutto, vale la pena conoscere l'idea, per evitare di doverlo inventare da zero un giorno ;-).

Answer 6

Una variazione sulla risposta di Alex. Ciò evita di dover digitare X ogni volta che si desidera utilizzare is_odd o qualsiasi predicato

>>> class X(object): 
...  def __init__(self, pred): self.pred = pred 
...  def __eq__(self, other): return self.pred(other) 
... 
>>> L = [8,10,4,5,7] 
>>> is_odd = X(lambda x: x%2 != 0) 
>>> L.index(is_odd) 
3 
>>> less_than_six = X(lambda x: x<6) 
>>> L.index(less_than_six) 
2