Por que a lista não possui um método "get" seguro como o dicionário?

Por que a lista não possui um método "get" seguro como o dicionário?

>>> 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

Por fim, provavelmente não possui um .getmétodo seguro , porque a dicté uma coleção associativa (os valores estão associados aos nomes), onde é ineficiente verificar se uma chave está presente (e retornar seu valor) sem gerar uma exceção, embora seja super trivial para evitar exceções ao acessar os elementos da lista (como o lenmétodo é muito rápido). O .getmétodo permite que você consulte o valor associado a um nome, não acesse diretamente o 37º item no dicionário (que seria mais parecido com o que você está pedindo na sua lista).

Obviamente, você pode implementar isso sozinho:

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

Você pode até monkeipá-lo no __builtins__.listconstrutor __main__, mas isso seria uma mudança menos difundida, já que a maioria dos códigos não o usa. Se você quiser apenas usá-lo com listas criadas por seu próprio código, basta subclassificar liste adicionar o getmétodo.

Isso funciona se você quiser o primeiro elemento, como my_list.get(0)

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

Eu sei que não é exatamente o que você pediu, mas pode ajudar os outros.

Provavelmente porque simplesmente não fazia muito sentido para a semântica da lista. No entanto, você pode facilmente criar seus próprios subclasses.

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()

Em vez de usar .get, usar desta forma deve estar ok para listas. Apenas uma diferença de uso.

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

Tente o seguinte:

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

Créditos a jose.angel.jimenez

Para os fãs "oneliner" ...

Se você deseja o primeiro elemento de uma lista ou se deseja um valor padrão, se a lista estiver vazia, tente:

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

retorna a

e

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

retorna default

Exemplos para outros elementos…

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

Com fallback padrão…

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

Testado com Python 3.6.0 (v3.6.0:41df79263a11, Dec 22 2016, 17:23:13)

A melhor coisa que você pode fazer é converter a lista em um dict e acessá-la com o método 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')

Então, eu fiz mais algumas pesquisas sobre isso e verifica-se que não há nada específico para isso. Fiquei empolgado quando encontrei list.index (value), ele retorna o índice de um item especificado, mas não há nada para obter o valor em um índice específico. Portanto, se você não quiser usar a solução safe_list_get, que eu acho muito boa. Aqui estão algumas instruções liner if que podem fazer o trabalho para você, dependendo do cenário:

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

Você também pode usar Nenhum em vez de 'Não', o que faz mais sentido:

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

Além disso, se você deseja apenas obter o primeiro ou o último item da lista, isso funciona

end_el = x[-1] if x else None

Você também pode transformá-las em funções, mas eu ainda gostei da solução de exceção IndexError. Eu experimentei uma versão dummied da safe_list_getsolução e a tornei um pouco mais simples (sem padrão):

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

Não foram comparados para ver o que é mais rápido.

Os dicionários são para pesquisas. Faz sentido perguntar se uma entrada existe ou não. As listas geralmente são iteradas. Não é comum perguntar se L [10] existe, mas se o comprimento de L é 11.

O seu caso de uso é basicamente relevante apenas para a criação de matrizes e matrizes de comprimento fixo, para que você saiba quanto tempo demora antes. Nesse caso, você normalmente também os cria antes de preenchê-los com Nenhum ou 0, para que, de fato, já exista qualquer índice que você usar.

Você poderia dizer o seguinte: preciso de .get () nos dicionários com bastante frequência. Depois de dez anos como programador em tempo integral, acho que nunca precisei disso em uma lista. :)