Melhor maneira de lidar com list.index (pode não existir) em python?

Eu tenho um código parecido com este:

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

ok isso é simplificado, mas essa é a idéia. Agora thingpode não estar realmente na lista, caso em que desejo passar -1 como thing_index. Em outras linguagens, isso é o que você esperaria index()retornar se não conseguisse encontrar o elemento. Na verdade, ele lança um ValueError.

Eu poderia fazer isso:

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

Mas isso parece sujo, além disso, não sei se ValueErrorpoderia ser criado por algum outro motivo. Eu vim com a seguinte solução baseada em funções geradoras, mas parece um pouco complexa:

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

Existe uma maneira mais limpa de conseguir a mesma coisa? Vamos supor que a lista não esteja classificada.

Não há nada "sujo" em usar a cláusula try-except. Este é o caminho python. ValueErrorserá gerado pelo .indexmétodo apenas, porque é o único código que você tem lá!

Para responder ao comentário:
Em Python, mais fácil pedir perdão do que obter permissão, a filosofia está bem estabelecida, e não index não levantará esse tipo de erro para quaisquer outras questões. Não que eu possa pensar em algum.

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

Uma linha. Simples. Sem exceções.

O dicttipo tem uma getfunção , onde se a chave não existir no dicionário, o segundo argumento para geté o valor que deve retornar. Da mesma forma, há setdefault, que retorna o valor em dictse a chave existir, caso contrário, ele define o valor de acordo com seu parâmetro padrão e retorna seu parâmetro padrão.

Você pode estender o listtipo para ter um getindexdefaultmétodo.

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

Que poderia ser usado como:

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

Não há nada de errado com o código que usa ValueError. Aqui está mais uma linha se você quiser evitar exceções:

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

Esta questão é de filosofia da linguagem. Em Java, por exemplo, sempre houve uma tradição de que as exceções deveriam ser usadas apenas em "circunstâncias excepcionais", ou seja, quando os erros aconteceram, e não para controle de fluxo . No início, isso era por motivos de desempenho, pois as exceções do Java eram lentas, mas agora esse se tornou o estilo aceito.

Em contraste, o Python sempre usou exceções para indicar o fluxo normal do programa, como levantar um, ValueErrorconforme discutimos aqui. Não há nada de "sujo" nisso no estilo Python e há muito mais de onde isso veio. Um exemplo ainda mais comum é a StopIterationexceção gerada por um next()método de iterador para sinalizar que não há mais valores.

Se você faz isso com frequência, é melhor colocá-lo em uma função auxiliar:

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

Que tal isso 😃:

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 

Que tal isso:

otherfunction(thing_collection, thing)

Em vez de expor algo tão dependente da implementação, como um índice de lista em uma interface de função, passe a coleção e a coisa e deixe a outra função lidar com os problemas de "teste de associação". Se outra função for escrita para ser agnóstica de tipo de coleção, então provavelmente começaria com:

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

que funcionará se thing_collection for uma lista, tupla, conjunto ou dicionário.

Isso é possivelmente mais claro do que:

if thing_index != MAGIC_VALUE_INDICATING_NOT_A_MEMBER:

que é o código que você já possui em outra função.

Que tal assim:

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

Tenho o mesmo problema com o método ".index ()" nas listas. Não tenho nenhum problema com o fato de que ele lança uma exceção, mas discordo totalmente do fato de que é um ValueError não descritivo. Eu poderia entender se teria sido um IndexError, no entanto.

Posso ver por que retornar "-1" também seria um problema, porque é um índice válido em Python. Mas, realisticamente, nunca espero que um método ".index ()" retorne um número negativo.

Aqui vai uma linha (ok, é uma linha bastante longa ...), percorre a lista exatamente uma vez e retorna "Nenhum" se o item não for encontrado. Seria trivial reescrever para retornar -1, se você desejar.

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

Como usar:

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

Não sei por que você deve pensar que é sujo ... por causa da exceção? se você quiser um oneliner, aqui está:

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

mas eu desaconselho o uso; Acho que a solução de Ross Rogers é a melhor, use um objeto para encapsular seu comportamento desejado, não tente levar a linguagem ao seu limite ao custo da legibilidade.

Eu sugiro:

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