Le meilleur moyen de gérer list.index (pourrait ne pas exister) en python?

J'ai du code qui ressemble à ceci:

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

ok donc c'est simplifié mais vous voyez l'idée. Maintenant, il se thingpeut que ce ne soit pas réellement dans la liste, auquel cas je veux passer -1 comme thing_index. Dans d'autres langues, c'est ce que vous vous attendez index()à retourner s'il ne trouve pas l'élément. En fait, il jette un ValueError.

Je pourrais faire ceci:

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

Mais cela semble sale, en plus je ne sais pas si cela ValueErrorpourrait être élevé pour une autre raison. J'ai proposé la solution suivante basée sur les fonctions du générateur, mais cela me semble un peu complexe:

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

Existe-t-il un moyen plus propre d'atteindre la même chose? Supposons que la liste n'est pas triée.

Il n'y a rien de «sale» à utiliser la clause try-except. C'est la voie pythonique. ValueErrorsera déclenché par la .indexméthode uniquement, car c'est le seul code que vous avez là!

Pour répondre au commentaire:
en Python, la philosophie plus facile de demander pardon que d'obtenir l'autorisation est bien établie, et non index ne soulèvera pas ce type d'erreur pour d'autres problèmes. Non pas que je puisse penser à aucun.

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

Une ligne. Facile. Aucune exception.

Le dicttype a une getfonction , où si la clé n'existe pas dans le dictionnaire, le 2ème argument de getest la valeur qu'il doit renvoyer. De même, il y a setdefault, qui renvoie la valeur dans dictsi la clé existe, sinon il définit la valeur en fonction de votre paramètre par défaut, puis retourne votre paramètre par défaut.

Vous pouvez étendre le listtype pour avoir une getindexdefaultméthode.

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

Qui pourrait alors être utilisé comme:

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

Il n'y a rien de mal avec votre code qui utilise ValueError. Voici encore un autre one-liner si vous souhaitez éviter les exceptions:

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

Ce problème relève de la philosophie du langage. En Java par exemple, il y a toujours eu une tradition selon laquelle les exceptions ne devraient vraiment être utilisées que dans des «circonstances exceptionnelles», c'est-à-dire lorsque des erreurs se sont produites, plutôt que pour le contrôle de flux . Au début, c'était pour des raisons de performances, car les exceptions Java étaient lentes, mais maintenant c'est devenu le style accepté.

En revanche, Python a toujours utilisé des exceptions pour indiquer le déroulement normal du programme, comme lever un ValueErrorcomme nous en discutons ici. Il n'y a rien de "sale" à ce sujet dans le style Python et il y en a beaucoup d'autres d'où cela vient. Un exemple encore plus courant est l' StopIterationexception qui est déclenchée par la next()méthode d' un itérateur pour signaler qu'il n'y a pas d'autres valeurs.

Si vous faites cela souvent, il est préférable de le réchauffer dans une fonction d'aide:

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

Et ça 😃:

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 

Et ça:

otherfunction(thing_collection, thing)

Plutôt que d'exposer quelque chose d'aussi dépendant de l'implémentation comme un index de liste dans une interface de fonction, transmettez la collection et l'objet et laissez l'autre fonction gérer les problèmes de "test d'appartenance". Si une autre fonction est écrite pour être indépendante du type de collection, elle commencerait probablement par:

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

qui fonctionnera si thing_collection est une liste, un tuple, un ensemble ou un dict.

C'est peut-être plus clair que:

if thing_index != MAGIC_VALUE_INDICATING_NOT_A_MEMBER:

qui est le code que vous avez déjà dans une autre fonction.

Et comme ça:

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

J'ai le même problème avec la méthode ".index ()" sur les listes. Je n'ai aucun problème avec le fait qu'il lève une exception mais je ne suis pas du tout d'accord avec le fait qu'il s'agit d'une ValueError non descriptive. Je pourrais comprendre si cela aurait été une IndexError, cependant.

Je peux voir pourquoi renvoyer "-1" serait également un problème car c'est un index valide en Python. Mais de façon réaliste, je ne m'attends jamais à ce qu'une méthode ".index ()" renvoie un nombre négatif.

Voici une ligne (ok, c'est une ligne assez longue ...), parcourt la liste exactement une fois et retourne "Aucun" si l'élément n'est pas trouvé. Il serait trivial de le réécrire pour renvoyer -1, si vous le désirez.

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

Comment utiliser:

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

Je ne sais pas pourquoi vous devriez penser que c'est sale ... à cause de l'exception? si vous voulez un oneliner, le voici:

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

mais je déconseillerais de l'utiliser; Je pense que la solution de Ross Rogers est la meilleure, utilisez un objet pour encapsuler votre comportement souhaité, n'essayez pas de pousser le langage à ses limites au détriment de la lisibilité.

Je suggérerais:

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