Python-Sprache für die Rückgabe des ersten Elements oder Keine

Ich bin sicher, es gibt einen einfacheren Weg, der mir einfach nicht einfällt.

Ich rufe eine Reihe von Methoden auf, die eine Liste zurückgeben. Die Liste ist möglicherweise leer. Wenn die Liste nicht leer ist, möchte ich das erste Element zurückgeben. Andernfalls möchte ich None zurückgeben. Dieser Code funktioniert:

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

Es scheint mir, dass es eine einfache einzeilige Redewendung dafür geben sollte, aber für mein Leben kann ich nicht daran denken. Gibt es?

Bearbeiten:

Der Grund, warum ich hier nach einem einzeiligen Ausdruck suche, ist nicht, dass ich unglaublich knappen Code mag, sondern dass ich so viel Code schreiben muss:

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

Was ich gerne tun würde, kann sicherlich mit einer Funktion erreicht werden (und wird es wahrscheinlich auch sein):

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

Ich habe die Frage gestellt, weil ich häufig überrascht bin, was einfache Ausdrücke in Python bewirken können, und ich dachte, dass das Schreiben einer Funktion eine dumme Sache ist, wenn es einen einfachen Ausdruck gibt, der den Trick macht. Aber diese Antworten zu sehen, wie es scheint , eine Funktion ist die einfache Lösung.

Python 2.6+

next(iter(your_list), None)

Wenn your_listkann sein 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

Beispiel:

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

Eine andere Möglichkeit besteht darin, die obige Funktion zu integrieren:

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

Um dies zu vermeiden break, könnten Sie schreiben:

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

Wo:

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

Der beste Weg ist folgender:

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

Sie können es auch in einer Zeile tun, aber für den Programmierer ist es viel schwieriger zu lesen:

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

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

Das sollte funktionieren.

Übrigens habe ich die Variable nicht verwendet list, da dies die eingebaute list()Funktion überschreibt .

Edit: Ich hatte hier früher eine etwas einfachere, aber falsche Version.

Die pythonischste Art ist die Verwendung von next () für einen Iterator, da die Liste iterierbar ist . Genau wie das, was @JFSebastian am 13. Dezember 2011 in den Kommentar aufgenommen hat.

next(iter(the_list), None)Dies gibt None zurück, wenn the_listes leer ist. siehe next () Python 2.6+

oder wenn Sie sicher wissen, the_listist nicht leer:

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

Wenn Sie versuchen, das Erste (oder Keine) aus einem Listenverständnis herauszuholen, können Sie zu einem Generator wechseln, um Folgendes zu tun:

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

Pro: Funktioniert, wenn bla nicht indizierbar ist. Con: Es ist eine ungewohnte Syntax. Es ist jedoch nützlich, wenn Sie in ipython herumhacken und Dinge filtern.

Die Lösung des OP ist fast da, es gibt nur ein paar Dinge, die es pythonischer machen.

Zum einen ist es nicht erforderlich, die Länge der Liste zu ermitteln. Leere Listen in Python werden bei einer if-Prüfung als falsch ausgewertet. Sag es einfach

if list:

Darüber hinaus ist es eine sehr schlechte Idee, Variablen zuzuweisen, die sich mit reservierten Wörtern überschneiden. "Liste" ist ein reserviertes Wort in Python.

Ändern wir das also in

some_list = get_list()
if some_list:

Ein wirklich wichtiger Punkt, den viele Lösungen hier übersehen, ist, dass alle Python-Funktionen / -Methoden standardmäßig None zurückgeben . Versuchen Sie Folgendes unten.

def does_nothing():
    pass

foo = does_nothing()
print foo

Sofern Sie None nicht zurückgeben müssen, um eine Funktion vorzeitig zu beenden, ist es nicht erforderlich, None explizit zurückzugeben. Kurz gesagt, geben Sie einfach den ersten Eintrag zurück, falls vorhanden.

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

Und schließlich wurde dies vielleicht impliziert, aber nur um explizit zu sein (weil explizit besser als implizit ist ), sollte Ihre Funktion die Liste nicht von einer anderen Funktion abrufen. Übergeben Sie es einfach als Parameter. Das Endergebnis wäre also

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

my_list = get_list()
first_item = get_first_item(my_list)

Wie gesagt, das OP war fast da und nur ein paar Berührungen verleihen ihm den Python-Geschmack, den Sie suchen.

for item in get_list():
    return item

Ehrlich gesagt glaube ich nicht, dass es eine bessere Redewendung gibt: Ihre ist klar und knapp - Sie brauchen nichts "Besseres". Vielleicht, aber das ist wirklich eine Frage des Geschmacks ist, könnten Sie verändern if len(list) > 0:mitif list: - einer leeren Liste wird immer auf False auswerten.

In einem ähnlichen Zusammenhang ist Python nicht Perl (kein Wortspiel beabsichtigt!), Sie müssen nicht den coolsten Code bekommen, der möglich ist.
Eigentlich war der schlechteste Code, den ich in Python gesehen habe, auch sehr cool :-) und völlig unbrauchbar.

Übrigens berücksichtigen die meisten Lösungen, die ich hier gesehen habe, nicht, wenn list [0] als False ausgewertet wird (z. B. leere Zeichenfolge oder Null). In diesem Fall geben alle None und nicht das richtige Element zurück.

Python-Sprache für die Rückgabe des ersten Elements oder Keine?

Der pythonischste Ansatz ist der, der in der am besten bewerteten Antwort gezeigt wurde, und es war das erste, was mir beim Lesen der Frage in den Sinn kam. So verwenden Sie es zuerst, wenn die möglicherweise leere Liste an eine Funktion übergeben wird:

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

Und wenn die Liste von einer get_listFunktion zurückgegeben wird:

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

Andere Möglichkeiten, dies zu tun, wurden hier anhand von Erklärungen demonstriert

for

Als ich anfing, über clevere Wege nachzudenken, war dies das zweite, woran ich dachte:

for item in get_list():
    return item

Dies setzt voraus, dass die Funktion hier endet und implizit zurückgibt, Nonewenn get_listeine leere Liste zurückgegeben wird. Der folgende explizite Code ist genau gleichwertig:

for item in get_list():
    return item
return None

if some_list

Das Folgende wurde ebenfalls vorgeschlagen (ich habe den falschen Variablennamen korrigiert), wobei auch das Implizite verwendet wird None. Dies wäre dem oben genannten vorzuziehen, da die logische Prüfung anstelle einer möglicherweise nicht stattfindenden Iteration verwendet wird. Dies sollte sofort leichter zu verstehen sein, was passiert. Wenn wir jedoch aus Gründen der Lesbarkeit und Wartbarkeit schreiben, sollten wir return Noneam Ende auch das Explizite hinzufügen :

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

Slice or [None]und wählen Sie den nullten Index

Dieser ist auch in der am besten bewerteten Antwort:

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

Das Slice ist nicht erforderlich und erstellt eine zusätzliche Liste mit einem Element im Speicher. Das Folgende sollte performanter sein. Um zu erklären, orgibt das zweite Element , wenn die erste ist , Falsein einem booleschen Kontext, also wenn get_listeine leere Liste zurückgegeben, der Ausdruck in den Klammern enthalten eine Liste mit ‚Keine‘ zurück, die dann durch den zugegriffen werden 0Index:

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

Der nächste verwendet die Tatsache, dass und das zweite Element zurückgibt, wenn sich das erste Truein einem booleschen Kontext befindet. Da es zweimal auf my_list verweist, ist es nicht besser als der ternäre Ausdruck (und technisch gesehen kein Einzeiler):

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

next

Dann haben wir den folgenden cleveren Einsatz des eingebauten nextunditer

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

Gibt zur Erklärung itereinen Iterator mit einer .nextMethode zurück. ( .__next__in Python 3.) Dann nextruft das eingebaute diese .nextMethode auf, und wenn der Iterator erschöpft ist, gibt es den von uns angegebenen Standard zurück.None .

redundanter ternärer Ausdruck (a if b else c ) und Zurückkreisen

Das Folgende wurde vorgeschlagen, aber das Umgekehrte wäre vorzuziehen, da die Logik normalerweise besser im Positiven als im Negativen verstanden wird. Da get_listzweimal aufgerufen wird, würde das Ergebnis schlecht funktionieren, es sei denn, das Ergebnis wird auf irgendeine Weise gespeichert.

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

Das bessere Gegenteil:

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

Verwenden Sie noch besser eine lokale Variable, die get_listnur einmal aufgerufen wird, und Sie haben die empfohlene Pythonic-Lösung zuerst besprochen:

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

In Bezug auf Idiome gibt es ein itertools Rezept genanntnth .

Aus itertools Rezepten:

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

Wenn Sie Einzeiler möchten, sollten Sie eine Bibliothek installieren, die dieses Rezept für Sie implementiert, z more_itertools.

import more_itertools as mit

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

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

Es steht ein weiteres Tool zur Verfügung, das nur das erste aufgerufene Element zurückgibt more_itertools.first.

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

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

Diese itertools werden generisch für alle iterierbaren Elemente skaliert, nicht nur für Listen.

my_list[0] if len(my_list) else None

Aus Neugier habe ich zwei der Lösungen zeitlich festgelegt. Die Lösung, die eine return-Anweisung verwendet, um eine for-Schleife vorzeitig zu beenden, ist auf meinem Computer mit Python 2.5.1 etwas teurer. Ich vermute, dies hat mit dem Einrichten der Iterable zu tun.

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

Dies sind die Timings, die ich bekommen habe:

leere_Listen:
  index_first_item:
    0,748353 Sekunden
    0,741086 Sekunden
    0,741191 Sekunden
    0,743543 Sekunden Durchschn.
  return_first_item:
    0,785511 Sekunden
    0,822178 Sekunden
    0,782846 Sekunden
    0,796845 Sekunden Durchschn.
full_lists:
  index_first_item:
    0,762618 Sekunden
    0,788040 Sekunden
    0,786849 Sekunden
    0,779169 Sekunden Durchschn.
  return_first_item:
    0,802735 Sekunden
    0,878706 Sekunden
    0,808781 Sekunden
    0,830074 Sekunden Durchschn.
gemischte_Listen:
  index_first_item:
    0,791129 Sekunden
    0,743526 Sekunden
    0,744441 Sekunden
    0,759699 Sekunden Durchschn.
  return_first_item:
    0,784801 Sekunden
    0,785146 Sekunden
    0,840193 Sekunden
    0,803380 Sekunden Durchschn.

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

Übrigens: Ich würde Ihren allgemeinen Programmablauf in etwa so überarbeiten:

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

(Vermeiden Sie Wiederholungen, wann immer dies möglich ist.)

Wie wäre es damit:

(my_list and my_list[0]) or None

Hinweis: Dies sollte für Objektlisten gut funktionieren, kann jedoch bei einer Nummern- oder Zeichenfolgenliste gemäß den folgenden Kommentaren zu einer falschen Antwort führen.

Ich bin mir nicht sicher, wie pythonisch das ist, aber bis es eine erste Funktion in der Bibliothek gibt, füge ich dies in die Quelle ein:

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

Es ist nur eine Zeile (entspricht Schwarz) und vermeidet Abhängigkeiten.

Verwenden des and-or-Tricks:

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

Wahrscheinlich nicht die schnellste Lösung, aber niemand erwähnte diese Option:

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

Wenn Sie zurückkehren können, get_list()können NoneSie Folgendes verwenden:

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

Vorteile:

-eine Linie

-Du rufst nur get_list()einmal an

-einfach zu verstehen

Mein Anwendungsfall bestand nur darin, den Wert einer lokalen Variablen festzulegen.

Persönlich fand ich den Versuch und außer Stilreiniger zu lesen

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

als eine Liste zu schneiden.

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

Einige Leute haben vorgeschlagen, so etwas zu tun:

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

Das funktioniert in vielen Fällen, aber es funktioniert nur, wenn list [0] nicht gleich 0, False oder einer leeren Zeichenfolge ist. Wenn list [0] 0, False oder eine leere Zeichenfolge ist, gibt die Methode fälschlicherweise None zurück.

Ich habe diesen Fehler zu oft in meinem eigenen Code erstellt!

Sie können die Extraktionsmethode verwenden . Mit anderen Worten, extrahieren Sie diesen Code in eine Methode, die Sie dann aufrufen würden.

Ich würde nicht versuchen, es viel mehr zu komprimieren, die Einzeiler scheinen schwerer zu lesen als die ausführliche Version. Und wenn Sie die Extraktionsmethode verwenden, ist es ein Einzeiler;)

if mylist != []:

       print(mylist[0])

   else:

       print(None)

ist nicht die idiomatische Python, die ternären Operatoren im C-Stil entspricht

cond and true_expr or false_expr

dh.

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