Idiom Pythona, aby zwrócić pierwszy element lub Brak

Jestem pewien, że istnieje prostszy sposób na zrobienie tego, co po prostu mi się nie zdarza.

Nazywam wiele metod, które zwracają listę. Lista może być pusta. Jeśli lista nie jest pusta, chcę zwrócić pierwszą pozycję; w przeciwnym razie chcę zwrócić Brak. Ten kod działa:

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

Wydaje mi się, że powinien istnieć prosty, jednowierszowy idiom do zrobienia tego, ale przez całe życie nie mogę o tym myśleć. Jest tu?

Edytować:

Powodem, dla którego szukam tutaj wyrażenia jednowierszowego, nie jest to, że lubię niewiarygodnie zwięzły kod, ale dlatego, że muszę napisać dużo takiego kodu:

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

To, co chciałbym robić, z pewnością można osiągnąć za pomocą funkcji (i prawdopodobnie będzie):

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

Zadałem pytanie, ponieważ często jestem zaskoczony tym, co potrafią proste wyrażenia w Pythonie, i pomyślałem, że napisanie funkcji było głupią rzeczą, gdyby istniało proste wyrażenie. Ale widząc te odpowiedzi, wydaje się, że funkcja jest prostym rozwiązaniem.

Python 2.6+

next(iter(your_list), None)

Jeśli your_listmoże być 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

Przykład:

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

Inną opcją jest wstawienie powyższej funkcji:

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

Aby tego uniknąć, breakmożesz napisać:

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

Gdzie:

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

Najlepszy sposób to:

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

Możesz także zrobić to w jednym wierszu, ale programiście jest o wiele trudniej odczytać:

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

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

To powinno działać.

BTW Nie użyłem zmiennej list, ponieważ to zastępuje wbudowaną list()funkcję.

Edycja: Miałem wcześniej nieco prostszą, ale złą wersję.

Najbardziej idiomatycznym sposobem Pythona jest użycie funkcji next () w iteratorze, ponieważ lista jest iterowalna . dokładnie tak, jak @JFSebastian w komentarzu z 13 grudnia 2011 r.

next(iter(the_list), None)Zwraca Brak, jeśli the_listjest pusty. zobacz next () Python 2.6+

lub jeśli wiesz na pewno the_listnie jest pusty:

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

Jeśli próbujesz wyciągnąć pierwszą rzecz (lub brak) ze zrozumienia listy, możesz przełączyć się na generator, aby to zrobić w następujący sposób:

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

Pro: działa, jeśli bla nie jest indeksowalny Con: to nieznana składnia. Jest to przydatne podczas hakowania i filtrowania rzeczy w ipython.

Rozwiązanie OP jest już blisko, jest tylko kilka rzeczy, aby uczynić go bardziej Pythonic.

Po pierwsze, nie ma potrzeby uzyskiwania długości listy. Puste listy w Pythonie oceniają na False w czeku if. Po prostu powiedz

if list:

Dodatkowo przypisywanie zmiennych zmiennych nakładających się na słowa zastrzeżone jest bardzo złym pomysłem. „lista” jest słowem zastrzeżonym w języku Python.

Zmieńmy to na

some_list = get_list()
if some_list:

Naprawdę ważną kwestią, której brakuje wielu rozwiązaniom, jest to, że wszystkie funkcje / metody Pythona domyślnie zwracają Brak . Spróbuj wykonać poniższe czynności.

def does_nothing():
    pass

foo = does_nothing()
print foo

O ile nie musisz zwracać None, aby wcześniej zakończyć działanie funkcji, nie jest konieczne jawne zwracanie None. Zupełnie zwięźle, po prostu zwróć pierwszy wpis, jeśli istnieje.

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

I na koniec, być może zostało to dorozumiane, ale żeby być jawnym (ponieważ jawne jest lepsze niż niejawne ), nie powinieneś mieć swojej funkcji, aby pobierała listę z innej funkcji; po prostu przekaż to jako parametr. Tak więc końcowy wynik byłby

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

my_list = get_list()
first_item = get_first_item(my_list)

Jak powiedziałem, OP już prawie się pojawił, a zaledwie kilka dotknięć nadaje mu smak Pythona, którego szukasz.

for item in get_list():
    return item

Szczerze mówiąc, nie sądzę, aby istniał lepszy idiom: twój jest jasny i zwięzły - nie potrzebujesz niczego „lepszego”. Być może, ale to naprawdę kwestia gustu, którą możesz zmienić za if len(list) > 0:pomocą if list:- pusta lista zawsze będzie oznaczać False.

W pokrewnej notatce Python nie jest Perlem (nie ma sensu!), Nie musisz uzyskiwać najfajniejszego możliwego kodu.
W rzeczywistości najgorszy kod, jaki widziałem w Pythonie, był również bardzo fajny :-) i całkowicie niemożliwy do utrzymania.

Nawiasem mówiąc, większość rozwiązań, które tu widziałem, nie biorą pod uwagę, gdy lista [0] ma wartość False (np. Pusty ciąg znaków lub zero) - w tym przypadku wszystkie zwracają None i niewłaściwy element.

Python idiom, aby zwrócić pierwszy element lub brak?

Najbardziej pytoniczne podejście jest tym, co wykazała najbardziej pozytywna odpowiedź, i po raz pierwszy przyszło mi do głowy, gdy czytam pytanie. Oto jak go użyć, po pierwsze, jeśli ewentualnie pusta lista zostanie przekazana do funkcji:

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

A jeśli lista zostanie zwrócona z get_listfunkcji:

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

Wykazano, że można to zrobić tutaj w inny sposób, wraz z objaśnieniami

for

Kiedy zacząłem wymyślać sprytne sposoby na zrobienie tego, to druga rzecz, o której pomyślałem:

for item in get_list():
    return item

Zakłada się, że funkcja kończy się tutaj, domyślnie zwraca, Nonejeśli get_listzwraca pustą listę. Poniższy jawny kod jest dokładnie równoważny:

for item in get_list():
    return item
return None

if some_list

Zaproponowano również następujące (poprawiłem niepoprawną nazwę zmiennej), która również korzysta z niejawnej None. Byłoby to lepsze niż powyższe, ponieważ wykorzystuje sprawdzanie logiczne zamiast iteracji, która może się nie zdarzyć. Powinno to być łatwiejsze do natychmiastowego zrozumienia, co się dzieje. Ale jeśli piszemy dla czytelności i łatwości konserwacji, powinniśmy również dodać return Nonena końcu wyraźne :

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

pokroić or [None]i wybrać indeks zerowy

Ten jest również w najczęściej głosowanej odpowiedzi:

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

Wycinek jest niepotrzebny i tworzy w pamięci dodatkową listę z jednym elementem. Następujące powinny być bardziej wydajne. Aby to wyjaśnić, orzwraca drugi element, jeśli pierwszy znajduje się Falsew kontekście logicznym, więc jeśli get_listzwróci pustą listę, wyrażenie zawarte w nawiasach zwróci listę z „Brak”, do której dostęp uzyska następnie 0indeks:

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

Następny wykorzystuje fakt, że zwraca drugi element, jeśli pierwszy jest Truew kontekście logicznym, a ponieważ dwukrotnie odwołuje się do mojej_listy, nie jest lepszy niż wyrażenie trójkowe (i technicznie nie jest to jednowierszowy):

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

next

Następnie mamy następujące sprytne użycie wbudowanego nextiiter

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

Aby wyjaśnić, iterzwraca iterator z .nextmetodą. ( .__next__W Pythonie 3.), a następnie wbudowane nextpołączenia, które .nextmetody, a jeśli iterator jest wyczerpany, przywraca domyślne dajemy, None.

redundantne wyrażenie trójskładnikowe ( a if b else c) i krążące w tył

Zaproponowano poniżej, ale odwrotność byłaby lepsza, ponieważ logika jest zwykle lepiej rozumiana w pozytywnych zamiast negatywnych. Ponieważ get_listjest wywoływany dwukrotnie, chyba że wynik zostanie w jakiś sposób zapamiętany, to działałoby to źle:

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

Im lepsza odwrotność:

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

Co więcej, użyj zmiennej lokalnej, która get_listjest wywoływana tylko raz, i najpierw omówiono zalecane rozwiązanie w języku Python:

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

Jeśli chodzi o idiomy, istnieje przepis itertools o nazwie nth.

Z przepisów itertools:

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

Jeśli chcesz mieć jeden wiersz, rozważ zainstalowanie biblioteki, która implementuje ten przepis dla Ciebie, np . more_itertools:

import more_itertools as mit

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

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

Dostępne jest inne narzędzie, które zwraca tylko pierwszy element o nazwie more_itertools.first.

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

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

Te narzędzia itertools są skalowane ogólnie dla dowolnej iteracji, nie tylko dla list.

my_list[0] if len(my_list) else None

Z ciekawości sprawdziłem czasy dwóch rozwiązań. Rozwiązanie wykorzystujące instrukcję return do przedwczesnego zakończenia pętli for jest nieco droższe na moim komputerze z Pythonem 2.5.1. Podejrzewam, że ma to związek z konfiguracją iterowalności.

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

Oto czasy, które otrzymałem:

puste_listy:
  index_first_item:
    0,748353 sekundy
    0,741086 sekund
    0,741191 sekund
    0,743543 sekund śr.
  return_first_item:
    0,785511 sekund
    0,822178 sekund
    0,782846 sekund
    0,796845 sekund śr.
pełne listy:
  index_first_item:
    0,762618 sekund
    0,788040 sekund
    0,786849 sekund
    0,779169 sekund śr.
  return_first_item:
    0,802735 sekund
    0,878706 sekund
    0,808781 sekund
    Średnio 0,830074 sekundy
mixed_lists:
  index_first_item:
    0,791129 sekund
    0,743526 sekund
    0,744441 sekundy
    0,759699 sekund śr.
  return_first_item:
    0,784801 sekund
    0,785146 sekund
    0,840193 sekundy
    0,803380 sekund śr.

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: Chciałbym przerobić ogólny przebieg programu na coś takiego:

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

(Unikanie powtarzania, gdy tylko jest to możliwe)

Co powiesz na to:

(my_list and my_list[0]) or None

Uwaga: Powinno to działać poprawnie w przypadku list obiektów, ale może zwrócić niepoprawną odpowiedź w przypadku listy liczb lub ciągów w komentarzach poniżej.

Nie jestem pewien, jak to jest pythonowe, ale dopóki nie pojawi się pierwsza funkcja w bibliotece, dołączam to do źródła:

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

To tylko jedna linia (odpowiada czerni) i pozwala uniknąć zależności.

Za pomocą sztuczki i-lub:

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

Prawdopodobnie nie jest to najszybsze rozwiązanie, ale nikt nie wspomniał o tej opcji:

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

jeśli get_list()możesz wrócić None, możesz użyć:

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

Zalety:

-jedna linia

- zadzwoń tylko get_list()raz

-łatwy do zrozumienia

Mój przypadek użycia polegał jedynie na ustawieniu wartości zmiennej lokalnej.

Osobiście znalazłem próbę i oprócz czyszczenia stylu do przeczytania

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

niż krojenie listy.

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

Kilka osób zasugerowało zrobienie czegoś takiego:

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

Działa to w wielu przypadkach, ale zadziała tylko wtedy, gdy lista [0] nie jest równa 0, False lub pusty ciąg znaków. Jeśli lista [0] ma wartość 0, Fałsz lub pusty ciąg znaków, metoda niepoprawnie zwróci Brak.

Ten błąd utworzyłem we własnym kodzie zbyt wiele razy!

Możesz użyć metody wyodrębnienia . Innymi słowy, wypakuj ten kod do metody, którą następnie wywołasz.

Nie próbowałbym go bardziej kompresować, te linijki wydają się trudniejsze do odczytania niż wersja pełna. A jeśli użyjesz metody ekstrakcji, jest to jedna linijka;)

if mylist != []:

       print(mylist[0])

   else:

       print(None)

nie jest idiomatycznym pytonem równoważnym do operatorów trójskładnikowych w stylu C.

cond and true_expr or false_expr

to znaczy.

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