Listede neden sözlük gibi güvenli “get” yöntemi bulunmuyor?

Listede neden sözlük gibi güvenli bir "get" yöntemi yok?

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

Sonuçta muhtemelen güvenli bir .getyöntemi yoktur, çünkü a dict, bir anahtarın istisna atmadan var olup olmadığını kontrol etmenin (ve değerini döndürmesinin) süper önemsiz olduğu durumlarda ilişkisel bir koleksiyon (değerler adlarla ilişkilidir). Liste öğelerine erişen istisnalardan kaçınmak için ( lenyöntem çok hızlı olduğu için). .getYöntem doğrudan (eğer listenizin soruyorsun fazla gibi olurdu) sözlükte 37 öğeye erişmek değil, bir adla ilişkilendirilmiş değeri sorgulamak için izin verir.

Tabii ki, bunu kendiniz kolayca uygulayabilirsiniz:

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

Hatta üzerine monkeypatch olabilir __builtins__.listiçinde yapıcı __main__, ancak çoğu kod kullanmak olmadığından bir az yaygın bir değişim olacaktır. Bunu sadece kendi kodunuz tarafından oluşturulan listelerle kullanmak istiyorsanız, sadece alt sınıfı sınıflandırabilir listve getyöntemi ekleyebilirsiniz .

Bu, ilk öğeyi istiyorsanız, my_list.get(0)

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

Tam olarak istediğin şey olmadığını biliyorum ama başkalarına yardımcı olabilir.

Muhtemelen liste anlambilimi için pek bir anlam ifade etmediği için. Ancak, alt sınıflama ile kendinizinkini kolayca oluşturabilirsiniz.

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

.Get kullanmak yerine, böyle kullanmak listeler için uygun olmalıdır. Sadece bir kullanım farkı.

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

Bunu dene:

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

İçin Kredi jose.angel.jimenez

"Oneliner" hayranları için…

Bir listenin ilk öğesini istiyorsanız veya liste boşsa varsayılan bir değer istiyorsanız şunu deneyin:

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

İadeler a

ve

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

İadeler default

Diğer öğeler için örnekler…

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

Varsayılan yedekle…

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

İle test edildi Python 3.6.0 (v3.6.0:41df79263a11, Dec 22 2016, 17:23:13)

Yapabileceğiniz en iyi şey, listeyi bir diktüre dönüştürmek ve ardından get yöntemiyle erişmektir:

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

Bunun üzerine biraz daha araştırma yaptım ve bunun için özel bir şey olmadığı ortaya çıktı. List.index (değer) bulduğumda heyecanlandım, belirtilen bir öğenin dizinini döndürür, ancak belirli bir dizinde değeri almak için hiçbir şey yoktur. Bu yüzden oldukça iyi olduğunu düşünüyorum safe_list_get çözümünü kullanmak istemiyorsanız. Senaryoya bağlı olarak işi sizin için halledebilecek bazı 1 liner if ifadeleri şunlardır:

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

Daha mantıklı olan 'Hayır' yerine Yok'u da kullanabilirsiniz:

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

Ayrıca listedeki ilk veya son öğeyi almak istiyorsanız, bu işe yarar

end_el = x[-1] if x else None

Bunları işlevlere de ekleyebilirsiniz, ancak hala IndexError istisna çözümünü beğendim. safe_list_getÇözümün aptal bir versiyonunu denedim ve biraz daha basit hale getirdim (varsayılan yok):

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

En hızlı olanı görmek için kıyaslama yapmadım.

Sözlükler aramalar içindir. Bir girişin olup olmadığını sormak mantıklıdır. Listeler genellikle yinelenir. L [10] 'un var olup olmadığını sormak yaygın değildir, aksine L uzunluğunun 11 olup olmadığını sormak yaygındır.

Usecase'iniz temel olarak sadece sabit uzunlukta diziler ve matrisler yaparken önemlidir, böylece ne kadar süre önce elinizde olduklarını bilirsiniz. Bu durumda, bunları genellikle Yok veya 0 ile doldurmadan önce de yaratırsınız, böylece kullanacağınız herhangi bir dizin zaten var olur.

Bunu söyleyebilirsin: Sözlüklerde sık sık .get () lazım. Tam zamanlı bir programcı olarak on yıl sonra, bir listeye hiç ihtiyaç duyduğumu düşünmüyorum. :)