İlk öğeyi döndürmek için Python deyimi veya Yok

Eminim bunu yapmanın daha basit bir yolu var.

Bir liste döndüren bir sürü yöntem arıyorum. Liste boş olabilir. Liste boş değilse, ilk öğeyi döndürmek istiyorum; Aksi takdirde, Hiçbiri dönmek istiyorum. Bu kod çalışır:

my_list = get_list()
if len(my_list) > 0: return my_list[0]
return None

Bana öyle geliyor ki bunu yapmak için tek satırlık basit bir deyim olmalı, ama benim için bunu düşünemiyorum. Var mı?

Düzenle:

Burada tek satırlık bir ifade arıyorum nedeni ben inanılmaz derecede terse kodu gibi değil, ama böyle bir çok kod yazmak zorunda çünkü:

x = get_first_list()
if x:
    # do something with x[0]
    # inevitably forget the [0] part, and have a bug to fix
y = get_second_list()
if y:
    # do something with y[0]
    # inevitably forget the [0] part AGAIN, and have another bug to fix

Ne yapmak istiyorum kesinlikle bir işlev ile başarılabilir (ve muhtemelen olacak):

def first_item(list_or_none):
    if list_or_none: return list_or_none[0]

x = first_item(get_first_list())
if x:
    # do something with x
y = first_item(get_second_list())
if y:
    # do something with y

Soruyu yayınladım çünkü Python'daki basit ifadelerin neler yapabileceğine sık sık şaşırdım ve basit bir ifade varsa hile yapabilen bir işlev yazmanın aptalca bir şey olduğunu düşündüm. Bir işlev gibi Ancak bu cevapları görünce, öyle görünüyor olduğunu basit bir çözüm.

Python 2.6 ve üzeri

next(iter(your_list), None)

Eğer your_listolabilir None:

next(iter(your_list or []), None)

Python 2.4

def get_first(iterable, default=None):
    if iterable:
        for item in iterable:
            return item
    return default

Misal:

x = get_first(get_first_list())
if x:
    ...
y = get_first(get_second_list())
if y:
    ...

Başka bir seçenek yukarıdaki işlevi satır içi yapmaktır:

for x in get_first_list() or []:
    # process x
    break # process at most one item
for y in get_second_list() or []:
    # process y
    break

Bunu önlemek için breakyazabilirsiniz:

for x in yield_first(get_first_list()):
    x # process x
for y in yield_first(get_second_list()):
    y # process y

Nerede:

def yield_first(iterable):
    for item in iterable or []:
        yield item
        return

En iyi yol şudur:

a = get_list()
return a[0] if a else None

Bunu bir satırda da yapabilirsiniz, ancak programcının okuması çok daha zordur:

return (get_list()[:1] or [None])[0]

(get_list() or [None])[0]

Bu işe yaramalı.

BTW Değişkeni kullanmadım list, çünkü bu yerleşik list()fonksiyonun üzerine yazıyor .

Düzenleme: Daha önce burada biraz daha basit, ama yanlış bir sürümü vardı.

En python deyimsel yolu, liste yinelenebilir olduğundan bir yineleyicide next () yöntemini kullanmaktır . @JFSebastian'ın 13 Aralık 2011'deki yorumuna söylediği gibi.

next(iter(the_list), None)Boşsa Yok değerini döndürür the_list. bkz yanındaki () Python 2.6+

veya the_listboş olmadığından eminseniz :

iter(the_list).next()bkz. iterator.next () Python 2.2+

Kendinizi bir liste kavrayışından ilk şeyi (veya Hiçbiri) koparmaya çalışırken bulursanız, bunu yapmak için bir jeneratöre geçebilirsiniz:

next((x for x in blah if cond), None)

Pro: falan dizine eklenemiyorsa çalışır Con: bu alışılmadık bir sözdizimidir. Etrafında hackleme ve ipython'da bir şeyler filtrelerken faydalıdır.

OP'nin çözümü neredeyse orada, daha Pythonic yapmak için sadece birkaç şey var.

Birincisi, listenin uzunluğunu elde etmeye gerek yok. Python'daki boş listeler bir if denetiminde False olarak değerlendirilir. Sadece basitçe söyle

if list:

Ayrıca, ayrılmış kelimelerle çakışan değişkenlere atamak da çok kötü bir fikirdir. "list" Python'da ayrılmış bir kelimedir.

Öyleyse bunu

some_list = get_list()
if some_list:

Burada çok sayıda çözümün kaçırdığı gerçekten önemli bir nokta, tüm Python işlevlerinin / yöntemlerinin varsayılan olarak Yok değerini döndürmesidir . Aşağıdakileri deneyin.

def does_nothing():
    pass

foo = does_nothing()
print foo

Bir işlevi erken sonlandırmak için Yok'u döndürmeniz gerekmedikçe, açıkça Yok'u döndürmek gereksizdir. Oldukça kısa bir süre içinde, varsa, ilk girişi geri getirin.

some_list = get_list()
if some_list:
    return list[0]

Ve son olarak, belki de bu ima edildi, ancak sadece açık olmak için ( açık, örtükten daha iyi olduğu için ), işlevinizin listeyi başka bir işlevden almasını sağlamamalısınız; sadece parametre olarak iletin. Sonuç olarak,

def get_first_item(some_list): 
    if some_list:
        return list[0]

my_list = get_list()
first_item = get_first_item(my_list)

Dediğim gibi OP neredeyse oradaydı ve sadece birkaç dokunuş aradığınız Python lezzetini verir.

for item in get_list():
    return item

Açıkçası, daha iyi bir deyim olduğunu düşünmüyorum: açık ve net - "daha iyi" bir şeye gerek yok. Belki, ama bu gerçekten zevk meselesi, sen değiştirebilir if len(list) > 0:ileif list: False her zaman değerlendirecek boş listeye -.

İlgili bir notta, Python Perl değildir (cinas amaçlanmamıştır!), Mümkün olan en havalı kodu almanız gerekmez.
Aslında, Python gördüğüm en kötü kod da çok güzel :-) ve tamamen sürdürülemez.

Bu arada, burada gördüğüm çözümün çoğu, [0] listesi Yanlış olarak değerlendirildiğinde (örneğin boş dize veya sıfır) dikkate alınmaz - bu durumda, hepsi doğru öğeyi değil, Hiçbiri'ni döndürür.

İlk öğeyi döndürmek için Python deyimi veya Yok?

En Pythonic yaklaşım en çok oylanan cevabın gösterdiği şeydir ve soruyu okuduğumda aklıma ilk gelen şey buydu. Öncelikle, olası boş liste bir işleve geçirilirse, nasıl kullanılacağı aşağıda açıklanmıştır:

def get_first(l): 
    return l[0] if l else None

Ve liste bir get_listişlevden döndürülürse :

l = get_list()
return l[0] if l else None

Burada bunu açıklamanın diğer yolları, açıklamalarla

for

Bunu yapmanın akıllıca yollarını düşünmeye başladığımda, düşündüğüm ikinci şey bu:

for item in get_list():
    return item

Bu örtük dönen, burada fonksiyon uçlarını varsaymaktadır Noneeğer get_listgetiri boş bir liste. Aşağıdaki açık kod tam olarak eşdeğerdir:

for item in get_list():
    return item
return None

if some_list

Ayrıca örtük kullanan da önerildi (yanlış değişken adı düzeltildi) None. Bu, gerçekleşmeyebilecek bir yineleme yerine mantıksal denetimi kullandığı için yukarıdakilere tercih edilir. Bunun ne olduğunu hemen anlamak daha kolay olmalı. Ancak, okunabilirlik ve sürdürülebilirlik için yazıyorsak return None, sonuna açık olanı da eklemeliyiz :

some_list = get_list()
if some_list:
    return some_list[0]

dilim or [None]ve sıfırıncı dizin seçin

Bu aynı zamanda en çok oylanan cevapta:

return (get_list()[:1] or [None])[0]

Dilim gereksizdir ve bellekte fazladan bir öğe listesi oluşturur. Aşağıdakiler daha iyi performans göstermelidir. Açıklamak için or, ilk öğe Falseboole bağlamındaysa ikinci öğeyi döndürür , bu nedenle get_listboş bir liste döndürürse, parantez içinde yer alan ifade, daha sonra 0dizin tarafından erişilecek olan 'Yok' içeren bir liste döndürür :

return (get_list() or [None])[0]

Bir sonraki, ilk öğeyi Trueboole bağlamındaysa ve ikinci öğeyi döndürdüğü gerçeğini kullanır ve my_list'e iki kez başvurduğundan, üçlü ifadeden daha iyi değildir (ve teknik olarak bir astar değildir):

my_list = get_list() 
return (my_list and my_list[0]) or None

next

Sonra yerleşik nextve aşağıdaki akıllı kullanımı variter

return next(iter(get_list()), None)

Açıklamak için, iterbir .nextyöntemle bir yineleyici döndürür . ( .__next__Python 3'te) Daha sonra yerleşik nextbu .nextyöntemi çağırır ve yineleyici biterse, verdiğimiz varsayılanı döndürür None.

gereksiz üçlü ifade ( a if b else c) ve geri dönme

Aşağıdakiler önerilmiştir, ancak mantık genellikle negatif yerine pozitifte daha iyi anlaşıldığı için tersi tercih edilir. Yana get_listsonuç bir şekilde memoized sürece iki kez denir, bu kötü performans göstereceğini:

return None if not get_list() else get_list()[0]

Daha iyi ters:

return get_list()[0] if get_list() else None

Daha da iyisi, get_listyalnızca bir kez çağrılacak yerel bir değişken kullanın ve ilk önce önerilen Pythonic çözümüne sahip olursunuz:

l = get_list()
return l[0] if l else None

Deyimlerle ilgili olarak, bir itertools tarifi var nth.

Itertools tariflerinden:

def nth(iterable, n, default=None):
    "Returns the nth item or a default value"
    return next(islice(iterable, n, None), default)

Tek gömlek istiyorsanız, bu tarifi sizin için uygulayan bir kütüphane kurmayı düşünün, örneğin more_itertools:

import more_itertools as mit

mit.nth([3, 2, 1], 0)
# 3

mit.nth([], 0)                                             # default is `None`
# None

Yalnızca ilk öğeyi döndüren başka bir araç kullanılabilir more_itertools.first.

mit.first([3, 2, 1])
# 3

mit.first([], default=None)
# None

Bu itertools, yalnızca listeler için değil, tüm yinelenebilirler için genel olarak ölçeklenir.

my_list[0] if len(my_list) else None

Meraktan iki çözüm üzerinde zamanlamalar yaptım. Bir for döngüsünü erken sona erdirmek için bir return ifadesi kullanan çözüm, Python 2.5.1 ile makinemde biraz daha pahalı, bunun yinelenebilir kurulumu ile ilgili olduğundan şüpheleniyorum.

import random
import timeit

def index_first_item(some_list):
    if some_list:
        return some_list[0]


def return_first_item(some_list):
    for item in some_list:
        return item


empty_lists = []
for i in range(10000):
    empty_lists.append([])

assert empty_lists[0] is not empty_lists[1]

full_lists = []
for i in range(10000):
    full_lists.append(list([random.random() for i in range(10)]))

mixed_lists = empty_lists[:50000] + full_lists[:50000]
random.shuffle(mixed_lists)

if __name__ == '__main__':
    ENV = 'import firstitem'
    test_data = ('empty_lists', 'full_lists', 'mixed_lists')
    funcs = ('index_first_item', 'return_first_item')
    for data in test_data:
        print "%s:" % data
        for func in funcs:
            t = timeit.Timer('firstitem.%s(firstitem.%s)' % (
                func, data), ENV)
            times = t.repeat()
            avg_time = sum(times) / len(times)
            print "  %s:" % func
            for time in times:
                print "    %f seconds" % time
            print "    %f seconds avg." % avg_time

Bunlar aldığım zamanlamalar:

empty_lists:
  index_first_item:
    0.748353 saniye
    0.741086 saniye
    0.741191 saniye
    0.743543 saniye ort.
  return_first_item:
    0.785511 saniye
    0.822178 saniye
    0.782846 saniye
    0.796845 saniye ort.
full_lists:
  index_first_item:
    0.762618 saniye
    0.788040 saniye
    0.786849 saniye
    0.779169 saniye ort.
  return_first_item:
    0.802735 saniye
    0.878706 saniye
    0.808781 saniye
    0.830074 saniye ort.
mixed_lists:
  index_first_item:
    0.791129 saniye
    0.743526 saniye
    0.744441 saniye
    0.759699 saniye ort.
  return_first_item:
    0.784801 saniye
    0.785146 saniye
    0.840193 saniye
    0.803380 saniye ort.

try:
    return a[0]
except IndexError:
    return None

def head(iterable):
    try:
        return iter(iterable).next()
    except StopIteration:
        return None

print head(xrange(42, 1000)  # 42
print head([])               # None

BTW: Genel program akışınızı şu şekilde yeniden işlerdim:

lists = [
    ["first", "list"],
    ["second", "list"],
    ["third", "list"]
]

def do_something(element):
    if not element:
        return
    else:
        # do something
        pass

for li in lists:
    do_something(head(li))

(Mümkün olduğunda tekrardan kaçınma)

Buna ne dersin:

(my_list and my_list[0]) or None

Not: Bu, nesne listeleri için iyi çalışmalıdır, ancak aşağıdaki yorumlara göre sayı veya dize listesi olması durumunda yanlış yanıt verebilir.

Bu nasıl pythonic emin değilim ama kütüphanede bir ilk işlevi olana kadar ben bu kaynak dahil:

first = lambda l, default=None: next(iter(l or []), default)

Sadece bir satır (siyaha uygundur) ve bağımlılıklardan kaçınır.

And- veya hile kullanarak:

a = get_list()
return a and a[0] or None

Muhtemelen en hızlı çözüm değil, ama kimse bu seçenekten bahsetmedi:

dict(enumerate(get_list())).get(0)

eğer get_list()dönebilir Nonekullanabilirsiniz:

dict(enumerate(get_list() or [])).get(0)

Avantajları:

-Tek çizgi

-Sadece bir get_list()kez ararsın

-anlaması kolay

Benim kullanım durumum sadece yerel bir değişkenin değerini ayarlamak oldu.

Şahsen denemek buldum ve okumak için stil temizleyici hariç

items = [10, 20]
try: first_item = items[0]
except IndexError: first_item = None
print first_item

bir listeyi dilimlemek yerine.

items = [10, 20]
first_item = (items[:1] or [None, ])[0]
print first_item

Birkaç kişi böyle bir şey yapmayı önerdi:

list = get_list()
return list and list[0] or None

Bu birçok durumda işe yarar, ancak yalnızca liste [0] 0, False veya boş bir dizeye eşit değilse çalışır. [0] listesi 0, False veya boş bir dize ise yöntem yanlış None döndürür.

Bu hatayı kendi kodumda bir çok kez oluşturdum!

Extract Method kullanabilirsiniz . Başka bir deyişle, bu kodu daha sonra çağıracağınız bir yönteme çıkarın.

Daha fazla sıkıştırmaya çalışmam, bir astarın ayrıntılı versiyondan daha zor okunması gibi görünüyor. Ve Extract Method kullanıyorsanız, bu bir astardır;)

if mylist != []:

       print(mylist[0])

   else:

       print(None)

deyimsel python C-tarzı üçlü operatörlere eşdeğer değil

cond and true_expr or false_expr

yani.

list = get_list()
return list and list[0] or None