Perché l'elenco non ha un metodo "get" sicuro come il dizionario?

Perché l'elenco non ha un metodo "get" sicuro come il dizionario?

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

In definitiva, probabilmente non ha un .getmetodo sicuro perché a dictè una raccolta associativa (i valori sono associati ai nomi) in cui è inefficace controllare se è presente una chiave (e restituire il suo valore) senza generare un'eccezione, mentre è super banale per evitare eccezioni nell'accesso agli elementi dell'elenco (in quanto il lenmetodo è molto veloce). Il .getmetodo ti consente di interrogare il valore associato a un nome, non di accedere direttamente al 37 ° elemento nel dizionario (che sarebbe più simile a quello che stai chiedendo al tuo elenco).

Naturalmente, puoi facilmente implementarlo da solo:

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

Si potrebbe persino eseguire il monkeypatch sul __builtins__.listcostruttore in __main__, ma sarebbe un cambiamento meno pervasivo poiché la maggior parte del codice non lo utilizza. Se volessi semplicemente usarlo con elenchi creati con il tuo codice, potresti semplicemente sottoclassare liste aggiungere il getmetodo.

Funziona se vuoi il primo elemento, come my_list.get(0)

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

So che non è esattamente quello che hai chiesto, ma potrebbe aiutare gli altri.

Probabilmente perché non aveva molto senso per la semantica delle liste. Tuttavia, puoi facilmente crearne uno tuo tramite la sottoclasse.

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

Invece di usare .get, usare così dovrebbe essere ok per le liste. Solo una differenza di utilizzo.

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

Prova questo:

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

Crediti a jose.angel.jimenez

Per i fan di "oneliner" ...

Se si desidera il primo elemento di un elenco o se si desidera un valore predefinito se l'elenco è vuoto, provare:

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

ritorna a

e

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

ritorna default

Esempi per altri elementi ...

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

Con fallback predefinito ...

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

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

La cosa migliore che puoi fare è convertire l'elenco in un dict e quindi accedervi con il metodo 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')

Quindi ho fatto qualche ricerca in più su questo e si scopre che non c'è nulla di specifico per questo. Mi sono emozionato quando ho trovato list.index (valore), restituisce l'indice di un elemento specificato, ma non c'è nulla per ottenere il valore in un indice specifico. Quindi se non vuoi usare la soluzione safe_list_get che penso sia abbastanza buona. Di seguito sono riportati alcuni esempi di istruzioni che possono svolgere il lavoro per te in base allo scenario:

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

Puoi anche usare Nessuno invece di 'No', il che ha più senso .:

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

Inoltre, se vuoi ottenere solo il primo o l'ultimo elemento nell'elenco, questo funziona

end_el = x[-1] if x else None

Puoi anche trasformarli in funzioni ma mi è comunque piaciuta la soluzione di eccezione IndexError. Ho sperimentato una versione ridotta della safe_list_getsoluzione e l'ho resa un po 'più semplice (nessun valore predefinito):

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

Non ho fatto benchmark per vedere cosa è più veloce.

I dizionari sono per le ricerche. Ha senso chiedere se esiste o meno una voce. Le liste sono di solito iterate. Non è comune chiedere se esiste L [10] ma piuttosto se la lunghezza di L è 11.

Il tuo caso d'uso è fondamentalmente rilevante solo quando si eseguono array e matrici di lunghezza fissa, in modo da sapere quanto tempo sono prima. In tal caso, in genere li crei anche prima di riempirli a mano con Nessuno o 0, in modo che qualsiasi indice che utilizzerai già esiste.

Potresti dire questo: ho bisogno di .get () sui dizionari abbastanza spesso. Dopo dieci anni come programmatore a tempo pieno non credo di averne mai avuto bisogno in un elenco. :)