Il modo migliore per gestire list.index (potrebbe-non-esistere) in Python?

Ho un codice che assomiglia a questo:

thing_index = thing_list.index(thing)
otherfunction(thing_list, thing_index)

ok quindi è semplificato ma hai capito. Ora thingpotrebbe non essere effettivamente nell'elenco, nel qual caso voglio passare -1 come thing_index. In altre lingue questo è ciò che ti aspetteresti index()di restituire se non riuscisse a trovare l'elemento. In effetti lancia un file ValueError.

Potrei farlo:

try:
    thing_index = thing_list.index(thing)
except ValueError:
    thing_index = -1
otherfunction(thing_list, thing_index)

Ma questo sembra sporco, inoltre non so se ValueErrorpotrebbe essere cresciuto per qualche altro motivo. Ho trovato la seguente soluzione basata sulle funzioni del generatore, ma sembra un po 'complessa:

thing_index = ( [(i for i in xrange(len(thing_list)) if thing_list[i]==thing)] or [-1] )[0]

Esiste un modo più pulito per ottenere la stessa cosa? Supponiamo che l'elenco non sia ordinato.

Non c'è niente di "sporco" nell'uso della clausola try-tranne. Questo è il modo pitonico. ValueErrorverrà generato solo dal .indexmetodo, perché è l'unico codice che hai lì!

Per rispondere al commento:
In Python, è più facile chiedere perdono che ottenere i permessi la filosofia è ben consolidata e no index non solleverà questo tipo di errore per nessun altro problema. Non che io riesca a pensare a nessuno.

thing_index = thing_list.index(elem) if elem in thing_list else -1

Una linea. Semplice. Nessuna eccezione.

Il dicttipo ha una getfunzione , dove se la chiave non esiste nel dizionario, il secondo argomento di getè il valore che dovrebbe restituire. Allo stesso modo c'è setdefault, che restituisce il valore nel dictse la chiave esiste, altrimenti imposta il valore in base al parametro predefinito e quindi restituisce il parametro predefinito.

Potresti estendere il listtipo per avere un getindexdefaultmetodo.

class SuperDuperList(list):
    def getindexdefault(self, elem, default):
        try:
            thing_index = self.index(elem)
            return thing_index
        except ValueError:
            return default

Che potrebbe quindi essere utilizzato come:

mylist = SuperDuperList([0,1,2])
index = mylist.getindexdefault( 'asdf', -1 )

Non c'è niente di sbagliato nel codice che usa ValueError. Ecco un'altra battuta se vuoi evitare eccezioni:

thing_index = next((i for i, x in enumerate(thing_list) if x == thing), -1)

Questo problema riguarda la filosofia del linguaggio. In Java, ad esempio, c'è sempre stata una tradizione secondo cui le eccezioni dovrebbero essere utilizzate solo in "circostanze eccezionali", cioè quando si sono verificati errori, piuttosto che per il controllo del flusso . All'inizio questo era per motivi di prestazioni poiché le eccezioni Java erano lente, ma ora questo è diventato lo stile accettato.

Al contrario, Python ha sempre utilizzato le eccezioni per indicare il normale flusso del programma, come sollevare a ValueErrorcome stiamo discutendo qui. Non c'è niente di "sporco" in questo in stile Python e ce ne sono molti altri da dove provengono. Un esempio ancora più comune è l' StopIterationeccezione che viene sollevata dal next()metodo di un iteratore per segnalare che non ci sono ulteriori valori.

Se lo fai spesso, è meglio spegnerlo in una funzione di aiuto:

def index_of(val, in_list):
    try:
        return in_list.index(val)
    except ValueError:
        return -1 

Che ne dici di questo 😃:

li = [1,2,3,4,5] # create list 

li = dict(zip(li,range(len(li)))) # convert List To Dict 
print( li ) # {1: 0, 2: 1, 3: 2, 4:3 , 5: 4}
li.get(20) # None 
li.get(1)  # 0 

Che dire di questo:

otherfunction(thing_collection, thing)

Piuttosto che esporre qualcosa di così dipendente dall'implementazione come un indice di lista in un'interfaccia di funzione, passare la raccolta e la cosa e lasciare che altre funzioni si occupino dei problemi di "verifica dell'appartenenza". Se l'altra funzione è scritta per essere indipendente dal tipo di raccolta, probabilmente inizierebbe con:

if thing in thing_collection:
    ... proceed with operation on thing

che funzionerà se thing_collection è una lista, una tupla, un set o un dict.

Questo è forse più chiaro di:

if thing_index != MAGIC_VALUE_INDICATING_NOT_A_MEMBER:

che è il codice che hai già in un'altra funzione.

Che ne dici di questo:

temp_inx = (L + [x]).index(x) 
inx = temp_inx if temp_inx < len(L) else -1

Ho lo stesso problema con il metodo ".index ()" negli elenchi. Non ho alcun problema con il fatto che generi un'eccezione, ma sono fortemente in disaccordo con il fatto che si tratti di un ValueError non descrittivo. Potrei capire se sarebbe stato un IndexError, però.

Posso capire perché anche la restituzione di "-1" sarebbe un problema perché è un indice valido in Python. Ma realisticamente, non mi aspetto mai che un metodo ".index ()" restituisca un numero negativo.

Qui va una riga (ok, è una riga piuttosto lunga ...), scorre l'elenco esattamente una volta e restituisce "Nessuno" se l'elemento non viene trovato. Sarebbe banale riscriverlo per restituire -1, se lo desideri.

indexOf = lambda list, thing: \
            reduce(lambda acc, (idx, elem): \
                   idx if (acc is None) and elem == thing else acc, list, None)

Come usare:

>>> indexOf([1,2,3], 4)
>>>
>>> indexOf([1,2,3], 1)
0
>>>

Non so perché dovresti pensare che sia sporco ... a causa dell'eccezione? se vuoi un oneliner, eccolo:

thing_index = thing_list.index(elem) if thing_list.count(elem) else -1

ma sconsiglierei di usarlo; Penso che la soluzione di Ross Rogers sia la migliore, usa un oggetto per incapsulare il tuo comportamento desiderato, non provare a spingere il linguaggio ai suoi limiti a scapito della leggibilità.

Suggerirei:

if thing in thing_list:
  list_index = -1
else:
  list_index = thing_list.index(thing)