Pourquoi la liste n'a-t-elle pas de méthode «get» sûre comme le dictionnaire?

Pourquoi la liste n'a-t-elle pas une méthode sûre "get" comme le dictionnaire?

>>> d = {'a':'b'}
>>> d['a']
'b'
>>> d['c']
KeyError: 'c'
>>> d.get('c', 'fail')
'fail'

>>> l = [1]
>>> l[10]
IndexError: list index out of range

En fin de compte, il n'a probablement pas de .getméthode sûre car a dictest une collection associative (les valeurs sont associées aux noms) où il est inefficace de vérifier si une clé est présente (et de renvoyer sa valeur) sans lever d'exception, alors qu'elle est super triviale pour éviter les exceptions d'accès aux éléments de la liste (car la lenméthode est très rapide). La .getméthode vous permet d'interroger la valeur associée à un nom, et non d'accéder directement au 37e élément du dictionnaire (ce qui ressemblerait davantage à ce que vous demandez à votre liste).

Bien sûr, vous pouvez facilement l'implémenter vous-même:

def safe_list_get (l, idx, default):
  try:
    return l[idx]
  except IndexError:
    return default

Vous pouvez même le monkeypatch sur le __builtins__.listconstructeur dans __main__, mais ce serait un changement moins répandu car la plupart du code ne l'utilise pas. Si vous souhaitez simplement l'utiliser avec des listes créées par votre propre code, vous pouvez simplement sous list- classer et ajouter la getméthode.

Cela fonctionne si vous voulez le premier élément, comme my_list.get(0)

>>> my_list = [1,2,3]
>>> next(iter(my_list), 'fail')
1
>>> my_list = []
>>> next(iter(my_list), 'fail')
'fail'

Je sais que ce n'est pas exactement ce que vous avez demandé, mais cela pourrait aider les autres.

Probablement parce que cela n'avait tout simplement pas beaucoup de sens pour la sémantique des listes. Cependant, vous pouvez facilement créer le vôtre en sous-classant.

class safelist(list):
    def get(self, index, default=None):
        try:
            return self.__getitem__(index)
        except IndexError:
            return default

def _test():
    l = safelist(range(10))
    print l.get(20, "oops")

if __name__ == "__main__":
    _test()

Au lieu d'utiliser .get, une utilisation comme celle-ci devrait être correcte pour les listes. Juste une différence d'utilisation.

>>> l = [1]
>>> l[10] if 10 < len(l) else 'fail'
'fail'

Essaye ça:

>>> i = 3
>>> a = [1, 2, 3, 4]
>>> next(iter(a[i:]), 'fail')
4
>>> next(iter(a[i + 1:]), 'fail')
'fail'

Crédits à jose.angel.jimenez

Pour les fans "oneliner"…

Si vous voulez le premier élément d'une liste ou si vous voulez une valeur par défaut si la liste est vide, essayez:

liste = ['a', 'b', 'c']
value = (liste[0:1] or ('default',))[0]
print(value)

Retour a

et

liste = []
value = (liste[0:1] or ('default',))[0]
print(value)

Retour default

Exemples pour d'autres éléments…

liste = ['a', 'b', 'c']
print(liste[0:1])  # returns ['a']
print(liste[1:2])  # returns ['b']
print(liste[2:3])  # returns ['c']

Avec repli par défaut…

liste = ['a', 'b', 'c']
print((liste[0:1] or ('default',))[0])  # returns a
print((liste[1:2] or ('default',))[0])  # returns b
print((liste[2:3] or ('default',))[0])  # returns c

Testé avec Python 3.6.0 (v3.6.0:41df79263a11, Dec 22 2016, 17:23:13)

La meilleure chose que vous puissiez faire est de convertir la liste en dict, puis d'y accéder avec la méthode get:

>>> my_list = ['a', 'b', 'c', 'd', 'e']
>>> my_dict = dict(enumerate(my_list))
>>> print my_dict
{0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e'}
>>> my_dict.get(2)
'c'
>>> my_dict.get(10, 'N/A')

J'ai donc fait des recherches supplémentaires à ce sujet et il s'avère qu'il n'y a rien de spécifique à cela. Je me suis excité quand j'ai trouvé list.index (valeur), il renvoie l'index d'un élément spécifié, mais il n'y a rien pour obtenir la valeur à un index spécifique. Donc, si vous ne voulez pas utiliser la solution safe_list_get qui, je pense, est plutôt bonne. Voici quelques instructions qui peuvent faire le travail pour vous selon le scénario:

>>> x = [1, 2, 3]
>>> el = x[4] if len(x) > 4 else 'No'
>>> el
'No'

Vous pouvez également utiliser None au lieu de 'No', ce qui est plus logique .:

>>> x = [1, 2, 3]
>>> i = 2
>>> el_i = x[i] if len(x) == i+1 else None

De plus, si vous souhaitez simplement obtenir le premier ou le dernier élément de la liste, cela fonctionne

end_el = x[-1] if x else None

Vous pouvez également en faire des fonctions, mais j'ai toujours aimé la solution d'exception IndexError. J'ai expérimenté avec une version factice de la safe_list_getsolution et je l'ai rendue un peu plus simple (pas de défaut):

def list_get(l, i):
    try:
        return l[i]
    except IndexError:
        return None

Je n'ai pas de référence pour voir ce qui est le plus rapide.

Les dictionnaires sont destinés aux recherches. Il est logique de demander si une entrée existe ou non. Les listes sont généralement itérées. Il n'est pas courant de demander si L [10] existe mais plutôt si la longueur de L est 11.

Votre cas d'utilisation n'est fondamentalement pertinent que lorsque vous effectuez des tableaux et des matrices de longueur fixe, afin que vous sachiez combien de temps ils sont avant la main. Dans ce cas, vous les créez généralement avant de les remplir manuellement avec None ou 0, de sorte qu'en fait, tout index que vous utiliserez existe déjà.

On pourrait dire ceci: j'ai souvent besoin de .get () dans les dictionnaires. Après dix ans en tant que programmeur à temps plein, je ne pense pas en avoir jamais eu besoin sur une liste. :)